CbmRoot
CbmMcbm2018UnpackerAlgoSts.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018UnpackerAlgoSts -----
4 // ----- Created 26.01.2019 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018UnpackerAlgoSts.h"
9 
10 #include "CbmFormatMsHeaderPrintout.h"
11 #include "CbmMcbm2018StsPar.h"
12 
13 #include <Logger.h>
14 
15 #include "TCanvas.h"
16 #include "TH1.h"
17 #include "TH2.h"
18 #include "TList.h"
19 #include "TProfile.h"
20 #include "TROOT.h"
21 #include "TString.h"
22 
23 #include <fstream>
24 #include <iomanip>
25 #include <iostream>
26 #include <stdint.h>
27 
28 // -------------------------------------------------------------------------
29 CbmMcbm2018UnpackerAlgoSts::CbmMcbm2018UnpackerAlgoSts()
30  : CbmStar2019Algo()
31  ,
33  fbMonitorMode(kFALSE)
34  , fbDebugMonitorMode(kFALSE)
35  , fvbMaskedComponents()
36  , fUnpackPar(nullptr)
37  , fuNbModules(0)
38  , fviModuleType()
39  , fviModAddress()
40  , fuNrOfDpbs(0)
41  , fDpbIdIndexMap()
42  , fvbCrobActiveFlag()
43  , fuNbFebs(0)
44  , fuNbStsXyters(0)
45  , fviFebModuleIdx()
46  , fviFebModuleSide()
47  , fviFebType()
48  , fviFebAddress()
49  , fviFebSide()
50  , fvdFebAdcGain()
51  , fvdFebAdcOffs()
52  , fdTimeOffsetNs(0.0)
53  , fvdTimeOffsetNsAsics()
54  , fbUseChannelMask(kFALSE)
55  , fvvbMaskedChannels()
56  , fdAdcCut(0)
57  , fulCurrentTsIdx(0)
58  , fulCurrentMsIdx(0)
59  , fdTsStartTime(-1.0)
60  , fdTsStopTimeCore(-1.0)
61  , fdMsTime(-1.0)
62  , fuMsIndex(0)
63  , fmMsgCounter()
64  , fuCurrentEquipmentId(0)
65  , fuCurrDpbId(0)
66  , fuCurrDpbIdx(0)
67  , fiRunStartDateTimeSec(-1)
68  , fiBinSizeDatePlots(-1)
69  , fvulCurrentTsMsb()
70  , fdStartTime(0.0)
71  , fdStartTimeMsSz(0.0)
72  , ftStartTimeUnix(std::chrono::steady_clock::now())
73  , fvmHitsInMs()
74  , fvvusLastTsChan()
75  , fvvusLastAdcChan()
76  , fvvusLastTsMsbChan()
77  , fvvusLastTsMsbCycleChan()
78  , fhDigisTimeInRun(nullptr)
79 /*
80  fvhHitsTimeToTriggerRaw(),
81  fvhMessDistributionInMs(),
82  fhEventNbPerTs( nullptr ),
83  fcTimeToTrigRaw( nullptr )
84 */
85 {}
86 CbmMcbm2018UnpackerAlgoSts::~CbmMcbm2018UnpackerAlgoSts() {
88  fvmHitsInMs.clear();
89  /*
90  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
91  {
92  fvmHitsInMs[ uDpb ].clear();
93  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
94 */
95  if (nullptr != fParCList) delete fParCList;
96  if (nullptr != fUnpackPar) delete fUnpackPar;
97 }
98 
99 // -------------------------------------------------------------------------
100 Bool_t CbmMcbm2018UnpackerAlgoSts::Init() {
101  LOG(info) << "Initializing mCBM STS 2019 unpacker algo";
102 
103  return kTRUE;
104 }
105 void CbmMcbm2018UnpackerAlgoSts::Reset() {}
106 void CbmMcbm2018UnpackerAlgoSts::Finish() {
108 
110 }
111 
112 // -------------------------------------------------------------------------
113 Bool_t CbmMcbm2018UnpackerAlgoSts::InitContainers() {
114  LOG(info) << "Init parameter containers for CbmMcbm2018UnpackerAlgoSts";
115  Bool_t initOK = ReInitContainers();
116 
117  return initOK;
118 }
119 Bool_t CbmMcbm2018UnpackerAlgoSts::ReInitContainers() {
120  LOG(info) << "**********************************************";
121  LOG(info) << "ReInit parameter containers for CbmMcbm2018UnpackerAlgoSts";
122 
123  fUnpackPar = (CbmMcbm2018StsPar*) fParCList->FindObject("CbmMcbm2018StsPar");
124  if (nullptr == fUnpackPar) return kFALSE;
125 
126  Bool_t initOK = InitParameters();
127 
128  return initOK;
129 }
130 TList* CbmMcbm2018UnpackerAlgoSts::GetParList() {
131  if (nullptr == fParCList) fParCList = new TList();
132  fUnpackPar = new CbmMcbm2018StsPar("CbmMcbm2018StsPar");
133  fParCList->Add(fUnpackPar);
134 
135  return fParCList;
136 }
137 Bool_t CbmMcbm2018UnpackerAlgoSts::InitParameters() {
138  fuNbModules = fUnpackPar->GetNbOfModules();
139  LOG(info) << "Nr. of STS Modules: " << fuNbModules;
140 
141  fviModuleType.resize(fuNbModules);
142  fviModAddress.resize(fuNbModules);
143  for (UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx) {
144  fviModuleType[uModIdx] = fUnpackPar->GetModuleType(uModIdx);
145  fviModAddress[uModIdx] = fUnpackPar->GetModuleAddress(uModIdx);
146  LOG(info) << "Module #" << std::setw(2) << uModIdx << " Type "
147  << std::setw(4) << fviModuleType[uModIdx] << " Address 0x"
148  << std::setw(8) << std::hex << fviModAddress[uModIdx] << std::dec;
149  } // for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx)
150 
151  fuNrOfDpbs = fUnpackPar->GetNrOfDpbs();
152  LOG(info) << "Nr. of STS DPBs: " << fuNrOfDpbs;
153 
154  fDpbIdIndexMap.clear();
155  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
156  fDpbIdIndexMap[fUnpackPar->GetDpbId(uDpb)] = uDpb;
157  LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x"
158  << std::setw(4) << std::hex << fUnpackPar->GetDpbId(uDpb)
159  << std::dec << " => "
160  << fDpbIdIndexMap[fUnpackPar->GetDpbId(uDpb)];
161  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
162 
163  fuNbFebs = fUnpackPar->GetNrOfFebs();
164  LOG(info) << "Nr. of FEBs: " << fuNbFebs;
165 
166  fuNbStsXyters = fUnpackPar->GetNrOfAsics();
167  LOG(info) << "Nr. of StsXyter ASICs: " << fuNbStsXyters;
168 
169  if (fvdTimeOffsetNsAsics.size() < fuNbStsXyters) {
170  fvdTimeOffsetNsAsics.resize(fuNbStsXyters, 0.0);
171  } // if( fvdTimeOffsetNsAsics.size() < fuNbStsXyters )
172 
173  fvbCrobActiveFlag.resize(fuNrOfDpbs);
174  fviFebModuleIdx.resize(fuNrOfDpbs);
175  fviFebModuleSide.resize(fuNrOfDpbs);
176  fviFebType.resize(fuNrOfDpbs);
177  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
178  fvbCrobActiveFlag[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
179  fviFebModuleIdx[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
180  fviFebModuleSide[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
181  fviFebType[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
182  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
183  ++uCrobIdx) {
184  fvbCrobActiveFlag[uDpb][uCrobIdx] =
185  fUnpackPar->IsCrobActive(uDpb, uCrobIdx);
186 
187  fviFebModuleIdx[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob());
188  fviFebModuleSide[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob());
189  fviFebType[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob(), -1);
190  for (UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob();
191  ++uFebIdx) {
192  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx] =
193  fUnpackPar->GetFebModuleIdx(uDpb, uCrobIdx, uFebIdx);
194  fviFebModuleSide[uDpb][uCrobIdx][uFebIdx] =
195  fUnpackPar->GetFebModuleSide(uDpb, uCrobIdx, uFebIdx);
196  fvdFebAdcGain.push_back(
197  fUnpackPar->GetFebAdcGain(uDpb, uCrobIdx, uFebIdx));
198  fvdFebAdcOffs.push_back(
199  fUnpackPar->GetFebAdcOffset(uDpb, uCrobIdx, uFebIdx));
200 
201  if (0 <= fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]
202  && static_cast<UInt_t>(fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx])
203  < fuNbModules
204  && 0 <= fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]
205  && fviFebModuleSide[uDpb][uCrobIdx][uFebIdx] < 2) {
206  switch (fviModuleType[fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]]) {
207  case 0: // FEB-8-1 with ZIF connector on the right
208  {
209  // P side (0) has type A (0)
210  // N side (1) has type B (1)
211  fviFebType[uDpb][uCrobIdx][uFebIdx] =
212  fviFebModuleSide[uDpb][uCrobIdx][uFebIdx];
213 
220  fviFebAddress.push_back(
221  fviModAddress[fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]]
222  + (fviFebModuleSide[uDpb][uCrobIdx][uFebIdx] << 25));
223  fviFebSide.push_back(fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]);
224  break;
225  } // case 0: // FEB-8-1 with ZIF connector on the right
226  case 1: // FEB-8-1 with ZIF connector on the left
227  {
228  // P side (0) has type B (1)
229  // N side (1) has type A (0)
230  fviFebType[uDpb][uCrobIdx][uFebIdx] =
231  !(fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]);
232 
239  fviFebAddress.push_back(
240  fviModAddress[fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]]
241  + ((!fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]) << 25));
242  fviFebSide.push_back(fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]);
243  break;
244  } // case 1: // FEB-8-1 with ZIF connector on the left
245  default:
246  LOG(fatal) << Form(
247  "Bad module type for DPB #%02u CROB #%u FEB %02u: %d",
248  uDpb,
249  uCrobIdx,
250  uFebIdx,
251  fviModuleType[fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]]);
252  break;
253  } // switch( fviModuleType[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ] )
254  } // FEB active and module index OK
255  else if (-1 == fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]
256  || -1 == fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]) {
257  fviFebAddress.push_back(0);
258  fviFebSide.push_back(-1);
259  } // Module index or type is set to inactive
260  else {
261  LOG(fatal) << Form("Bad module Index and/or Side for DPB #%02u CROB "
262  "#%u FEB %02u: %d %d",
263  uDpb,
264  uCrobIdx,
265  uFebIdx,
266  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx],
267  fviFebModuleSide[uDpb][uCrobIdx][uFebIdx]);
268  } // Bad module index or type for this FEB
269  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
270  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
271  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
272 
273  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
274  TString sPrintoutLine = Form("DPB #%02u CROB Active ?: ", uDpb);
275  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
276  ++uCrobIdx) {
277  sPrintoutLine +=
278  Form("%1u", (fvbCrobActiveFlag[uDpb][uCrobIdx] == kTRUE));
279  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
280  LOG(info) << sPrintoutLine;
281  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
282 
283  UInt_t uGlobalFebIdx = 0;
284  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
285  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
286  ++uCrobIdx) {
287  LOG(info) << Form("DPB #%02u CROB #%u: ", uDpb, uCrobIdx);
288  for (UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob();
289  ++uFebIdx) {
290  if (0 <= fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx])
291  LOG(info) << Form(
292  " FEB #%02u (%02u): Mod. Idx = %03d Side %c (%2d) Type %c "
293  "(%2d) (Addr. 0x%08x) ADC gain %4.0f e- ADC Offs %5.0f e-",
294  uFebIdx,
295  uGlobalFebIdx,
296  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx],
297  1 == fviFebModuleSide[uDpb][uCrobIdx][uFebIdx] ? 'N' : 'P',
298  fviFebModuleSide[uDpb][uCrobIdx][uFebIdx],
299  1 == fviFebType[uDpb][uCrobIdx][uFebIdx] ? 'B' : 'A',
300  fviFebType[uDpb][uCrobIdx][uFebIdx],
301  fviFebAddress[uGlobalFebIdx],
302  fvdFebAdcGain[uGlobalFebIdx],
303  fvdFebAdcOffs[uGlobalFebIdx]);
304  else
305  LOG(info) << Form(
306  "Disabled FEB #%02u (%02u): Mod. Idx = %03d Side %c (%2d) Type %c "
307  "(%2d) (Addr. 0x%08x) ADC gain %4.0f e- ADC Offs %5.0f e-",
308  uFebIdx,
309  uGlobalFebIdx,
310  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx],
311  1 == fviFebModuleSide[uDpb][uCrobIdx][uFebIdx] ? 'N' : 'P',
312  fviFebModuleSide[uDpb][uCrobIdx][uFebIdx],
313  1 == fviFebType[uDpb][uCrobIdx][uFebIdx] ? 'B' : 'A',
314  fviFebType[uDpb][uCrobIdx][uFebIdx],
315  fviFebAddress[uGlobalFebIdx],
316  fvdFebAdcGain[uGlobalFebIdx],
317  fvdFebAdcOffs[uGlobalFebIdx]);
318  uGlobalFebIdx++;
319  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
320  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
321  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
322 
323  if (fbBinningFw)
324  LOG(info) << "Unpacking data in bin sorter FW mode";
325  else
326  LOG(info) << "Unpacking data in full time sorter FW mode (legacy)";
327 
328  // Internal status initialization
329  fvulCurrentTsMsb.resize(fuNrOfDpbs);
330  fvuCurrentTsMsbCycle.resize(fuNrOfDpbs);
331  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
332  fvulCurrentTsMsb[uDpb] = 0;
333  fvuCurrentTsMsbCycle[uDpb] = 0;
334  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
335 
336  fvvusLastTsChan.resize(fuNbStsXyters);
337  fvvusLastAdcChan.resize(fuNbStsXyters);
338  fvvusLastTsMsbChan.resize(fuNbStsXyters);
339  fvvusLastTsMsbCycleChan.resize(fuNbStsXyters);
340  for (UInt_t uAsicIdx = 0; uAsicIdx < fuNbStsXyters; ++uAsicIdx) {
341  fvvusLastTsChan[uAsicIdx].resize(fUnpackPar->GetNbChanPerAsic(), 0);
342  fvvusLastAdcChan[uAsicIdx].resize(fUnpackPar->GetNbChanPerAsic(), 0);
343  fvvusLastTsMsbChan[uAsicIdx].resize(fUnpackPar->GetNbChanPerAsic(), 0);
344  fvvusLastTsMsbCycleChan[uAsicIdx].resize(fUnpackPar->GetNbChanPerAsic(), 0);
345  } // for( UInt_t uAsicIdx = 0; uAsicIdx < fuNbStsXyters; ++ uAsicIdx )
346 
347  return kTRUE;
348 }
349 // -------------------------------------------------------------------------
350 
351 void CbmMcbm2018UnpackerAlgoSts::AddMsComponentToList(size_t component,
352  UShort_t usDetectorId) {
354  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
355  if (component == fvMsComponentsList[uCompIdx]) return;
356 
358  fvMsComponentsList.push_back(component);
359 
360  LOG(info) << "CbmMcbm2018UnpackerAlgoSts::AddMsComponentToList => Component "
361  << component << " with detector ID 0x" << std::hex << usDetectorId
362  << std::dec << " added to list";
363 }
364 // -------------------------------------------------------------------------
365 
366 Bool_t CbmMcbm2018UnpackerAlgoSts::ProcessTs(const fles::Timeslice& ts) {
367  fulCurrentTsIdx = ts.index();
368  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
369 
371  if (0 == fulCurrentTsIdx) { return kTRUE; } // if( 0 == fulCurrentTsIdx )
372 
374  if (-1.0 == fdTsCoreSizeInNs) {
375  fuNbCoreMsPerTs = ts.num_core_microslices();
376  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
377  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
378  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
379  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
380  << " Core MS and " << fuNbOverMsPerTs
381  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
382  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
383 
385  fuNbMsLoop = fuNbCoreMsPerTs;
386  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
387  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
388  } // if( -1.0 == fdTsCoreSizeInNs )
389 
391  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
392  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
393 
395  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
397  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
398  ++uMsCompIdx) {
399  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
400 
401  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
402  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
403  << fuMsIndex << " for component " << uMsComp;
404  return kFALSE;
405  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
406  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
407 
410  // std::sort( fvmHitsInMs.begin(), fvmHitsInMs.end() );
411 
413  for (auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end();
414  ++itHitIn) {
415  /*
416  UInt_t uFebIdx = itHitIn->GetAsic() / fUnpackPar->GetNbAsicsPerFeb()
417  + ( itHitIn->GetDpb() * fUnpackPar->GetNbCrobsPerDpb() + itHitIn->GetCrob() )
418  * fUnpackPar->GetNbFebsPerCrob();
419 */
420  UInt_t uAsicIdx = itHitIn->GetAsic();
421  UInt_t uFebIdx = itHitIn->GetAsic() / fUnpackPar->GetNbAsicsPerFeb();
422  UInt_t uChanInMod =
423  itHitIn->GetChan()
424  + fUnpackPar->GetNbChanPerAsic()
425  * (itHitIn->GetAsic() % fUnpackPar->GetNbAsicsPerFeb());
429  if (0 == fviFebSide[uFebIdx])
430  uChanInMod =
431  fUnpackPar->GetNbChanPerFeb() - uChanInMod
432  - 1 // Invert channel order
433  + fUnpackPar->GetNbChanPerFeb(); // Offset for P (back) side
434 
435  Double_t dTimeInNs =
436  itHitIn->GetTs() * stsxyter::kdClockCycleNs - fdTimeOffsetNs;
437  if (uAsicIdx < fvdTimeOffsetNsAsics.size())
438  dTimeInNs -= fvdTimeOffsetNsAsics[uAsicIdx];
439  ULong64_t ulTimeInNs = static_cast<ULong64_t>(dTimeInNs);
440 
441  Double_t dCalAdc = fvdFebAdcOffs[uFebIdx]
442  + (itHitIn->GetAdc() - 1) * fvdFebAdcGain[uFebIdx];
443 
444  if (0 == fviFebAddress[uFebIdx] || -1 == fviFebSide[uFebIdx]) {
445  LOG(error) << Form(
446  "Digi on disabled FEB %02u has address 0x%08x and side %d",
447  uFebIdx,
448  fviFebAddress[uFebIdx],
449  fviFebSide[uFebIdx]);
450  } // if( 0 == fviFebAddress[ uFebIdx ] || -1 == fviFebSide[ uFebIdx ] )
451 
452  fDigiVect.emplace_back(
453  fviFebAddress[uFebIdx], uChanInMod, ulTimeInNs, dCalAdc);
454  } // for( auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end(); ++itHitIn )
455 
457  fvmHitsInMs.clear();
458  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
459 
461  fvmHitsInMs.clear();
462  /*
463  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
464  {
465  fvmHitsInMs[ uDpb ].clear();
466  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
467 */
468 
470  std::sort(fDigiVect.begin(),
471  fDigiVect.end(),
472  [](const CbmStsDigi& a, const CbmStsDigi& b) -> bool {
473  return a.GetTime() < b.GetTime();
474  });
475 
477  if (fbMonitorMode) {
478  if (kFALSE == FillHistograms()) {
479  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx;
480  return kFALSE;
481  } // if( kFALSE == FillHistograms() )
482 
483  fhVectorSize->Fill(fulCurrentTsIdx, fDigiVect.size());
484  fhVectorCapacity->Fill(fulCurrentTsIdx, fDigiVect.capacity());
485  } // if( fbMonitorMode )
486 
487  if (fuTsMaxVectorSize < fDigiVect.size()) {
488  fuTsMaxVectorSize = fDigiVect.size() * fdCapacityIncFactor;
489  fDigiVect.shrink_to_fit();
490  fDigiVect.reserve(fuTsMaxVectorSize);
491  } // if( fuTsMaxVectorSize < fDigiVect.size() )
492 
493  return kTRUE;
494 }
495 
496 Bool_t CbmMcbm2018UnpackerAlgoSts::ProcessMs(const fles::Timeslice& ts,
497  size_t uMsCompIdx,
498  size_t uMsIdx) {
499  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
500  fuCurrentEquipmentId = msDescriptor.eq_id;
501  const uint8_t* msContent =
502  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
503 
504  uint32_t uSize = msDescriptor.size;
505  fulCurrentMsIdx = msDescriptor.idx;
506  // Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
507  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
508  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
509 
510  if (0 == fvbMaskedComponents.size())
511  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
512 
513  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
514  // fuCurrDpbIdx = fDpbIdIndexMap[ fuCurrDpbId ];
515 
517  auto it = fDpbIdIndexMap.find(fuCurrDpbId);
518  if (it == fDpbIdIndexMap.end()) {
519  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
520  LOG(info)
521  << "---------------------------------------------------------------";
522  /*
523  LOG(info) << "hi hv eqid flag si sv idx/start crc size offset";
524  LOG(info) << Form( "%02x %02x %04x %04x %02x %02x %016llx %08x %08x %016llx",
525  static_cast<unsigned int>(msDescriptor.hdr_id),
526  static_cast<unsigned int>(msDescriptor.hdr_ver), msDescriptor.eq_id, msDescriptor.flags,
527  static_cast<unsigned int>(msDescriptor.sys_id),
528  static_cast<unsigned int>(msDescriptor.sys_ver), msDescriptor.idx, msDescriptor.crc,
529  msDescriptor.size, msDescriptor.offset );
530 */
531  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
532  LOG(warning) << "Could not find the sDPB index for AFCK id 0x" << std::hex
533  << fuCurrDpbId << std::dec << " in timeslice "
534  << fulCurrentTsIdx << " in microslice " << uMsIdx
535  << " component " << uMsCompIdx << "\n"
536  << "If valid this index has to be added in the STS "
537  "parameter file in the DbpIdArray field";
538  fvbMaskedComponents[uMsCompIdx] = kTRUE;
539 
542  if (1 == fulCurrentTsIdx) return kTRUE;
543  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
544  else
545  return kTRUE;
546 
547  return kFALSE;
548  } // if( it == fDpbIdIndexMap.end() )
549  else
550  fuCurrDpbIdx = fDpbIdIndexMap[fuCurrDpbId];
551 
552  if (fbMonitorMode || fbDebugMonitorMode)
553  fhMsCntEvo->Fill(fulCurrentMsIdx * 1e-9);
554 
556  UInt_t uTsMsbCycleHeader = std::floor(
557  fulCurrentMsIdx / (stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs));
558 
560  if (kTRUE == fbBinningFw)
561  uTsMsbCycleHeader = std::floor(
562  fulCurrentMsIdx
563  / (stsxyter::kulTsCycleNbBinsBinning * stsxyter::kdClockCycleNs));
564 
565  if (0 == uMsIdx) {
566  if (uTsMsbCycleHeader != fvuCurrentTsMsbCycle[fuCurrDpbIdx])
567  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
568  << std::setw(12) << fulCurrentMsIdx << " MS Idx "
569  << std::setw(4) << uMsIdx << " Msg Idx " << std::setw(5) << 0
570  << " DPB " << std::setw(2) << fuCurrDpbIdx << " Old TsMsb "
571  << std::setw(5) << fvulCurrentTsMsb[fuCurrDpbIdx]
572  << " Old MsbCy " << std::setw(5)
573  << fvuCurrentTsMsbCycle[fuCurrDpbIdx] << " New MsbCy "
574  << uTsMsbCycleHeader;
575  fvuCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
576  fvulCurrentTsMsb[fuCurrDpbIdx] = 0;
577  } // if( 0 == uMsIdx )
578  else if (uTsMsbCycleHeader != fvuCurrentTsMsbCycle[fuCurrDpbIdx]) {
579  if (4194303 == fvulCurrentTsMsb[fuCurrDpbIdx]) {
580  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
581  << std::setw(12) << fulCurrentMsIdx << " MS Idx "
582  << std::setw(4) << uMsIdx << " Msg Idx " << std::setw(5) << 0
583  << " DPB " << std::setw(2) << fuCurrDpbIdx << " Old TsMsb "
584  << std::setw(5) << fvulCurrentTsMsb[fuCurrDpbIdx]
585  << " Old MsbCy " << std::setw(5)
586  << fvuCurrentTsMsbCycle[fuCurrDpbIdx] << " New MsbCy "
587  << uTsMsbCycleHeader;
588  } else {
589  LOG(warning)
590  << "TS MSB cycle from MS header does not match current cycle from data "
591  << "for TS " << std::setw(12) << fulCurrentTsIdx << " MS "
592  << std::setw(12) << fulCurrentMsIdx << " MsInTs " << std::setw(3)
593  << uMsIdx << " ====> " << fvuCurrentTsMsbCycle[fuCurrDpbIdx]
594  << " (cnt) VS " << uTsMsbCycleHeader << " (header)";
595  } // else of if( 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx] )
596  fvuCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
597  } // else if( uTsMsbCycleHeader != fvuCurrentTsMsbCycle[ fuCurrDpbIdx ] )
598 
599  // If not integer number of message in input buffer, print warning/error
600  if (0 != (uSize % sizeof(stsxyter::Message)))
601  LOG(error) << "The input microslice buffer does NOT "
602  << "contain only complete sDPB messages!";
603 
604  // Compute the number of complete messages in the input microslice buffer
605  uint32_t uNbMessages =
606  (uSize - (uSize % sizeof(stsxyter::Message))) / sizeof(stsxyter::Message);
607 
608  // std::vector< uint32_t > vNbMessType( 7, 0 );
609  // std::string sMessPatt = "";
610  // bool bError = false;
611 
612  // Prepare variables for the loop on contents
613  const stsxyter::Message* pMess =
614  reinterpret_cast<const stsxyter::Message*>(msContent);
615  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
617  stsxyter::MessType typeMess = pMess[uIdx].GetMessType();
618  fmMsgCounter[typeMess]++;
619  // fhStsMessType->Fill( static_cast< uint16_t > (typeMess) );
620  // fhStsMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) );
621 
622  switch (typeMess) {
623  case stsxyter::MessType::Hit: {
624  // ++vNbMessType[0];
625  // sMessPatt += " H ";
626  // sMessPatt += ".";
627 
628  // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
629  UShort_t usElinkIdx = pMess[uIdx].GetLinkIndex();
631  if (kTRUE == fbBinningFw)
632  usElinkIdx = pMess[uIdx].GetLinkIndexHitBinning();
633  // fhStsMessTypePerElink->Fill( usElinkIdx, static_cast< uint16_t > (typeMess) );
634  // fhStsHitsElinkPerDpb->Fill( fuCurrDpbIdx, usElinkIdx );
635 
636  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
637  Int_t uFebIdx = fUnpackPar->ElinkIdxToFebIdx(usElinkIdx);
638 
639  if (-1 == uFebIdx) {
640  LOG(warning) << "CbmMcbm2018UnpackerAlgoSts::DoUnpack => "
641  << "Wrong elink Idx! Elink raw "
642  << Form("%d remap %d", usElinkIdx, uFebIdx);
643  continue;
644  } // if( -1 == uFebIdx )
645 
646  UInt_t uAsicIdx =
647  (fuCurrDpbIdx * fUnpackPar->GetNbCrobsPerDpb() + uCrobIdx)
648  * fUnpackPar->GetNbAsicsPerCrob()
649  + fUnpackPar->ElinkIdxToAsicIdx(
650  1 == fviFebType[fuCurrDpbIdx][uCrobIdx][uFebIdx], usElinkIdx);
651 
652  ProcessHitInfo(pMess[uIdx], usElinkIdx, uAsicIdx, uMsIdx);
653  break;
654  } // case stsxyter::MessType::Hit :
655  case stsxyter::MessType::TsMsb: {
656  // ++vNbMessType[1];
657  // sMessPatt += " T ";
658 
659  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
660 
661  ProcessTsMsbInfo(pMess[uIdx], uIdx, uMsIdx);
662  break;
663  } // case stsxyter::MessType::TsMsb :
664  case stsxyter::MessType::Epoch: {
665  // ++vNbMessType[2];
666  // sMessPatt += " E ";
667 
668  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
669 
670  // The first message in the TS is a special ones: EPOCH
671  ProcessEpochInfo(pMess[uIdx]);
672 
673  if (0 < uIdx)
674  LOG(info) << "CbmMcbm2018UnpackerAlgoSts::DoUnpack => "
675  << "EPOCH message at unexpected position in MS: message "
676  << uIdx << " VS message 0 expected!";
677  break;
678  } // case stsxyter::MessType::TsMsb :
679  case stsxyter::MessType::Status: {
680  // ++vNbMessType[3];
681  // sMessPatt += " S ";
682 
683  // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
684  UShort_t usElinkIdx = pMess[uIdx].GetStatusLink();
685 
686  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
687  Int_t uFebIdx = fUnpackPar->ElinkIdxToFebIdx(usElinkIdx);
688 
689  if (-1 == uFebIdx) {
690  LOG(warning) << "CbmMcbm2018UnpackerAlgoSts::DoUnpack => "
691  << "Wrong elink Idx! Elink raw "
692  << Form("%d remap %d", usElinkIdx, uFebIdx);
693  continue;
694  } // if( -1 == uFebIdx )
695  UInt_t uAsicIdx =
696  (fuCurrDpbIdx * fUnpackPar->GetNbCrobsPerDpb() + uCrobIdx)
697  * fUnpackPar->GetNbAsicsPerCrob()
698  + fUnpackPar->ElinkIdxToAsicIdx(
699  1 == fviFebType[fuCurrDpbIdx][uCrobIdx][uFebIdx], usElinkIdx);
700 
701  ProcessStatusInfo(pMess[uIdx], uAsicIdx);
702  break;
703  } // case stsxyter::MessType::Status
704  case stsxyter::MessType::Empty: {
705  // ++vNbMessType[4];
706  // sMessPatt += " Em";
707 
708  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
709  // FillTsMsbInfo( pMess[uIdx] );
710  break;
711  } // case stsxyter::MessType::Empty :
712  case stsxyter::MessType::EndOfMs: {
713  // ++vNbMessType[5];
714  // sMessPatt += " En";
715  // bError = pMess[uIdx].IsMsErrorFlagOn();
716 
717  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
718  // FillTsMsbInfo( pMess[uIdx] );
719  if (pMess[uIdx].IsMsErrorFlagOn()) {
720  if (fbMonitorMode || fbDebugMonitorMode)
721  fhMsErrorsEvo->Fill(1e-9 * fulCurrentMsIdx,
722  pMess[uIdx].GetMsErrorType());
723  fErrVect.push_back(CbmErrorMessage(ECbmModuleId::kSts,
724  fulCurrentMsIdx,
725  fuCurrDpbIdx,
726  0x20,
727  pMess[uIdx].GetMsErrorType()));
728  } // if( pMess[uIdx].IsMsErrorFlagOn() )
729  break;
730  } // case stsxyter::MessType::EndOfMs :
731  case stsxyter::MessType::Dummy: {
732  // ++vNbMessType[6];
733  // sMessPatt += " D ";
734 
735  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
736  break;
737  } // case stsxyter::MessType::Dummy / ReadDataAck / Ack :
738  default: {
739  LOG(fatal) << "CbmMcbm2018UnpackerAlgoSts::DoUnpack => "
740  << "Unknown message type, should never happen, stopping "
741  "here! Type found was: "
742  << static_cast<int>(typeMess);
743  }
744  } // switch( typeMess )
745  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
746 
747  // if( 18967040000 == fulCurrentMsIdx || 18968320000 == fulCurrentMsIdx )
748  // LOG( info ) << sMessPatt;
749 
750  /*
751  if( static_cast< uint16_t >( fles::MicrosliceFlags::CrcValid ) != msDescriptor.flags )
752  {
753  LOG(info) << "STS unp "
754  << " TS " << std::setw( 12 ) << fulCurrentTsIdx
755  << " MS " << std::setw( 12 ) << fulCurrentMsIdx
756  << " MS flags 0x" << std::setw( 4 ) << std::hex << msDescriptor.flags << std::dec
757  << " Size " << std::setw( 8 ) << uSize << " bytes "
758  << " H " << std::setw( 5 ) << vNbMessType[0]
759  << " T " << std::setw( 5 ) << vNbMessType[1]
760  << " E " << std::setw( 5 ) << vNbMessType[2]
761  << " S " << std::setw( 5 ) << vNbMessType[3]
762  << " Em " << std::setw( 5 ) << vNbMessType[4]
763  << " En " << std::setw( 5 ) << vNbMessType[5]
764  << " D " << std::setw( 5 ) << vNbMessType[6]
765  << " Err " << bError
766  << " Undet. bad " << ( !bError && 400 != vNbMessType[1] );
767  } // if( MicrosliceFlags::CrcValid != msDescriptor.flags )
768 */
769  return kTRUE;
770 }
771 
772 // -------------------------------------------------------------------------
773 void CbmMcbm2018UnpackerAlgoSts::ProcessHitInfo(const stsxyter::Message& mess,
774  const UShort_t& usElinkIdx,
775  const UInt_t& uAsicIdx,
776  const UInt_t& /*uMsIdx*/) {
777  UShort_t usChan = mess.GetHitChannel();
778  UShort_t usRawAdc = mess.GetHitAdc();
779  // UShort_t usFullTs = mess.GetHitTimeFull();
780  // UShort_t usTsOver = mess.GetHitTimeOver();
781  UShort_t usRawTs = mess.GetHitTime();
782 
784  if (kTRUE == fbBinningFw) usRawTs = mess.GetHitTimeBinning();
785 
787  // usChan = 127 - usChan;
788 
789  /*
790  fhStsChanCntRaw[ uAsicIdx ]->Fill( usChan );
791  fhStsChanAdcRaw[ uAsicIdx ]->Fill( usChan, usRawAdc );
792  fhStsChanAdcRawProf[ uAsicIdx ]->Fill( usChan, usRawAdc );
793  fhStsChanRawTs[ uAsicIdx ]->Fill( usChan, usRawTs );
794  fhStsChanMissEvt[ uAsicIdx ]->Fill( usChan, mess.IsHitMissedEvts() );
795 */
796  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
797  UInt_t uFebIdx = uAsicIdx / fUnpackPar->GetNbAsicsPerFeb();
798  // UInt_t uAsicInFeb = uAsicIdx % fUnpackPar->GetNbAsicsPerFeb();
799  UInt_t uChanInFeb = usChan
800  + fUnpackPar->GetNbChanPerAsic()
801  * (uAsicIdx % fUnpackPar->GetNbAsicsPerFeb());
802 
804  if (
805  usRawTs == fvvusLastTsChan[uAsicIdx][usChan] &&
806  // usRawAdc == fvvusLastAdcChan[ uAsicIdx ][ usChan ] &&
807  fvulCurrentTsMsb[fuCurrDpbIdx] - fvvusLastTsMsbChan[uAsicIdx][usChan]
808  < kuMaxTsMsbDiffDuplicates
809  && fvuCurrentTsMsbCycle[fuCurrDpbIdx]
810  == fvvusLastTsMsbCycleChan[uAsicIdx][usChan]) {
812  return;
813  } // if SMX 2.0 DPB and same TS, ADC, TS MSB, TS MSB cycle!
814  fvvusLastTsChan[uAsicIdx][usChan] = usRawTs;
815  fvvusLastAdcChan[uAsicIdx][usChan] = usRawAdc;
816  fvvusLastTsMsbChan[uAsicIdx][usChan] = fvulCurrentTsMsb[fuCurrDpbIdx];
817  fvvusLastTsMsbCycleChan[uAsicIdx][usChan] =
818  fvuCurrentTsMsbCycle[fuCurrDpbIdx];
819 
820  /*
821  fhStsFebChanCntRaw[ uFebIdx ]->Fill( uChanInFeb );
822  fhStsFebChanAdcRaw[ uFebIdx ]->Fill( uChanInFeb, usRawAdc );
823  fhStsFebChanAdcRawProf[ uFebIdx ]->Fill( uChanInFeb, usRawAdc );
824  fhStsFebChanAdcCal[ uFebIdx ]->Fill( uChanInFeb, dCalAdc );
825  fhStsFebChanAdcCalProf[ uFebIdx ]->Fill( uChanInFeb, dCalAdc );
826  fhStsFebChanRawTs[ uFebIdx ]->Fill( usChan, usRawTs );
827  fhStsFebChanMissEvt[ uFebIdx ]->Fill( usChan, mess.IsHitMissedEvts() );
828 */
829 
830  // Compute the Full time stamp
831  // Use TS w/o overlap bits as they will anyway come from the TS_MSB
832  Long64_t ulHitTime = usRawTs;
833  ulHitTime += static_cast<ULong64_t>(stsxyter::kuHitNbTsBins)
834  * static_cast<ULong64_t>(fvulCurrentTsMsb[fuCurrDpbIdx])
835  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
836  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle[fuCurrDpbIdx]);
837 
839  if (kTRUE == fbBinningFw)
840  ulHitTime =
841  usRawTs
842  + static_cast<ULong64_t>(stsxyter::kuHitNbTsBinsBinning)
843  * static_cast<ULong64_t>(fvulCurrentTsMsb[fuCurrDpbIdx])
844  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBinsBinning)
845  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle[fuCurrDpbIdx]);
846 
847  // Convert the Hit time in bins to Hit time in ns
848  Double_t dHitTimeNs = ulHitTime * stsxyter::kdClockCycleNs;
849  /*
850  if( 3 == uAsicIdx && 32 == usChan && 10 < usRawAdc )
851  {
852 
853  LOG(info) << "; TS; " << std::setw( 12 ) << fulCurrentTsIdx
854  << "; MS; " << std::setw( 12 ) << fulCurrentMsIdx
855  << "; time; " << std::setw( 12 ) << dHitTimeNs
856  << "; time to MS; " << std::setw( 12 ) << (dHitTimeNs / fulCurrentMsIdx)
857  << "; time; " << std::setw( 12 ) << ulHitTime
858  << "; TS; " << std::setw( 4 ) << usRawTs
859  << "; MSB; " << std::setw( 12 ) << fvulCurrentTsMsb[fuCurrDpbIdx]
860  << "; Cy; " << std::setw( 4 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx]
861  << "; dt; " << std::setw( 12 ) << dHitTimeNs - fdTimeA - 20971600;
862 
863  if( 0.0 < fdTimeA )
864  fhPulserVsTsAB->Fill( fusTsA, usRawTs, dHitTimeNs - fdTimeA - 20971600 );
865 
866  fusTsA = usRawTs;
867  fdTimeA = dHitTimeNs;
868  } // if( 3 == uAsicIdx && 32 == usChan && 10 < usRawAdc )
869 */
871  if (0 != fviFebAddress[uFebIdx] && fdAdcCut < usRawAdc) {
874  if (kFALSE == fbUseChannelMask
875  || false == fvvbMaskedChannels[uFebIdx][uChanInFeb])
876  fvmHitsInMs.push_back(stsxyter::FinalHit(
877  ulHitTime, usRawAdc, uAsicIdx, usChan, fuCurrDpbIdx, uCrobIdx));
878  } // if( 0 != fviFebAddress[ uFebIdx ] )
879 
881  if (mess.IsHitMissedEvts())
882  fErrVect.push_back(CbmErrorMessage(ECbmModuleId::kSts,
883  dHitTimeNs,
884  uAsicIdx,
885  1 << stsxyter::kusLenStatStatus,
886  usChan));
887 
888  // Check Starting point of histos with time as X axis
889  if (-1 == fdStartTime) fdStartTime = dHitTimeNs;
890  /*
891  // Fill histos with time as X axis
892  Double_t dTimeSinceStartSec = (dHitTimeNs - fdStartTime)* 1e-9;
893  Double_t dTimeSinceStartMin = dTimeSinceStartSec / 60.0;
894 
895  fviFebCountsSinceLastRateUpdate[uFebIdx]++;
896  fvdFebChanCountsSinceLastRateUpdate[uFebIdx][uChanInFeb] += 1;
897 
898  fhStsFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
899  fhStsFebAsicHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb );
900  fhStsFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
901  fhStsFebChanHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uChanInFeb, 1.0/60.0 );
902  fhStsFebAsicHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uAsicInFeb, 1.0/60.0 );
903  fhStsFebHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, 1.0/60.0 );
904  if( mess.IsHitMissedEvts() )
905  {
906  fhStsFebChanMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
907  fhStsFebAsicMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb );
908  fhStsFebMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
909  } // if( mess.IsHitMissedEvts() )
910 */
911  /*
912  if( kTRUE == fbLongHistoEnable )
913  {
914  std::chrono::steady_clock::time_point tNow = std::chrono::steady_clock::now();
915  Double_t dUnixTimeInRun = std::chrono::duration_cast< std::chrono::seconds >(tNow - ftStartTimeUnix).count();
916  fhFebRateEvoLong[ uAsicIdx ]->Fill( dUnixTimeInRun , 1.0 / fuLongHistoBinSizeSec );
917  fhFebChRateEvoLong[ uAsicIdx ]->Fill( dUnixTimeInRun , usChan, 1.0 / fuLongHistoBinSizeSec );
918  } // if( kTRUE == fbLongHistoEnable )
919 */
920 }
921 
922 void CbmMcbm2018UnpackerAlgoSts::ProcessTsMsbInfo(const stsxyter::Message& mess,
923  UInt_t uMessIdx,
924  UInt_t uMsIdx) {
925  UInt_t uVal = mess.GetTsMsbVal();
926 
928  if (kTRUE == fbBinningFw) uVal = mess.GetTsMsbValBinning();
929 
930  /*
931  if( (uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1) && 0 < uVal &&
932  !( 1 == uMessIdx && usVal == fvulCurrentTsMsb[fuCurrDpbIdx] ) ) // 1st TS_MSB in MS is always a repeat of the last one in previous MS!
933  {
934  LOG(info) << "TS MSB not increasing by 1! TS " << std::setw( 12 ) << fulCurrentTsIdx
935  << " MS " << std::setw( 12 ) << fulCurrentMsIdx
936  << " MsInTs " << std::setw( 3 ) << uMsIdx
937  << " DPB " << std::setw( 2 ) << fuCurrDpbIdx
938  << " Mess " << std::setw( 5 ) << uMessIdx
939  << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx]
940  << " new TsMsb " << std::setw( 5 ) << uVal
941  << " Diff " << std::setw( 5 ) << uVal - fvulCurrentTsMsb[fuCurrDpbIdx]
942  << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx];
943  } // if( (uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1) && 0 < uVal )
944 */
945 
946  // Update Status counters
947  if (uVal < fvulCurrentTsMsb[fuCurrDpbIdx]) {
948 
949  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
950  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
951  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB "
952  << std::setw(2) << fuCurrDpbIdx << " Old TsMsb " << std::setw(5)
953  << fvulCurrentTsMsb[fuCurrDpbIdx] << " Old MsbCy " << std::setw(5)
954  << fvuCurrentTsMsbCycle[fuCurrDpbIdx] << " new TsMsb "
955  << std::setw(5) << uVal;
956 
957  fvuCurrentTsMsbCycle[fuCurrDpbIdx]++;
958  } // if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
959  if (
960  uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1
961  && !(0 == uVal && 4194303 == fvulCurrentTsMsb[fuCurrDpbIdx])
962  &&
963  1 != uMessIdx &&
964  !(0 == uVal && 0 == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx)
965  &&
966  !(uVal == fvulCurrentTsMsb[fuCurrDpbIdx] && 2 == uMessIdx)
967  &&
968  uVal < fvulCurrentTsMsb
969  [fuCurrDpbIdx]
970  ) {
971  LOG(info) << "TS MSb Jump in "
972  << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
973  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
974  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB "
975  << std::setw(2) << fuCurrDpbIdx << " => Old TsMsb "
976  << std::setw(5) << fvulCurrentTsMsb[fuCurrDpbIdx] << " new TsMsb "
977  << std::setw(5) << uVal;
978  } // if( uVal + 1 != fvulCurrentTsMsb[fuCurrDpbIdx] && 4194303 != uVal && 0 != fvulCurrentTsMsb[fuCurrDpbIdx] )
979 
982  if (4194303 == uVal && 1 == uMessIdx)
983  fvulCurrentTsMsb[fuCurrDpbIdx] = 0;
984  else
985  fvulCurrentTsMsb[fuCurrDpbIdx] = uVal;
986  /*
987  if( 1 < uMessIdx )
988  {
989  fhStsDpbRawTsMsb->Fill( fuCurrDpbIdx, fvulCurrentTsMsb[fuCurrDpbIdx] );
990  fhStsDpbRawTsMsbSx->Fill( fuCurrDpbIdx, ( fvulCurrentTsMsb[fuCurrDpbIdx] & 0x1F ) );
991  fhStsDpbRawTsMsbDpb->Fill( fuCurrDpbIdx, ( fvulCurrentTsMsb[fuCurrDpbIdx] >> 5 ) );
992  } // if( 0 < uMessIdx )
993 */
994  // fhStsAsicTsMsb->Fill( fvulCurrentTsMsb[fuCurrDpbIdx], uAsicIdx );
995  /*
996  ULong64_t ulNewTsMsbTime = static_cast< ULong64_t >( stsxyter::kuHitNbTsBins )
997  * static_cast< ULong64_t >( fvulCurrentTsMsb[fuCurrDpbIdx])
998  + static_cast< ULong64_t >( stsxyter::kulTsCycleNbBins )
999  * static_cast< ULong64_t >( fvuCurrentTsMsbCycle[fuCurrDpbIdx] );
1000 */
1001 }
1002 
1003 void CbmMcbm2018UnpackerAlgoSts::ProcessEpochInfo(
1004  const stsxyter::Message& /*mess*/) {
1005  // UInt_t uVal = mess.GetEpochVal();
1006  // UInt_t uCurrentCycle = uVal % stsxyter::kulTsCycleNbBins;
1007 
1008  /*
1009  // Update Status counters
1010  if( usVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
1011  fvuCurrentTsMsbCycle[fuCurrDpbIdx] ++;
1012  fvulCurrentTsMsb[fuCurrDpbIdx] = usVal;
1013 
1014 // fhStsAsicTsMsb->Fill( fvulCurrentTsMsb[fuCurrDpbIdx], uAsicIdx );
1015 */
1016 }
1017 
1018 void CbmMcbm2018UnpackerAlgoSts::ProcessStatusInfo(
1019  const stsxyter::Message& mess,
1020  const UInt_t& uAsicIdx) {
1021  /*
1022  UShort_t usStatusField = mess.GetStatusStatus();
1023 
1024  fhPulserStatusMessType->Fill( uAsicIdx, usStatusField );
1026  if( fbPrintMessages )
1027  {
1028  std::cout << Form("DPB %2u TS %12u MS %12u mess %5u ", fuCurrDpbIdx, fulCurrentTsIdx, fulCurrentMsIdx, uIdx );
1029  mess.PrintMess( std::cout, fPrintMessCtrl );
1030  } // if( fbPrintMessages )
1031 */
1034  Long64_t ulTime =
1035  static_cast<ULong64_t>(stsxyter::kuHitNbTsBins)
1036  * static_cast<ULong64_t>(fvulCurrentTsMsb[fuCurrDpbIdx])
1037  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
1038  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle[fuCurrDpbIdx]);
1039 
1041  if (kTRUE == fbBinningFw)
1042  ulTime = static_cast<ULong64_t>(stsxyter::kuHitNbTsBinsBinning)
1043  * static_cast<ULong64_t>(fvulCurrentTsMsb[fuCurrDpbIdx])
1044  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBinsBinning)
1045  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle[fuCurrDpbIdx]);
1046 
1048  Double_t dTimeNs = ulTime * stsxyter::kdClockCycleNs;
1049 
1050  fErrVect.push_back(CbmErrorMessage(ECbmModuleId::kSts,
1051  dTimeNs,
1052  uAsicIdx,
1053  mess.GetStatusStatus(),
1054  mess.GetData()));
1055 }
1056 
1057 // -------------------------------------------------------------------------
1058 
1059 // -------------------------------------------------------------------------
1060 
1061 Bool_t CbmMcbm2018UnpackerAlgoSts::CreateHistograms() {
1063  fhDigisTimeInRun =
1064  new TH1I("hStsDigisTimeInRun",
1065  "Digis Nb vs Time in Run; Time in run [s]; Digis Nb []",
1066  36000,
1067  0,
1068  3600);
1069  AddHistoToVector(fhDigisTimeInRun, "");
1070 
1071  fhVectorSize =
1072  new TH1I("fhVectorSize",
1073  "Size of the vector VS TS index; TS index; Size [bytes]",
1074  10000,
1075  0.,
1076  10000.);
1077  fhVectorCapacity =
1078  new TH1I("fhVectorCapacity",
1079  "Size of the vector VS TS index; TS index; Size [bytes]",
1080  10000,
1081  0.,
1082  10000.);
1083  AddHistoToVector(fhVectorSize, "");
1084  AddHistoToVector(fhVectorCapacity, "");
1085 
1086 
1087  fhMsCntEvo =
1088  new TH1I("fhMsCntEvo", "; MS index [s]; Counts []", 600, 0.0, 600.0);
1089  AddHistoToVector(fhMsCntEvo, "");
1090 
1091  fhMsErrorsEvo = new TH2I("fhMsErrorsEvo",
1092  "; MS index [s]; Error type []; Counts []",
1093  600,
1094  0.0,
1095  600.0,
1096  4,
1097  -0.5,
1098  3.5);
1099  AddHistoToVector(fhMsErrorsEvo, "");
1100 
1101  /*
1102  fhPulserVsTsAB = new TProfile2D( "fhPulserVsTsAB", "; TS A [bin]; TS B [bin]; dT B - A [ns]",
1103  1024, -0.5, 1023.5,
1104  1024, -0.5, 1023.5 );
1105  AddHistoToVector( fhPulserVsTsAB, "" );
1106 */
1107  /*
1109  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1110  {
1111  UInt_t uSector = fUnpackPar->GetGdpbToSectorOffset() + uGdpb;
1112  std::string sFolder = Form( "sector%2u", uSector);
1113 
1114  LOG(info) << "gDPB " << uGdpb << " is " << sFolder;
1115 
1116  fvhHitsTimeToTriggerRaw.push_back( new TH1D(
1117  Form( "hHitsTimeToTriggerRawSect%2u", uSector ),
1118  Form( "Time to trigger for all neighboring hits in sector %2u; t - Ttrigg [ns]; Hits []", uSector ),
1119  2000, -5000, 5000 ) );
1120 
1121  UInt_t uNbBinsDtSel = fdStarTriggerWinSize[ uGdpb ];
1122  Double_t dMaxDtSel = fdStarTriggerDelay[ uGdpb ] + fdStarTriggerWinSize[ uGdpb ];
1123  fvhHitsTimeToTriggerSel.push_back( new TH1D(
1124  Form( "hHitsTimeToTriggerSelSect%2u", uSector ),
1125  Form( "Time to trigger for all selected hits in sector %2u; t - Ttrigg [ns]; Hits []", uSector ),
1126  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel ) );
1127 
1129  AddHistoToVector( fvhHitsTimeToTriggerRaw[ uGdpb ], sFolder );
1130  AddHistoToVector( fvhHitsTimeToTriggerSel[ uGdpb ], sFolder );
1131 
1132  if( kTRUE == fbDebugMonitorMode )
1133  {
1134  fvhHitsTimeToTriggerSelVsDaq.push_back( new TH2D(
1135  Form( "hHitsTimeToTriggerSelVsDaqSect%2u", uSector ),
1136  Form( "Time to trigger for all selected hits vs DAQ CMD in sector %2u; t - Ttrigg [ns]; DAQ CMD []; Hits []", uSector ),
1137  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel,
1138  16, 0., 16. ) );
1139 
1140  fvhHitsTimeToTriggerSelVsTrig.push_back( new TH2D(
1141  Form( "hHitsTimeToTriggerSelVsTrigSect%2u", uSector ),
1142  Form( "Time to trigger for all selected hits vs TRIG CMD in sector %2u; t - Ttrigg [ns]; TRIG CMD []; Hits []", uSector ),
1143  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel,
1144  16, 0., 16. ) );
1145 
1146  fvhTriggerDt.push_back( new TH1I(
1147  Form( "hTriggerDtSect%2u", uSector ),
1148  Form( "Trigger time difference between sector %2u and the first sector, full events only; Ttrigg%2u - TtriggRef [Clk]; events []",
1149  uSector, uSector ),
1150  200, -100, 100 ) );
1151 
1154  UInt_t uNbBinsInTs = fdMsSizeInNs * 111 / 1000. / 10.;
1155  UInt_t uNbBinsInMs = fdMsSizeInNs * 20 / 1000. / 10.;
1156 
1157  fvhTriggerDistributionInTs.push_back( new TH1I( Form( "hTriggerDistInTsSect%2u", uSector ),
1158  Form( "Trigger distribution inside TS in sector %2u; Time in TS [us]; Trigger [];", uSector ),
1159  uNbBinsInTs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 101 / 1000. - 0.5 ) );
1160 
1161  fvhTriggerDistributionInMs.push_back( new TH1I( Form( "hTriggerDistInMsSect%2u", uSector ),
1162  Form( "Trigger distribution inside MS in sector %2u; Time in MS [us]; Trigger [];", uSector ),
1163  uNbBinsInMs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 10 / 1000. - 0.5 ) );
1164 
1165  fvhMessDistributionInMs.push_back( new TH1I( Form( "hMessDistInMsSect%2u", uSector ),
1166  Form( "Messages distribution inside MS in sector %2u; Time in MS [us]; Trigger [];", uSector ),
1167  uNbBinsInMs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 10 / 1000. - 0.5 ) );
1168 
1170  AddHistoToVector( fvhHitsTimeToTriggerSelVsDaq[ uGdpb ], sFolder );
1171  AddHistoToVector( fvhHitsTimeToTriggerSelVsTrig[ uGdpb ], sFolder );
1172  AddHistoToVector( fvhTriggerDt[ uGdpb ], sFolder );
1173  AddHistoToVector( fvhTriggerDistributionInTs[ uGdpb ], sFolder );
1174  AddHistoToVector( fvhTriggerDistributionInMs[ uGdpb ], sFolder );
1175  AddHistoToVector( fvhMessDistributionInMs[ uGdpb ], sFolder );
1176  } // if( kTRUE == fbDebugMonitorMode )
1177  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1178 
1180  fhEventNbPerTs = new TH1I( "hEventNbPerTs",
1181  "Number of Events per TS; Events []; TS []",
1182  1000 , 0, 1000 );
1183 
1184  fhEventSizeDistribution = new TH1I( "hEventSizeDistribution",
1185  "Event size distribution; Event size [byte]; Events []",
1186  CbmTofStarSubevent2019::GetMaxOutputSize()/8 , 0, CbmTofStarSubevent2019::GetMaxOutputSize() );
1187 
1188  fhEventSizeEvolution = new TProfile( "hEventSizeEvolution",
1189  "Event size evolution; Time in run [min]; mean Event size [byte];",
1190  14400, 0, 14400 );
1191 
1192  fhEventNbEvolution = new TH1I( "hEventNbEvolution",
1193  "Event number evolution; Time in run [min]; Events [];",
1194  14400, 0, 14400 );
1195 
1197  AddHistoToVector( fhEventNbPerTs, "eventbuilder" );
1198  AddHistoToVector( fhEventSizeDistribution, "eventbuilder" );
1199  AddHistoToVector( fhEventSizeEvolution, "eventbuilder" );
1200  AddHistoToVector( fhEventNbEvolution, "eventbuilder" );
1201 
1202  if( kTRUE == fbDebugMonitorMode )
1203  {
1206  UInt_t uNbBinsInTs = fdMsSizeInNs * 101 / 1000. / 10.;
1207 
1208  fhEventNbDistributionInTs = new TH1I( "hEventNbDistributionInTs",
1209  "Event number distribution inside TS; Time in TS [us]; Events [];",
1210  uNbBinsInTs, -0.5, fdMsSizeInNs * 101 / 1000. - 0.5 );
1211 
1212  fhEventSizeDistributionInTs = new TProfile( "hEventSizeDistributionInTs",
1213  "Event size distribution inside TS; Time in TS [us]; mean Event size [Byte];",
1214  uNbBinsInTs, -0.5, fdMsSizeInNs * 101 / 1000. - 0.5 );
1215 
1216  fhRawTriggersStats = new TH2I(
1217  "hRawTriggersStats",
1218  "Raw triggers statistics per sector; ; Sector []; Messages []",
1219  5, 0, 5,
1220  12, 13, 25 );
1221  fhRawTriggersStats->GetXaxis()->SetBinLabel( 1, "A");
1222  fhRawTriggersStats->GetXaxis()->SetBinLabel( 2, "B");
1223  fhRawTriggersStats->GetXaxis()->SetBinLabel( 3, "C");
1224  fhRawTriggersStats->GetXaxis()->SetBinLabel( 4, "D");
1225  fhRawTriggersStats->GetXaxis()->SetBinLabel( 5, "F");
1226 
1227  fhMissingTriggersEvolution = new TH2I(
1228  "hMissingTriggersEvolution",
1229  "Missing trigger counts per sector vs time in run; Time in run [min]; Sector []; Missing triggers []",
1230  14400, 0, 14400,
1231  12, 13, 25 );
1232 
1234  AddHistoToVector( fhEventNbDistributionInTs, "eventbuilder" );
1235  AddHistoToVector( fhEventSizeDistributionInTs, "eventbuilder" );
1236  AddHistoToVector( fhRawTriggersStats, "eventbuilder" );
1237  AddHistoToVector( fhMissingTriggersEvolution, "eventbuilder" );
1238  } // if( kTRUE == fbDebugMonitorMode )
1239 
1241  Double_t w = 10;
1242  Double_t h = 10;
1243 
1245  fcTimeToTrigRaw = new TCanvas( "cTimeToTrigRaw", "Raw Time to trig for all sectors", w, h);
1246  fcTimeToTrigRaw->Divide( 2, fuNrOfGdpbs / 2 );
1247  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1248  {
1249  fcTimeToTrigRaw->cd( 1 + uGdpb );
1250  gPad->SetGridx();
1251  gPad->SetGridy();
1252  gPad->SetLogy();
1253  fvhHitsTimeToTriggerRaw[ uGdpb ]->Draw();
1254  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1255 
1257  fcTimeToTrigSel = new TCanvas( "cTimeToTrigSel", "Selected Time to trig for all sectors", w, h);
1258  fcTimeToTrigSel->Divide( 2, fuNrOfGdpbs / 2 );
1259  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1260  {
1261  fcTimeToTrigSel->cd( 1 + uGdpb );
1262  gPad->SetGridx();
1263  gPad->SetGridy();
1264  gPad->SetLogy();
1265  fvhHitsTimeToTriggerSel[ uGdpb ]->Draw();
1266  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1267 
1268  if( kTRUE == fbDebugMonitorMode )
1269  {
1271  fcTrigDistMs = new TCanvas( "cTrigDistMs", "Trigger time to MS start for all sectors", w, h);
1272  fcTrigDistMs->Divide( 2, fuNrOfGdpbs / 2 );
1273  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1274  {
1275  fcTrigDistMs->cd( 1 + uGdpb );
1276  gPad->SetGridx();
1277  gPad->SetGridy();
1278  gPad->SetLogy();
1279  fvhTriggerDistributionInMs[ uGdpb ]->Draw();
1280  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1281 
1283  fcMessDistMs = new TCanvas( "cMessDistMs", "Message time to MS start for all sectors", w, h);
1284  fcMessDistMs->Divide( 2, fuNrOfGdpbs / 2 );
1285  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1286  {
1287  fcMessDistMs->cd( 1 + uGdpb );
1288  gPad->SetGridx();
1289  gPad->SetGridy();
1290  gPad->SetLogy();
1291  fvhMessDistributionInMs[ uGdpb ]->Draw();
1292  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1293  } // if( kTRUE == fbDebugMonitorMode )
1294 
1296  fcEventBuildStats = new TCanvas( "cEvtBuildStats", "Event building statistics", w, h);
1297  if( kTRUE == fbDebugMonitorMode )
1298  fcEventBuildStats->Divide( 2, 3 );
1299  else fcEventBuildStats->Divide( 2, 2 );
1300 
1301  fcEventBuildStats->cd( 1 );
1302  gPad->SetGridx();
1303  gPad->SetGridy();
1304  gPad->SetLogy();
1305  fhEventNbPerTs->Draw();
1306 
1307  fcEventBuildStats->cd( 2 );
1308  gPad->SetGridx();
1309  gPad->SetGridy();
1310  gPad->SetLogy();
1311  fhEventSizeDistribution->Draw();
1312 
1313  fcEventBuildStats->cd( 3 );
1314  gPad->SetGridx();
1315  gPad->SetGridy();
1316  gPad->SetLogy();
1317  fhEventSizeEvolution->Draw();
1318 
1319  fcEventBuildStats->cd( 4 );
1320  gPad->SetGridx();
1321  gPad->SetGridy();
1322  gPad->SetLogy();
1323  fhEventNbEvolution->Draw();
1324 
1325  if( kTRUE == fbDebugMonitorMode )
1326  {
1327  fcEventBuildStats->cd( 5 );
1328  gPad->SetGridx();
1329  gPad->SetGridy();
1330  gPad->SetLogy();
1331  fhEventNbDistributionInTs->Draw();
1332 
1333  fcEventBuildStats->cd( 6 );
1334  gPad->SetGridx();
1335  gPad->SetGridy();
1336  gPad->SetLogy();
1337  fhEventSizeDistributionInTs->Draw();
1338  } // if( kTRUE == fbDebugMonitorMode )
1339 
1340  AddCanvasToVector( fcEventBuildStats, "canvases" );
1341 */
1342  return kTRUE;
1343 }
1344 Bool_t CbmMcbm2018UnpackerAlgoSts::FillHistograms() {
1345  for (auto itHit = fDigiVect.begin(); itHit != fDigiVect.end(); ++itHit) {
1346  fhDigisTimeInRun->Fill(itHit->GetTime() * 1e-9);
1347  } // for( auto itHit = fDigiVect.begin(); itHit != fDigiVect.end(); ++itHit)
1348  return kTRUE;
1349 }
1350 Bool_t CbmMcbm2018UnpackerAlgoSts::ResetHistograms() {
1351  fhDigisTimeInRun->Reset();
1352  /*
1353  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1354  {
1355  fvhHitsTimeToTriggerRaw[ uGdpb ]->Reset();
1356  fvhHitsTimeToTriggerSel[ uGdpb ]->Reset();
1357 
1358  if( kTRUE == fbDebugMonitorMode )
1359  {
1360  fvhHitsTimeToTriggerSelVsDaq[ uGdpb ]->Reset();
1361  fvhHitsTimeToTriggerSelVsTrig[ uGdpb ]->Reset();
1362  fvhTriggerDt[ uGdpb ]->Reset();
1363  fvhTriggerDistributionInTs[ uGdpb ]->Reset();
1364  fvhTriggerDistributionInMs[ uGdpb ]->Reset();
1365  fvhMessDistributionInMs[ uGdpb ]->Reset();
1366  } // if( kTRUE == fbDebugMonitorMode )
1367  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1368 
1370  fhEventNbPerTs->Reset();
1371  fhEventSizeDistribution->Reset();
1372  fhEventSizeEvolution->Reset();
1373  fhEventNbEvolution->Reset();
1374 
1375  if( kTRUE == fbDebugMonitorMode )
1376  {
1377  fhEventNbDistributionInTs->Reset();
1378  fhEventSizeDistributionInTs->Reset();
1379  fhRawTriggersStats->Reset();
1380  fhMissingTriggersEvolution->Reset();
1381  } // if( kTRUE == fbDebugMonitorMode )
1382 */
1383  return kTRUE;
1384 }
1385 // -------------------------------------------------------------------------
1386 
1387 void CbmMcbm2018UnpackerAlgoSts::SetTimeOffsetNsAsic(UInt_t uAsicIdx,
1388  Double_t dOffsetIn) {
1389  if (uAsicIdx >= fvdTimeOffsetNsAsics.size()) {
1390  fvdTimeOffsetNsAsics.resize(uAsicIdx + 1, 0.0);
1391  } // if( uAsicIdx < fvdTimeOffsetNsAsics.size() )
1392 
1393  fvdTimeOffsetNsAsics[uAsicIdx] = dOffsetIn;
1394 }
1395 // -------------------------------------------------------------------------
1396 void CbmMcbm2018UnpackerAlgoSts::MaskNoisyChannel(UInt_t uFeb,
1397  UInt_t uChan,
1398  Bool_t bMasked) {
1399  if (kFALSE == fbUseChannelMask) {
1400  fbUseChannelMask = kTRUE;
1401  fvvbMaskedChannels.resize(fuNbFebs);
1402  for (UInt_t uFebIdx = 0; uFebIdx < fuNbFebs; ++uFebIdx) {
1403  fvvbMaskedChannels[uFebIdx].resize(fUnpackPar->GetNbChanPerFeb(), false);
1404  } // for( UInt_t uFeb = 0; uFeb < fuNbFebs; ++uFeb )
1405  } // if( kFALSE == fbUseChannelMask )
1406 
1407  if (uFeb < fuNbFebs && uChan < fUnpackPar->GetNbChanPerFeb())
1408  fvvbMaskedChannels[uFeb][uChan] = bMasked;
1409  else
1410  LOG(fatal) << "CbmMcbm2018UnpackerAlgoSts::MaskNoisyChannel => Invalid FEB "
1411  "and/or CHAN index:"
1412  << Form(" %u vs %u and %u vs %u",
1413  uFeb,
1414  fuNbFebs,
1415  uChan,
1416  fUnpackPar->GetNbChanPerFeb());
1417 }
1418 // -------------------------------------------------------------------------
CbmMcbm2018UnpackerAlgoSts::ProcessStatusInfo
void ProcessStatusInfo(const stsxyter::Message &mess, const UInt_t &uAsicIdx)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1018
CbmMcbm2018UnpackerAlgoSts::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1344
CbmMcbm2018UnpackerAlgoSts::fvvusLastTsMsbChan
std::vector< std::vector< UShort_t > > fvvusLastTsMsbChan
ADC of last hit message for each channel, [ AsicIdx ][ Chan ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:176
CbmMcbm2018UnpackerAlgoSts::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018UnpackerAlgoSts.h:142
CbmMcbm2018StsPar::GetNbChanPerFeb
static constexpr UInt_t GetNbChanPerFeb()
Definition: CbmMcbm2018StsPar.h:53
CbmMcbm2018UnpackerAlgoSts::fdCapacityIncFactor
Double_t fdCapacityIncFactor
Definition: CbmMcbm2018UnpackerAlgoSts.h:191
CbmMcbm2018StsPar::GetModuleAddress
UInt_t GetModuleAddress(UInt_t uModuleIdx)
Definition: CbmMcbm2018StsPar.cxx:175
CbmMcbm2018UnpackerAlgoSts::fbBinningFw
Bool_t fbBinningFw
=> Quick and dirty hack for binning FW!!!
Definition: CbmMcbm2018UnpackerAlgoSts.h:89
CbmMcbm2018UnpackerAlgoSts::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1061
CbmMcbm2018UnpackerAlgoSts::fviFebModuleSide
std::vector< std::vector< std::vector< Int_t > > > fviFebModuleSide
Idx of the STS module for each FEB, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ], -1 if inactive.
Definition: CbmMcbm2018UnpackerAlgoSts.h:109
CbmMcbm2018StsPar::GetFebModuleSide
Int_t GetFebModuleSide(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018StsPar.cxx:307
CbmStar2019Algo< CbmStsDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018StsPar::GetModuleType
UInt_t GetModuleType(UInt_t uModuleIdx)
Definition: CbmMcbm2018StsPar.cxx:166
CbmMcbm2018UnpackerAlgoSts::ProcessHitInfo
void ProcessHitInfo(const stsxyter::Message &mess, const UShort_t &usElinkIdx, const UInt_t &uAsicIdx, const UInt_t &uMsIdx)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:773
CbmStar2019Algo< CbmStsDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018UnpackerAlgoSts::fvvusLastTsChan
std::vector< std::vector< UShort_t > > fvvusLastTsChan
Definition: CbmMcbm2018UnpackerAlgoSts.h:172
CbmMcbm2018UnpackerAlgoSts::fviFebModuleIdx
std::vector< std::vector< std::vector< Int_t > > > fviFebModuleIdx
Number of StsXyter ASICs.
Definition: CbmMcbm2018UnpackerAlgoSts.h:107
CbmStar2019Algo< CbmStsDigi >::fErrVect
std::vector< CbmErrorMessage > fErrVect
Definition: CbmStar2019Algo.h:141
CbmMcbm2018UnpackerAlgoSts::fuNbFebs
UInt_t fuNbFebs
Array to hold the active flag for all CROBs, [ NbDpb ][ NbCrobPerDpb ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:104
CbmMcbm2018UnpackerAlgoSts::fvvusLastTsMsbCycleChan
std::vector< std::vector< UShort_t > > fvvusLastTsMsbCycleChan
TS MSB of last hit message for each channel, [ AsicIdx ][ Chan ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:178
stsxyter::Message
Definition: StsXyterMessage.h:165
stsxyter::MessType::Status
@ Status
CbmMcbm2018StsPar::GetDpbId
UInt_t GetDpbId(UInt_t uDpbIdx)
Definition: CbmMcbm2018StsPar.cxx:206
CbmMcbm2018UnpackerAlgoSts::CbmMcbm2018UnpackerAlgoSts
CbmMcbm2018UnpackerAlgoSts()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:29
CbmMcbm2018StsPar::IsCrobActive
Bool_t IsCrobActive(UInt_t uDpbIdx, UInt_t uCrobIdx)
Definition: CbmMcbm2018StsPar.cxx:215
CbmMcbm2018UnpackerAlgoSts::fviModAddress
std::vector< Int_t > fviModAddress
Type of each module: 0 for connectors on the right, 1 for connectors on the left.
Definition: CbmMcbm2018UnpackerAlgoSts.h:98
stsxyter::kulTsCycleNbBinsBinning
static const uint64_t kulTsCycleNbBinsBinning
Definition: StsXyterMessage.h:161
CbmStar2019Algo< CbmStsDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018UnpackerAlgoSts::fdAdcCut
UInt_t fdAdcCut
Vector of channel masks, [ NbFeb ][ NbCHanInFeb ], used only if fbUseChannelMask is true.
Definition: CbmMcbm2018UnpackerAlgoSts.h:127
stsxyter::Message::GetLinkIndexHitBinning
uint16_t GetLinkIndexHitBinning() const
Definition: StsXyterMessage.h:296
CbmStar2019Algo< CbmStsDigi >::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
For monitor algos.
Definition: CbmStar2019Algo.h:80
stsxyter::Message::GetTsMsbVal
uint32_t GetTsMsbVal() const
For TS MSB data: Returns the TS MSB 22 bit field)
Definition: StsXyterMessage.h:334
CbmMcbm2018UnpackerAlgoSts::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018UnpackerAlgoSts.h:150
CbmMcbm2018StsPar::GetNrOfFebs
UInt_t GetNrOfFebs()
Definition: CbmMcbm2018StsPar.h:86
CbmMcbm2018UnpackerAlgoSts::fviFebAddress
std::vector< Int_t > fviFebAddress
FEB type, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ], 0 = A, 1 = B, -1 if inactive.
Definition: CbmMcbm2018UnpackerAlgoSts.h:113
stsxyter::Message::GetLinkIndex
uint16_t GetLinkIndex() const
For all data: Returns the (global) index of the eLink on which the message was received (n bit field)
Definition: StsXyterMessage.h:249
stsxyter::MessType
MessType
Message types.
Definition: StsXyterMessage.h:27
CbmStar2019Algo< CbmStsDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
CbmMcbm2018UnpackerAlgoSts::fdTimeOffsetNs
Double_t fdTimeOffsetNs
ADC offset in e-, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:122
CbmMcbm2018StsPar::GetNrOfAsics
UInt_t GetNrOfAsics()
Definition: CbmMcbm2018StsPar.h:87
CbmMcbm2018UnpackerAlgoSts::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:137
stsxyter::kulTsCycleNbBins
static const uint64_t kulTsCycleNbBins
Definition: StsXyterMessage.h:152
CbmMcbm2018StsPar::GetNbFebsPerCrob
static constexpr UInt_t GetNbFebsPerCrob()
Definition: CbmMcbm2018StsPar.h:41
CbmMcbm2018UnpackerAlgoSts::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018UnpackerAlgoSts.h:134
CbmStar2019Algo< CbmStsDigi >::fdTsFullSizeInNs
Double_t fdTsFullSizeInNs
Total size of the core MS in a TS, [nanoseconds].
Definition: CbmStar2019Algo.h:121
CbmStar2019Algo< CbmStsDigi >::fParCList
TList * fParCList
Parameter management.
Definition: CbmStar2019Algo.h:108
CbmMcbm2018StsPar::GetNrOfDpbs
UInt_t GetNrOfDpbs()
Definition: CbmMcbm2018StsPar.h:83
CbmMcbm2018StsPar::GetNbAsicsPerCrob
static constexpr UInt_t GetNbAsicsPerCrob()
Definition: CbmMcbm2018StsPar.h:46
CbmStar2019Algo< CbmStsDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
stsxyter::Message::IsHitMissedEvts
bool IsHitMissedEvts() const
For Hit data: Returns Missed event flag (1 bit field)
Definition: StsXyterMessage.h:301
stsxyter::Message::GetData
uint32_t GetData() const
Definition: StsXyterMessage.h:189
CbmMcbm2018UnpackerAlgoSts::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:351
CbmMcbm2018UnpackerAlgoSts::ProcessEpochInfo
void ProcessEpochInfo(const stsxyter::Message &mess)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1003
CbmMcbm2018UnpackerAlgoSts::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:496
stsxyter::Message::GetHitAdc
uint16_t GetHitAdc() const
For Hit data: Returns ADC value (5 bit field)
Definition: StsXyterMessage.h:277
CbmMcbm2018UnpackerAlgoSts::fvvbMaskedChannels
std::vector< std::vector< bool > > fvvbMaskedChannels
Definition: CbmMcbm2018UnpackerAlgoSts.h:126
CbmMcbm2018UnpackerAlgoSts::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018UnpackerAlgoSts.h:87
CbmMcbm2018UnpackerAlgoSts::fvdTimeOffsetNsAsics
std::vector< Double_t > fvdTimeOffsetNsAsics
Definition: CbmMcbm2018UnpackerAlgoSts.h:123
CbmMcbm2018UnpackerAlgoSts::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018UnpackerAlgoSts.h:139
CbmMcbm2018StsPar::GetFebAdcOffset
Double_t GetFebAdcOffset(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018StsPar.cxx:369
CbmMcbm2018StsPar::GetNbAsicsPerFeb
static constexpr UInt_t GetNbAsicsPerFeb()
Definition: CbmMcbm2018StsPar.h:45
stsxyter::MessType::Empty
@ Empty
CbmMcbm2018UnpackerAlgoSts::fdStartTime
Double_t fdStartTime
Definition: CbmMcbm2018UnpackerAlgoSts.h:159
CbmMcbm2018UnpackerAlgoSts::fbDebugMonitorMode
Bool_t fbDebugMonitorMode
Switch ON the filling of a minimal set of histograms.
Definition: CbmMcbm2018UnpackerAlgoSts.h:86
CbmMcbm2018UnpackerAlgoSts::fviModuleType
std::vector< Int_t > fviModuleType
Total number of STS modules in the setup.
Definition: CbmMcbm2018UnpackerAlgoSts.h:96
CbmMcbm2018UnpackerAlgoSts::fhDigisTimeInRun
TH1 * fhDigisTimeInRun
TS MSB cycle of last hit message for each channel, [ AsicIdx ][ Chan ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:181
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
CbmMcbm2018UnpackerAlgoSts::SetTimeOffsetNsAsic
void SetTimeOffsetNsAsic(UInt_t uAsicIdx, Double_t dOffsetIn=0.0)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1387
stsxyter::FinalHit
Definition: StsXyterFinalHit.h:16
stsxyter::MessType::Hit
@ Hit
CbmMcbm2018UnpackerAlgoSts::fvvusLastAdcChan
std::vector< std::vector< UShort_t > > fvvusLastAdcChan
TS of last hit message for each channel, [ AsicIdx ][ Chan ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:174
CbmErrorMessage
CbmRoot (+externals) headers.
Definition: CbmErrorMessage.h:39
CbmMcbm2018UnpackerAlgoSts::fhMsErrorsEvo
TH2 * fhMsErrorsEvo
Definition: CbmMcbm2018UnpackerAlgoSts.h:195
stsxyter::kuHitNbTsBins
static const uint32_t kuHitNbTsBins
Definition: StsXyterMessage.h:146
CbmMcbm2018UnpackerAlgoSts::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1350
CbmMcbm2018StsPar::ElinkIdxToAsicIdx
UInt_t ElinkIdxToAsicIdx(Bool_t bFebType, UInt_t uElink)
Definition: CbmMcbm2018StsPar.h:69
CbmStar2019Algo< CbmStsDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018UnpackerAlgoSts::~CbmMcbm2018UnpackerAlgoSts
~CbmMcbm2018UnpackerAlgoSts()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:86
stsxyter::Message::GetStatusStatus
uint16_t GetStatusStatus() const
For Status data: Returns the Status field from ACK frame (4 bit field)
Definition: StsXyterMessage.h:359
CbmStar2019Algo< CbmStsDigi >::fDigiVect
std::vector< CbmStsDigi > fDigiVect
Vector of pointers to canvases + optional folder name.
Definition: CbmStar2019Algo.h:140
CbmMcbm2018StsPar::GetNbOfModules
UInt_t GetNbOfModules()
Definition: CbmMcbm2018StsPar.h:76
CbmMcbm2018UnpackerAlgoSts::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018UnpackerAlgoSts.h:148
CbmMcbm2018UnpackerAlgoSts.h
CbmMcbm2018UnpackerAlgoSts::fviFebSide
std::vector< Int_t > fviFebSide
STS address for each FEB, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:115
CbmStsDigi
Data class for a single-channel message in the STS.
Definition: CbmStsDigi.h:29
CbmMcbm2018UnpackerAlgoSts::fuNbStsXyters
UInt_t fuNbStsXyters
Number of FEBs with StsXyter ASICs.
Definition: CbmMcbm2018UnpackerAlgoSts.h:105
CbmMcbm2018UnpackerAlgoSts::fUnpackPar
CbmMcbm2018StsPar * fUnpackPar
Settings from parameter file.
Definition: CbmMcbm2018UnpackerAlgoSts.h:92
CbmMcbm2018UnpackerAlgoSts::fvmHitsInMs
std::vector< stsxyter::FinalHit > fvmHitsInMs
Hits time-sorting.
Definition: CbmMcbm2018UnpackerAlgoSts.h:167
stsxyter::kdClockCycleNs
static const double kdClockCycleNs
Definition: StsXyterMessage.h:156
CbmMcbm2018StsPar::GetNbElinkPerCrob
static constexpr UInt_t GetNbElinkPerCrob()
Definition: CbmMcbm2018StsPar.h:37
stsxyter::kuHitNbTsBinsBinning
static const uint32_t kuHitNbTsBinsBinning
Definition: StsXyterMessage.h:160
CbmMcbm2018UnpackerAlgoSts::fvdFebAdcOffs
std::vector< Double_t > fvdFebAdcOffs
ADC gain in e-/b, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:119
CbmMcbm2018StsPar
Definition: CbmMcbm2018StsPar.h:18
stsxyter::Message::GetMessType
MessType GetMessType() const
Returns the message type, see enum MessType.
Definition: StsXyterMessage.h:259
CbmMcbm2018StsPar::GetFebModuleIdx
Int_t GetFebModuleIdx(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018StsPar.cxx:276
CbmMcbm2018UnpackerAlgoSts::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:113
CbmMcbm2018UnpackerAlgoSts::Init
virtual Bool_t Init()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:100
CbmMcbm2018UnpackerAlgoSts::fbMonitorMode
Bool_t fbMonitorMode
Control flags.
Definition: CbmMcbm2018UnpackerAlgoSts.h:84
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
CbmMcbm2018UnpackerAlgoSts::Reset
virtual void Reset()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:105
CbmMcbm2018UnpackerAlgoSts::fvbCrobActiveFlag
std::vector< std::vector< Bool_t > > fvbCrobActiveFlag
Map of DPB Identifier to DPB index.
Definition: CbmMcbm2018UnpackerAlgoSts.h:103
CbmMcbm2018UnpackerAlgoSts::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018UnpackerAlgoSts.h:135
CbmMcbm2018UnpackerAlgoSts::fhVectorCapacity
TH1 * fhVectorCapacity
Definition: CbmMcbm2018UnpackerAlgoSts.h:189
CbmMcbm2018UnpackerAlgoSts::fvulCurrentTsMsb
std::vector< ULong64_t > fvulCurrentTsMsb
Definition: CbmMcbm2018UnpackerAlgoSts.h:155
CbmMcbm2018UnpackerAlgoSts::fuTsMaxVectorSize
size_t fuTsMaxVectorSize
Definition: CbmMcbm2018UnpackerAlgoSts.h:190
stsxyter::Message::GetHitChannel
uint16_t GetHitChannel() const
For Hit data: Returns StsXYTER channel number (7 bit field)
Definition: StsXyterMessage.h:274
stsxyter::Message::GetStatusLink
uint16_t GetStatusLink() const
For Status data: Returns the Link Inedx (9 bit field)
Definition: StsXyterMessage.h:353
CbmMcbm2018UnpackerAlgoSts::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018UnpackerAlgoSts.h:146
CbmMcbm2018UnpackerAlgoSts::MaskNoisyChannel
void MaskNoisyChannel(UInt_t uFeb, UInt_t uChan, Bool_t bMasked=kTRUE)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:1396
CbmMcbm2018UnpackerAlgoSts::fhMsCntEvo
TH1 * fhMsCntEvo
Definition: CbmMcbm2018UnpackerAlgoSts.h:194
CbmMcbm2018StsPar::GetFebAdcGain
Double_t GetFebAdcGain(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018StsPar.cxx:338
CbmMcbm2018UnpackerAlgoSts::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:119
CbmMcbm2018UnpackerAlgoSts::ProcessTsMsbInfo
void ProcessTsMsbInfo(const stsxyter::Message &mess, UInt_t uMessIdx=0, UInt_t uMsIdx=0)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:922
stsxyter::MessType::TsMsb
@ TsMsb
stsxyter::Message::GetHitTime
uint16_t GetHitTime() const
For Hit data: Returns timestamp (8 bit field, 2 MSB bits overlap removed)
Definition: StsXyterMessage.h:286
stsxyter::MessType::Dummy
@ Dummy
CbmMcbm2018UnpackerAlgoSts::GetParList
TList * GetParList()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:130
CbmMcbm2018StsPar.h
CbmMcbm2018UnpackerAlgoSts::fviFebType
std::vector< std::vector< std::vector< Int_t > > > fviFebType
STS module side for each FEB, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ], 0 = P, 1 = N,...
Definition: CbmMcbm2018UnpackerAlgoSts.h:111
CbmMcbm2018UnpackerAlgoSts::fuNbModules
UInt_t fuNbModules
Definition: CbmMcbm2018UnpackerAlgoSts.h:94
stsxyter::MessType::Epoch
@ Epoch
CbmMcbm2018UnpackerAlgoSts::fvuCurrentTsMsbCycle
std::vector< UInt_t > fvuCurrentTsMsbCycle
Current TS MSB for each DPB.
Definition: CbmMcbm2018UnpackerAlgoSts.h:156
CbmMcbm2018UnpackerAlgoSts::fbUseChannelMask
Bool_t fbUseChannelMask
Definition: CbmMcbm2018UnpackerAlgoSts.h:124
stsxyter::Message::GetTsMsbValBinning
uint32_t GetTsMsbValBinning() const
For TS MSB data: Returns the TS MSB 29 bit field)
Definition: StsXyterMessage.h:337
ECbmModuleId::kSts
@ kSts
Silicon Tracking System.
CbmMcbm2018UnpackerAlgoSts::fmMsgCounter
std::map< stsxyter::MessType, UInt_t > fmMsgCounter
Definition: CbmMcbm2018UnpackerAlgoSts.h:144
CbmMcbm2018UnpackerAlgoSts::fvdFebAdcGain
std::vector< Double_t > fvdFebAdcGain
Module side for each FEB, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoSts.h:117
CbmMcbm2018UnpackerAlgoSts::kuMaxTsMsbDiffDuplicates
static const UInt_t kuMaxTsMsbDiffDuplicates
All hits (time in bins, ADC in bins, asic, channel) in last MS, sorted with "<" operator.
Definition: CbmMcbm2018UnpackerAlgoSts.h:170
CbmMcbm2018StsPar::ElinkIdxToFebIdx
Int_t ElinkIdxToFebIdx(UInt_t uElink)
Definition: CbmMcbm2018StsPar.cxx:125
stsxyter::kusLenStatStatus
static const uint16_t kusLenStatStatus
Definition: StsXyterMessage.h:106
CbmStar2019Algo< CbmStsDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018StsPar::GetNbCrobsPerDpb
static constexpr UInt_t GetNbCrobsPerDpb()
Definition: CbmMcbm2018StsPar.h:36
CbmMcbm2018StsPar::GetNbChanPerAsic
static constexpr UInt_t GetNbChanPerAsic()
Definition: CbmMcbm2018StsPar.h:52
CbmMcbm2018UnpackerAlgoSts::fDpbIdIndexMap
std::map< UInt_t, UInt_t > fDpbIdIndexMap
Total number of STS DPBs in system.
Definition: CbmMcbm2018UnpackerAlgoSts.h:101
CbmMcbm2018UnpackerAlgoSts::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:366
CbmMcbm2018UnpackerAlgoSts::fhVectorSize
TH1 * fhVectorSize
Definition: CbmMcbm2018UnpackerAlgoSts.h:188
CbmFormatMsHeaderPrintout.h
CbmMcbm2018UnpackerAlgoSts::fuNrOfDpbs
UInt_t fuNrOfDpbs
STS address for the first strip of each module.
Definition: CbmMcbm2018UnpackerAlgoSts.h:99
stsxyter::MessType::EndOfMs
@ EndOfMs
CbmMcbm2018UnpackerAlgoSts::fdTsStartTime
Double_t fdTsStartTime
Definition: CbmMcbm2018UnpackerAlgoSts.h:137
stsxyter::Message::GetHitTimeBinning
uint16_t GetHitTimeBinning() const
Definition: StsXyterMessage.h:290
CbmMcbm2018UnpackerAlgoSts::Finish
virtual void Finish()
Definition: CbmMcbm2018UnpackerAlgoSts.cxx:106