CbmRoot
CbmMcbm2018MonitorAlgoHodo.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018MonitorAlgoHodo -----
4 // ----- Created 03.07.2019 by P.-A. Loizeau -----
5 // ----- -----
6 // -----------------------------------------------------------------------------
7 
8 #include "CbmMcbm2018MonitorAlgoHodo.h"
9 
10 #include "CbmFormatMsHeaderPrintout.h"
11 
12 //#include "CbmMcbm2018HodoPar.h"
13 
14 #include "FairLogger.h"
15 #include "FairRootManager.h"
16 #include "FairRun.h"
17 #include "FairRunOnline.h"
18 #include "FairRuntimeDb.h"
19 
20 #include "TCanvas.h"
21 #include "TH1.h"
22 #include "TH2.h"
23 #include "TList.h"
24 #include "TProfile.h"
25 #include "TROOT.h"
26 #include "TString.h"
27 
28 #include <fstream>
29 #include <iomanip>
30 #include <iostream>
31 #include <stdint.h>
32 
33 // -------------------------------------------------------------------------
34 CbmMcbm2018MonitorAlgoHodo::CbmMcbm2018MonitorAlgoHodo()
35  : CbmStar2019Algo()
36  ,
38  fbMonitorMode(kFALSE)
39  , fbDebugMonitorMode(kFALSE)
40  , fvbMaskedComponents()
41  , fuDpbId(0x5b75)
42  , fvuElinkIdxHodo(kuNbHodos, 0)
43  , fvbHodoSwapXY(kuNbHodos, kFALSE)
44  , fvbHodoInvertX(kuNbHodos, kFALSE)
45  , fvbHodoInvertY(kuNbHodos, kFALSE)
46  , fvuAdcGainHodo(kuNbHodos, 0)
47  , fvuAdcOffsHodo(kuNbHodos, 0)
48  ,
49  /*
50  fUnpackPar( nullptr ),
51  fuNbModules( 0 ),
52  fviModuleType(),
53  fviModAddress(),
54  fuNrOfDpbs( 0 ),
55  fDpbIdIndexMap(),
56  fvbCrobActiveFlag(),
57  fuNbFebs( 0 ),
58  fuNbHodoXyters( 0 ),
59  fviFebModuleIdx(),
60  fviFebModuleSide(),
61  fviFebType(),
62  fvdFebAdcGain(),
63  fvdFebAdcOffs(),
64  fviFebAddress(),
65 */
66  fdTimeOffsetNs(0.0)
67  , fulCurrentTsIdx(0)
68  , fulCurrentMsIdx(0)
69  , fdTsStartTime(-1.0)
70  , fdTsStopTimeCore(-1.0)
71  , fvdPrevMsTime(kiMaxNbFlibLinks, -1.0)
72  , fdMsTime(-1.0)
73  , fuMsIndex(0)
74  , fmMsgCounter()
75  , fuCurrentEquipmentId(0)
76  , fuCurrDpbId(0)
77  , fiRunStartDateTimeSec(-1)
78  , fiBinSizeDatePlots(-1)
79  , fvulCurrentTsMsb()
80  , fdStartTime(-1.0)
81  , fdStartTimeMsSz(-1.0)
82  , ftStartTimeUnix(std::chrono::steady_clock::now())
83  , fvmHitsInMs()
84  , fhHodoMessType(nullptr)
85  , fhHodoStatusMessType(nullptr)
86  , fhHodoMsStatusFieldType(nullptr)
87  , fhHodoMessTypePerElink(nullptr)
88  , fhHodoChanCntRaw(kuNbHodos, nullptr)
89  , fhHodoChanAdcRaw(kuNbHodos, nullptr)
90  , fhHodoChanAdcRawProf(kuNbHodos, nullptr)
91  , fhHodoChanAdcCal(kuNbHodos, nullptr)
92  , fhHodoChanAdcCalProf(kuNbHodos, nullptr)
93  , fhHodoChanRawTs(kuNbHodos, nullptr)
94  , fhHodoChanMissEvt(kuNbHodos, nullptr)
95  , fhHodoChanMissEvtEvo(kuNbHodos, nullptr)
96  , fhHodoChanHitRateEvo(kuNbHodos, nullptr)
97  , fhHodoChanHitRateProf(kuNbHodos, nullptr)
98  , fhHodoChanDistT(kuNbHodos, nullptr)
99  , fhHodoFiberCnt(kuNbHodos, std::vector<TH1*>(kuNbAxis, nullptr))
100  , fhHodoFiberAdc(kuNbHodos, std::vector<TH2*>(kuNbAxis, nullptr))
101  , fhHodoFiberAdcProf(kuNbHodos, std::vector<TProfile*>(kuNbAxis, nullptr))
102  , fhHodoFiberHitRateEvo(kuNbHodos, std::vector<TH2*>(kuNbAxis, nullptr))
103  , fhHodoFiberCoincMapXY(kuNbHodos, nullptr)
104  , fhHodoFiberCoincTimeXY(kuNbHodos, nullptr)
105  , fhHodoFiberCoincWalkXY_X(kuNbHodos, nullptr)
106  , fhHodoFiberCoincWalkXY_Y(kuNbHodos, nullptr)
107  , fhHodoFiberCoincMapSameAB(kuNbAxis, nullptr)
108  , fhHodoFiberCoincTimeSameAB(kuNbAxis, nullptr)
109  , fhHodoFiberCoincMapDiffAB(kuNbAxis, nullptr)
110  , fhHodoFiberCoincTimeDiffAB(kuNbAxis, nullptr)
111  , fhHodoFullCoincPosA(nullptr)
112  , fhHodoFullCoincPosB(nullptr)
113  , fhHodoFullCoincCompX(nullptr)
114  , fhHodoFullCoincCompY(nullptr)
115  , fhHodoFullCoincResidualXY(nullptr)
116  , fhHodoFullCoincTimeDiff(nullptr)
117  , fhHodoFullCoincTimeWalk(kuNbHodos, std::vector<TH2*>(kuNbAxis, nullptr))
118  , fhHodoFullCoincRateEvo(nullptr)
119  , fhHodoFullCoincPosEvo(kuNbHodos, std::vector<TH2*>(kuNbAxis, nullptr))
120  , fhPrevHitDtAllAsics(nullptr)
121  , fhPrevHitDtAsicA(nullptr)
122  , fhPrevHitDtAsicB(nullptr)
123  , fhPrevHitDtAsicsAB(nullptr)
124  , fiTimeIntervalRateUpdate(-1)
125  , fviTimeSecLastRateUpdate(kuNbHodos, 0)
126  , fvdChanCountsSinceLastRateUpdate(
127  kuNbHodos,
128  std::vector<Double_t>(kuNbChanPerAsic, 0.0))
129  , fdHodoChanLastTimeForDist(kuNbHodos,
130  std::vector<Double_t>(kuNbChanPerAsic, 0.0))
131  , fuPreviousHitAsic(0)
132  , fvdPreviousHitTimePerAsic(2, 0.0)
133  , fcSummary(nullptr)
134  , fcHodoSummaryRaw(kuNbHodos, nullptr)
135  , fcHodoSummaryFiber(kuNbHodos, nullptr)
136  , fcHodoFiberCoinc(nullptr)
137  , fcHodoFiberCoincAB(nullptr)
138  , fcHodoFullCoinc(nullptr)
139  , fcHodoFullCoincPos(nullptr)
140  , fcHodoPrevHitDt(nullptr) {}
141 CbmMcbm2018MonitorAlgoHodo::~CbmMcbm2018MonitorAlgoHodo() {
143  fvmHitsInMs.clear();
144 }
145 
146 // -------------------------------------------------------------------------
147 Bool_t CbmMcbm2018MonitorAlgoHodo::Init() {
148  LOG(info) << "Initializing mCBM HODO 2019 monitor algo";
149 
150  return kTRUE;
151 }
152 void CbmMcbm2018MonitorAlgoHodo::Reset() {}
153 void CbmMcbm2018MonitorAlgoHodo::Finish() {
155 
157 }
158 
159 // -------------------------------------------------------------------------
160 Bool_t CbmMcbm2018MonitorAlgoHodo::InitContainers() {
161  LOG(info) << "Init parameter containers for CbmMcbm2018MonitorAlgoHodo";
162  Bool_t initOK = ReInitContainers();
163 
164  return initOK;
165 }
166 Bool_t CbmMcbm2018MonitorAlgoHodo::ReInitContainers() {
167  LOG(info) << "**********************************************";
168  LOG(info) << "ReInit parameter containers for CbmMcbm2018MonitorAlgoHodo";
169  /*
170  fUnpackPar = (CbmMcbm2018HodoPar*)fParCList->FindObject("CbmMcbm2018HodoPar");
171  if( nullptr == fUnpackPar )
172  return kFALSE;
173 */
174  Bool_t initOK = InitParameters();
175 
176  return initOK;
177 }
178 TList* CbmMcbm2018MonitorAlgoHodo::GetParList() {
179  if (nullptr == fParCList) fParCList = new TList();
180  /*
181  fUnpackPar = new CbmMcbm2018HodoPar("CbmMcbm2018HodoPar");
182  fParCList->Add(fUnpackPar);
183 */
184  return fParCList;
185 }
186 Bool_t CbmMcbm2018MonitorAlgoHodo::InitParameters() {
187  /*
188  fuNbModules = fUnpackPar->GetNbOfModules();
189  LOG(info) << "Nr. of STS Modules: " << fuNbModules;
190 
191  fviModuleType.resize( fuNbModules );
192  fviModAddress.resize( fuNbModules );
193  for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx)
194  {
195  fviModuleType[ uModIdx ] = fUnpackPar->GetModuleType( uModIdx );
196  fviModAddress[ uModIdx ] = fUnpackPar->GetModuleAddress( uModIdx );
197  LOG(info) << "Module #" << std::setw(2) << uModIdx
198  << " Type " << std::setw(4) << fviModuleType[ uModIdx ]
199  << " Address 0x" << std::setw(8) << std::hex <<fviModAddress[ uModIdx ]
200  << std::dec;
201  } // for( UInt_t uModIdx = 0; uModIdx < fuNbModules; ++uModIdx)
202 
203  fuNrOfDpbs = fUnpackPar->GetNrOfDpbs();
204  LOG(info) << "Nr. of STS DPBs: " << fuNrOfDpbs;
205 
206  fDpbIdIndexMap.clear();
207  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
208  {
209  fDpbIdIndexMap[ fUnpackPar->GetDpbId( uDpb ) ] = uDpb;
210  LOG(info) << "Eq. ID for DPB #" << std::setw(2) << uDpb << " = 0x"
211  << std::setw(4) << std::hex << fUnpackPar->GetDpbId( uDpb )
212  << std::dec
213  << " => " << fDpbIdIndexMap[ fUnpackPar->GetDpbId( uDpb ) ];
214  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
215 
216  fuNbFebs = fUnpackPar->GetNrOfFebs();
217  LOG(info) << "Nr. of FEBs: " << fuNbFebs;
218 
219  fuNbHodoXyters = fUnpackPar->GetNrOfAsics();
220  LOG(info) << "Nr. of HodoXyter ASICs: " << fuNbHodoXyters;
221 
222  fvbCrobActiveFlag.resize( fuNrOfDpbs );
223  fviFebModuleIdx.resize( fuNrOfDpbs );
224  fviFebModuleSide.resize( fuNrOfDpbs );
225  fviFebType.resize( fuNrOfDpbs );
226  fvdFebAdcGain.resize( fuNrOfDpbs );
227  fvdFebAdcOffs.resize( fuNrOfDpbs );
228  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
229  {
230  fvbCrobActiveFlag[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
231  fviFebModuleIdx[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
232  fviFebModuleSide[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
233  fviFebType[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
234  fvdFebAdcGain[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
235  fvdFebAdcOffs[ uDpb ].resize( fUnpackPar->GetNbCrobsPerDpb() );
236  for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
237  {
238  fvbCrobActiveFlag[ uDpb ][ uCrobIdx ] = fUnpackPar->IsCrobActive( uDpb, uCrobIdx );
239 
240  fviFebModuleIdx[ uDpb ][ uCrobIdx ].resize( fUnpackPar->GetNbFebsPerCrob() );
241  fviFebModuleSide[ uDpb ][ uCrobIdx ].resize( fUnpackPar->GetNbFebsPerCrob() );
242  fviFebType[ uDpb ][ uCrobIdx ].resize( fUnpackPar->GetNbFebsPerCrob(), -1 );
243  fvdFebAdcGain[ uDpb ][ uCrobIdx ].resize( fUnpackPar->GetNbFebsPerCrob(), 0.0 );
244  fvdFebAdcOffs[ uDpb ][ uCrobIdx ].resize( fUnpackPar->GetNbFebsPerCrob(), 0.0 );
245  for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
246  {
247  fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] = fUnpackPar->GetFebModuleIdx( uDpb, uCrobIdx, uFebIdx );
248  fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] = fUnpackPar->GetFebModuleSide( uDpb, uCrobIdx, uFebIdx );
249  fvdFebAdcGain[ uDpb ][ uCrobIdx ][ uFebIdx ] = fUnpackPar->GetFebAdcGain( uDpb, uCrobIdx, uFebIdx );
250  fvdFebAdcOffs[ uDpb ][ uCrobIdx ][ uFebIdx ] = fUnpackPar->GetFebAdcOffset( uDpb, uCrobIdx, uFebIdx );
251 
252  if( 0 <= fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] &&
253  fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] < fuNbModules &&
254  0 <= fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] &&
255  fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] < 2 )
256  {
257  switch( fviModuleType[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ] )
258  {
259  case 0: // FEB-8-1 with ZIF connector on the right
260  {
261  // P side (0) has type A (0)
262  // N side (1) has type B (1)
263  fviFebType[ uDpb ][ uCrobIdx ][ uFebIdx ] = fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ];
264 
269  fviFebAddress.push_back( fviModAddress[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ]
270  + ( fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] << 25 ) );
271 
272  break;
273  } // case 0: // FEB-8-1 with ZIF connector on the right
274  case 1: // FEB-8-1 with ZIF connector on the left
275  {
276  // P side (0) has type B (1)
277  // N side (1) has type A (0)
278  fviFebType[ uDpb ][ uCrobIdx ][ uFebIdx ] = !(fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ]);
279 
284  fviFebAddress.push_back( fviModAddress[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ]
285  + ( (!fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ]) << 25 ) );
286  break;
287  } // case 1: // FEB-8-1 with ZIF connector on the left
288  default:
289  LOG(fatal) << Form( "Bad module type for DPB #%02u CROB #%u FEB %02u: %d",
290  uDpb, uCrobIdx, uFebIdx,
291  fviModuleType[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ] );
292  break;
293  } // switch( fviModuleType[ fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ] )
294  } // FEB active and module index OK
295  else if( -1 == fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] ||
296  -1 == fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] )
297  {
298  fviFebAddress.push_back( 0 );
299  } // Module index or type is set to inactive
300  else
301  {
302  LOG(fatal) << Form( "Bad module Index and/or Side for DPB #%02u CROB #%u FEB %02u: %d %d",
303  uDpb, uCrobIdx, uFebIdx,
304  fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ],
305  fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] );
306  } // Bad module index or type for this FEB
307  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
308  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
309  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
310 
311  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
312  {
313  TString sPrintoutLine = Form( "DPB #%02u CROB Active ?: ", uDpb);
314  for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
315  {
316  sPrintoutLine += Form( "%1u", ( fvbCrobActiveFlag[ uDpb ][ uCrobIdx ] == kTRUE ) );
317  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
318  LOG(info) << sPrintoutLine;
319  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
320 
321  UInt_t uGlobalFebIdx = 0;
322  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
323  {
324  for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
325  {
326  LOG(info) << Form( "DPB #%02u CROB #%u: ", uDpb, uCrobIdx);
327  for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
328  {
329  if( 0 <= fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ] )
330  LOG(info) << Form( " FEB #%02u (%02u): Mod. Idx = %03d Side %c (%2d) Type %c (%2d) (Addr. 0x%08x) ADC gain %4.0f e- ADC Offs %5.0f e-",
331  uFebIdx, uGlobalFebIdx,
332  fviFebModuleIdx[ uDpb ][ uCrobIdx ][ uFebIdx ],
333  1 == fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ] ? 'N': 'P',
334  fviFebModuleSide[ uDpb ][ uCrobIdx ][ uFebIdx ],
335  1 == fviFebType[ uDpb ][ uCrobIdx ][ uFebIdx ] ? 'B' : 'A',
336  fviFebType[ uDpb ][ uCrobIdx ][ uFebIdx ],
337  fviFebAddress[ uGlobalFebIdx ],
338  fvdFebAdcGain[ uDpb ][ uCrobIdx ][ uFebIdx ],
339  fvdFebAdcOffs[ uDpb ][ uCrobIdx ][ uFebIdx ]
340  );
341  uGlobalFebIdx ++;
342  } // for( UInt_t uFebIdx = 0; uFebIdx < fUnpackPar->GetNbFebsPerCrob(); ++ uFebIdx )
343  } // for( UInt_t uCrobIdx = 0; uCrobIdx < fUnpackPar->GetNbCrobsPerDpb(); ++uCrobIdx )
344  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
345 
346  // Internal status initialization
347  fvulCurrentTsMsb.resize( fuNrOfDpbs );
348  fvuCurrentTsMsbCycle.resize( fuNrOfDpbs );
349  for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
350  {
351  fvulCurrentTsMsb[uDpb] = 0;
352  fvuCurrentTsMsbCycle[uDpb] = 0;
353  } // for( UInt_t uDpb = 0; uDpb < fuNrOfDpbs; ++uDpb )
354 */
355 
357  /*
358  for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
359  {
360  fhHodoFiberCnt[ uHodoIdx ].resize( kuNbAxis, nullptr );
361  fhHodoFiberAdc[ uHodoIdx ].resize( kuNbAxis, nullptr );
362  fhHodoFiberAdcProf[ uHodoIdx ].resize( kuNbAxis, nullptr );
363  fhHodoFiberHitRateEvo[ uHodoIdx ].resize( kuNbAxis, nullptr );
364  fvdChanCountsSinceLastRateUpdate[ uHodoIdx ].resize( kuNbChanPerAsic, 0.0 );
365  fdHodoChanLastTimeForDist[ uHodoIdx ].resize( kuNbChanPerAsic, 0.0 );
366  } // for( uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
367 */
368  return kTRUE;
369 }
370 // -------------------------------------------------------------------------
371 
372 void CbmMcbm2018MonitorAlgoHodo::AddMsComponentToList(size_t component,
373  UShort_t usDetectorId) {
375  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
376  if (component == fvMsComponentsList[uCompIdx]) return;
377 
379  fvMsComponentsList.push_back(component);
380 
381  LOG(info) << "CbmMcbm2018MonitorAlgoHodo::AddMsComponentToList => Component "
382  << component << " with detector ID 0x" << std::hex << usDetectorId
383  << std::dec << " added to list";
384 }
385 // -------------------------------------------------------------------------
386 
387 Bool_t CbmMcbm2018MonitorAlgoHodo::ProcessTs(const fles::Timeslice& ts) {
388  fulCurrentTsIdx = ts.index();
389  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
390 
392  if (0 == fulCurrentTsIdx) { return kTRUE; } // if( 0 == fulCurrentTsIdx )
393 
395  if (-1.0 == fdTsCoreSizeInNs) {
396  fuNbCoreMsPerTs = ts.num_core_microslices();
397  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
398  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
399  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
400  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
401  << " Core MS and " << fuNbOverMsPerTs
402  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
403  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
404 
406  fuNbMsLoop = fuNbCoreMsPerTs;
407  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
408  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
409  } // if( -1.0 == fdTsCoreSizeInNs )
410 
412  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
413  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
414 
416  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
418  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
419  ++uMsCompIdx) {
420  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
421 
422  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
423  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
424  << fuMsIndex << " for component " << uMsComp;
425  return kFALSE;
426  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
427  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
428 
430  std::sort(fvmHitsInMs.begin(), fvmHitsInMs.end());
431  /*
433  for( auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end(); ++itHitIn )
434  {
435  UInt_t uFebIdx = itHitIn->GetAsic() / fUnpackPar->GetNbAsicsPerFeb();
436  UInt_t uChanInFeb = itHitIn->GetChan()
437  + fUnpackPar->GetNbChanPerAsic() * (itHitIn->GetAsic() % fUnpackPar->GetNbAsicsPerFeb());
438 
439  ULong64_t ulTimeInNs = static_cast< ULong64_t >( itHitIn->GetTs() * stsxyter::kdClockCycleNs - fdTimeOffsetNs );
440 
441  fDigiVect.push_back( CbmHodoDigi( fviFebAddress[ uFebIdx ], uChanInFeb, ulTimeInNs, itHitIn->GetAdc() ) );
442  } // for( auto itHitIn = fvmHitsInMs.begin(); itHitIn < fvmHitsInMs.end(); ++itHitIn )
443 */
444 
445  if (kFALSE == FillHistograms()) {
446  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx << " MS "
447  << fuMsIndex;
448  return kFALSE;
449  } // if( kFALSE == FillHistograms() )
450 
452  fvmHitsInMs.clear();
453  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
454 
456  fvmHitsInMs.clear();
457 
458 
459  return kTRUE;
460 }
461 
462 Bool_t CbmMcbm2018MonitorAlgoHodo::ProcessMs(const fles::Timeslice& ts,
463  size_t uMsCompIdx,
464  size_t uMsIdx) {
465  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
466  fuCurrentEquipmentId = msDescriptor.eq_id;
467  const uint8_t* msContent =
468  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
469 
470  uint32_t uSize = msDescriptor.size;
471  fulCurrentMsIdx = msDescriptor.idx;
472 
473  Double_t dMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
474  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
475  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
476 
477  if (0 == fvbMaskedComponents.size())
478  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
479 
480  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
481 
483  if (fuDpbId != fuCurrDpbId) {
484  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
485  LOG(info)
486  << "---------------------------------------------------------------";
487  /*
488  LOG(info) << "hi hv eqid flag si sv idx/start crc size offset";
489  LOG(info) << Form( "%02x %02x %04x %04x %02x %02x %016llx %08x %08x %016llx",
490  static_cast<unsigned int>(msDescriptor.hdr_id),
491  static_cast<unsigned int>(msDescriptor.hdr_ver), msDescriptor.eq_id, msDescriptor.flags,
492  static_cast<unsigned int>(msDescriptor.sys_id),
493  static_cast<unsigned int>(msDescriptor.sys_ver), msDescriptor.idx, msDescriptor.crc,
494  msDescriptor.size, msDescriptor.offset );
495 */
496  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
497  LOG(warning) << "Could not find the sDPB index for AFCK id 0x" << std::hex
498  << fuCurrDpbId << std::dec << " in timeslice "
499  << fulCurrentTsIdx << " in microslice " << uMsIdx
500  << " component " << uMsCompIdx << "\n"
501  << "If valid this index has to be added in the STS "
502  "parameter file in the DbpIdArray field";
503  fvbMaskedComponents[uMsCompIdx] = kTRUE;
504 
507  if (1 == fulCurrentTsIdx) return kTRUE;
508  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
509  else
510  return kTRUE;
511 
512  return kFALSE;
513  } // if( fuDpbId != fuCurrDpbId )
514 
516  if (static_cast<Int_t>(fvdPrevMsTime[uMsCompIdx])
517  < static_cast<Int_t>(dMsTime)) {
519  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
521  if (0 == fviTimeSecLastRateUpdate[uHodoIdx]) {
522  fviTimeSecLastRateUpdate[uHodoIdx] = static_cast<Int_t>(dMsTime);
523  for (UInt_t uChan = 0; uChan < kuNbChanPerAsic; ++uChan) {
524  fvdChanCountsSinceLastRateUpdate[uHodoIdx][uChan] = 0.0;
525  } // for( UInt_t uChan = 0; uChan < kuNbChanPerAsic; ++uChan )
526  continue;
527  } // if( 0 == fviTimeSecLastRateUpdate[ uHodoIdx ] )
528 
529  Int_t iTimeInt =
530  static_cast<Int_t>(dMsTime) - fviTimeSecLastRateUpdate[uHodoIdx];
531  if (fiTimeIntervalRateUpdate <= iTimeInt) {
532  for (UInt_t uChan = 0; uChan < kuNbChanPerAsic; ++uChan) {
533  fhHodoChanHitRateProf[uHodoIdx]->Fill(
534  uChan,
535  fvdChanCountsSinceLastRateUpdate[uHodoIdx][uChan] / iTimeInt);
536  fvdChanCountsSinceLastRateUpdate[uHodoIdx][uChan] = 0.0;
537  } // for( UInt_t uChan = 0; uChan < kuNbChanPerAsic; ++uChan )
538 
539  fviTimeSecLastRateUpdate[uHodoIdx] = static_cast<Int_t>(dMsTime);
540  } // if( fiTimeIntervalRateUpdate <= iTimeInt )
541  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
542  } // if( static_cast<Int_t>( fvdPrevMsTime[ uMsCompIdx ] ) < static_cast<Int_t>( dMsTime ) )
543  fvdPrevMsTime[uMsCompIdx] = dMsTime;
544 
546  uint16_t uMsHeaderFlags = msDescriptor.flags;
547  for (UInt_t uBit = 0; uBit < 16; ++uBit)
548  fhHodoMsStatusFieldType->Fill(uBit, (uMsHeaderFlags >> uBit) & 0x1);
549 
551  UInt_t uTsMsbCycleHeader = std::floor(
552  fulCurrentMsIdx / (stsxyter::kulTsCycleNbBins * stsxyter::kdClockCycleNs));
553 
554  if (0 == uMsIdx) {
555  fvuCurrentTsMsbCycle = uTsMsbCycleHeader;
556  fvulCurrentTsMsb = 0;
557  } // if( 0 == uMsIdx )
558  else if (uTsMsbCycleHeader != fvuCurrentTsMsbCycle
559  && 4194303 != fvulCurrentTsMsb) {
560  LOG(warning)
561  << "TS MSB cycle from MS header does not match current cycle from data "
562  << "for TS " << std::setw(12) << fulCurrentTsIdx << " MS "
563  << std::setw(12) << fulCurrentMsIdx << " MsInTs " << std::setw(3)
564  << uMsIdx << " ====> " << fvuCurrentTsMsbCycle << " VS "
565  << uTsMsbCycleHeader;
566  fvuCurrentTsMsbCycle = uTsMsbCycleHeader;
567  }
568 
569  // If not integer number of message in input buffer, print warning/error
570  if (0 != (uSize % kuBytesPerMessage))
571  LOG(error) << "The input microslice buffer does NOT "
572  << "contain only complete nDPB messages!";
573 
574  // Compute the number of complete messages in the input microslice buffer
575  uint32_t uNbMessages =
576  (uSize - (uSize % kuBytesPerMessage)) / kuBytesPerMessage;
577 
578  // Prepare variables for the loop on contents
579  const uint32_t* pInBuff = reinterpret_cast<const uint32_t*>(msContent);
580  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
581  // Fill message
582  uint32_t ulData = static_cast<uint32_t>(pInBuff[uIdx]);
583 
584  stsxyter::Message mess(static_cast<uint32_t>(ulData & 0xFFFFFFFF));
585 
587  stsxyter::MessType typeMess = mess.GetMessType();
588  fmMsgCounter[typeMess]++;
589  fhHodoMessType->Fill(static_cast<uint16_t>(typeMess));
590 
591  switch (typeMess) {
592  case stsxyter::MessType::Hit: {
593  // Extract the eLink and Asic indices => Should GO IN the fill method now that obly hits are link/asic specific!
594  UShort_t usElinkIdx = mess.GetLinkIndex();
595  fhHodoMessTypePerElink->Fill(usElinkIdx,
596  static_cast<uint16_t>(typeMess));
597 
599  UInt_t uHodoIdx = 0;
600  Bool_t bBadElink = kTRUE;
601  for (uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx)
602  if (fvuElinkIdxHodo[uHodoIdx] == usElinkIdx) {
603  bBadElink = kFALSE;
604  break;
605  } // if( fuElinkIdxHodo[ uHodo ] == usElinkIdx )
606 
607  if (bBadElink) {
608  LOG(warning) << "CbmMcbm2018MonitorAlgoHodo::DoUnpack => "
609  << "Wrong elink Idx! Elink raw "
610  << Form("%2d", usElinkIdx);
611  continue;
612  } // if( bBadElink )
613 
614  ProcessHitInfo(mess, uHodoIdx, uMsIdx);
615  break;
616  } // case stsxyter::MessType::Hit :
617  case stsxyter::MessType::TsMsb: {
618  fhHodoMessTypePerElink->Fill(0., static_cast<uint16_t>(typeMess));
619 
620  ProcessTsMsbInfo(mess, uIdx, uMsIdx);
621  break;
622  } // case stsxyter::MessType::TsMsb :
623  case stsxyter::MessType::Epoch: {
624  fhHodoMessTypePerElink->Fill(0., static_cast<uint16_t>(typeMess));
625 
626  // The first message in the TS is a special ones: EPOCH
627  ProcessEpochInfo(mess);
628 
629  if (0 < uIdx)
630  LOG(info) << "CbmMcbm2018MonitorAlgoHodo::DoUnpack => "
631  << "EPOCH message at unexpected position in MS: message "
632  << uIdx << " VS message 0 expected!";
633  break;
634  } // case stsxyter::MessType::TsMsb :
635  case stsxyter::MessType::Status: {
636  UShort_t usElinkIdx = mess.GetStatusLink();
637  fhHodoMessTypePerElink->Fill(usElinkIdx,
638  static_cast<uint16_t>(typeMess));
639  ProcessStatusInfo(mess);
640  break;
641  } // case stsxyter::MessType::Status
642  case stsxyter::MessType::Empty: {
643  fhHodoMessTypePerElink->Fill(0., static_cast<uint16_t>(typeMess));
644  // FillTsMsbInfo( mess );
645  break;
646  } // case stsxyter::MessType::Empty :
647  case stsxyter::MessType::Dummy: {
648  fhHodoMessTypePerElink->Fill(0., static_cast<uint16_t>(typeMess));
649  break;
650  } // case stsxyter::MessType::Dummy / ReadDataAck / Ack :
651  default: {
652  LOG(fatal) << "CbmMcbm2018MonitorAlgoHodo::DoUnpack => "
653  << "Unknown message type, should never happen, stopping "
654  "here! Type found was: "
655  << static_cast<int>(typeMess);
656  }
657  } // switch( typeMess )
658  } // for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx ++)
659 
660  return kTRUE;
661 }
662 
663 // -------------------------------------------------------------------------
664 void CbmMcbm2018MonitorAlgoHodo::ProcessHitInfo(stsxyter::Message mess,
665  const UInt_t& uHodoIdx,
666  const UInt_t& /*uMsIdx*/) {
667  UShort_t usChan = mess.GetHitChannel();
668  UShort_t usRawAdc = mess.GetHitAdc();
669  // UShort_t usTsOver = mess.GetHitTimeOver();
670  UShort_t usRawTs = mess.GetHitTime();
671 
672  fhHodoChanCntRaw[uHodoIdx]->Fill(usChan);
673  fhHodoChanAdcRaw[uHodoIdx]->Fill(usChan, usRawAdc);
674  fhHodoChanAdcRawProf[uHodoIdx]->Fill(usChan, usRawAdc);
675  fhHodoChanRawTs[uHodoIdx]->Fill(usChan, usRawTs);
676  fhHodoChanMissEvt[uHodoIdx]->Fill(usChan, mess.IsHitMissedEvts());
677 
678  /*
679  Double_t dCalAdc = fvdFebAdcOffs[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ]
680  + (usRawAdc - 1)* fvdFebAdcGain[ fuCurrDpbIdx ][ uCrobIdx ][ uFebIdx ];
681  fhHodoChanAdcCal[ uHodoIdx ]->Fill( usChan, dCalAdc );
682  fhHodoChanAdcCalProf[ uHodoIdx ]->Fill( usChan, dCalAdc );
683 */
684 
686  UInt_t uAxis = kuChannelToPlaneMap[usChan];
687  UInt_t uFiber = kuChannelToFiberMap[usChan];
688 
690  fhHodoFiberCnt[uHodoIdx][uAxis]->Fill(uFiber);
691  fhHodoFiberAdc[uHodoIdx][uAxis]->Fill(uFiber, usRawAdc);
692  fhHodoFiberAdcProf[uHodoIdx][uAxis]->Fill(uFiber, usRawAdc);
693 
696  Long64_t ulHitTime = usRawTs;
697  ulHitTime += static_cast<ULong64_t>(stsxyter::kuHitNbTsBins)
698  * static_cast<ULong64_t>(fvulCurrentTsMsb)
699  + static_cast<ULong64_t>(stsxyter::kulTsCycleNbBins)
700  * static_cast<ULong64_t>(fvuCurrentTsMsbCycle);
701 
703  Double_t dHitTimeNs = ulHitTime * stsxyter::kdClockCycleNs;
704 
706  fhHodoChanDistT[uHodoIdx]->Fill(
707  dHitTimeNs - fdHodoChanLastTimeForDist[uHodoIdx][usChan], usChan);
708  fdHodoChanLastTimeForDist[uHodoIdx][usChan] = dHitTimeNs;
709 
710  fvmHitsInMs.push_back(
711  stsxyter::FinalHit(ulHitTime, usRawAdc, uHodoIdx, uFiber, uAxis, 0));
712 
714  if (-1 == fdStartTime) fdStartTime = dHitTimeNs;
715 
716  // Fill histos with time as X axis
717  Double_t dTimeSinceStartSec = (dHitTimeNs - fdStartTime) * 1e-9;
718  // Double_t dTimeSinceStartMin = dTimeSinceStartSec / 60.0;
719 
720  fvdChanCountsSinceLastRateUpdate[uHodoIdx][usChan] += 1;
721 
722  fhHodoChanHitRateEvo[uHodoIdx]->Fill(dTimeSinceStartSec, usChan);
723  fhHodoFiberHitRateEvo[uHodoIdx][uAxis]->Fill(dTimeSinceStartSec, uFiber);
724  if (mess.IsHitMissedEvts()) {
725  fhHodoChanMissEvtEvo[uHodoIdx]->Fill(dTimeSinceStartSec, usChan);
726  } // if( mess.IsHitMissedEvts() )
727 }
728 
729 void CbmMcbm2018MonitorAlgoHodo::ProcessTsMsbInfo(stsxyter::Message mess,
730  UInt_t uMessIdx,
731  UInt_t uMsIdx) {
732  UInt_t uVal = mess.GetTsMsbVal();
733 
734  // Update Status counters
735  if (uVal < fvulCurrentTsMsb) {
736 
737  LOG(info) << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
738  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
739  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx
740  << " Old TsMsb " << std::setw(5) << fvulCurrentTsMsb
741  << " Old MsbCy " << std::setw(5) << fvuCurrentTsMsbCycle
742  << " new TsMsb " << std::setw(5) << uVal;
743 
744  fvuCurrentTsMsbCycle++;
745  } // if( uVal < fvulCurrentTsMsb )
746  if (uVal != fvulCurrentTsMsb + 1 && 0 != uVal && 4194303 != fvulCurrentTsMsb
747  && 1 != uMessIdx) // 1st TS MSB in MS always repat of last in prev MS
748  {
749  LOG(info) << "TS MSb Jump in "
750  << " TS " << std::setw(12) << fulCurrentTsIdx << " MS "
751  << std::setw(12) << fulCurrentMsIdx << " MS Idx " << std::setw(4)
752  << uMsIdx << " Msg Idx " << std::setw(5) << uMessIdx
753  << " => Old TsMsb " << std::setw(5) << fvulCurrentTsMsb
754  << " new TsMsb " << std::setw(5) << uVal;
755  } // if( uVal + 1 != fvulCurrentTsMsb && 4194303 != uVal && 0 != fvulCurrentTsMsb && 1 != uMessIdx )
756  fvulCurrentTsMsb = uVal;
757  /*
758  ULong64_t ulNewTsMsbTime = static_cast< ULong64_t >( stsxyter::kuHitNbTsBins )
759  * static_cast< ULong64_t >( fvulCurrentTsMsb )
760  + static_cast< ULong64_t >( stsxyter::kulTsCycleNbBins )
761  * static_cast< ULong64_t >( fvuCurrentTsMsbCycle );
762 */
763 }
764 
765 void CbmMcbm2018MonitorAlgoHodo::ProcessEpochInfo(stsxyter::Message /*mess*/) {
766  // UInt_t uVal = mess.GetEpochVal();
767  // UInt_t uCurrentCycle = uVal % stsxyter::kulTsCycleNbBins;
768 
769  /*
770  // Update Status counters
771  if( usVal < fvulCurrentTsMsb )
772  fvuCurrentTsMsbCycle ++;
773  fvulCurrentTsMsb = usVal;
774 */
775 }
776 
777 void CbmMcbm2018MonitorAlgoHodo::ProcessStatusInfo(stsxyter::Message /*mess*/) {
778  /*
779  UInt_t uCrobIdx = usElinkIdx / XXXX
780  Int_t uFebIdx = XXXX
781  UInt_t uAsicIdx = XXX
782 
783  UShort_t usStatusField = mess.GetStatusStatus();
784 
785  fhPulserStatusMessType->Fill( uAsicIdx, usStatusField );
787  if( fbPrintMessages )
788  {
789  std::cout << Form("TS %12u MS %12u mess %5u ", fulCurrentTsIdx, fulCurrentMsIdx, uIdx );
790  mess.PrintMess( std::cout, fPrintMessCtrl );
791  } // if( fbPrintMessages )
792 */
793 }
794 
795 // -------------------------------------------------------------------------
796 
797 // -------------------------------------------------------------------------
798 
799 Bool_t CbmMcbm2018MonitorAlgoHodo::CreateHistograms() {
800  fhHodoMessType =
801  new TH1I("hHodoMessType", "Nb of message for each type; Type", 6, 0., 6.);
802  fhHodoMessType->GetXaxis()->SetBinLabel(1, "Dummy");
803  fhHodoMessType->GetXaxis()->SetBinLabel(2, "Hit");
804  fhHodoMessType->GetXaxis()->SetBinLabel(3, "TsMsb");
805  fhHodoMessType->GetXaxis()->SetBinLabel(4, "Epoch");
806  fhHodoMessType->GetXaxis()->SetBinLabel(5, "Status");
807  fhHodoMessType->GetXaxis()->SetBinLabel(6, "Empty");
808 
809  fhHodoStatusMessType = new TH2I(
810  "hHodoStatusMessType",
811  "Nb of status message of each type for each DPB; ASIC; Status Type",
812  kuNbHodos,
813  0,
814  kuNbHodos,
815  16,
816  0.,
817  16.);
818  /*
819  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 1, "Dummy");
820  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 2, "Hit");
821  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 3, "TsMsb");
822  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 4, "Epoch");
823 */
824 
825  fhHodoMsStatusFieldType = new TH2I(
826  "hHodoMsStatusFieldType",
827  "For each flag in the MS header, ON/OFF counts; Flag bit []; ON/OFF; MS []",
828  16,
829  -0.5,
830  15.5,
831  2,
832  -0.5,
833  1.5);
834  /*
835  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 1, "Dummy");
836  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 2, "Hit");
837  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 3, "TsMsb");
838  fhHodoStatusMessType->GetYaxis()->SetBinLabel( 4, "Epoch");
839 */
840 
841  fhHodoMessTypePerElink =
842  new TH2I("hHodoMessTypePerElink",
843  "Nb of message of each type for each eLink; eLink; Type",
844  kuNbElinksDpb,
845  0,
846  kuNbElinksDpb,
847  6,
848  0.,
849  6.);
850  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(1, "Dummy");
851  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(2, "Hit");
852  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(3, "TsMsb");
853  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(4, "Epoch");
854  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(5, "Status");
855  fhHodoMessTypePerElink->GetYaxis()->SetBinLabel(6, "Empty");
856 
857  AddHistoToVector(fhHodoMessType, "MessTypes");
858  AddHistoToVector(fhHodoStatusMessType, "MessTypes");
859  AddHistoToVector(fhHodoMsStatusFieldType, "MessTypes");
860  AddHistoToVector(fhHodoMessTypePerElink, "MessTypes");
861 
862  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
865  fhHodoChanCntRaw[uHodoIdx] = new TH1I(
866  Form("hHodoChanCntRaw_%u", uHodoIdx),
867  Form("Hits Count per channel, Hodo #%u; Channel; Hits []", uHodoIdx),
868  kuNbChanPerAsic,
869  -0.5,
870  kuNbChanPerAsic - 0.5);
871 
873  fhHodoChanAdcRaw[uHodoIdx] =
874  new TH2I(Form("hHodoChanAdcRaw_%u", uHodoIdx),
875  Form("Raw Adc distribution per channel, Hodo #%u; Channel []; "
876  "Adc []; Hits []",
877  uHodoIdx),
878  kuNbChanPerAsic,
879  -0.5,
880  kuNbChanPerAsic - 0.5,
881  stsxyter::kuHitNbAdcBins,
882  -0.5,
883  stsxyter::kuHitNbAdcBins - 0.5);
884 
886  fhHodoChanAdcRawProf[uHodoIdx] = new TProfile(
887  Form("hHodoChanAdcRawProf_%u", uHodoIdx),
888  Form("Raw Adc prodile per channel, Hodo #%u; Channel []; Adc []",
889  uHodoIdx),
890  kuNbChanPerAsic,
891  -0.5,
892  kuNbChanPerAsic - 0.5);
893  /*
895  fhHodoChanAdcCal[ uHodoIdx ] = new TH2I( Form( "hHodoChanAdcCal_%u", uHodoIdx ),
896  Form( "Cal. Adc distribution per channel, Hodo #%u; Channel []; Adc [e-]; Hits []", uHodoIdx ),
897  kuNbChanPerAsic, -0.5, kuNbChanPerAsic - 0.5,
898  50, 0., 100000. );
899 
901  fhHodoChanAdcCalProf[ uHodoIdx ] = new TProfile( Form( "hHodoChanAdcCalProf_%u", uHodoIdx ),
902  Form( "Cal. Adc prodile per channel, Hodo #%u; Channel []; Adc [e-]", uHodoIdx ),
903  kuNbChanPerAsic, -0.5, kuNbChanPerAsic - 0.5 );
904 */
906  fhHodoChanRawTs[uHodoIdx] =
907  new TH2I(Form("hHodoChanRawTs_%u", uHodoIdx),
908  Form("Raw Timestamp distribution per channel, FEB #%03u; "
909  "Channel []; Ts []; Hits []",
910  uHodoIdx),
911  kuNbChanPerAsic,
912  -0.5,
913  kuNbChanPerAsic - 0.5,
914  stsxyter::kuHitNbTsBins,
915  -0.5,
916  stsxyter::kuHitNbTsBins - 0.5);
917 
919  fhHodoChanMissEvt[uHodoIdx] =
920  new TH2I(Form("hHodoChanMissEvt_%u", uHodoIdx),
921  Form("Missed Event flags per channel, Hodo #%u; Channel []; "
922  "Miss Evt []; Hits []",
923  uHodoIdx),
924  kuNbChanPerAsic,
925  -0.5,
926  kuNbChanPerAsic - 0.5,
927  2,
928  -0.5,
929  1.5);
930 
932  fhHodoChanMissEvtEvo[uHodoIdx] =
933  new TH2I(Form("hHodoChanMissEvtEvo_%u", uHodoIdx),
934  Form("Missed Evt flags per second & channel in Hodo #%u; Time "
935  "[s]; Channel []; Missed Evt flags []",
936  uHodoIdx),
937  1800,
938  0,
939  1800,
940  kuNbChanPerAsic,
941  -0.5,
942  kuNbChanPerAsic - 0.5);
943 
945  fhHodoChanHitRateEvo[uHodoIdx] = new TH2I(
946  Form("hHodoChanHitRateEvo_%u", uHodoIdx),
947  Form(
948  "Hits per second & channel in Hodo #%u; Time [s]; Channel []; Hits []",
949  uHodoIdx),
950  1800,
951  0,
952  1800,
953  kuNbChanPerAsic,
954  -0.5,
955  kuNbChanPerAsic - 0.5);
956 
958  fhHodoChanHitRateProf[uHodoIdx] = new TProfile(
959  Form("hHodoChanHitRateProf_%u", uHodoIdx),
960  Form(
961  "Hits per second for each channel in Hodo #%u; Channel []; Hits/s []",
962  uHodoIdx),
963  kuNbChanPerAsic,
964  -0.5,
965  kuNbChanPerAsic - 0.5);
966 
968  fhHodoChanDistT[uHodoIdx] =
969  new TH2I(Form("hHodoChanDistT_%u", uHodoIdx),
970  Form("Time distance between hits on same channel in Hodo #%u; "
971  "Time difference [ns]; Channel []; ",
972  uHodoIdx),
973  1000,
974  -0.5,
975  6250.0 - 0.5,
976  kuNbChanPerAsic,
977  -0.5,
978  kuNbChanPerAsic - 0.5);
979 
981  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
982  Char_t cAxisName = (uAxis ? 'Y' : 'X');
984  fhHodoFiberCnt[uHodoIdx][uAxis] =
985  new TH1I(Form("hHodoFiberCnt%c_%u", cAxisName, uHodoIdx),
986  Form("Hits Count per Fiber, Hodo #%u Axis %c; Fiber; Hits []",
987  uHodoIdx,
988  cAxisName),
989  kuNbChanPerAsic / 2,
990  -0.5,
991  kuNbChanPerAsic / 2 - 0.5);
992 
994  fhHodoFiberAdc[uHodoIdx][uAxis] =
995  new TH2I(Form("fhHodoFiberAdc%c_%u", cAxisName, uHodoIdx),
996  Form("Raw Adc distribution per Fiber, Hodo #%u Axis %c; "
997  "Channel []; Adc []; Hits []",
998  uHodoIdx,
999  cAxisName),
1000  kuNbChanPerAsic / 2,
1001  -0.5,
1002  kuNbChanPerAsic / 2 - 0.5,
1003  stsxyter::kuHitNbAdcBins,
1004  -0.5,
1005  stsxyter::kuHitNbAdcBins - 0.5);
1006 
1008  fhHodoFiberAdcProf[uHodoIdx][uAxis] = new TProfile(
1009  Form("hHodoFiberAdcProf%c_%u", cAxisName, uHodoIdx),
1010  Form("Raw Adc prodile per Fiber, Hodo #%u Axis %c; Channel []; Adc []",
1011  uHodoIdx,
1012  cAxisName),
1013  kuNbChanPerAsic / 2,
1014  -0.5,
1015  kuNbChanPerAsic / 2 - 0.5);
1016 
1018  fhHodoFiberHitRateEvo[uHodoIdx][uAxis] =
1019  new TH2I(Form("hHodoFiberHitRateEvo%c_%u", cAxisName, uHodoIdx),
1020  Form("Hits per second & Fiber in Hodo #%u Axis %c; Time [s]; "
1021  "Channel []; Hits []",
1022  uHodoIdx,
1023  cAxisName),
1024  1800,
1025  0,
1026  1800,
1027  kuNbChanPerAsic / 2,
1028  -0.5,
1029  kuNbChanPerAsic / 2 - 0.5);
1030 
1031  AddHistoToVector(fhHodoFiberCnt[uHodoIdx][uAxis], "Fibers");
1032  AddHistoToVector(fhHodoFiberAdc[uHodoIdx][uAxis], "Fibers");
1033  AddHistoToVector(fhHodoFiberAdcProf[uHodoIdx][uAxis], "Fibers");
1034  AddHistoToVector(fhHodoFiberHitRateEvo[uHodoIdx][uAxis], "Fibers");
1035  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1036 
1039 
1042  fhHodoFiberCoincMapXY[uHodoIdx] =
1043  new TH2I(Form("hHodoFiberCoincMapXY_%u", uHodoIdx),
1044  Form("Map of coincident (X, Y) pairs in Hodo #%u; X [Fiber]; Y "
1045  "[Fiber]; Hits []",
1046  uHodoIdx),
1047  kuNbChanPerAsic / 2,
1048  -0.5,
1049  kuNbChanPerAsic / 2 - 0.5,
1050  kuNbChanPerAsic / 2,
1051  -0.5,
1052  kuNbChanPerAsic / 2 - 0.5);
1054  fhHodoFiberCoincTimeXY[uHodoIdx] =
1055  new TH1I(Form("hHodoFiberCoincTimeXY_%u", uHodoIdx),
1056  Form("Time difference of coincident (X, Y) pairs in Hodo #%u; "
1057  "t_Y - t_X [ns]; Hits []",
1058  uHodoIdx),
1059  2 * fdTimeCoincLimit + 1,
1060  -fdTimeCoincLimitNs,
1061  fdTimeCoincLimitNs);
1063  fhHodoFiberCoincWalkXY_X[uHodoIdx] =
1064  new TH2I(Form("hHodoFiberCoincWalkXY_X_%u", uHodoIdx),
1065  Form("Walk X of coincident (X, Y) pairs in Hodo #%u; ADC X "
1066  "[bin]; t_Y - t_X [ns]; Hits []",
1067  uHodoIdx),
1068  stsxyter::kuHitNbAdcBins,
1069  -0.5,
1070  stsxyter::kuHitNbAdcBins - 0.5,
1071  2 * fdTimeCoincLimit + 1,
1072  -fdTimeCoincLimitNs,
1073  fdTimeCoincLimitNs);
1074  fhHodoFiberCoincWalkXY_Y[uHodoIdx] =
1075  new TH2I(Form("hHodoFiberCoincWalkXY_Y_%u", uHodoIdx),
1076  Form("Walk X of coincident (X, Y) pairs in Hodo #%u; ADC X "
1077  "[bin]; t_Y - t_X [ns]; Hits []",
1078  uHodoIdx),
1079  stsxyter::kuHitNbAdcBins,
1080  -0.5,
1081  stsxyter::kuHitNbAdcBins - 0.5,
1082  2 * fdTimeCoincLimit + 1,
1083  -fdTimeCoincLimitNs,
1084  fdTimeCoincLimitNs);
1085 
1086  AddHistoToVector(fhHodoChanCntRaw[uHodoIdx], "Raw");
1087  AddHistoToVector(fhHodoChanAdcRaw[uHodoIdx], "Raw");
1088  AddHistoToVector(fhHodoChanAdcRawProf[uHodoIdx], "Raw");
1089  // AddHistoToVector( fhHodoChanAdcCal[ uHodoIdx ], "Raw" );
1090  // AddHistoToVector( fhHodoChanAdcCalProf[ uHodoIdx ], "Raw" );
1091  AddHistoToVector(fhHodoChanRawTs[uHodoIdx], "Raw");
1092  AddHistoToVector(fhHodoChanMissEvt[uHodoIdx], "Raw");
1093  AddHistoToVector(fhHodoChanMissEvtEvo[uHodoIdx], "Raw");
1094  AddHistoToVector(fhHodoChanHitRateEvo[uHodoIdx], "Raw");
1095  AddHistoToVector(fhHodoChanHitRateProf[uHodoIdx], "Raw");
1096  AddHistoToVector(fhHodoChanDistT[uHodoIdx], "Raw");
1097  AddHistoToVector(fhHodoFiberCoincMapXY[uHodoIdx], "Coinc");
1098  AddHistoToVector(fhHodoFiberCoincTimeXY[uHodoIdx], "Coinc");
1099  AddHistoToVector(fhHodoFiberCoincWalkXY_X[uHodoIdx], "Coinc");
1100  AddHistoToVector(fhHodoFiberCoincWalkXY_Y[uHodoIdx], "Coinc");
1101  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
1102 
1103  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1104  Char_t cAxisName = (uAxis ? 'Y' : 'X');
1105  Char_t cOtherAxisName = (uAxis ? 'X' : 'Y');
1108  fhHodoFiberCoincMapSameAB[uAxis] =
1109  new TH2I(Form("hHodoFiberCoincMapSameAB_%c%c", cAxisName, cAxisName),
1110  Form("Map of coincident (%c, %c) pairs in Hodo A and B; %c_A "
1111  "[Fiber]; %c_B [Fiber]; Hits []",
1112  cAxisName,
1113  cAxisName,
1114  cAxisName,
1115  cAxisName),
1116  kuNbChanPerAsic / 2,
1117  -0.5,
1118  kuNbChanPerAsic / 2 - 0.5,
1119  kuNbChanPerAsic / 2,
1120  -0.5,
1121  kuNbChanPerAsic / 2 - 0.5);
1123  fhHodoFiberCoincTimeSameAB[uAxis] =
1124  new TH1I(Form("hHodoFiberCoincTimeSameAB_%c%c", cAxisName, cAxisName),
1125  Form("Time difference of coincident (%c, %c) pairs in Hodo A "
1126  "and B; t_%c_B - t_%c_A [ns]; Hits []",
1127  cAxisName,
1128  cAxisName,
1129  cAxisName,
1130  cAxisName),
1131  2 * fdTimeCoincLimit + 1,
1132  -fdTimeCoincLimitNs,
1133  fdTimeCoincLimitNs);
1134 
1136  fhHodoFiberCoincMapDiffAB[uAxis] =
1137  new TH2I(Form("hHodoFiberCoincMapDiffAB_%c%c", cAxisName, cOtherAxisName),
1138  Form("Map of coincident (%c, %c) pairs in Hodo A and B; %c_A "
1139  "[Fiber]; %c_B [Fiber]; Hits []",
1140  cAxisName,
1141  cOtherAxisName,
1142  cOtherAxisName,
1143  cAxisName),
1144  kuNbChanPerAsic / 2,
1145  -0.5,
1146  kuNbChanPerAsic / 2 - 0.5,
1147  kuNbChanPerAsic / 2,
1148  -0.5,
1149  kuNbChanPerAsic / 2 - 0.5);
1151  fhHodoFiberCoincTimeDiffAB[uAxis] = new TH1I(
1152  Form("hHodoFiberCoincTimeDiffAB_%c%c", cAxisName, cOtherAxisName),
1153  Form("Time difference of coincident (%c, %c) pairs in Hodo A and B; "
1154  "t_%c_B - t_%c_A [ns]; Hits []",
1155  cAxisName,
1156  cOtherAxisName,
1157  cOtherAxisName,
1158  cAxisName),
1159  2 * fdTimeCoincLimit + 1,
1160  -fdTimeCoincLimitNs,
1161  fdTimeCoincLimitNs);
1162 
1163  AddHistoToVector(fhHodoFiberCoincMapSameAB[uAxis], "Coinc");
1164  AddHistoToVector(fhHodoFiberCoincTimeSameAB[uAxis], "Coinc");
1165  AddHistoToVector(fhHodoFiberCoincMapDiffAB[uAxis], "Coinc");
1166  AddHistoToVector(fhHodoFiberCoincTimeDiffAB[uAxis], "Coinc");
1167  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1168 
1171  fhHodoFullCoincPosA =
1172  new TH2I("fhHodoFullCoincPosA",
1173  "Position on Hodo A for coincident pairs in Hodo A and B; X_A "
1174  "[Fiber]; Y_A [Fiber]; Hits []",
1175  kuNbChanPerAsic / 2,
1176  -0.5,
1177  kuNbChanPerAsic / 2 - 0.5,
1178  kuNbChanPerAsic / 2,
1179  -0.5,
1180  kuNbChanPerAsic / 2 - 0.5);
1182  fhHodoFullCoincPosB =
1183  new TH2I("fhHodoFullCoincPosB",
1184  "Position on Hodo B for coincident pairs in Hodo A and B; X_B "
1185  "[Fiber]; Y_B [Fiber]; Hits []",
1186  kuNbChanPerAsic / 2,
1187  -0.5,
1188  kuNbChanPerAsic / 2 - 0.5,
1189  kuNbChanPerAsic / 2,
1190  -0.5,
1191  kuNbChanPerAsic / 2 - 0.5);
1193  fhHodoFullCoincCompX =
1194  new TH2I("hHodoFullCoincCompX",
1195  "Comparison of X pos for coincident pairs in Hodo A and B; X_A "
1196  "[Fiber]; X_B [Fiber]; Hits []",
1197  kuNbChanPerAsic / 2,
1198  -0.5,
1199  kuNbChanPerAsic / 2 - 0.5,
1200  kuNbChanPerAsic / 2,
1201  -0.5,
1202  kuNbChanPerAsic / 2 - 0.5);
1204  fhHodoFullCoincCompY =
1205  new TH2I("hHodoFullCoincCompY",
1206  "Comparison of Y pos for coincident pairs in Hodo A and B; Y_A "
1207  "[Fiber]; Y_B [Fiber]; Hits []",
1208  kuNbChanPerAsic / 2,
1209  -0.5,
1210  kuNbChanPerAsic / 2 - 0.5,
1211  kuNbChanPerAsic / 2,
1212  -0.5,
1213  kuNbChanPerAsic / 2 - 0.5);
1214 
1216  fhHodoFullCoincResidualXY =
1217  new TH2I("hHodoFullCoincResidualXY",
1218  "X and Y residuals for coincident pairs in Hodo A and B; X_B - "
1219  "X_A [Fiber]; Y_B - Y_A [Fiber]; Hits []",
1220  kuNbChanPerAsic + 1,
1221  -1.0 * kuNbChanPerAsic / 2 - 0.5,
1222  kuNbChanPerAsic / 2 + 0.5,
1223  kuNbChanPerAsic + 1,
1224  -1.0 * kuNbChanPerAsic / 2 - 0.5,
1225  kuNbChanPerAsic / 2 + 0.5);
1227  fhHodoFullCoincTimeDiff =
1228  new TH1I("hHodoFullCoincTimeDiff",
1229  "Time difference of coincident pairs in Hodo A and B; (t_X_B + "
1230  "t_Y_B)/2 - (t_X_A + t_Y_A)/2 [ns]; Hits []",
1231  2 * fdTimeCoincLimit + 1,
1232  -fdTimeCoincLimitNs,
1233  fdTimeCoincLimitNs);
1234 
1235  fhHodoFullCoincRateEvo = new TH1I("fhHodoFullCoincRateEvo",
1236  "Evolution of the full coincidence rate; "
1237  "Time in run [s]; Full coincidences;",
1238  1800,
1239  -0.5,
1240  1800 - 0.5);
1241 
1242  AddHistoToVector(fhHodoFullCoincPosA, "FullCoinc");
1243  AddHistoToVector(fhHodoFullCoincPosB, "FullCoinc");
1244  AddHistoToVector(fhHodoFullCoincCompX, "FullCoinc");
1245  AddHistoToVector(fhHodoFullCoincCompY, "FullCoinc");
1246  AddHistoToVector(fhHodoFullCoincResidualXY, "FullCoinc");
1247  AddHistoToVector(fhHodoFullCoincTimeDiff, "FullCoinc");
1248  AddHistoToVector(fhHodoFullCoincRateEvo, "FullCoinc");
1249 
1250  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
1251  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1252  Char_t cAxisName = (uAxis ? 'Y' : 'X');
1253  fhHodoFullCoincTimeWalk[uHodoIdx][uAxis] =
1254  new TH2I(Form("hHodoFullCoincTimeWalk_%u%c", uHodoIdx, cAxisName),
1255  Form("Time walk of coincident (A, B) pairs in Hodo #%u Axis "
1256  "%c; ADC %u_%c [bin]; Time Diff <B> - <A> [ns]; Hits []",
1257  uHodoIdx,
1258  cAxisName,
1259  uHodoIdx,
1260  cAxisName),
1261  stsxyter::kuHitNbAdcBins,
1262  -0.5,
1263  stsxyter::kuHitNbAdcBins - 0.5,
1264  2 * fdTimeCoincLimit + 1,
1265  -fdTimeCoincLimitNs,
1266  fdTimeCoincLimitNs);
1267  AddHistoToVector(fhHodoFullCoincTimeWalk[uHodoIdx][uAxis], "Walk");
1268 
1269  fhHodoFullCoincPosEvo[uHodoIdx][uAxis] = new TH2I(
1270  Form("hHodoFullCoincPosEvo_%u%c", uHodoIdx, cAxisName),
1271  Form("Time evolution of coincident (A, B) pairs position in Hodo #%u "
1272  "Axis %c; Time in run [s]; Position %u_%c [Fiber]; Hits []",
1273  uHodoIdx,
1274  cAxisName,
1275  uHodoIdx,
1276  cAxisName),
1277  2000,
1278  -0.5,
1279  1000 - 0.5,
1280  kuNbChanPerAsic / 2,
1281  -0.5,
1282  kuNbChanPerAsic / 2 - 0.5);
1283  AddHistoToVector(fhHodoFullCoincPosEvo[uHodoIdx][uAxis], "FullCoinc");
1284  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1285  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
1286 
1288  fhPrevHitDtAllAsics =
1289  new TH1I("hPrevHitDtAllAsics",
1290  "Time difference between current and previous hits in any ASIC; t "
1291  "- t_prev [ns]; Hit pairs []",
1292  10000,
1293  0.0,
1294  10000 * stsxyter::kdClockCycleNs);
1295  fhPrevHitDtAsicA = new TH1I("hPrevHitDtAsicA",
1296  "Time difference between current and previous "
1297  "hits in ASIC A; t - t_prev [ns]; Hit pairs []",
1298  10000,
1299  0.0,
1300  10000 * stsxyter::kdClockCycleNs);
1301  fhPrevHitDtAsicB = new TH1I("hPrevHitDtAsicB",
1302  "Time difference between current and previous "
1303  "hits in ASIC B; t - t_prev [ns]; Hit pairs []",
1304  10000,
1305  0.0,
1306  10000 * stsxyter::kdClockCycleNs);
1307  fhPrevHitDtAsicsAB =
1308  new TH1I("hPrevHitDtAsicsAB",
1309  "Time difference between current in ASIC A and previous hit in "
1310  "ASIC B; t - t_prev [ns]; Hit pairs []",
1311  10000,
1312  0.0,
1313  10000 * stsxyter::kdClockCycleNs);
1314 
1315  AddHistoToVector(fhPrevHitDtAllAsics, "SetupDebugging");
1316  AddHistoToVector(fhPrevHitDtAsicA, "SetupDebugging");
1317  AddHistoToVector(fhPrevHitDtAsicB, "SetupDebugging");
1318  AddHistoToVector(fhPrevHitDtAsicsAB, "SetupDebugging");
1319 
1321  Double_t w = 860;
1322  Double_t h = 480;
1323 
1324  fcSummary = new TCanvas("fcSummary", "Summary for the Hodo sDPB", w, h);
1325  fcSummary->Divide(2, 2);
1326 
1327  fcSummary->cd(1);
1328  gPad->SetGridx();
1329  gPad->SetGridy();
1330  gPad->SetLogy();
1331  fhHodoMessType->Draw("hist");
1332 
1333  fcSummary->cd(2);
1334  gPad->SetGridx();
1335  gPad->SetGridy();
1336  gPad->SetLogz();
1337  fhHodoStatusMessType->Draw("colz");
1338 
1339  fcSummary->cd(3);
1340  gPad->SetGridx();
1341  gPad->SetGridy();
1342  gPad->SetLogz();
1343  fhHodoMsStatusFieldType->Draw("colz");
1344 
1345  fcSummary->cd(4);
1346  gPad->SetGridx();
1347  gPad->SetGridy();
1348  gPad->SetLogz();
1349  fhHodoMessTypePerElink->Draw("colz");
1350 
1351  AddCanvasToVector(fcSummary, "canvases");
1352 
1353 
1354  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
1356  fcHodoSummaryRaw[uHodoIdx] =
1357  new TCanvas(Form("cHodoSummaryRaw%u", uHodoIdx),
1358  Form("Raw Summary for Hodo %u", uHodoIdx),
1359  w,
1360  h);
1361  fcHodoSummaryRaw[uHodoIdx]->Divide(4, 2);
1362 
1363  fcHodoSummaryRaw[uHodoIdx]->cd(1);
1364  gPad->SetGridx();
1365  gPad->SetGridy();
1366  gPad->SetLogy();
1367  fhHodoChanCntRaw[uHodoIdx]->Draw("hist");
1368 
1369  fcHodoSummaryRaw[uHodoIdx]->cd(2);
1370  gPad->SetGridx();
1371  gPad->SetGridy();
1372  gPad->SetLogy();
1373  fhHodoChanHitRateProf[uHodoIdx]->Draw("hist");
1374 
1375  fcHodoSummaryRaw[uHodoIdx]->cd(3);
1376  gPad->SetGridx();
1377  gPad->SetGridy();
1378  gPad->SetLogz();
1379  fhHodoChanAdcRaw[uHodoIdx]->Draw("colz");
1380 
1381  fcHodoSummaryRaw[uHodoIdx]->cd(4);
1382  gPad->SetGridx();
1383  gPad->SetGridy();
1384  fhHodoChanAdcRawProf[uHodoIdx]->Draw("hist");
1385 
1386  fcHodoSummaryRaw[uHodoIdx]->cd(5);
1387  gPad->SetGridx();
1388  gPad->SetGridy();
1389  gPad->SetLogz();
1390  fhHodoChanDistT[uHodoIdx]->Draw("colz");
1391 
1392  fcHodoSummaryRaw[uHodoIdx]->cd(6);
1393  gPad->SetGridx();
1394  gPad->SetGridy();
1395  gPad->SetLogz();
1396  fhHodoChanHitRateEvo[uHodoIdx]->Draw("colz");
1397 
1398  fcHodoSummaryRaw[uHodoIdx]->cd(7);
1399  gPad->SetGridx();
1400  gPad->SetGridy();
1401  gPad->SetLogz();
1402  fhHodoChanMissEvt[uHodoIdx]->Draw("colz");
1403 
1404  fcHodoSummaryRaw[uHodoIdx]->cd(8);
1405  gPad->SetGridx();
1406  gPad->SetGridy();
1407  gPad->SetLogz();
1408  fhHodoChanMissEvtEvo[uHodoIdx]->Draw("colz");
1409 
1411  fcHodoSummaryFiber[uHodoIdx] =
1412  new TCanvas(Form("cHodoSummaryFiber%u", uHodoIdx),
1413  Form("Fiber Summary for Hodo %u", uHodoIdx),
1414  w,
1415  h);
1416  fcHodoSummaryFiber[uHodoIdx]->Divide(4, 2);
1417 
1418  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1419  fcHodoSummaryFiber[uHodoIdx]->cd(1 + 4 * uAxis);
1420  gPad->SetGridx();
1421  gPad->SetGridy();
1422  gPad->SetLogy();
1423  fhHodoFiberCnt[uHodoIdx][uAxis]->Draw("hist");
1424 
1425  fcHodoSummaryFiber[uHodoIdx]->cd(2 + 4 * uAxis);
1426  gPad->SetGridx();
1427  gPad->SetGridy();
1428  gPad->SetLogz();
1429  fhHodoFiberAdc[uHodoIdx][uAxis]->Draw("colz");
1430 
1431  fcHodoSummaryFiber[uHodoIdx]->cd(3 + 4 * uAxis);
1432  gPad->SetGridx();
1433  gPad->SetGridy();
1434  fhHodoFiberAdcProf[uHodoIdx][uAxis]->Draw("hist");
1435 
1436  fcHodoSummaryFiber[uHodoIdx]->cd(4 + 4 * uAxis);
1437  gPad->SetGridx();
1438  gPad->SetGridy();
1439  gPad->SetLogz();
1440  fhHodoFiberHitRateEvo[uHodoIdx][uAxis]->Draw("colz");
1441  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1442 
1443  AddCanvasToVector(fcHodoSummaryRaw[uHodoIdx], "canvases");
1444  AddCanvasToVector(fcHodoSummaryFiber[uHodoIdx], "canvases");
1445  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
1446 
1447  fcHodoFiberCoinc =
1448  new TCanvas("fcHodoFiberCoinc", "X/Y coincidences in same hodoscope", w, h);
1449  fcHodoFiberCoinc->Divide(4, 2);
1450 
1451  fcHodoFiberCoinc->cd(1);
1452  gPad->SetGridx();
1453  gPad->SetGridy();
1454  gPad->SetLogz();
1455  fhHodoFiberCoincMapXY[0]->Draw("colz");
1456 
1457  fcHodoFiberCoinc->cd(2);
1458  gPad->SetGridx();
1459  gPad->SetGridy();
1460  gPad->SetLogy();
1461  fhHodoFiberCoincTimeXY[0]->Draw("hist");
1462 
1463  fcHodoFiberCoinc->cd(3);
1464  gPad->SetGridx();
1465  gPad->SetGridy();
1466  gPad->SetLogz();
1467  fhHodoFiberCoincWalkXY_X[0]->Draw("colz");
1468 
1469  fcHodoFiberCoinc->cd(4);
1470  gPad->SetGridx();
1471  gPad->SetGridy();
1472  gPad->SetLogz();
1473  fhHodoFiberCoincWalkXY_Y[0]->Draw("colz");
1474 
1475  fcHodoFiberCoinc->cd(5);
1476  gPad->SetGridx();
1477  gPad->SetGridy();
1478  gPad->SetLogz();
1479  fhHodoFiberCoincMapXY[1]->Draw("colz");
1480 
1481  fcHodoFiberCoinc->cd(6);
1482  gPad->SetGridx();
1483  gPad->SetGridy();
1484  gPad->SetLogy();
1485  fhHodoFiberCoincTimeXY[1]->Draw("hist");
1486 
1487  fcHodoFiberCoinc->cd(7);
1488  gPad->SetGridx();
1489  gPad->SetGridy();
1490  gPad->SetLogz();
1491  fhHodoFiberCoincWalkXY_X[1]->Draw("colz");
1492 
1493  fcHodoFiberCoinc->cd(8);
1494  gPad->SetGridx();
1495  gPad->SetGridy();
1496  gPad->SetLogz();
1497  fhHodoFiberCoincWalkXY_Y[1]->Draw("colz");
1498 
1499  fcHodoFiberCoincAB = new TCanvas(
1500  "fcHodoFiberCoincAB", "X/Y coincidences between hodoscopes", w, h);
1501  fcHodoFiberCoincAB->Divide(4, 2);
1502 
1503  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1504  fcHodoFiberCoincAB->cd(1 + 4 * uAxis);
1505  gPad->SetGridx();
1506  gPad->SetGridy();
1507  gPad->SetLogz();
1508  fhHodoFiberCoincMapSameAB[uAxis]->Draw("colz");
1509 
1510  fcHodoFiberCoincAB->cd(2 + 4 * uAxis);
1511  gPad->SetGridx();
1512  gPad->SetGridy();
1513  gPad->SetLogy();
1514  fhHodoFiberCoincTimeSameAB[uAxis]->Draw("hist");
1515 
1516  fcHodoFiberCoincAB->cd(3 + 4 * uAxis);
1517  gPad->SetGridx();
1518  gPad->SetGridy();
1519  gPad->SetLogz();
1520  fhHodoFiberCoincMapDiffAB[uAxis]->Draw("colz");
1521 
1522  fcHodoFiberCoincAB->cd(4 + 4 * uAxis);
1523  gPad->SetGridx();
1524  gPad->SetGridy();
1525  gPad->SetLogy();
1526  fhHodoFiberCoincTimeDiffAB[uAxis]->Draw("hist");
1527  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1528 
1529  fcHodoFullCoinc = new TCanvas(
1530  "fcHodoFullCoinc", "Full coincidences between hodoscopes", w, h);
1531  fcHodoFullCoinc->Divide(4, 2);
1532 
1533  fcHodoFullCoinc->cd(1);
1534  gPad->SetGridx();
1535  gPad->SetGridy();
1536  gPad->SetLogz();
1537  fhHodoFullCoincCompX->Draw("colz");
1538 
1539  fcHodoFullCoinc->cd(2);
1540  gPad->SetGridx();
1541  gPad->SetGridy();
1542  gPad->SetLogz();
1543  fhHodoFullCoincResidualXY->Draw("colz");
1544 
1545  fcHodoFullCoinc->cd(3);
1546  gPad->SetGridx();
1547  gPad->SetGridy();
1548  gPad->SetLogz();
1549  fhHodoFullCoincTimeWalk[0][0]->Draw("colz");
1550 
1551  fcHodoFullCoinc->cd(4);
1552  gPad->SetGridx();
1553  gPad->SetGridy();
1554  gPad->SetLogz();
1555  fhHodoFullCoincTimeWalk[0][1]->Draw("colz");
1556 
1557  fcHodoFullCoinc->cd(5);
1558  gPad->SetGridx();
1559  gPad->SetGridy();
1560  gPad->SetLogz();
1561  fhHodoFullCoincCompY->Draw("colz");
1562 
1563 
1564  fcHodoFullCoinc->cd(6);
1565  gPad->SetGridx();
1566  gPad->SetGridy();
1567  gPad->SetLogy();
1568  fhHodoFullCoincTimeDiff->Draw("hist");
1569 
1570  fcHodoFullCoinc->cd(7);
1571  gPad->SetGridx();
1572  gPad->SetGridy();
1573  gPad->SetLogz();
1574  fhHodoFullCoincTimeWalk[1][0]->Draw("colz");
1575 
1576  fcHodoFullCoinc->cd(8);
1577  gPad->SetGridx();
1578  gPad->SetGridy();
1579  gPad->SetLogz();
1580  fhHodoFullCoincTimeWalk[1][1]->Draw("colz");
1581 
1582  fcHodoFullCoincPos =
1583  new TCanvas("fcHodoFullCoincPos",
1584  "Hit Positions for Full coincidences between hodoscopes",
1585  w,
1586  h);
1587  fcHodoFullCoincPos->Divide(2);
1588 
1589  fcHodoFullCoincPos->cd(1);
1590  gPad->SetGridx();
1591  gPad->SetGridy();
1592  gPad->SetLogz();
1593  fhHodoFullCoincPosA->Draw("colz");
1594 
1595  fcHodoFullCoincPos->cd(2);
1596  gPad->SetGridx();
1597  gPad->SetGridy();
1598  gPad->SetLogz();
1599  fhHodoFullCoincPosB->Draw("colz");
1600 
1601  fcHodoFullCoincPosEvo =
1602  new TCanvas("fcHodoFullCoincPosEvo",
1603  "Hit Positions Evo for Full coincidences between hodoscopes",
1604  w,
1605  h);
1606  fcHodoFullCoincPosEvo->Divide(4);
1607 
1608  fcHodoFullCoincPosEvo->cd(1);
1609  gPad->SetGridx();
1610  gPad->SetGridy();
1611  gPad->SetLogz();
1612  fhHodoFullCoincPosEvo[0][0]->Draw("colz");
1613 
1614  fcHodoFullCoincPosEvo->cd(2);
1615  gPad->SetGridx();
1616  gPad->SetGridy();
1617  gPad->SetLogz();
1618  fhHodoFullCoincPosEvo[0][1]->Draw("colz");
1619 
1620  fcHodoFullCoincPosEvo->cd(3);
1621  gPad->SetGridx();
1622  gPad->SetGridy();
1623  gPad->SetLogz();
1624  fhHodoFullCoincPosEvo[1][0]->Draw("colz");
1625 
1626  fcHodoFullCoincPosEvo->cd(4);
1627  gPad->SetGridx();
1628  gPad->SetGridy();
1629  gPad->SetLogz();
1630  fhHodoFullCoincPosEvo[1][1]->Draw("colz");
1631 
1632  fcHodoPrevHitDt =
1633  new TCanvas("fcHodoPrevHitDt",
1634  "Time difference between current and previous hits",
1635  w,
1636  h);
1637  fcHodoPrevHitDt->Divide(2, 2);
1638 
1639  fcHodoPrevHitDt->cd(1);
1640  gPad->SetGridx();
1641  gPad->SetGridy();
1642  gPad->SetLogy();
1643  fhPrevHitDtAllAsics->Draw("hist");
1644 
1645  fcHodoPrevHitDt->cd(2);
1646  gPad->SetGridx();
1647  gPad->SetGridy();
1648  gPad->SetLogy();
1649  fhPrevHitDtAsicA->Draw("hist");
1650 
1651  fcHodoPrevHitDt->cd(3);
1652  gPad->SetGridx();
1653  gPad->SetGridy();
1654  gPad->SetLogy();
1655  fhPrevHitDtAsicB->Draw("hist");
1656 
1657  fcHodoPrevHitDt->cd(4);
1658  gPad->SetGridx();
1659  gPad->SetGridy();
1660  gPad->SetLogy();
1661  fhPrevHitDtAsicsAB->Draw("hist");
1662 
1663  AddCanvasToVector(fcHodoFiberCoinc, "canvases");
1664  AddCanvasToVector(fcHodoFiberCoincAB, "canvases");
1665  AddCanvasToVector(fcHodoFullCoinc, "canvases");
1666  AddCanvasToVector(fcHodoFullCoincPos, "canvases");
1667  AddCanvasToVector(fcHodoFullCoincPosEvo, "canvases");
1668 
1669  return kTRUE;
1670 }
1671 Bool_t CbmMcbm2018MonitorAlgoHodo::FillHistograms() {
1673  std::vector<std::vector<stsxyter::FinalHit>> lastHitHodoAxis;
1674  std::vector<std::vector<Bool_t>> bHitFoundHodoAxis;
1675  lastHitHodoAxis.resize(kuNbHodos);
1676  bHitFoundHodoAxis.resize(kuNbHodos);
1677  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
1678  lastHitHodoAxis[uHodoIdx].resize(kuNbAxis);
1679  bHitFoundHodoAxis[uHodoIdx].resize(kuNbAxis, kFALSE);
1680  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
1681 
1683  UInt_t uTotalNbHits = fvmHitsInMs.size();
1684  for (UInt_t uHit = 0; uHit < uTotalNbHits; ++uHit) {
1685  UInt_t uHodo = fvmHitsInMs[uHit].GetAsic();
1686  UInt_t uAxis = fvmHitsInMs[uHit].GetDpb();
1687  // UInt_t uFiber = fvmHitsInMs[ uHit ].GetChan();
1688 
1690  Double_t dCurrentHitTime =
1691  fvmHitsInMs[uHit].GetTs() * stsxyter::kdClockCycleNs;
1692  fhPrevHitDtAllAsics->Fill(dCurrentHitTime
1693  - fvdPreviousHitTimePerAsic[fuPreviousHitAsic]);
1694  if (0 == uHodo) {
1695  fhPrevHitDtAsicA->Fill(dCurrentHitTime - fvdPreviousHitTimePerAsic[0]);
1696  fhPrevHitDtAsicsAB->Fill(dCurrentHitTime - fvdPreviousHitTimePerAsic[1]);
1697  } // if( 0 == uHodo )
1698  else
1699  fhPrevHitDtAsicB->Fill(dCurrentHitTime - fvdPreviousHitTimePerAsic[1]);
1700 
1701  fuPreviousHitAsic = uHodo;
1702  fvdPreviousHitTimePerAsic[uHodo] = dCurrentHitTime;
1703 
1704  lastHitHodoAxis[uHodo][uAxis] = fvmHitsInMs[uHit];
1705  bHitFoundHodoAxis[uHodo][uAxis] = kTRUE;
1706 
1708  if (bHitFoundHodoAxis[uHodo][0] && bHitFoundHodoAxis[uHodo][1]) {
1709  Double_t dTimeDiffAxis =
1710  lastHitHodoAxis[uHodo][1].GetTs() * stsxyter::kdClockCycleNs
1711  - lastHitHodoAxis[uHodo][0].GetTs() * stsxyter::kdClockCycleNs;
1712 
1713  if (-fdTimeCoincLimitNs < dTimeDiffAxis
1714  && dTimeDiffAxis < fdTimeCoincLimitNs) {
1715  fhHodoFiberCoincMapXY[uHodo]->Fill(lastHitHodoAxis[uHodo][0].GetChan(),
1716  lastHitHodoAxis[uHodo][1].GetChan());
1717  fhHodoFiberCoincTimeXY[uHodo]->Fill(dTimeDiffAxis);
1718  fhHodoFiberCoincWalkXY_X[uHodo]->Fill(
1719  lastHitHodoAxis[uHodo][0].GetAdc(), dTimeDiffAxis);
1720  fhHodoFiberCoincWalkXY_Y[uHodo]->Fill(
1721  lastHitHodoAxis[uHodo][1].GetAdc(), dTimeDiffAxis);
1722  } // if( -fdTimeCoincLimitNs < dTimeDiffAxis && dTimeDiffAxis < fdTimeCoincLimitNs )
1723  } // if( bHitFoundHodoAxis[ uHodo ][ 0 ] && bHitFoundHodoAxis[ uHodo ][ 1 ] )
1724 
1726  if (bHitFoundHodoAxis[0][uAxis] && bHitFoundHodoAxis[1][uAxis]) {
1727  Double_t dTimeDiffHodoSame =
1728  lastHitHodoAxis[1][uAxis].GetTs() * stsxyter::kdClockCycleNs
1729  - lastHitHodoAxis[0][uAxis].GetTs() * stsxyter::kdClockCycleNs;
1730 
1731  if (-fdTimeCoincLimitNs < dTimeDiffHodoSame
1732  && dTimeDiffHodoSame < fdTimeCoincLimitNs) {
1733  fhHodoFiberCoincMapSameAB[uAxis]->Fill(
1734  lastHitHodoAxis[0][uAxis].GetChan(),
1735  lastHitHodoAxis[1][uAxis].GetChan());
1736  fhHodoFiberCoincTimeSameAB[uAxis]->Fill(dTimeDiffHodoSame);
1737  } // if( -fdTimeCoincLimitNs < dTimeDiffAxis && dTimeDiffAxis < fdTimeCoincLimitNs )
1738  } // if( bHitFoundHodoAxis[ 0 ][ uAxis ] && bHitFoundHodoAxis[ 1 ][ uAxis ] )
1739 
1740  UInt_t uAxisA = (uHodo ? !uAxis : uAxis);
1741  UInt_t uAxisB = (uHodo ? uAxis : !uAxis);
1742  if (bHitFoundHodoAxis[0][uAxisA] && bHitFoundHodoAxis[1][uAxisB]) {
1743  Double_t dTimeDiffHodoDiff =
1744  lastHitHodoAxis[1][uAxisB].GetTs() * stsxyter::kdClockCycleNs
1745  - lastHitHodoAxis[0][uAxisA].GetTs() * stsxyter::kdClockCycleNs;
1746 
1747  if (-fdTimeCoincLimitNs < dTimeDiffHodoDiff
1748  && dTimeDiffHodoDiff < fdTimeCoincLimitNs) {
1749  fhHodoFiberCoincMapDiffAB[uAxisA]->Fill(
1750  lastHitHodoAxis[0][uAxisA].GetChan(),
1751  lastHitHodoAxis[1][uAxisB].GetChan());
1752  fhHodoFiberCoincTimeDiffAB[uAxisA]->Fill(dTimeDiffHodoDiff);
1753  } // if( -fdTimeCoincLimitNs < dTimeDiffAxis && dTimeDiffAxis < fdTimeCoincLimitNs )
1754  }
1755 
1757  if (bHitFoundHodoAxis[0][0] && bHitFoundHodoAxis[0][1]
1758  && bHitFoundHodoAxis[1][0] && bHitFoundHodoAxis[1][1]) {
1759  Double_t dTimeDiffHodoA =
1760  lastHitHodoAxis[0][1].GetTs() * stsxyter::kdClockCycleNs
1761  - lastHitHodoAxis[0][0].GetTs() * stsxyter::kdClockCycleNs;
1762  Double_t dTimeDiffHodoB =
1763  lastHitHodoAxis[1][1].GetTs() * stsxyter::kdClockCycleNs
1764  - lastHitHodoAxis[1][0].GetTs() * stsxyter::kdClockCycleNs;
1765  Double_t dTimeDiffHodoAB =
1766  (lastHitHodoAxis[1][1].GetTs() * stsxyter::kdClockCycleNs
1767  + lastHitHodoAxis[1][0].GetTs() * stsxyter::kdClockCycleNs)
1768  / 2.0
1769  - (lastHitHodoAxis[0][1].GetTs() * stsxyter::kdClockCycleNs
1770  + lastHitHodoAxis[0][0].GetTs() * stsxyter::kdClockCycleNs)
1771  / 2.0;
1772  Double_t dTimeHitHodoAB =
1773  (lastHitHodoAxis[1][1].GetTs() * stsxyter::kdClockCycleNs
1774  + lastHitHodoAxis[1][0].GetTs() * stsxyter::kdClockCycleNs
1775  + lastHitHodoAxis[0][1].GetTs() * stsxyter::kdClockCycleNs
1776  + lastHitHodoAxis[0][0].GetTs() * stsxyter::kdClockCycleNs)
1777  / 4.0;
1778 
1779  if (-fdTimeCoincLimitNs < dTimeDiffHodoA
1780  && dTimeDiffHodoA < fdTimeCoincLimitNs
1781  && -fdTimeCoincLimitNs < dTimeDiffHodoB
1782  && dTimeDiffHodoB < fdTimeCoincLimitNs
1783  && -fdTimeCoincLimitNs < dTimeDiffHodoAB
1784  && dTimeDiffHodoAB < fdTimeCoincLimitNs) {
1785  UInt_t uPosXA = fvbHodoSwapXY[0] ? lastHitHodoAxis[0][1].GetChan()
1786  : lastHitHodoAxis[0][0].GetChan();
1787  UInt_t uPosYA = fvbHodoSwapXY[0] ? lastHitHodoAxis[0][0].GetChan()
1788  : lastHitHodoAxis[0][1].GetChan();
1789  UInt_t uPosXB = fvbHodoSwapXY[1] ? lastHitHodoAxis[1][1].GetChan()
1790  : lastHitHodoAxis[1][0].GetChan();
1791  UInt_t uPosYB = fvbHodoSwapXY[1] ? lastHitHodoAxis[1][0].GetChan()
1792  : lastHitHodoAxis[1][1].GetChan();
1793 
1794  if (fvbHodoInvertX[0]) uPosXA = kuNbChanPerAsic / 2 - 1 - uPosXA;
1795  if (fvbHodoInvertY[0]) uPosYA = kuNbChanPerAsic / 2 - 1 - uPosYA;
1796  if (fvbHodoInvertX[1]) uPosXB = kuNbChanPerAsic / 2 - 1 - uPosXB;
1797  if (fvbHodoInvertY[1]) uPosYB = kuNbChanPerAsic / 2 - 1 - uPosYB;
1798 
1799  Double_t dResX = uPosXB;
1800  Double_t dResY = uPosYB;
1801 
1802  dResX -= uPosXA;
1803  dResY -= uPosYA;
1804 
1805  fhHodoFullCoincPosA->Fill(uPosXA, uPosYA);
1806  fhHodoFullCoincPosB->Fill(uPosXB, uPosYB);
1807 
1808  fhHodoFullCoincCompX->Fill(uPosXA, uPosXB);
1809  fhHodoFullCoincCompY->Fill(uPosYA, uPosYB);
1810  fhHodoFullCoincResidualXY->Fill(dResX, dResY);
1811  fhHodoFullCoincTimeDiff->Fill(dTimeDiffHodoAB);
1812 
1813  fhHodoFullCoincTimeWalk[0][0]->Fill(lastHitHodoAxis[0][0].GetAdc(),
1814  dTimeDiffHodoAB);
1815  fhHodoFullCoincTimeWalk[0][1]->Fill(lastHitHodoAxis[0][1].GetAdc(),
1816  dTimeDiffHodoAB);
1817  fhHodoFullCoincTimeWalk[1][0]->Fill(lastHitHodoAxis[1][0].GetAdc(),
1818  dTimeDiffHodoAB);
1819  fhHodoFullCoincTimeWalk[1][1]->Fill(lastHitHodoAxis[1][1].GetAdc(),
1820  dTimeDiffHodoAB);
1821 
1822  Double_t dTimeSinceStart = (dTimeHitHodoAB - fdStartTime) * 1e-9;
1823  fhHodoFullCoincRateEvo->Fill(dTimeSinceStart);
1824 
1825  fhHodoFullCoincPosEvo[0][0]->Fill(dTimeSinceStart, uPosXA);
1826  fhHodoFullCoincPosEvo[0][1]->Fill(dTimeSinceStart, uPosYA);
1827  fhHodoFullCoincPosEvo[1][0]->Fill(dTimeSinceStart, uPosXB);
1828  fhHodoFullCoincPosEvo[1][1]->Fill(dTimeSinceStart, uPosYB);
1829  /*
1830  LOG(info) << "Hodoscopes full coincidence found at " << (dTimeHitHodoAB*1e-9)
1831  << " Position A = ( " << uPosXA << ", " << uPosYA << ")"
1832  << " Position B = ( " << uPosXB << ", " << uPosYB << ")"
1833  << " dT = " << dTimeDiffHodoAB;
1834 */
1835  } // if all hodo axis in coinc and hodos in coinc
1836  } // if all ( Hodo, Axis ) pairs have at least 1 hit
1837  /*
1838  for( UInt_t uHodoOther = 0; uHodoOther < kuNbHodos; ++uHodoOther )
1839  {
1840  for( UInt_t uAxisOther = 0; uAxisOther < kuNbAxis; ++uAxisOther )
1841  {
1842  if( uHodoOther == uHodo )
1843  {
1844  if( uAxisOther == uAxis )
1845  continue;
1846 
1847  } // if( uHodoOther == uHodo )
1848 
1849  } // for( UInt_t uAxisOther = 0; uAxisOther < kuNbAxis; ++uAxisOther )
1850  } // for( UInt_t uHodoOther = 0; uHodoOther < kuNbHodos; ++uHodoOther )
1851 */
1852  } // for( UInt_t uHit = 0; uHit < uTotalNbHits; ++uHit )
1853 
1854  return kTRUE;
1855 }
1856 Bool_t CbmMcbm2018MonitorAlgoHodo::ResetHistograms() {
1857  fhHodoMessType->Reset();
1858  fhHodoStatusMessType->Reset();
1859  fhHodoMsStatusFieldType->Reset();
1860  fhHodoMessTypePerElink->Reset();
1861 
1862  for (UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx) {
1863  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1864  fhHodoFiberCnt[uHodoIdx][uAxis]->Reset();
1865  fhHodoFiberAdc[uHodoIdx][uAxis]->Reset();
1866  fhHodoFiberAdcProf[uHodoIdx][uAxis]->Reset();
1867  fhHodoFiberHitRateEvo[uHodoIdx][uAxis]->Reset();
1868 
1869  fhHodoFullCoincTimeWalk[uHodoIdx][uAxis]->Reset();
1870  fhHodoFullCoincPosEvo[uHodoIdx][uAxis]->Reset();
1871  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1872 
1873  fhHodoChanCntRaw[uHodoIdx]->Reset();
1874  fhHodoChanAdcRaw[uHodoIdx]->Reset();
1875  fhHodoChanAdcRawProf[uHodoIdx]->Reset();
1876  fhHodoChanAdcCal[uHodoIdx]->Reset();
1877  fhHodoChanAdcCalProf[uHodoIdx]->Reset();
1878  fhHodoChanRawTs[uHodoIdx]->Reset();
1879  fhHodoChanMissEvt[uHodoIdx]->Reset();
1880  fhHodoChanMissEvtEvo[uHodoIdx]->Reset();
1881  fhHodoChanHitRateEvo[uHodoIdx]->Reset();
1882  fhHodoChanHitRateProf[uHodoIdx]->Reset();
1883  fhHodoChanDistT[uHodoIdx]->Reset();
1884 
1885  fhHodoFiberCoincMapXY[uHodoIdx]->Reset();
1886  fhHodoFiberCoincTimeXY[uHodoIdx]->Reset();
1887  fhHodoFiberCoincWalkXY_X[uHodoIdx]->Reset();
1888  fhHodoFiberCoincWalkXY_Y[uHodoIdx]->Reset();
1889 
1890  } // for( UInt_t uHodoIdx = 0; uHodoIdx < kuNbHodos; ++uHodoIdx )
1891 
1892 
1893  for (UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis) {
1894  fhHodoFiberCoincMapSameAB[uAxis]->Reset();
1895  fhHodoFiberCoincTimeSameAB[uAxis]->Reset();
1896  fhHodoFiberCoincMapDiffAB[uAxis]->Reset();
1897  fhHodoFiberCoincTimeDiffAB[uAxis]->Reset();
1898  } // for( UInt_t uAxis = 0; uAxis < kuNbAxis; ++uAxis )
1899 
1900  fhHodoFullCoincPosA->Reset();
1901  fhHodoFullCoincPosB->Reset();
1902  fhHodoFullCoincCompX->Reset();
1903  fhHodoFullCoincCompY->Reset();
1904  fhHodoFullCoincResidualXY->Reset();
1905  fhHodoFullCoincTimeDiff->Reset();
1906 
1907  fhPrevHitDtAllAsics->Reset();
1908  fhPrevHitDtAsicA->Reset();
1909  fhPrevHitDtAsicB->Reset();
1910  fhPrevHitDtAsicsAB->Reset();
1911 
1912  return kTRUE;
1913 }
1914 // -------------------------------------------------------------------------
CbmMcbm2018MonitorAlgoHodo::kuNbChanPerAsic
static const UInt_t kuNbChanPerAsic
Per hodoscope = X and Y.
Definition: CbmMcbm2018MonitorAlgoHodo.h:136
CbmMcbm2018MonitorAlgoHodo::fcSummary
TCanvas * fcSummary
[ Asic ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:280
CbmMcbm2018MonitorAlgoHodo::fvbHodoInvertY
std::vector< Bool_t > fvbHodoInvertY
Definition: CbmMcbm2018MonitorAlgoHodo.h:122
CbmMcbm2018MonitorAlgoHodo.h
CbmMcbm2018MonitorAlgoHodo::fcHodoFullCoinc
TCanvas * fcHodoFullCoinc
Definition: CbmMcbm2018MonitorAlgoHodo.h:285
CbmMcbm2018MonitorAlgoHodo::fhHodoStatusMessType
TH2 * fhHodoStatusMessType
Definition: CbmMcbm2018MonitorAlgoHodo.h:218
CbmStar2019Algo< CbmStsDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018MonitorAlgoHodo::fdHodoChanLastTimeForDist
std::vector< std::vector< Double_t > > fdHodoChanLastTimeForDist
[ Hodo ][ Chan ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:275
CbmMcbm2018MonitorAlgoHodo::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018MonitorAlgoHodo.h:97
CbmMcbm2018MonitorAlgoHodo::kuNbAxis
static const UInt_t kuNbAxis
Nb of hodoscopes = Nb FEBs = Nb ASICs.
Definition: CbmMcbm2018MonitorAlgoHodo.h:135
CbmMcbm2018MonitorAlgoHodo::fvuElinkIdxHodo
std::vector< UInt_t > fvuElinkIdxHodo
Definition: CbmMcbm2018MonitorAlgoHodo.h:119
CbmMcbm2018MonitorAlgoHodo::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoHodo.h:186
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincTimeDiffAB
std::vector< TH1 * > fhHodoFiberCoincTimeDiffAB
[ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:252
CbmMcbm2018MonitorAlgoHodo::fhPrevHitDtAsicA
TH1 * fhPrevHitDtAsicA
Definition: CbmMcbm2018MonitorAlgoHodo.h:264
CbmMcbm2018MonitorAlgoHodo::fvbHodoSwapXY
std::vector< Bool_t > fvbHodoSwapXY
Definition: CbmMcbm2018MonitorAlgoHodo.h:120
CbmStar2019Algo< CbmStsDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018MonitorAlgoHodo::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:387
stsxyter::Message
Definition: StsXyterMessage.h:165
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCnt
std::vector< std::vector< TH1 * > > fhHodoFiberCnt
Definition: CbmMcbm2018MonitorAlgoHodo.h:234
stsxyter::MessType::Status
@ Status
CbmMcbm2018MonitorAlgoHodo::fdStartTime
Double_t fdStartTime
Definition: CbmMcbm2018MonitorAlgoHodo.h:205
CbmMcbm2018MonitorAlgoHodo::fuDpbId
UInt_t fuDpbId
Settings from parameter file => For now use only accessors!
Definition: CbmMcbm2018MonitorAlgoHodo.h:118
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincRateEvo
TH1 * fhHodoFullCoincRateEvo
[ Hodo ][ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:260
CbmMcbm2018MonitorAlgoHodo::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018MonitorAlgoHodo.h:190
CbmMcbm2018MonitorAlgoHodo::fhHodoChanAdcCal
std::vector< TH2 * > fhHodoChanAdcCal
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:225
CbmStar2019Algo< CbmStsDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018MonitorAlgoHodo::ProcessEpochInfo
void ProcessEpochInfo(stsxyter::Message mess)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:765
CbmMcbm2018MonitorAlgoHodo::fvdChanCountsSinceLastRateUpdate
std::vector< std::vector< Double_t > > fvdChanCountsSinceLastRateUpdate
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:273
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
CbmMcbm2018MonitorAlgoHodo::ProcessHitInfo
void ProcessHitInfo(stsxyter::Message mess, const UInt_t &uHodoIdx, const UInt_t &uMsIdx)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:664
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincMapXY
std::vector< TH2 * > fhHodoFiberCoincMapXY
+/- in clock cycles
Definition: CbmMcbm2018MonitorAlgoHodo.h:245
CbmMcbm2018MonitorAlgoHodo::kuNbElinksDpb
static const UInt_t kuNbElinksDpb
Definition: CbmMcbm2018MonitorAlgoHodo.h:132
CbmMcbm2018MonitorAlgoHodo::fhHodoChanAdcRawProf
std::vector< TProfile * > fhHodoChanAdcRawProf
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:224
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
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberAdc
std::vector< std::vector< TH2 * > > fhHodoFiberAdc
[ Hodo ][ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:235
stsxyter::MessType
MessType
Message types.
Definition: StsXyterMessage.h:27
CbmMcbm2018MonitorAlgoHodo::kuNbHodos
static const UInt_t kuNbHodos
Max Nb of eLinks for this sDPB: 2 GBTx with 42 eLinks each.
Definition: CbmMcbm2018MonitorAlgoHodo.h:134
CbmStar2019Algo< CbmStsDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
CbmMcbm2018MonitorAlgoHodo::~CbmMcbm2018MonitorAlgoHodo
~CbmMcbm2018MonitorAlgoHodo()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:141
stsxyter::kulTsCycleNbBins
static const uint64_t kulTsCycleNbBins
Definition: StsXyterMessage.h:152
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
CbmMcbm2018MonitorAlgoHodo::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Definition: CbmMcbm2018MonitorAlgoHodo.h:194
CbmMcbm2018MonitorAlgoHodo::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018MonitorAlgoHodo.h:196
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincResidualXY
TH2 * fhHodoFullCoincResidualXY
Definition: CbmMcbm2018MonitorAlgoHodo.h:257
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
CbmMcbm2018MonitorAlgoHodo::fcHodoFullCoincPosEvo
TCanvas * fcHodoFullCoincPosEvo
Definition: CbmMcbm2018MonitorAlgoHodo.h:287
CbmMcbm2018MonitorAlgoHodo::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:160
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincPosEvo
std::vector< std::vector< TH2 * > > fhHodoFullCoincPosEvo
Definition: CbmMcbm2018MonitorAlgoHodo.h:261
CbmMcbm2018MonitorAlgoHodo::fuPreviousHitAsic
UInt_t fuPreviousHitAsic
[ Hodo ][ Chan ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:276
stsxyter::Message::GetHitAdc
uint16_t GetHitAdc() const
For Hit data: Returns ADC value (5 bit field)
Definition: StsXyterMessage.h:277
CbmMcbm2018MonitorAlgoHodo::fhHodoChanRawTs
std::vector< TH2 * > fhHodoChanRawTs
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:227
CbmMcbm2018MonitorAlgoHodo::fhHodoChanMissEvt
std::vector< TH2 * > fhHodoChanMissEvt
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:228
CbmMcbm2018MonitorAlgoHodo::fhHodoChanCntRaw
std::vector< TH1 * > fhHodoChanCntRaw
Raw = ASIC channels.
Definition: CbmMcbm2018MonitorAlgoHodo.h:222
stsxyter::MessType::Empty
@ Empty
CbmMcbm2018MonitorAlgoHodo::fhHodoChanDistT
std::vector< TH2 * > fhHodoChanDistT
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:232
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincPosA
TH2 * fhHodoFullCoincPosA
[ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:253
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincTimeSameAB
std::vector< TH1 * > fhHodoFiberCoincTimeSameAB
[ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:250
h
Data class with information on a STS local track.
CbmMcbm2018MonitorAlgoHodo::fhHodoMessType
TH1 * fhHodoMessType
All hits (time in bins, ADC in bins, asic, channel) in last MS, sorted with "<" operator.
Definition: CbmMcbm2018MonitorAlgoHodo.h:217
CbmMcbm2018MonitorAlgoHodo::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018MonitorAlgoHodo.h:182
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
stsxyter::FinalHit
Definition: StsXyterFinalHit.h:16
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincWalkXY_X
std::vector< TH2 * > fhHodoFiberCoincWalkXY_X
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:247
stsxyter::MessType::Hit
@ Hit
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincTimeXY
std::vector< TH1 * > fhHodoFiberCoincTimeXY
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:246
stsxyter::kuHitNbTsBins
static const uint32_t kuHitNbTsBins
Definition: StsXyterMessage.h:146
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincTimeDiff
TH1 * fhHodoFullCoincTimeDiff
Definition: CbmMcbm2018MonitorAlgoHodo.h:258
CbmMcbm2018MonitorAlgoHodo::kuChannelToFiberMap
const UInt_t kuChannelToFiberMap[kuNbChanPerAsic]
Definition: CbmMcbm2018MonitorAlgoHodo.h:149
CbmMcbm2018MonitorAlgoHodo::Finish
virtual void Finish()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:153
CbmMcbm2018MonitorAlgoHodo::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:372
CbmStar2019Algo< CbmStsDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018MonitorAlgoHodo::fvdPreviousHitTimePerAsic
std::vector< Double_t > fvdPreviousHitTimePerAsic
Definition: CbmMcbm2018MonitorAlgoHodo.h:277
CbmMcbm2018MonitorAlgoHodo::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:799
CbmMcbm2018MonitorAlgoHodo::fhHodoMsStatusFieldType
TH2 * fhHodoMsStatusFieldType
Definition: CbmMcbm2018MonitorAlgoHodo.h:219
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberAdcProf
std::vector< std::vector< TProfile * > > fhHodoFiberAdcProf
[ Hodo ][ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:236
CbmMcbm2018MonitorAlgoHodo::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:1856
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincCompX
TH2 * fhHodoFullCoincCompX
Definition: CbmMcbm2018MonitorAlgoHodo.h:255
CbmMcbm2018MonitorAlgoHodo::fhPrevHitDtAllAsics
TH1 * fhPrevHitDtAllAsics
Setup debugging.
Definition: CbmMcbm2018MonitorAlgoHodo.h:263
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincWalkXY_Y
std::vector< TH2 * > fhHodoFiberCoincWalkXY_Y
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:248
CbmMcbm2018MonitorAlgoHodo::fhPrevHitDtAsicsAB
TH1 * fhPrevHitDtAsicsAB
Definition: CbmMcbm2018MonitorAlgoHodo.h:266
stsxyter::kdClockCycleNs
static const double kdClockCycleNs
Definition: StsXyterMessage.h:156
CbmMcbm2018MonitorAlgoHodo::fvdPrevMsTime
std::vector< Double_t > fvdPrevMsTime
End Time in ns of current TS Core from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoHodo.h:187
stsxyter::Message::GetMessType
MessType GetMessType() const
Returns the message type, see enum MessType.
Definition: StsXyterMessage.h:259
CbmMcbm2018MonitorAlgoHodo::fcHodoPrevHitDt
TCanvas * fcHodoPrevHitDt
Definition: CbmMcbm2018MonitorAlgoHodo.h:288
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
CbmMcbm2018MonitorAlgoHodo::fcHodoFullCoincPos
TCanvas * fcHodoFullCoincPos
Definition: CbmMcbm2018MonitorAlgoHodo.h:286
CbmMcbm2018MonitorAlgoHodo::fcHodoFiberCoincAB
TCanvas * fcHodoFiberCoincAB
Definition: CbmMcbm2018MonitorAlgoHodo.h:284
CbmMcbm2018MonitorAlgoHodo::kuChannelToPlaneMap
const UInt_t kuChannelToPlaneMap[kuNbChanPerAsic]
Map from channel index to PMT pixel.
Definition: CbmMcbm2018MonitorAlgoHodo.h:170
CbmMcbm2018MonitorAlgoHodo::fhPrevHitDtAsicB
TH1 * fhPrevHitDtAsicB
Definition: CbmMcbm2018MonitorAlgoHodo.h:265
CbmMcbm2018MonitorAlgoHodo::fhHodoChanMissEvtEvo
std::vector< TH2 * > fhHodoChanMissEvtEvo
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:229
CbmMcbm2018MonitorAlgoHodo::kuBytesPerMessage
static const UInt_t kuBytesPerMessage
Definition: CbmMcbm2018MonitorAlgoHodo.h:131
CbmMcbm2018MonitorAlgoHodo::fcHodoSummaryRaw
std::vector< TCanvas * > fcHodoSummaryRaw
Definition: CbmMcbm2018MonitorAlgoHodo.h:281
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
CbmMcbm2018MonitorAlgoHodo::fhHodoChanAdcRaw
std::vector< TH2 * > fhHodoChanAdcRaw
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:223
CbmMcbm2018MonitorAlgoHodo::fvmHitsInMs
std::vector< stsxyter::FinalHit > fvmHitsInMs
Hits time-sorting.
Definition: CbmMcbm2018MonitorAlgoHodo.h:213
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberHitRateEvo
std::vector< std::vector< TH2 * > > fhHodoFiberHitRateEvo
[ Hodo ][ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:237
CbmMcbm2018MonitorAlgoHodo::fhHodoChanHitRateEvo
std::vector< TH2 * > fhHodoChanHitRateEvo
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:230
CbmMcbm2018MonitorAlgoHodo::fvulCurrentTsMsb
ULong64_t fvulCurrentTsMsb
Definition: CbmMcbm2018MonitorAlgoHodo.h:201
CbmMcbm2018MonitorAlgoHodo::Reset
virtual void Reset()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:152
CbmMcbm2018MonitorAlgoHodo::fdTimeCoincLimit
Double_t fdTimeCoincLimit
Definition: CbmMcbm2018MonitorAlgoHodo.h:241
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincPosB
TH2 * fhHodoFullCoincPosB
Definition: CbmMcbm2018MonitorAlgoHodo.h:254
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincTimeWalk
std::vector< std::vector< TH2 * > > fhHodoFullCoincTimeWalk
Definition: CbmMcbm2018MonitorAlgoHodo.h:259
CbmMcbm2018MonitorAlgoHodo::fcHodoFiberCoinc
TCanvas * fcHodoFiberCoinc
Definition: CbmMcbm2018MonitorAlgoHodo.h:283
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincMapDiffAB
std::vector< TH2 * > fhHodoFiberCoincMapDiffAB
[ Axis ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:251
stsxyter::MessType::TsMsb
@ TsMsb
CbmStar2019Algo< CbmStsDigi >::AddCanvasToVector
void AddCanvasToVector(TCanvas *pointer, std::string sFolder="")
Definition: CbmStar2019Algo.h:87
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
CbmMcbm2018MonitorAlgoHodo::CbmMcbm2018MonitorAlgoHodo
CbmMcbm2018MonitorAlgoHodo()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:34
stsxyter::MessType::Epoch
@ Epoch
CbmMcbm2018MonitorAlgoHodo::fcHodoSummaryFiber
std::vector< TCanvas * > fcHodoSummaryFiber
Definition: CbmMcbm2018MonitorAlgoHodo.h:282
CbmMcbm2018MonitorAlgoHodo::fhHodoFullCoincCompY
TH2 * fhHodoFullCoincCompY
Definition: CbmMcbm2018MonitorAlgoHodo.h:256
CbmMcbm2018MonitorAlgoHodo::GetParList
TList * GetParList()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:178
CbmMcbm2018MonitorAlgoHodo::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:462
CbmMcbm2018MonitorAlgoHodo::fviTimeSecLastRateUpdate
std::vector< Int_t > fviTimeSecLastRateUpdate
Definition: CbmMcbm2018MonitorAlgoHodo.h:271
CbmMcbm2018MonitorAlgoHodo::fdTsStartTime
Double_t fdTsStartTime
Definition: CbmMcbm2018MonitorAlgoHodo.h:184
CbmMcbm2018MonitorAlgoHodo::Init
virtual Bool_t Init()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:147
CbmMcbm2018MonitorAlgoHodo::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:166
stsxyter::kuHitNbAdcBins
static const uint32_t kuHitNbAdcBins
Status/properties constants.
Definition: StsXyterMessage.h:144
CbmMcbm2018MonitorAlgoHodo::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:1671
CbmMcbm2018MonitorAlgoHodo::fmMsgCounter
std::map< stsxyter::MessType, UInt_t > fmMsgCounter
Definition: CbmMcbm2018MonitorAlgoHodo.h:192
CbmMcbm2018MonitorAlgoHodo::fhHodoMessTypePerElink
TH2 * fhHodoMessTypePerElink
Definition: CbmMcbm2018MonitorAlgoHodo.h:220
CbmMcbm2018MonitorAlgoHodo::fvuCurrentTsMsbCycle
UInt_t fvuCurrentTsMsbCycle
Current TS MSB for each DPB.
Definition: CbmMcbm2018MonitorAlgoHodo.h:202
CbmMcbm2018MonitorAlgoHodo::fdTimeCoincLimitNs
Double_t fdTimeCoincLimitNs
+/- in clock cycles
Definition: CbmMcbm2018MonitorAlgoHodo.h:242
CbmMcbm2018MonitorAlgoHodo::ProcessStatusInfo
void ProcessStatusInfo(stsxyter::Message mess)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:777
CbmMcbm2018MonitorAlgoHodo::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Map from channel index to Hodoscope Axis (X or Y)
Definition: CbmMcbm2018MonitorAlgoHodo.h:181
CbmStar2019Algo< CbmStsDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018MonitorAlgoHodo::fhHodoFiberCoincMapSameAB
std::vector< TH2 * > fhHodoFiberCoincMapSameAB
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:249
CbmMcbm2018MonitorAlgoHodo::fhHodoChanAdcCalProf
std::vector< TProfile * > fhHodoChanAdcCalProf
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:226
CbmFormatMsHeaderPrintout.h
CbmMcbm2018MonitorAlgoHodo::fvbHodoInvertX
std::vector< Bool_t > fvbHodoInvertX
Definition: CbmMcbm2018MonitorAlgoHodo.h:121
CbmMcbm2018MonitorAlgoHodo::fhHodoChanHitRateProf
std::vector< TProfile * > fhHodoChanHitRateProf
[ Hodo ]
Definition: CbmMcbm2018MonitorAlgoHodo.h:231
CbmMcbm2018MonitorAlgoHodo::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:186
CbmMcbm2018MonitorAlgoHodo::fiTimeIntervalRateUpdate
Int_t fiTimeIntervalRateUpdate
Definition: CbmMcbm2018MonitorAlgoHodo.h:270
CbmMcbm2018MonitorAlgoHodo::ProcessTsMsbInfo
void ProcessTsMsbInfo(stsxyter::Message mess, UInt_t uMessIdx=0, UInt_t uMsIdx=0)
Definition: CbmMcbm2018MonitorAlgoHodo.cxx:729