CbmRoot
CbmMcbm2018UnpackerAlgoHodo.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018UnpackerAlgoHodo -----
4 // ----- Created 31/07/19 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018UnpackerAlgoHodo.h"
9 
10 #include "CbmFormatMsHeaderPrintout.h"
11 #include "CbmMcbm2018HodoPar.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 CbmMcbm2018UnpackerAlgoHodo::CbmMcbm2018UnpackerAlgoHodo()
30  : CbmStar2019Algo()
31  ,
33  fbMonitorMode(kFALSE)
34  , fbDebugMonitorMode(kFALSE)
35  , fvbMaskedComponents()
36  , fUnpackPar(nullptr)
37  , fuNbModules(0)
38  , fviModAddress()
39  , fuNrOfDpbs(0)
40  , fDpbIdIndexMap()
41  , fvbCrobActiveFlag()
42  , fuNbFebs(0)
43  , fuNbStsXyters(0)
44  , fviFebModuleIdx()
45  , fvdFebAdcGain()
46  , fvdFebAdcOffs()
47  , fviFebAddress()
48  , fviFebModule()
49  , fdTimeOffsetNs(0.0)
50  , fvdTimeOffsetNsAsics()
51  , fulCurrentTsIdx(0)
52  , fulCurrentMsIdx(0)
53  , fdTsStartTime(-1.0)
54  , fdTsStopTimeCore(-1.0)
55  , fdMsTime(-1.0)
56  , fuMsIndex(0)
57  , fmMsgCounter()
58  , fuCurrentEquipmentId(0)
59  , fuCurrDpbId(0)
60  , fuCurrDpbIdx(0)
61  , fiRunStartDateTimeSec(-1)
62  , fiBinSizeDatePlots(-1)
63  , fvulCurrentTsMsb()
64  , fdStartTime(0.0)
65  , fdStartTimeMsSz(0.0)
66  , ftStartTimeUnix(std::chrono::steady_clock::now())
67  , fvmHitsInMs()
68  , fhDigisTimeInRun(nullptr)
69 /*
70  fvhHitsTimeToTriggerRaw(),
71  fvhMessDistributionInMs(),
72  fhEventNbPerTs( nullptr ),
73  fcTimeToTrigRaw( nullptr )
74 */
75 {}
76 CbmMcbm2018UnpackerAlgoHodo::~CbmMcbm2018UnpackerAlgoHodo() {
78  fvmHitsInMs.clear();
79  /*
80  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
81  {
82  fvmHitsInMs[ uDpb ].clear();
83  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
84 */
85 }
86 
87 // -------------------------------------------------------------------------
88 Bool_t CbmMcbm2018UnpackerAlgoHodo::Init() {
89  LOG(info) << "Initializing mCBM STS 2019 unpacker algo";
90 
91  return kTRUE;
92 }
93 void CbmMcbm2018UnpackerAlgoHodo::Reset() {}
94 void CbmMcbm2018UnpackerAlgoHodo::Finish() {
96 
98 }
99 
100 // -------------------------------------------------------------------------
101 Bool_t CbmMcbm2018UnpackerAlgoHodo::InitContainers() {
102  LOG(info) << "Init parameter containers for CbmMcbm2018UnpackerAlgoHodo";
103  Bool_t initOK = ReInitContainers();
104 
105  return initOK;
106 }
107 Bool_t CbmMcbm2018UnpackerAlgoHodo::ReInitContainers() {
108  LOG(info) << "**********************************************";
109  LOG(info) << "ReInit parameter containers for CbmMcbm2018UnpackerAlgoHodo";
110 
111  fUnpackPar =
112  (CbmMcbm2018HodoPar*) fParCList->FindObject("CbmMcbm2018HodoPar");
113  if (nullptr == fUnpackPar) return kFALSE;
114 
115  Bool_t initOK = InitParameters();
116 
117  return initOK;
118 }
119 TList* CbmMcbm2018UnpackerAlgoHodo::GetParList() {
120  if (nullptr == fParCList) fParCList = new TList();
121  fUnpackPar = new CbmMcbm2018HodoPar("CbmMcbm2018HodoPar");
122  fParCList->Add(fUnpackPar);
123 
124  return fParCList;
125 }
126 Bool_t CbmMcbm2018UnpackerAlgoHodo::InitParameters() {
127  fuNbModules = fUnpackPar->GetNbOfModules();
128  LOG(info) << "Nr. of STS Modules: " << fuNbModules;
129 
130  fviModAddress.resize(fuNbModules);
131  for (UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx) {
132  fviModAddress[uModIdx] = fUnpackPar->GetModuleAddress(uModIdx);
133  LOG(info) << "Module #" << std::setw(2) << uModIdx << " Address 0x"
134  << std::setw(8) << std::hex << fviModAddress[uModIdx] << std::dec;
135  } // for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx)
136 
137  fuNrOfDpbs = fUnpackPar->GetNrOfDpbs();
138  LOG(info) << "Nr. of STS DPBs: " << fuNrOfDpbs;
139 
140  fDpbIdIndexMap.clear();
141  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
142  fDpbIdIndexMap[fUnpackPar->GetDpbId(uDpb)] = uDpb;
143  LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x"
144  << std::setw(4) << std::hex << fUnpackPar->GetDpbId(uDpb)
145  << std::dec << " => "
146  << fDpbIdIndexMap[fUnpackPar->GetDpbId(uDpb)];
147  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
148 
149  fuNbFebs = fUnpackPar->GetNrOfFebs();
150  LOG(info) << "Nr. of FEBs: " << fuNbFebs;
151 
152  fuNbStsXyters = fUnpackPar->GetNrOfAsics();
153  LOG(info) << "Nr. of StsXyter ASICs: " << fuNbStsXyters;
154 
155  if (fvdTimeOffsetNsAsics.size() < fuNbStsXyters) {
156  fvdTimeOffsetNsAsics.resize(fuNbStsXyters, 0.0);
157  } // if( fvdTimeOffsetNsAsics.size() < fuNbStsXyters )
158 
159  fvbCrobActiveFlag.resize(fuNrOfDpbs);
160  fviFebModuleIdx.resize(fuNrOfDpbs);
161  fvdFebAdcGain.resize(fuNrOfDpbs);
162  fvdFebAdcOffs.resize(fuNrOfDpbs);
163  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
164  fvbCrobActiveFlag[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
165  fviFebModuleIdx[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
166  fvdFebAdcGain[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
167  fvdFebAdcOffs[uDpb].resize(fUnpackPar->GetNbCrobsPerDpb());
168  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
169  ++uCrobIdx) {
170  fvbCrobActiveFlag[uDpb][uCrobIdx] =
171  fUnpackPar->IsCrobActive(uDpb, uCrobIdx);
172 
173  fviFebModuleIdx[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob());
174  fvdFebAdcGain[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob(), 0.0);
175  fvdFebAdcOffs[uDpb][uCrobIdx].resize(fUnpackPar->GetNbFebsPerCrob(), 0.0);
176  for (UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob();
177  ++uFebIdx) {
178  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx] =
179  fUnpackPar->GetFebModuleIdx(uDpb, uCrobIdx, uFebIdx);
180  fvdFebAdcGain[uDpb][uCrobIdx][uFebIdx] =
181  fUnpackPar->GetFebAdcGain(uDpb, uCrobIdx, uFebIdx);
182  fvdFebAdcOffs[uDpb][uCrobIdx][uFebIdx] =
183  fUnpackPar->GetFebAdcOffset(uDpb, uCrobIdx, uFebIdx);
184 
185  if (0 <= fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]
186  && static_cast<UInt_t>(fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx])
187  < fuNbModules) {
188 
195  fviFebAddress.push_back(
196  fviModAddress[fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]]);
197  fviFebModule.push_back(fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]);
198  } // FEB active and module index OK
199  else if (-1 == fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]) {
200  fviFebAddress.push_back(0);
201  fviFebModule.push_back(-1);
202  } // Module index or type is set to inactive
203  else {
204  LOG(fatal) << Form(
205  "Bad module Index for DPB #%02u CROB #%u FEB %02u: %d",
206  uDpb,
207  uCrobIdx,
208  uFebIdx,
209  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx]);
210  } // Bad module index or type for this FEB
211  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
212  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
213  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
214 
215  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
216  TString sPrintoutLine = Form("DPB #%02u CROB Active ?: ", uDpb);
217  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
218  ++uCrobIdx) {
219  sPrintoutLine +=
220  Form("%1u", (fvbCrobActiveFlag[uDpb][uCrobIdx] == kTRUE));
221  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
222  LOG(info) << sPrintoutLine;
223  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
224 
225  UInt_t uGlobalFebIdx = 0;
226  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
227  for (UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb();
228  ++uCrobIdx) {
229  LOG(info) << Form("DPB #%02u CROB #%u: ", uDpb, uCrobIdx);
230  for (UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob();
231  ++uFebIdx) {
232  if (0 <= fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx])
233  LOG(info) << Form(" FEB #%02u (%02u): Mod. Idx = %03d (Addr. "
234  "0x%08x) ADC gain %4.0f e- ADC Offs %5.0f e-",
235  uFebIdx,
236  uGlobalFebIdx,
237  fviFebModuleIdx[uDpb][uCrobIdx][uFebIdx],
238  fviFebAddress[uGlobalFebIdx],
239  fvdFebAdcGain[uDpb][uCrobIdx][uFebIdx],
240  fvdFebAdcOffs[uDpb][uCrobIdx][uFebIdx]);
241  uGlobalFebIdx++;
242  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
243  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
244  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
245 
246  // Internal status initialization
247  fvulCurrentTsMsb.resize(fuNrOfDpbs);
248  fvuCurrentTsMsbCycle.resize(fuNrOfDpbs);
249  for (UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb) {
250  fvulCurrentTsMsb[uDpb] = 0;
251  fvuCurrentTsMsbCycle[uDpb] = 0;
252  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
253 
254  return kTRUE;
255 }
256 // -------------------------------------------------------------------------
257 
258 void CbmMcbm2018UnpackerAlgoHodo::AddMsComponentToList(size_t component,
259  UShort_t usDetectorId) {
261  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
262  if (component == fvMsComponentsList[uCompIdx]) return;
263 
265  fvMsComponentsList.push_back(component);
266 
267  LOG(info) << "CbmMcbm2018UnpackerAlgoHodo::AddMsComponentToList => Component "
268  << component << " with detector ID 0x" << std::hex << usDetectorId
269  << std::dec << " added to list";
270 }
271 // -------------------------------------------------------------------------
272 
273 Bool_t CbmMcbm2018UnpackerAlgoHodo::ProcessTs(const fles::Timeslice& ts) {
274  fulCurrentTsIdx = ts.index();
275  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
276 
278  if (0 == fulCurrentTsIdx) { return kTRUE; } // if( 0 == fulCurrentTsIdx )
279 
281  if (-1.0 == fdTsCoreSizeInNs) {
282  fuNbCoreMsPerTs = ts.num_core_microslices();
283  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
284  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
285  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
286  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
287  << " Core MS and " << fuNbOverMsPerTs
288  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
289  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
290 
292  fuNbMsLoop = fuNbCoreMsPerTs;
293  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
294  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
295  } // if( -1.0 == fdTsCoreSizeInNs )
296 
298  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
299  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
300 
302  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
304  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
305  ++uMsCompIdx) {
306  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
307 
308  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
309  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
310  << fuMsIndex << " for component " << uMsComp;
311  return kFALSE;
312  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
313  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
314 
316  std::sort(fvmHitsInMs.begin(), fvmHitsInMs.end());
317 
319  for (auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end();
320  ++itHitIn) {
321  UInt_t uAsicIdx = itHitIn->GetAsic();
322  UInt_t uFebIdx = itHitIn->GetAsic() / fUnpackPar->GetNbAsicsPerFeb();
323 
325  if (-1 == fviFebModule[uFebIdx]) continue;
326 
327  UInt_t uChanInMod = fUnpackPar->GetChannelInModule(
328  fviFebModule[uFebIdx], itHitIn->GetChan()); // 0-63 = X, 64-127 = Y
329 
330  Double_t dTimeInNs =
331  itHitIn->GetTs() * stsxyter::kdClockCycleNs - fdTimeOffsetNs;
332  if (uAsicIdx < fvdTimeOffsetNsAsics.size())
333  dTimeInNs -= fvdTimeOffsetNsAsics[uAsicIdx];
334  ULong64_t ulTimeInNs = static_cast<ULong64_t>(dTimeInNs);
335  /*
336  LOG(info) << Form("Hit in ASIC %2u FEB %2u (Address %08x) Chan %3u Time %12u ",
337  uAsicIdx, uFebIdx, fviFebAddress[ uFebIdx ], uChanInMod, ulTimeInNs );
338 */
339  fDigiVect.emplace_back(
340  fviFebAddress[uFebIdx], uChanInMod, ulTimeInNs, itHitIn->GetAdc());
341  } // for( auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end(); ++itHitIn )
342 
344  fvmHitsInMs.clear();
345  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
346 
348  fvmHitsInMs.clear();
349  /*
350  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
351  {
352  fvmHitsInMs[ uDpb ].clear();
353  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
354 */
356  if (fbMonitorMode) {
357  if (kFALSE == FillHistograms()) {
358  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx;
359  return kFALSE;
360  } // if( kFALSE == FillHistograms() )
361 
362  fhVectorSize->Fill(fulCurrentTsIdx, fDigiVect.size());
363  fhVectorCapacity->Fill(fulCurrentTsIdx, fDigiVect.capacity());
364  } // if( fbMonitorMode )
365 
366  if (fuTsMaxVectorSize < fDigiVect.size()) {
367  fuTsMaxVectorSize = fDigiVect.size() * fdCapacityIncFactor;
368  fDigiVect.shrink_to_fit();
369  fDigiVect.reserve(fuTsMaxVectorSize);
370  } // if( fuTsMaxVectorSize < fDigiVect.size() )
371 
372  return kTRUE;
373 }
374 
375 Bool_t CbmMcbm2018UnpackerAlgoHodo::ProcessMs(const fles::Timeslice& ts,
376  size_t uMsCompIdx,
377  size_t uMsIdx) {
378  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
379  fuCurrentEquipmentId = msDescriptor.eq_id;
380  const uint8_t* msContent =
381  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
382 
383  uint32_t uSize = msDescriptor.size;
384  fulCurrentMsIdx = msDescriptor.idx;
385  // Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
386  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
387  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
388 
389  if (0 == fvbMaskedComponents.size())
390  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
391 
392  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
393  // fuCurrDpbIdx = fDpbIdIndexMap[ fuCurrDpbId ];
394 
396  auto it = fDpbIdIndexMap.find(fuCurrDpbId);
397  if (it == fDpbIdIndexMap.end()) {
398  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
399  LOG(info)
400  << "---------------------------------------------------------------";
401  /*
402  LOG(info) << "hi hv eqid flag si sv idx/start crc size offset";
403  LOG(info) << Form( "%02x %02x %04x %04x %02x %02x %016llx %08x %08x %016llx",
404  static_cast<unsigned int>(msDescriptor.hdr_id),
405  static_cast<unsigned int>(msDescriptor.hdr_ver), msDescriptor.eq_id, msDescriptor.flags,
406  static_cast<unsigned int>(msDescriptor.sys_id),
407  static_cast<unsigned int>(msDescriptor.sys_ver), msDescriptor.idx, msDescriptor.crc,
408  msDescriptor.size, msDescriptor.offset );
409 */
410  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
411  // LOG(info) << msDescriptor;
412  LOG(warning) << "Could not find the sDPB index for AFCK id 0x" << std::hex
413  << fuCurrDpbId << std::dec << " in timeslice "
414  << fulCurrentTsIdx << " in microslice " << uMsIdx
415  << " component " << uMsCompIdx << "\n"
416  << "If valid this index has to be added in the HODO "
417  "parameter file in the DbpIdArray field";
418  fvbMaskedComponents[uMsCompIdx] = kTRUE;
419 
422  if (1 == fulCurrentTsIdx) return kTRUE;
423  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
424  else
425  return kTRUE;
426 
427  return kFALSE;
428  } // if( it == fDpbIdIndexMap.end() )
429  else
430  fuCurrDpbIdx = fDpbIdIndexMap[fuCurrDpbId];
431 
433  UInt_t uTsMsbCycleHeader = std::floor(
434  fulCurrentMsIdx / (stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs));
435 
436  if (0 == uMsIdx) {
437  fvuCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
438  fvulCurrentTsMsb[fuCurrDpbIdx] = 0;
439  } // if( 0 == uMsIdx )
440  else if (uTsMsbCycleHeader != fvuCurrentTsMsbCycle[fuCurrDpbIdx]
441  && 4194303 != fvulCurrentTsMsb[fuCurrDpbIdx]) {
442  LOG(warning)
443  << "TS MSB cycle from MS header does not match current cycle from data "
444  << "for TS " << std::setw(12) << fulCurrentTsIdx << " MS "
445  << std::setw(12) << fulCurrentMsIdx << " MsInTs " << std::setw(3)
446  << uMsIdx << " ====> " << fvuCurrentTsMsbCycle[fuCurrDpbIdx] << " VS "
447  << uTsMsbCycleHeader;
448  fvuCurrentTsMsbCycle[fuCurrDpbIdx] = uTsMsbCycleHeader;
449  }
450 
451  // If not integer number of message in input buffer, print warning/error
452  if (0 != (uSize % sizeof(stsxyter::Message)))
453  LOG(error) << "The input microslice buffer does NOT "
454  << "contain only complete sDPB messages!";
455 
456  // Compute the number of complete messages in the input microslice buffer
457  uint32_t uNbMessages =
458  (uSize - (uSize % sizeof(stsxyter::Message))) / sizeof(stsxyter::Message);
459 
460  // Prepare variables for the loop on contents
461  const stsxyter::Message* pMess =
462  reinterpret_cast<const stsxyter::Message*>(msContent);
463  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
464 
466  stsxyter::MessType typeMess = pMess[uIdx].GetMessType();
467  fmMsgCounter[typeMess]++;
468  // fhStsMessType->Fill( static_cast< uint16_t > (typeMess) );
469  // fhStsMessTypePerDpb->Fill( fuCurrDpbIdx, static_cast< uint16_t > (typeMess) );
470 
471  switch (typeMess) {
472  case stsxyter::MessType::Hit: {
473  // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
474  UShort_t usElinkIdx = pMess[uIdx].GetLinkIndex();
475  // fhStsMessTypePerElink->Fill( usElinkIdx, static_cast< uint16_t > (typeMess) );
476  // fhStsHitsElinkPerDpb->Fill( fuCurrDpbIdx, usElinkIdx );
477 
478  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
479  Int_t uFebIdx = fUnpackPar->ElinkIdxToFebIdx(usElinkIdx);
480 
481  if (-1 == uFebIdx) {
482  LOG(warning) << "CbmMcbm2018UnpackerAlgoHodo::DoUnpack => "
483  << "Wrong elink Idx! Elink raw "
484  << Form("%d remap %d", usElinkIdx, uFebIdx);
485  continue;
486  } // if( -1 == uFebIdx )
487 
488  UInt_t uAsicIdx =
489  (fuCurrDpbIdx * fUnpackPar->GetNbCrobsPerDpb() + uCrobIdx)
490  * fUnpackPar->GetNbAsicsPerCrob()
491  + fUnpackPar->ElinkIdxToAsicIdx(usElinkIdx);
492 
493  ProcessHitInfo(pMess[uIdx], usElinkIdx, uAsicIdx, uMsIdx);
494  break;
495  } // case stsxyter::MessType::Hit :
496  case stsxyter::MessType::TsMsb: {
497  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
498 
499  ProcessTsMsbInfo(pMess[uIdx], uIdx, uMsIdx);
500  break;
501  } // case stsxyter::MessType::TsMsb :
502  case stsxyter::MessType::Epoch: {
503  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
504 
505  // The first message in the TS is a special ones: EPOCH
506  ProcessEpochInfo(pMess[uIdx]);
507 
508  if (0 < uIdx)
509  LOG(info) << "CbmMcbm2018UnpackerAlgoHodo::DoUnpack => "
510  << "EPOCH message at unexpected position in MS: message "
511  << uIdx << " VS message 0 expected!";
512  break;
513  } // case stsxyter::MessType::TsMsb :
514  case stsxyter::MessType::Status: {
515  // UShort_t usElinkIdx = pMess[uIdx].GetStatusLink();
516  // fhStsMessTypePerElink->Fill( usElinkIdx, static_cast< uint16_t > (typeMess) );
517  ProcessStatusInfo(pMess[uIdx]);
518  break;
519  } // case stsxyter::MessType::Status
520  case stsxyter::MessType::Empty: {
521  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
522  // FillTsMsbInfo( pMess[uIdx] );
523  break;
524  } // case stsxyter::MessType::Empty :
525  case stsxyter::MessType::Dummy: {
526  // fhStsMessTypePerElink->Fill( fuCurrDpbIdx * fUnpackPar->GetNbElinkPerDpb(), static_cast< uint16_t > (typeMess) );
527  break;
528  } // case stsxyter::MessType::Dummy / ReadDataAck / Ack :
529  default: {
530  LOG(fatal) << "CbmMcbm2018UnpackerAlgoHodo::DoUnpack => "
531  << "Unknown message type, should never happen, stopping "
532  "here! Type found was: "
533  << static_cast<int>(typeMess);
534  }
535  } // switch( typeMess )
536  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
537 
538  return kTRUE;
539 }
540 
541 // -------------------------------------------------------------------------
542 void CbmMcbm2018UnpackerAlgoHodo::ProcessHitInfo(const stsxyter::Message& mess,
543  const UShort_t& usElinkIdx,
544  const UInt_t& uAsicIdx,
545  const UInt_t& /*uMsIdx*/) {
546  UShort_t usChan = mess.GetHitChannel();
547  UShort_t usRawAdc = mess.GetHitAdc();
548  // UShort_t usFullTs = mess.GetHitTimeFull();
549  // UShort_t usTsOver = mess.GetHitTimeOver();
550  UShort_t usRawTs = mess.GetHitTime();
551 
553  // usChan = 127 - usChan;
554 
555  /*
556  fhStsChanCntRaw[ uAsicIdx ]->Fill( usChan );
557  fhStsChanAdcRaw[ uAsicIdx ]->Fill( usChan, usRawAdc );
558  fhStsChanAdcRawProf[ uAsicIdx ]->Fill( usChan, usRawAdc );
559  fhStsChanRawTs[ uAsicIdx ]->Fill( usChan, usRawTs );
560  fhStsChanMissEvt[ uAsicIdx ]->Fill( usChan, mess.IsHitMissedEvts() );
561 */
562  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
563  // UInt_t uFebIdx = uAsicIdx / fUnpackPar->GetNbAsicsPerFeb();
564  // UInt_t uAsicInFeb = uAsicIdx % fUnpackPar->GetNbAsicsPerFeb();
565  // UInt_t uChanInFeb = usChan + fUnpackPar->GetNbChanPerAsic() * (uAsicIdx % fUnpackPar->GetNbAsicsPerFeb());
566 
567  /*
568  Double_t dCalAdc = fvdFebAdcOffs[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ]
569  + (usRawAdc - 1)* fvdFebAdcGain[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ];
570 */
571  /*
572  fhStsFebChanCntRaw[ uFebIdx ]->Fill( uChanInFeb );
573  fhStsFebChanAdcRaw[ uFebIdx ]->Fill( uChanInFeb, usRawAdc );
574  fhStsFebChanAdcRawProf[ uFebIdx ]->Fill( uChanInFeb, usRawAdc );
575  fhStsFebChanAdcCal[ uFebIdx ]->Fill( uChanInFeb, dCalAdc );
576  fhStsFebChanAdcCalProf[ uFebIdx ]->Fill( uChanInFeb, dCalAdc );
577  fhStsFebChanRawTs[ uFebIdx ]->Fill( usChan, usRawTs );
578  fhStsFebChanMissEvt[ uFebIdx ]->Fill( usChan, mess.IsHitMissedEvts() );
579 */
580 
581  // Compute the Full time stamp
582  // Use TS w/o overlap bits as they will anyway come from the TS_MSB
583  Long64_t ulHitTime = usRawTs;
584  ulHitTime += static_cast<ULong64_t>(stsxyter::kuHitNbTsBins)
585  * static_cast<ULong64_t>(fvulCurrentTsMsb[fuCurrDpbIdx])
586  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
587  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle[fuCurrDpbIdx]);
588 
589  // Convert the Hit time in bins to Hit time in ns
590  Double_t dHitTimeNs = ulHitTime * stsxyter::kdClockCycleNs;
591 
592  fvmHitsInMs.push_back(stsxyter::FinalHit(
593  ulHitTime, usRawAdc, uAsicIdx, usChan, fuCurrDpbIdx, uCrobIdx));
594 
595  // Check Starting point of histos with time as X axis
596  if (-1 == fdStartTime) fdStartTime = dHitTimeNs;
597  /*
598  // Fill histos with time as X axis
599  Double_t dTimeSinceStartSec = (dHitTimeNs - fdStartTime)* 1e-9;
600  Double_t dTimeSinceStartMin = dTimeSinceStartSec / 60.0;
601 
602  fviFebCountsSinceLastRateUpdate[uFebIdx]++;
603  fvdFebChanCountsSinceLastRateUpdate[uFebIdx][uChanInFeb] += 1;
604 
605  fhStsFebChanHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
606  fhStsFebAsicHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb );
607  fhStsFebHitRateEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
608  fhStsFebChanHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uChanInFeb, 1.0/60.0 );
609  fhStsFebAsicHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, uAsicInFeb, 1.0/60.0 );
610  fhStsFebHitRateEvoLong[ uFebIdx ]->Fill( dTimeSinceStartMin, 1.0/60.0 );
611  if( mess.IsHitMissedEvts() )
612  {
613  fhStsFebChanMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uChanInFeb );
614  fhStsFebAsicMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec, uAsicInFeb );
615  fhStsFebMissEvtEvo[ uFebIdx ]->Fill( dTimeSinceStartSec );
616  } // if( mess.IsHitMissedEvts() )
617 */
618  /*
619  if( kTRUE == fbLongHistoEnable )
620  {
621  std::chrono::steady_clock::time_point tNow = std::chrono::steady_clock::now();
622  Double_t dUnixTimeInRun = std::chrono::duration_cast< std::chrono::seconds >(tNow - ftStartTimeUnix).count();
623  fhFebRateEvoLong[ uAsicIdx ]->Fill( dUnixTimeInRun , 1.0 / fuLongHistoBinSizeSec );
624  fhFebChRateEvoLong[ uAsicIdx ]->Fill( dUnixTimeInRun , usChan, 1.0 / fuLongHistoBinSizeSec );
625  } // if( kTRUE == fbLongHistoEnable )
626 */
627 }
628 
629 void CbmMcbm2018UnpackerAlgoHodo::ProcessTsMsbInfo(
630  const stsxyter::Message& mess,
631  UInt_t uMessIdx,
632  UInt_t uMsIdx) {
633  UInt_t uVal = mess.GetTsMsbVal();
634 
635  /*
636  if( (uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1) && 0 < uVal &&
637  !( 1 == uMessIdx && usVal == fvulCurrentTsMsb[fuCurrDpbIdx] ) ) // 1st TS_MSB in MS is always a repeat of the last one in previous MS!
638  {
639  LOG(info) << "TS MSB not increasing by 1! TS " << std::setw( 12 ) << fulCurrentTsIdx
640  << " MS " << std::setw( 12 ) << fulCurrentMsIdx
641  << " MsInTs " << std::setw( 3 ) << uMsIdx
642  << " DPB " << std::setw( 2 ) << fuCurrDpbIdx
643  << " Mess " << std::setw( 5 ) << uMessIdx
644  << " Old TsMsb " << std::setw( 5 ) << fvulCurrentTsMsb[fuCurrDpbIdx]
645  << " new TsMsb " << std::setw( 5 ) << uVal
646  << " Diff " << std::setw( 5 ) << uVal - fvulCurrentTsMsb[fuCurrDpbIdx]
647  << " Old MsbCy " << std::setw( 5 ) << fvuCurrentTsMsbCycle[fuCurrDpbIdx];
648  } // if( (uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1) && 0 < uVal )
649 */
650 
651  // Update Status counters
652  if (uVal < fvulCurrentTsMsb[fuCurrDpbIdx]) {
653 
654  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
655  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
656  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB "
657  << std::setw(2) << fuCurrDpbIdx << " Old TsMsb " << std::setw(5)
658  << fvulCurrentTsMsb[fuCurrDpbIdx] << " Old MsbCy " << std::setw(5)
659  << fvuCurrentTsMsbCycle[fuCurrDpbIdx] << " new TsMsb "
660  << std::setw(5) << uVal;
661 
662  fvuCurrentTsMsbCycle[fuCurrDpbIdx]++;
663  } // if( uVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
664  if (uVal != fvulCurrentTsMsb[fuCurrDpbIdx] + 1 && 0 != uVal
665  && 4194303 != fvulCurrentTsMsb[fuCurrDpbIdx] && 1 != uMessIdx) {
666  LOG(info) << "TS MSb Jump in "
667  << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
668  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
669  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx << " DPB "
670  << std::setw(2) << fuCurrDpbIdx << " => Old TsMsb "
671  << std::setw(5) << fvulCurrentTsMsb[fuCurrDpbIdx] << " new TsMsb "
672  << std::setw(5) << uVal;
673  } // if( uVal + 1 != fvulCurrentTsMsb[fuCurrDpbIdx] && 4194303 != uVal && 0 != fvulCurrentTsMsb[fuCurrDpbIdx] )
674  fvulCurrentTsMsb[fuCurrDpbIdx] = uVal;
675  /*
676  if( 1 < uMessIdx )
677  {
678  fhStsDpbRawTsMsb->Fill( fuCurrDpbIdx, fvulCurrentTsMsb[fuCurrDpbIdx] );
679  fhStsDpbRawTsMsbSx->Fill( fuCurrDpbIdx, ( fvulCurrentTsMsb[fuCurrDpbIdx] & 0x1F ) );
680  fhStsDpbRawTsMsbDpb->Fill( fuCurrDpbIdx, ( fvulCurrentTsMsb[fuCurrDpbIdx] >> 5 ) );
681  } // if( 0 < uMessIdx )
682 */
683  // fhStsAsicTsMsb->Fill( fvulCurrentTsMsb[fuCurrDpbIdx], uAsicIdx );
684  /*
685  ULong64_t ulNewTsMsbTime = static_cast< ULong64_t >( stsxyter::kuHitNbTsBins )
686  * static_cast< ULong64_t >( fvulCurrentTsMsb[fuCurrDpbIdx])
687  + static_cast< ULong64_t >( stsxyter::kulTsCycleNbBins )
688  * static_cast< ULong64_t >( fvuCurrentTsMsbCycle[fuCurrDpbIdx] );
689 */
690 }
691 
692 void CbmMcbm2018UnpackerAlgoHodo::ProcessEpochInfo(
693  const stsxyter::Message& /*mess*/) {
694  // UInt_t uVal = mess.GetEpochVal();
695  // UInt_t uCurrentCycle = uVal % stsxyter::kulTsCycleNbBins;
696 
697  /*
698  // Update Status counters
699  if( usVal < fvulCurrentTsMsb[fuCurrDpbIdx] )
700  fvuCurrentTsMsbCycle[fuCurrDpbIdx] ++;
701  fvulCurrentTsMsb[fuCurrDpbIdx] = usVal;
702 
703 // fhStsAsicTsMsb->Fill( fvulCurrentTsMsb[fuCurrDpbIdx], uAsicIdx );
704 */
705 }
706 
707 void CbmMcbm2018UnpackerAlgoHodo::ProcessStatusInfo(
708  const stsxyter::Message& /*mess*/) {
709  /*
710  UInt_t uCrobIdx = usElinkIdx / fUnpackPar->GetNbElinkPerCrob();
711  Int_t uFebIdx = fUnpackPar->ElinkIdxToFebIdx( usElinkIdx );
712  UInt_t uAsicIdx = ( fuCurrDpbIdx * fUnpackPar->GetNbCrobsPerDpb() + uCrobIdx
713  ) * fUnpackPar->GetNbAsicsPerCrob()
714  + fUnpackPar->ElinkIdxToAsicIdx( usElinkIdx );
715 
716  UShort_t usStatusField = mess.GetStatusStatus();
717 
718  fhPulserStatusMessType->Fill( uAsicIdx, usStatusField );
720  if( fbPrintMessages )
721  {
722  std::cout << Form("DPB %2u TS %12u MS %12u mess %5u ", fuCurrDpbIdx, fulCurrentTsIdx, fulCurrentMsIdx, uIdx );
723  mess.PrintMess( std::cout, fPrintMessCtrl );
724  } // if( fbPrintMessages )
725 */
726 }
727 
728 // -------------------------------------------------------------------------
729 
730 // -------------------------------------------------------------------------
731 
732 Bool_t CbmMcbm2018UnpackerAlgoHodo::CreateHistograms() {
734  fhDigisTimeInRun =
735  new TH1I("hStsDigisTimeInRun",
736  "Digis Nb vs Time in Run; Time in run [s]; Digis Nb []",
737  36000,
738  0,
739  3600);
740  AddHistoToVector(fhDigisTimeInRun, "");
741 
742  fhVectorSize =
743  new TH1I("fhVectorSize",
744  "Size of the vector VS TS index; TS index; Size [bytes]",
745  10000,
746  0.,
747  10000.);
748  fhVectorCapacity =
749  new TH1I("fhVectorCapacity",
750  "Size of the vector VS TS index; TS index; Size [bytes]",
751  10000,
752  0.,
753  10000.);
754  AddHistoToVector(fhVectorSize, "");
755  AddHistoToVector(fhVectorCapacity, "");
756  /*
758  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
759  {
760  UInt_t uSector = fUnpackPar->GetGdpbToSectorOffset() + uGdpb;
761  std::string sFolder = Form( "sector%2u", uSector);
762 
763  LOG(info) << "gDPB " << uGdpb << " is " << sFolder;
764 
765  fvhHitsTimeToTriggerRaw.push_back( new TH1D(
766  Form( "hHitsTimeToTriggerRawSect%2u", uSector ),
767  Form( "Time to trigger for all neighboring hits in sector %2u; t - Ttrigg [ns]; Hits []", uSector ),
768  2000, -5000, 5000 ) );
769 
770  UInt_t uNbBinsDtSel = fdStarTriggerWinSize[ uGdpb ];
771  Double_t dMaxDtSel = fdStarTriggerDelay[ uGdpb ] + fdStarTriggerWinSize[ uGdpb ];
772  fvhHitsTimeToTriggerSel.push_back( new TH1D(
773  Form( "hHitsTimeToTriggerSelSect%2u", uSector ),
774  Form( "Time to trigger for all selected hits in sector %2u; t - Ttrigg [ns]; Hits []", uSector ),
775  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel ) );
776 
778  AddHistoToVector( fvhHitsTimeToTriggerRaw[ uGdpb ], sFolder );
779  AddHistoToVector( fvhHitsTimeToTriggerSel[ uGdpb ], sFolder );
780 
781  if( kTRUE == fbDebugMonitorMode )
782  {
783  fvhHitsTimeToTriggerSelVsDaq.push_back( new TH2D(
784  Form( "hHitsTimeToTriggerSelVsDaqSect%2u", uSector ),
785  Form( "Time to trigger for all selected hits vs DAQ CMD in sector %2u; t - Ttrigg [ns]; DAQ CMD []; Hits []", uSector ),
786  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel,
787  16, 0., 16. ) );
788 
789  fvhHitsTimeToTriggerSelVsTrig.push_back( new TH2D(
790  Form( "hHitsTimeToTriggerSelVsTrigSect%2u", uSector ),
791  Form( "Time to trigger for all selected hits vs TRIG CMD in sector %2u; t - Ttrigg [ns]; TRIG CMD []; Hits []", uSector ),
792  uNbBinsDtSel, fdStarTriggerDelay[ uGdpb ], dMaxDtSel,
793  16, 0., 16. ) );
794 
795  fvhTriggerDt.push_back( new TH1I(
796  Form( "hTriggerDtSect%2u", uSector ),
797  Form( "Trigger time difference between sector %2u and the first sector, full events only; Ttrigg%2u - TtriggRef [Clk]; events []",
798  uSector, uSector ),
799  200, -100, 100 ) );
800 
803  UInt_t uNbBinsInTs = fdMsSizeInNs * 111 / 1000. / 10.;
804  UInt_t uNbBinsInMs = fdMsSizeInNs * 20 / 1000. / 10.;
805 
806  fvhTriggerDistributionInTs.push_back( new TH1I( Form( "hTriggerDistInTsSect%2u", uSector ),
807  Form( "Trigger distribution inside TS in sector %2u; Time in TS [us]; Trigger [];", uSector ),
808  uNbBinsInTs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 101 / 1000. - 0.5 ) );
809 
810  fvhTriggerDistributionInMs.push_back( new TH1I( Form( "hTriggerDistInMsSect%2u", uSector ),
811  Form( "Trigger distribution inside MS in sector %2u; Time in MS [us]; Trigger [];", uSector ),
812  uNbBinsInMs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 10 / 1000. - 0.5 ) );
813 
814  fvhMessDistributionInMs.push_back( new TH1I( Form( "hMessDistInMsSect%2u", uSector ),
815  Form( "Messages distribution inside MS in sector %2u; Time in MS [us]; Trigger [];", uSector ),
816  uNbBinsInMs, -0.5 - fdMsSizeInNs * 10 / 1000., fdMsSizeInNs * 10 / 1000. - 0.5 ) );
817 
819  AddHistoToVector( fvhHitsTimeToTriggerSelVsDaq[ uGdpb ], sFolder );
820  AddHistoToVector( fvhHitsTimeToTriggerSelVsTrig[ uGdpb ], sFolder );
821  AddHistoToVector( fvhTriggerDt[ uGdpb ], sFolder );
822  AddHistoToVector( fvhTriggerDistributionInTs[ uGdpb ], sFolder );
823  AddHistoToVector( fvhTriggerDistributionInMs[ uGdpb ], sFolder );
824  AddHistoToVector( fvhMessDistributionInMs[ uGdpb ], sFolder );
825  } // if( kTRUE == fbDebugMonitorMode )
826  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
827 
829  fhEventNbPerTs = new TH1I( "hEventNbPerTs",
830  "Number of Events per TS; Events []; TS []",
831  1000 , 0, 1000 );
832 
833  fhEventSizeDistribution = new TH1I( "hEventSizeDistribution",
834  "Event size distribution; Event size [byte]; Events []",
835  CbmTofStarSubevent2019::GetMaxOutputSize()/8 , 0, CbmTofStarSubevent2019::GetMaxOutputSize() );
836 
837  fhEventSizeEvolution = new TProfile( "hEventSizeEvolution",
838  "Event size evolution; Time in run [min]; mean Event size [byte];",
839  14400, 0, 14400 );
840 
841  fhEventNbEvolution = new TH1I( "hEventNbEvolution",
842  "Event number evolution; Time in run [min]; Events [];",
843  14400, 0, 14400 );
844 
846  AddHistoToVector( fhEventNbPerTs, "eventbuilder" );
847  AddHistoToVector( fhEventSizeDistribution, "eventbuilder" );
848  AddHistoToVector( fhEventSizeEvolution, "eventbuilder" );
849  AddHistoToVector( fhEventNbEvolution, "eventbuilder" );
850 
851  if( kTRUE == fbDebugMonitorMode )
852  {
855  UInt_t uNbBinsInTs = fdMsSizeInNs * 101 / 1000. / 10.;
856 
857  fhEventNbDistributionInTs = new TH1I( "hEventNbDistributionInTs",
858  "Event number distribution inside TS; Time in TS [us]; Events [];",
859  uNbBinsInTs, -0.5, fdMsSizeInNs * 101 / 1000. - 0.5 );
860 
861  fhEventSizeDistributionInTs = new TProfile( "hEventSizeDistributionInTs",
862  "Event size distribution inside TS; Time in TS [us]; mean Event size [Byte];",
863  uNbBinsInTs, -0.5, fdMsSizeInNs * 101 / 1000. - 0.5 );
864 
865  fhRawTriggersStats = new TH2I(
866  "hRawTriggersStats",
867  "Raw triggers statistics per sector; ; Sector []; Messages []",
868  5, 0, 5,
869  12, 13, 25 );
870  fhRawTriggersStats->GetXaxis()->SetBinLabel( 1, "A");
871  fhRawTriggersStats->GetXaxis()->SetBinLabel( 2, "B");
872  fhRawTriggersStats->GetXaxis()->SetBinLabel( 3, "C");
873  fhRawTriggersStats->GetXaxis()->SetBinLabel( 4, "D");
874  fhRawTriggersStats->GetXaxis()->SetBinLabel( 5, "F");
875 
876  fhMissingTriggersEvolution = new TH2I(
877  "hMissingTriggersEvolution",
878  "Missing trigger counts per sector vs time in run; Time in run [min]; Sector []; Missing triggers []",
879  14400, 0, 14400,
880  12, 13, 25 );
881 
883  AddHistoToVector( fhEventNbDistributionInTs, "eventbuilder" );
884  AddHistoToVector( fhEventSizeDistributionInTs, "eventbuilder" );
885  AddHistoToVector( fhRawTriggersStats, "eventbuilder" );
886  AddHistoToVector( fhMissingTriggersEvolution, "eventbuilder" );
887  } // if( kTRUE == fbDebugMonitorMode )
888 
890  Double_t w = 10;
891  Double_t h = 10;
892 
894  fcTimeToTrigRaw = new TCanvas( "cTimeToTrigRaw", "Raw Time to trig for all sectors", w, h);
895  fcTimeToTrigRaw->Divide( 2, fuNrOfGdpbs / 2 );
896  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
897  {
898  fcTimeToTrigRaw->cd( 1 + uGdpb );
899  gPad->SetGridx();
900  gPad->SetGridy();
901  gPad->SetLogy();
902  fvhHitsTimeToTriggerRaw[ uGdpb ]->Draw();
903  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
904 
906  fcTimeToTrigSel = new TCanvas( "cTimeToTrigSel", "Selected Time to trig for all sectors", w, h);
907  fcTimeToTrigSel->Divide( 2, fuNrOfGdpbs / 2 );
908  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
909  {
910  fcTimeToTrigSel->cd( 1 + uGdpb );
911  gPad->SetGridx();
912  gPad->SetGridy();
913  gPad->SetLogy();
914  fvhHitsTimeToTriggerSel[ uGdpb ]->Draw();
915  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
916 
917  if( kTRUE == fbDebugMonitorMode )
918  {
920  fcTrigDistMs = new TCanvas( "cTrigDistMs", "Trigger time to MS start for all sectors", w, h);
921  fcTrigDistMs->Divide( 2, fuNrOfGdpbs / 2 );
922  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
923  {
924  fcTrigDistMs->cd( 1 + uGdpb );
925  gPad->SetGridx();
926  gPad->SetGridy();
927  gPad->SetLogy();
928  fvhTriggerDistributionInMs[ uGdpb ]->Draw();
929  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
930 
932  fcMessDistMs = new TCanvas( "cMessDistMs", "Message time to MS start for all sectors", w, h);
933  fcMessDistMs->Divide( 2, fuNrOfGdpbs / 2 );
934  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
935  {
936  fcMessDistMs->cd( 1 + uGdpb );
937  gPad->SetGridx();
938  gPad->SetGridy();
939  gPad->SetLogy();
940  fvhMessDistributionInMs[ uGdpb ]->Draw();
941  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
942  } // if( kTRUE == fbDebugMonitorMode )
943 
945  fcEventBuildStats = new TCanvas( "cEvtBuildStats", "Event building statistics", w, h);
946  if( kTRUE == fbDebugMonitorMode )
947  fcEventBuildStats->Divide( 2, 3 );
948  else fcEventBuildStats->Divide( 2, 2 );
949 
950  fcEventBuildStats->cd( 1 );
951  gPad->SetGridx();
952  gPad->SetGridy();
953  gPad->SetLogy();
954  fhEventNbPerTs->Draw();
955 
956  fcEventBuildStats->cd( 2 );
957  gPad->SetGridx();
958  gPad->SetGridy();
959  gPad->SetLogy();
960  fhEventSizeDistribution->Draw();
961 
962  fcEventBuildStats->cd( 3 );
963  gPad->SetGridx();
964  gPad->SetGridy();
965  gPad->SetLogy();
966  fhEventSizeEvolution->Draw();
967 
968  fcEventBuildStats->cd( 4 );
969  gPad->SetGridx();
970  gPad->SetGridy();
971  gPad->SetLogy();
972  fhEventNbEvolution->Draw();
973 
974  if( kTRUE == fbDebugMonitorMode )
975  {
976  fcEventBuildStats->cd( 5 );
977  gPad->SetGridx();
978  gPad->SetGridy();
979  gPad->SetLogy();
980  fhEventNbDistributionInTs->Draw();
981 
982  fcEventBuildStats->cd( 6 );
983  gPad->SetGridx();
984  gPad->SetGridy();
985  gPad->SetLogy();
986  fhEventSizeDistributionInTs->Draw();
987  } // if( kTRUE == fbDebugMonitorMode )
988 
989  AddCanvasToVector( fcEventBuildStats, "canvases" );
990 */
991  return kTRUE;
992 }
993 Bool_t CbmMcbm2018UnpackerAlgoHodo::FillHistograms() {
994  for (auto itHit = fDigiVect.begin(); itHit != fDigiVect.end(); ++itHit) {
995  fhDigisTimeInRun->Fill(itHit->GetTime() * 1e-9);
996  } // for( auto itHit = fDigiVect.begin(); itHit != fDigiVect.end(); ++itHit)
997  return kTRUE;
998 }
999 Bool_t CbmMcbm2018UnpackerAlgoHodo::ResetHistograms() {
1000  fhDigisTimeInRun->Reset();
1001  /*
1002  for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1003  {
1004  fvhHitsTimeToTriggerRaw[ uGdpb ]->Reset();
1005  fvhHitsTimeToTriggerSel[ uGdpb ]->Reset();
1006 
1007  if( kTRUE == fbDebugMonitorMode )
1008  {
1009  fvhHitsTimeToTriggerSelVsDaq[ uGdpb ]->Reset();
1010  fvhHitsTimeToTriggerSelVsTrig[ uGdpb ]->Reset();
1011  fvhTriggerDt[ uGdpb ]->Reset();
1012  fvhTriggerDistributionInTs[ uGdpb ]->Reset();
1013  fvhTriggerDistributionInMs[ uGdpb ]->Reset();
1014  fvhMessDistributionInMs[ uGdpb ]->Reset();
1015  } // if( kTRUE == fbDebugMonitorMode )
1016  } // for( UInt_t uGdpb = 0; uGdpb < fuNrOfGdpbs; ++uGdpb )
1017 
1019  fhEventNbPerTs->Reset();
1020  fhEventSizeDistribution->Reset();
1021  fhEventSizeEvolution->Reset();
1022  fhEventNbEvolution->Reset();
1023 
1024  if( kTRUE == fbDebugMonitorMode )
1025  {
1026  fhEventNbDistributionInTs->Reset();
1027  fhEventSizeDistributionInTs->Reset();
1028  fhRawTriggersStats->Reset();
1029  fhMissingTriggersEvolution->Reset();
1030  } // if( kTRUE == fbDebugMonitorMode )
1031 */
1032  return kTRUE;
1033 }
1034 // -------------------------------------------------------------------------
1035 
1036 void CbmMcbm2018UnpackerAlgoHodo::SetTimeOffsetNsAsic(UInt_t uAsicIdx,
1037  Double_t dOffsetIn) {
1038  if (uAsicIdx >= fvdTimeOffsetNsAsics.size()) {
1039  fvdTimeOffsetNsAsics.resize(uAsicIdx + 1, 0.0);
1040  } // if( uAsicIdx < fvdTimeOffsetNsAsics.size() )
1041 
1042  fvdTimeOffsetNsAsics[uAsicIdx] = dOffsetIn;
1043 }
1044 // -------------------------------------------------------------------------
CbmMcbm2018UnpackerAlgoHodo::fdCapacityIncFactor
Double_t fdCapacityIncFactor
Definition: CbmMcbm2018UnpackerAlgoHodo.h:162
CbmMcbm2018UnpackerAlgoHodo::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:126
CbmMcbm2018UnpackerAlgoHodo::fdTimeOffsetNs
Double_t fdTimeOffsetNs
Module for each FEB, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoHodo.h:108
CbmMcbm2018UnpackerAlgoHodo::fhVectorSize
TH1 * fhVectorSize
Definition: CbmMcbm2018UnpackerAlgoHodo.h:159
CbmMcbm2018HodoPar::GetFebAdcOffset
Double_t GetFebAdcOffset(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:377
CbmMcbm2018UnpackerAlgoHodo::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:121
CbmMcbm2018UnpackerAlgoHodo::fDpbIdIndexMap
std::map< UInt_t, UInt_t > fDpbIdIndexMap
Total number of STS DPBs in system.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:91
CbmStar2019Algo< CbmStsDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018HodoPar::GetNbAsicsPerCrob
static constexpr UInt_t GetNbAsicsPerCrob()
Definition: CbmMcbm2018HodoPar.h:43
CbmMcbm2018UnpackerAlgoHodo::fvdTimeOffsetNsAsics
std::vector< Double_t > fvdTimeOffsetNsAsics
Definition: CbmMcbm2018UnpackerAlgoHodo.h:109
CbmMcbm2018UnpackerAlgoHodo::fviFebModuleIdx
std::vector< std::vector< std::vector< Int_t > > > fviFebModuleIdx
Number of StsXyter ASICs.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:97
CbmMcbm2018UnpackerAlgoHodo::fviFebAddress
std::vector< Int_t > fviFebAddress
ADC offset in e-, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoHodo.h:103
CbmStar2019Algo< CbmStsDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018UnpackerAlgoHodo::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018UnpackerAlgoHodo.h:116
CbmMcbm2018UnpackerAlgoHodo::fmMsgCounter
std::map< stsxyter::MessType, UInt_t > fmMsgCounter
Definition: CbmMcbm2018UnpackerAlgoHodo.h:126
CbmMcbm2018UnpackerAlgoHodo::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:130
CbmMcbm2018HodoPar::GetFebModuleIdx
Int_t GetFebModuleIdx(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:315
stsxyter::Message
Definition: StsXyterMessage.h:165
stsxyter::MessType::Status
@ Status
CbmMcbm2018UnpackerAlgoHodo::fvbCrobActiveFlag
std::vector< std::vector< Bool_t > > fvbCrobActiveFlag
Map of DPB Identifier to DPB index.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:93
CbmMcbm2018HodoPar.h
CbmMcbm2018HodoPar::GetNbFebsPerCrob
static constexpr UInt_t GetNbFebsPerCrob()
Definition: CbmMcbm2018HodoPar.h:38
CbmStar2019Algo< CbmStsDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018HodoPar::ElinkIdxToAsicIdx
UInt_t ElinkIdxToAsicIdx(UInt_t uElink)
Definition: CbmMcbm2018HodoPar.h:55
CbmMcbm2018HodoPar::GetNrOfFebs
UInt_t GetNrOfFebs()
Definition: CbmMcbm2018HodoPar.h:77
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
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
CbmMcbm2018HodoPar::GetNbElinkPerCrob
static constexpr UInt_t GetNbElinkPerCrob()
Definition: CbmMcbm2018HodoPar.h:37
CbmStar2019Algo< CbmStsDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
CbmMcbm2018UnpackerAlgoHodo::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:81
CbmMcbm2018UnpackerAlgoHodo::ProcessEpochInfo
void ProcessEpochInfo(const stsxyter::Message &mess)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:692
CbmMcbm2018UnpackerAlgoHodo::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:993
CbmMcbm2018UnpackerAlgoHodo::fvuCurrentTsMsbCycle
std::vector< UInt_t > fvuCurrentTsMsbCycle
Current TS MSB for each DPB.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:138
stsxyter::kulTsCycleNbBins
static const uint64_t kulTsCycleNbBins
Definition: StsXyterMessage.h:152
CbmMcbm2018UnpackerAlgoHodo::Finish
virtual void Finish()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:94
CbmMcbm2018HodoPar::ElinkIdxToFebIdx
Int_t ElinkIdxToFebIdx(UInt_t uElink)
Definition: CbmMcbm2018HodoPar.cxx:122
CbmMcbm2018UnpackerAlgoHodo::fviModAddress
std::vector< Int_t > fviModAddress
Total number of STS modules in the setup.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:88
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
CbmStar2019Algo< CbmStsDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
stsxyter::Message::GetHitAdc
uint16_t GetHitAdc() const
For Hit data: Returns ADC value (5 bit field)
Definition: StsXyterMessage.h:277
CbmMcbm2018UnpackerAlgoHodo::ProcessTsMsbInfo
void ProcessTsMsbInfo(const stsxyter::Message &mess, UInt_t uMessIdx=0, UInt_t uMsIdx=0)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:629
CbmMcbm2018UnpackerAlgoHodo::Reset
virtual void Reset()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:93
CbmMcbm2018UnpackerAlgoHodo::fvdFebAdcOffs
std::vector< std::vector< std::vector< Double_t > > > fvdFebAdcOffs
ADC gain in e-/b, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoHodo.h:101
stsxyter::MessType::Empty
@ Empty
CbmMcbm2018HodoPar::GetModuleAddress
UInt_t GetModuleAddress(UInt_t uModuleIdx)
Definition: CbmMcbm2018HodoPar.cxx:182
CbmMcbm2018HodoPar::GetNbCrobsPerDpb
static constexpr UInt_t GetNbCrobsPerDpb()
Definition: CbmMcbm2018HodoPar.h:36
CbmMcbm2018UnpackerAlgoHodo::fvulCurrentTsMsb
std::vector< ULong64_t > fvulCurrentTsMsb
Definition: CbmMcbm2018UnpackerAlgoHodo.h:137
CbmMcbm2018UnpackerAlgoHodo::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:999
CbmMcbm2018UnpackerAlgoHodo::fuNbFebs
UInt_t fuNbFebs
Array to hold the active flag for all CROBs, [ NbDpb ][ NbCrobPerDpb ].
Definition: CbmMcbm2018UnpackerAlgoHodo.h:94
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
stsxyter::FinalHit
Definition: StsXyterFinalHit.h:16
stsxyter::MessType::Hit
@ Hit
CbmMcbm2018HodoPar::GetChannelInModule
UInt_t GetChannelInModule(UInt_t uModuleIdx, UInt_t uChan)
Definition: CbmMcbm2018HodoPar.cxx:503
CbmMcbm2018HodoPar::GetNrOfDpbs
UInt_t GetNrOfDpbs()
Definition: CbmMcbm2018HodoPar.h:74
stsxyter::kuHitNbTsBins
static const uint32_t kuHitNbTsBins
Definition: StsXyterMessage.h:146
CbmMcbm2018UnpackerAlgoHodo::fuTsMaxVectorSize
size_t fuTsMaxVectorSize
Definition: CbmMcbm2018UnpackerAlgoHodo.h:161
CbmStar2019Algo< CbmStsDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018UnpackerAlgoHodo::GetParList
TList * GetParList()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:119
CbmStar2019Algo< CbmStsDigi >::fDigiVect
std::vector< CbmStsDigi > fDigiVect
Vector of pointers to canvases + optional folder name.
Definition: CbmStar2019Algo.h:140
CbmMcbm2018HodoPar::GetNrOfAsics
UInt_t GetNrOfAsics()
Definition: CbmMcbm2018HodoPar.h:78
CbmMcbm2018HodoPar::GetFebAdcGain
Double_t GetFebAdcGain(UInt_t uDpbIdx, UInt_t uCrobIdx, UInt_t uFebIdx)
Definition: CbmMcbm2018HodoPar.cxx:346
CbmMcbm2018UnpackerAlgoHodo::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:124
CbmMcbm2018HodoPar::GetNbOfModules
UInt_t GetNbOfModules()
Definition: CbmMcbm2018HodoPar.h:65
CbmMcbm2018UnpackerAlgoHodo::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:107
CbmMcbm2018UnpackerAlgoHodo::fuNbStsXyters
UInt_t fuNbStsXyters
Number of FEBs with StsXyter ASICs.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:95
CbmMcbm2018UnpackerAlgoHodo::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:732
CbmMcbm2018UnpackerAlgoHodo::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:132
CbmMcbm2018UnpackerAlgoHodo.h
stsxyter::kdClockCycleNs
static const double kdClockCycleNs
Definition: StsXyterMessage.h:156
stsxyter::Message::GetMessType
MessType GetMessType() const
Returns the message type, see enum MessType.
Definition: StsXyterMessage.h:259
CbmMcbm2018UnpackerAlgoHodo::ProcessStatusInfo
void ProcessStatusInfo(const stsxyter::Message &mess)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:707
CbmMcbm2018UnpackerAlgoHodo::fvmHitsInMs
std::vector< stsxyter::FinalHit > fvmHitsInMs
Hits time-sorting.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:149
CbmMcbm2018UnpackerAlgoHodo::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:273
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
CbmMcbm2018UnpackerAlgoHodo::fhDigisTimeInRun
TH1 * fhDigisTimeInRun
All hits (time in bins, ADC in bins, asic, channel) in last MS, sorted with "<" operator.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:152
CbmMcbm2018UnpackerAlgoHodo::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:258
CbmMcbm2018UnpackerAlgoHodo::SetTimeOffsetNsAsic
void SetTimeOffsetNsAsic(UInt_t uAsicIdx, Double_t dOffsetIn=0.0)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:1036
stsxyter::Message::GetHitChannel
uint16_t GetHitChannel() const
For Hit data: Returns StsXYTER channel number (7 bit field)
Definition: StsXyterMessage.h:274
CbmMcbm2018UnpackerAlgoHodo::fdTsStartTime
Double_t fdTsStartTime
Definition: CbmMcbm2018UnpackerAlgoHodo.h:119
CbmMcbm2018UnpackerAlgoHodo::fdStartTime
Double_t fdStartTime
Definition: CbmMcbm2018UnpackerAlgoHodo.h:141
CbmMcbm2018UnpackerAlgoHodo::fbMonitorMode
Bool_t fbMonitorMode
Control flags.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:78
CbmMcbm2018UnpackerAlgoHodo::CbmMcbm2018UnpackerAlgoHodo
CbmMcbm2018UnpackerAlgoHodo()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:29
CbmMcbm2018UnpackerAlgoHodo::fviFebModule
std::vector< Int_t > fviFebModule
STS address for each FEB, [ NbDpb * NbCrobPerDpb * NbFebsPerCrob ].
Definition: CbmMcbm2018UnpackerAlgoHodo.h:105
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
CbmMcbm2018UnpackerAlgoHodo::fuNbModules
UInt_t fuNbModules
Definition: CbmMcbm2018UnpackerAlgoHodo.h:86
CbmMcbm2018HodoPar::GetNbAsicsPerFeb
static constexpr UInt_t GetNbAsicsPerFeb()
Definition: CbmMcbm2018HodoPar.h:42
stsxyter::MessType::Epoch
@ Epoch
CbmMcbm2018UnpackerAlgoHodo::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018UnpackerAlgoHodo.h:117
CbmMcbm2018UnpackerAlgoHodo::fvdFebAdcGain
std::vector< std::vector< std::vector< Double_t > > > fvdFebAdcGain
Idx of the STS module for each FEB, [ NbDpb ][ NbCrobPerDpb ][ NbFebsPerCrob ], -1 if inactive.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:99
CbmMcbm2018HodoPar::IsCrobActive
Bool_t IsCrobActive(UInt_t uDpbIdx, UInt_t uCrobIdx)
Definition: CbmMcbm2018HodoPar.cxx:252
CbmMcbm2018UnpackerAlgoHodo::fhVectorCapacity
TH1 * fhVectorCapacity
Definition: CbmMcbm2018UnpackerAlgoHodo.h:160
CbmMcbm2018UnpackerAlgoHodo::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:101
CbmMcbm2018UnpackerAlgoHodo::~CbmMcbm2018UnpackerAlgoHodo
~CbmMcbm2018UnpackerAlgoHodo()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:76
CbmMcbm2018HodoPar::GetDpbId
UInt_t GetDpbId(UInt_t uDpbIdx)
Definition: CbmMcbm2018HodoPar.cxx:243
CbmStar2019Algo< CbmStsDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018HodoPar
Definition: CbmMcbm2018HodoPar.h:18
CbmMcbm2018UnpackerAlgoHodo::Init
virtual Bool_t Init()
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:88
CbmMcbm2018UnpackerAlgoHodo::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018UnpackerAlgoHodo.h:128
CbmFormatMsHeaderPrintout.h
CbmMcbm2018UnpackerAlgoHodo::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:375
CbmMcbm2018UnpackerAlgoHodo::fUnpackPar
CbmMcbm2018HodoPar * fUnpackPar
Settings from parameter file.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:84
CbmMcbm2018UnpackerAlgoHodo::ProcessHitInfo
void ProcessHitInfo(const stsxyter::Message &mess, const UShort_t &usElinkIdx, const UInt_t &uAsicIdx, const UInt_t &uMsIdx)
Definition: CbmMcbm2018UnpackerAlgoHodo.cxx:542
CbmMcbm2018UnpackerAlgoHodo::fuNrOfDpbs
UInt_t fuNrOfDpbs
STS address for the first strip of each module.
Definition: CbmMcbm2018UnpackerAlgoHodo.h:89