CbmRoot
CbmMcbm2018MonitorAlgoPsd.cxx
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // ----- -----
3 // ----- CbmMcbm2018MonitorAlgoPsd -----
4 // ----- Created 26.09.2019 by N.Karpushkin -----
5 // ----- based on CbmMcbm2018MonitorAlgoT0 by P.-A. Loizeau -----
6 // ----- -----
7 // -----------------------------------------------------------------------------
8 
9 #include "CbmMcbm2018MonitorAlgoPsd.h"
10 
11 #include "CbmFlesHistosTools.h"
12 #include "CbmFormatMsHeaderPrintout.h"
13 #include "CbmMcbm2018PsdPar.h"
14 
15 #include "FairLogger.h"
16 #include "FairRootManager.h"
17 #include "FairRun.h"
18 #include "FairRunOnline.h"
19 #include "FairRuntimeDb.h"
20 
21 #include "TCanvas.h"
22 #include "TGraph.h"
23 #include "TH1.h"
24 #include "TH2.h"
25 #include "TList.h"
26 #include "TPaveStats.h"
27 #include "TProfile.h"
28 #include "TROOT.h"
29 #include "TString.h"
30 
31 #include <fstream>
32 #include <iomanip>
33 #include <iostream>
34 #include <stdint.h>
35 
36 // -------------------------------------------------------------------------
37 CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd()
38  : CbmStar2019Algo()
39  ,
41  fbMonitorMode(kFALSE)
42  , fbDebugMonitorMode(kTRUE)
43  , fvbMaskedComponents()
44  , fbFirstPackageError(kTRUE)
45  , fUnpackPar(nullptr)
46  , fuNrOfGdpbs(0)
47  , fGdpbIdIndexMap()
48  , fuNrOfFeePerGdpb(0)
49  , fuNrOfChannelsPerFee(0)
50  , fuNrOfChannelsPerGdpb(0)
51  , fulCurrentTsIdx(0)
52  , fulCurrentMsIdx(0)
53  , fdTsStartTime(-1.0)
54  , fdTsStopTimeCore(-1.0)
55  , fdMsTime(-1.0)
56  , fdPrevMsTime(-1.0)
57  , fuMsIndex(0)
58  , fuCurrentEquipmentId(0)
59  , fuCurrDpbId(0)
60  , fuCurrDpbIdx(0)
61  , fiRunStartDateTimeSec(-1)
62  , fiBinSizeDatePlots(-1)
63  , fvulCurrentEpoch()
64  , fvulCurrentEpochCycle()
65  , fvulCurrentEpochFull()
66  , fdStartTime(-1.0)
67  , fdStartTimeMsSz(0.0)
68  , ftStartTimeUnix(std::chrono::steady_clock::now())
69  , fuHistoryHistoSize(3600)
70  , fviHistoChargeArgs(3, 0)
71  , fviHistoAmplArgs(3, 0)
72  , fviHistoZLArgs(3, 0)
73  , fuReadEvtCnt(0)
74  , fuMsgsCntInMs(0)
75  , fuReadMsgsCntInMs(0)
76  , fuLostMsgsCntInMs(0)
77  , fuReadEvtCntInMs(0)
78  , fvuHitCntChanMs(kuNbChanPsd, 0)
79  , fvuErrorCntChanMs(kuNbChanPsd, 0)
80  , fvuEvtLostCntChanMs(kuNbChanPsd, 0)
81  , fvhHitCntEvoChan(kuNbChanPsd, nullptr)
82  , fvhHitCntPerMsEvoChan(kuNbChanPsd, nullptr)
83  , fvhHitChargeChan(kuNbChanPsd, nullptr)
84  , fvhHitZeroLevelChan(kuNbChanPsd, nullptr)
85  , fvhHitAmplChan(kuNbChanPsd, nullptr)
86  , fvhHitChargeByWfmChan(kuNbChanPsd, nullptr)
87  , fvhHitChargeEvoChan(kuNbChanPsd, nullptr)
88  , fvhHitWfmChan(kuNbChanPsd, nullptr)
89  , fvhHitFitWfmChan(kuNbChanPsd, nullptr)
90  , kvuWfmRanges(kuNbWfmRanges, 0)
91  , kvuWfmInRangeToChangeChan(kuNbChanPsd * kuNbWfmRanges, 0)
92  , fv3hHitWfmFlattenedChan(kuNbChanPsd * kuNbWfmRanges * kuNbWfmExamples,
93  nullptr)
94  , fbSpillOn(kTRUE)
95  , fuCurrentSpillIdx(0)
96  , fuCurrentSpillPlot(0)
97  , fdStartTimeSpill(-1.0)
98  , fdLastSecondTime(-1.0)
99  , fuCountsLastSecond(0)
100  , fhChannelMap(nullptr)
101  , fhHitChargeMap(nullptr)
102  , fhHitMapEvo(nullptr)
103  , fhChanHitMapEvo(nullptr)
104  , fvhChannelMapSpill()
105  , fhHitsPerSpill(nullptr)
106  , fhMsgsCntEvo(nullptr)
107  , fhReadMsgsCntEvo(nullptr)
108  , fhLostMsgsCntEvo(nullptr)
109  , fhReadEvtsCntEvo(nullptr)
110  , fhAdcTimeEvo(nullptr)
111  , fhMsLengthEvo(nullptr)
112  , fhMsgsCntPerMsEvo(nullptr)
113  , fhReadMsgsCntPerMsEvo(nullptr)
114  , fhLostMsgsCntPerMsEvo(nullptr)
115  , fhReadEvtsCntPerMsEvo(nullptr)
116  , fvhFitHarmonic1Chan(kuNbChanPsd, nullptr)
117  , fvhFitHarmonic2Chan(kuNbChanPsd, nullptr)
118  , fvhFitQaChan(kuNbChanPsd, nullptr)
119  , fcSummary(nullptr)
120  , fcHitMaps(nullptr)
121  , fcChargesFPGA(nullptr)
122  , fcChargesWfm(nullptr)
123  , fcAmplitudes(nullptr)
124  , fcGenCntsPerMs(nullptr)
125  , fcSpillCounts(nullptr)
126  , fcSpillCountsHori(nullptr)
127  , fcWfmsAllChannels(nullptr)
128  , fvcWfmsChan(kuNbChanPsd, nullptr) {}
129 CbmMcbm2018MonitorAlgoPsd::~CbmMcbm2018MonitorAlgoPsd() {
131 }
132 
133 // -------------------------------------------------------------------------
134 Bool_t CbmMcbm2018MonitorAlgoPsd::Init() {
135  LOG(info) << "Initializing mCBM Psd 2019 monitor algo";
136 
137  return kTRUE;
138 }
139 void CbmMcbm2018MonitorAlgoPsd::Reset() {}
140 void CbmMcbm2018MonitorAlgoPsd::Finish() {
142 
144 }
145 
146 // -------------------------------------------------------------------------
147 Bool_t CbmMcbm2018MonitorAlgoPsd::InitContainers() {
148  LOG(info) << "Init parameter containers for CbmMcbm2018MonitorAlgoPsd";
149  Bool_t initOK = ReInitContainers();
150 
151  return initOK;
152 }
153 Bool_t CbmMcbm2018MonitorAlgoPsd::ReInitContainers() {
154  LOG(info) << "**********************************************";
155  LOG(info) << "ReInit parameter containers for CbmMcbm2018MonitorAlgoPsd";
156 
157  fUnpackPar = (CbmMcbm2018PsdPar*) fParCList->FindObject("CbmMcbm2018PsdPar");
158  if (nullptr == fUnpackPar) return kFALSE;
159 
160  Bool_t initOK = InitParameters();
161 
162  return initOK;
163 }
164 TList* CbmMcbm2018MonitorAlgoPsd::GetParList() {
165  if (nullptr == fParCList) fParCList = new TList();
166  fUnpackPar = new CbmMcbm2018PsdPar("CbmMcbm2018PsdPar");
167  fParCList->Add(fUnpackPar);
168 
169  return fParCList;
170 }
171 Bool_t CbmMcbm2018MonitorAlgoPsd::InitParameters() {
172  fuNrOfGdpbs = fUnpackPar->GetNrOfGdpbs();
173  LOG(info) << "Nr. of Tof GDPBs: " << fuNrOfGdpbs;
174 
175  fuNrOfFeePerGdpb = fUnpackPar->GetNrOfFeesPerGdpb();
176  LOG(info) << "Nr. of FEEs per Psd GDPB: " << fuNrOfFeePerGdpb;
177 
178  fuNrOfChannelsPerFee = fUnpackPar->GetNrOfChannelsPerFee();
179  LOG(info) << "Nr. of channels per FEE: " << fuNrOfChannelsPerFee;
180 
181  fuNrOfChannelsPerGdpb = fuNrOfChannelsPerFee * fuNrOfFeePerGdpb;
182  LOG(info) << "Nr. of channels per GDPB: " << fuNrOfChannelsPerGdpb;
183 
184  fGdpbIdIndexMap.clear();
185  for (UInt_t i = 0; i < fuNrOfGdpbs; ++i) {
186  fGdpbIdIndexMap[fUnpackPar->GetGdpbId(i)] = i;
187  LOG(info) << "GDPB Id of PSD " << i << " : " << std::hex
188  << fUnpackPar->GetGdpbId(i) << std::dec;
189  } // for( UInt_t i = 0; i < fuNrOfGdpbs; ++i )
190 
192  fvulCurrentEpoch.resize(fuNrOfGdpbs, 0);
193  fvulCurrentEpochCycle.resize(fuNrOfGdpbs, 0);
194  fvulCurrentEpochFull.resize(fuNrOfGdpbs, 0);
195 
196  return kTRUE;
197 }
198 // -------------------------------------------------------------------------
199 
200 void CbmMcbm2018MonitorAlgoPsd::AddMsComponentToList(size_t component,
201  UShort_t usDetectorId) {
203  for (UInt_t uCompIdx = 0; uCompIdx < fvMsComponentsList.size(); ++uCompIdx)
204  if (component == fvMsComponentsList[uCompIdx]) return;
205 
207  fvMsComponentsList.push_back(component);
208 
209  LOG(info) << "CbmMcbm2018MonitorAlgoPsd::AddMsComponentToList => Component "
210  << component << " with detector ID 0x" << std::hex << usDetectorId
211  << std::dec << " added to list";
212 }
213 // -------------------------------------------------------------------------
214 
215 Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessTs(const fles::Timeslice& ts) {
216  fulCurrentTsIdx = ts.index();
217  fdTsStartTime = static_cast<Double_t>(ts.descriptor(0, 0).idx);
218 
220  if (0 == fulCurrentTsIdx) {
221  LOG(info) << "Reseting Histos for a new run";
222  ResetHistograms();
223  return kTRUE;
224  }
225 
227  if (-1.0 == fdTsCoreSizeInNs) {
228  fuNbCoreMsPerTs = ts.num_core_microslices();
229  fuNbOverMsPerTs = ts.num_microslices(0) - ts.num_core_microslices();
230  fdTsCoreSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs);
231  fdTsFullSizeInNs = fdMsSizeInNs * (fuNbCoreMsPerTs + fuNbOverMsPerTs);
232  LOG(info) << "Timeslice parameters: each TS has " << fuNbCoreMsPerTs
233  << " Core MS and " << fuNbOverMsPerTs
234  << " Overlap MS, for a core duration of " << fdTsCoreSizeInNs
235  << " ns and a full duration of " << fdTsFullSizeInNs << " ns";
236 
238  fuNbMsLoop = fuNbCoreMsPerTs;
239  if (kFALSE == fbIgnoreOverlapMs) fuNbMsLoop += fuNbOverMsPerTs;
240  LOG(info) << "In each TS " << fuNbMsLoop << " MS will be looped over";
241  } // if( -1.0 == fdTsCoreSizeInNs )
242 
244  fdTsStopTimeCore = fdTsStartTime + fdTsCoreSizeInNs;
245  // LOG(info) << Form( "TS %5d Start %12f Stop %12f", fulCurrentTsIdx, fdTsStartTime, fdTsStopTimeCore );
246 
248  for (fuMsIndex = 0; fuMsIndex < fuNbMsLoop; fuMsIndex++) {
250  for (UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size();
251  ++uMsCompIdx) {
252  UInt_t uMsComp = fvMsComponentsList[uMsCompIdx];
253 
254  if (kFALSE == ProcessMs(ts, uMsComp, fuMsIndex)) {
255  LOG(error) << "Failed to process ts " << fulCurrentTsIdx << " MS "
256  << fuMsIndex << " for component " << uMsComp;
257  return kFALSE;
258  } // if( kFALSE == ProcessMs( ts, uMsCompIdx, fuMsIndex ) )
259  } // for( UInt_t uMsCompIdx = 0; uMsCompIdx < fvMsComponentsList.size(); ++uMsCompIdx )
260 
262 
263  } // for( fuMsIndex = 0; fuMsIndex < uNbMsLoop; fuMsIndex ++ )
264 
266 
267 
269  if (fbMonitorMode) {
270  if (kFALSE == FillHistograms()) {
271  LOG(error) << "Failed to fill histos in ts " << fulCurrentTsIdx;
272  return kFALSE;
273  } // if( kFALSE == FillHistograms() )
274  } // if( fbMonitorMode )
275 
276  return kTRUE;
277 }
278 
279 Bool_t CbmMcbm2018MonitorAlgoPsd::ProcessMs(const fles::Timeslice& ts,
280  size_t uMsCompIdx,
281  size_t uMsIdx) {
282  auto msDescriptor = ts.descriptor(uMsCompIdx, uMsIdx);
283  fuCurrentEquipmentId = msDescriptor.eq_id;
284  const uint8_t* msContent =
285  reinterpret_cast<const uint8_t*>(ts.content(uMsCompIdx, uMsIdx));
286 
287  uint32_t uSize = msDescriptor.size;
288  fulCurrentMsIdx = msDescriptor.idx;
289 
290  fdMsTime = (1e-9) * static_cast<double>(fulCurrentMsIdx);
291 
292  LOG(debug) << "Microslice: " << fulCurrentMsIdx << " from EqId " << std::hex
293  << fuCurrentEquipmentId << std::dec << " has size: " << uSize;
294 
295  if (0 == fvbMaskedComponents.size())
296  fvbMaskedComponents.resize(ts.num_components(), kFALSE);
297 
298  fuCurrDpbId = static_cast<uint32_t>(fuCurrentEquipmentId & 0xFFFF);
299 
301  auto it = fGdpbIdIndexMap.find(fuCurrDpbId);
302  if (it == fGdpbIdIndexMap.end()) {
303  if (kFALSE == fvbMaskedComponents[uMsCompIdx]) {
304  LOG(info)
305  << "---------------------------------------------------------------";
306 
307  LOG(info) << FormatMsHeaderPrintout(msDescriptor);
308  LOG(warning) << "Could not find the gDPB index for AFCK id 0x" << std::hex
309  << fuCurrDpbId << std::dec << " in timeslice "
310  << fulCurrentTsIdx << " in microslice " << uMsIdx
311  << " component " << uMsCompIdx << "\n"
312  << "If valid this index has to be added in the PSD "
313  "parameter file in the DbpIdArray field";
314  fvbMaskedComponents[uMsCompIdx] = kTRUE;
315  } // if( kFALSE == fvbMaskedComponents[ uMsComp ] )
316  else
317  return kTRUE;
318 
321 
322 
323  return kFALSE;
324 
325  } // if( it == fGdpbIdIndexMap.end() )
326  else
327  fuCurrDpbIdx = fGdpbIdIndexMap[fuCurrDpbId];
328 
330  if (0 == fuCurrDpbIdx) {
332  if (1.0 < fdMsTime - fdLastSecondTime) {
334  if (fbSpillOn && fuCountsLastSecond < kuOffSpillCountLimit) {
335  fbSpillOn = kFALSE;
336  fuCurrentSpillIdx++;
337  fuCurrentSpillPlot = (fuCurrentSpillPlot + 1) % kuNbSpillPlots;
338  fdStartTimeSpill = fdMsTime;
339  fvhChannelMapSpill[fuCurrentSpillPlot]->Reset();
340  fhHitsPerSpill->SetBinContent(fuCurrentSpillPlot + 1, 0);
341  } // if( fbSpillOn && fuCountsLastSecond < kuOffSpillCountLimit )
342  else if (kuOffSpillCountLimit < fuCountsLastSecond)
343  fbSpillOn = kTRUE;
344 
345  fuCountsLastSecond = 0;
346  fdLastSecondTime = fdMsTime;
347  } // if( 1 < fdMsTime - fdLastSecondTime )
348  } // if( 0 == fuCurrDpbIdx )
349 
351  if (fdStartTime < 0) fdStartTime = fdMsTime;
352 
354  else if (fuHistoryHistoSize < fdMsTime - fdStartTime) {
355  ResetHistograms();
356  fdStartTime = fdMsTime;
357  } // else if( fuHistoryHistoSize < fdMsTime - fdStartTime )
358 
359  // If MS time is less than start time print error and return
360  if (fdMsTime - fdStartTime < 0) {
361  LOG(error) << "negative time! ";
362  ResetHistograms();
363  return kFALSE;
364  }
365 
366  // If not integer number of message in input buffer, print warning/error
367  if (0 != (uSize % kuBytesPerMessage))
368  LOG(error) << "The input microslice buffer does NOT "
369  << "contain only complete nDPB messages!";
370 
371  // Compute the number of complete messages in the input microslice buffer
372  uint32_t uNbMessages =
373  (uSize - (uSize % kuBytesPerMessage)) / kuBytesPerMessage;
374 
375  // Prepare variables for the loop on contents
376  const uint64_t* pInBuff = reinterpret_cast<const uint64_t*>(msContent);
377 
378  if (gLogger->IsLogNeeded(fair::Severity::debug)) {
379  if (uNbMessages != 0) printf("\n\n");
380  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
381  // Fill message
382  uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
383  printf("%016llx\n", (long long int) ulData);
384  }
385  }
386 
387  kvuWfmRanges.clear();
388  for (uint8_t i = 0; i <= kuNbWfmRanges; ++i)
389  kvuWfmRanges.push_back(
390  fviHistoChargeArgs.at(1)
391  + i * (fviHistoChargeArgs.at(2) - fviHistoChargeArgs.at(1))
392  / kuNbWfmRanges);
393 
394  PsdData::PsdGbtReader PsdReader(pInBuff);
395  if (gLogger->IsLogNeeded(fair::Severity::debug))
396  PsdReader.SetPrintOutMode(true);
397  if (uSize > 0) {
398  while (PsdReader.GetTotalGbtWordsRead() < uNbMessages) {
399  int ReadResult = PsdReader.ReadEventFles();
400  if (PsdReader.EvHdrAb.uHitsNumber > kuNbChanPsd) {
401  LOG(error) << "too many triggered channels! In header: "
402  << PsdReader.EvHdrAb.uHitsNumber
403  << " in PSD: " << GetNbChanPsd();
404  break;
405  }
406 
407  if (ReadResult == 0) {
408  fuCountsLastSecond++;
409  fhAdcTimeEvo->Fill(fdMsTime - fdStartTime, PsdReader.EvHdrAc.uAdcTime);
410  fuReadEvtCnt++;
411  fuReadEvtCntInMs++;
412  fhHitsPerSpill->AddBinContent(fuCurrentSpillPlot + 1,
413  PsdReader.EvHdrAb.uHitsNumber);
414  //hit loop
415  for (int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber;
416  hit_iter++) {
417  UInt_t uHitChannel = PsdReader.VectHitHdr.at(hit_iter).uHitChannel;
418  UInt_t uSignalCharge =
419  PsdReader.VectHitHdr.at(hit_iter).uSignalCharge;
420  UInt_t uZeroLevel = PsdReader.VectHitHdr.at(hit_iter).uZeroLevel;
421  std::vector<uint16_t> uWfm = PsdReader.VectHitData.at(hit_iter).uWfm;
422 
423  if (uHitChannel >= kuNbChanPsd) //uHitChannel numerated from 0
424  {
425  LOG(error) << "hit channel number out of range! channel index: "
426  << uHitChannel << " max: " << GetNbChanPsd();
427  break;
428  }
429  //Hit header
430  fhChannelMap->Fill(uHitChannel);
431  fhHitChargeMap->Fill(uHitChannel, uSignalCharge);
432  fvhChannelMapSpill[fuCurrentSpillPlot]->Fill(
433  uHitChannel); //should be placed map(channel)
434  fhHitMapEvo->Fill(uHitChannel, fdMsTime - fdStartTime);
435  fhChanHitMapEvo->Fill(
436  uHitChannel,
437  fdMsTime - fdStartTime); //should be placed map(channel)
438 
439  fvhHitCntEvoChan[uHitChannel]->Fill(fdMsTime - fdStartTime);
440  fvuHitCntChanMs[uHitChannel]++;
441 
442  fvhHitChargeChan[uHitChannel]->Fill(uSignalCharge);
443  fvhHitZeroLevelChan[uHitChannel]->Fill(uZeroLevel);
444  fvhHitChargeEvoChan[uHitChannel]->Fill(fdMsTime - fdStartTime,
445  uSignalCharge);
446 
447  //Hit data
448  uint16_t uHitAmlpitude = 0;
449  uint16_t uHitChargeWfm = 0;
450  fvhHitWfmChan[uHitChannel]->Reset();
451  fvhHitFitWfmChan[uHitChannel]->Reset();
452  for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++) {
453  if (uWfm.at(wfm_iter) > uHitAmlpitude)
454  uHitAmlpitude = uWfm.at(wfm_iter);
455  uHitChargeWfm += uWfm.at(wfm_iter) - uZeroLevel;
456  fvhHitWfmChan[uHitChannel]->Fill(wfm_iter, uWfm.at(wfm_iter));
457  }
458  fvhHitWfmChan[uHitChannel]->SetTitle(
459  Form("Waveform channel %03u charge %0u zero level %0u; Time [adc "
460  "counts]; Amplitude [adc counts]",
461  uHitChannel,
462  uSignalCharge,
463  uZeroLevel));
464  uHitAmlpitude -= uZeroLevel;
465  fvhHitAmplChan[uHitChannel]->Fill(uHitAmlpitude);
466  fvhHitChargeByWfmChan[uHitChannel]->Fill(uHitChargeWfm);
467 
468  for (uint8_t i = 0; i < kuNbWfmRanges; ++i) {
469  if (uSignalCharge > kvuWfmRanges.at(i)
470  && uSignalCharge < kvuWfmRanges.at(i + 1)) {
471  UInt_t uFlatIndexOfChange = i * kuNbChanPsd + uHitChannel;
472 
473  UInt_t uWfmExampleIter =
474  kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange);
475  UInt_t uFlatIndexHisto =
476  uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd + i * kuNbChanPsd
477  + uHitChannel;
478  fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Reset();
479 
480  for (UInt_t wfm_iter = 0; wfm_iter < uWfm.size(); wfm_iter++)
481  fv3hHitWfmFlattenedChan[uFlatIndexHisto]->Fill(
482  wfm_iter, uWfm.at(wfm_iter));
483  fv3hHitWfmFlattenedChan[uFlatIndexHisto]->SetTitle(
484  Form("Waveform channel %03u charge %0u zero level %0u; Time "
485  "[adc counts]; Amplitude [adc counts]",
486  uHitChannel,
487  uSignalCharge,
488  uZeroLevel));
489 
490  kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange)++;
491  if (kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange)
492  == kuNbWfmExamples)
493  kvuWfmInRangeToChangeChan.at(uFlatIndexOfChange) = 0;
494 
495  } // if( uSignalCharge > kvuWfmRanges.at(i) && uSignalCharge < kvuWfmRanges.at(i+1) )
496  } // for (uint8_t i=0; i<kuNbWfmRanges; ++i)
497 
498 
499  int gate_beg = 0;
500  int gate_end = 7;
501  PsdSignalFitting::PronyFitter Pfitter(2, 2, gate_beg, gate_end);
502 
503  Pfitter.SetDebugMode(0);
504  Pfitter.SetWaveform(uWfm, uZeroLevel);
505  int SignalBeg = 2;
506  Int_t best_signal_begin = Pfitter.ChooseBestSignalBeginHarmonics(
507  SignalBeg - 1, SignalBeg + 1);
508 
509  Pfitter.SetSignalBegin(best_signal_begin);
510  Pfitter.CalculateFitHarmonics();
511  Pfitter.CalculateFitAmplitudes();
512 
513  Float_t fit_integral = Pfitter.GetIntegral(gate_beg, gate_end);
514  Float_t fit_R2 = Pfitter.GetRSquare(gate_beg, gate_end);
515 
516  std::complex<float>* harmonics = Pfitter.GetHarmonics();
517  std::vector<uint16_t> uFitWfm = Pfitter.GetFitWfm();
518  for (UInt_t wfm_iter = 0; wfm_iter < uFitWfm.size(); wfm_iter++) {
519  fvhHitFitWfmChan[uHitChannel]->Fill(wfm_iter, uFitWfm.at(wfm_iter));
520  fvhHitWfmChan[uHitChannel]->SetTitle(
521  Form("Waveform channel %03u charge %0u zero level %0u R2 %.5f; "
522  "Time [adc counts]; Amplitude [adc counts]",
523  uHitChannel,
524  uSignalCharge,
525  uZeroLevel,
526  fit_R2));
527  }
528 
529  fvhFitQaChan[uHitChannel]->Fill(fit_integral, fit_R2);
530 
531  if (fit_R2 > 0.02) continue;
532  fvhFitHarmonic1Chan[uHitChannel]->Fill(std::real(harmonics[1]),
533  std::imag(harmonics[1]));
534  fvhFitHarmonic2Chan[uHitChannel]->Fill(std::real(harmonics[2]),
535  std::imag(harmonics[2]));
536  } // for(int hit_iter = 0; hit_iter < PsdReader.EvHdrAb.uHitsNumber; hit_iter++)
537 
538  } else if (ReadResult == 1) {
539  LOG(error) << "no event headers in message!";
540  break;
541  } else if (ReadResult == 2) {
542  LOG(error) << "check number of waveform points! In header: "
543  << PsdReader.HitHdr.uWfmPoints << " should be: " << 8;
544  break;
545  } else if (ReadResult == 3) {
546  LOG(error) << "wrong amount of hits read! In header: "
547  << PsdReader.EvHdrAb.uHitsNumber
548  << " in hit vector: " << PsdReader.VectHitHdr.size();
549  break;
550  } else {
551  LOG(error)
552  << "PsdGbtReader.ReadEventFles() didn't return expected values";
553  break;
554  }
555 
556  } // while(PsdReader.GetTotalGbtWordsRead()<uNbMessages)
557 
558  if (uNbMessages != PsdReader.GetTotalGbtWordsRead()) {
559  LOG(error) << "Wrong amount of messages read!"
560  << " in microslice " << uNbMessages << " by PsdReader "
561  << PsdReader.GetTotalGbtWordsRead();
562 
563  if (fbFirstPackageError) {
564  std::ofstream error_log(Form("%llu_errorlog.txt", fulCurrentMsIdx),
565  std::ofstream::out);
566  for (uint32_t uIdx = 0; uIdx < uNbMessages; uIdx++) {
567  uint64_t ulData = static_cast<uint64_t>(pInBuff[uIdx]);
568  error_log << Form("%016llx\n", (long long int) ulData);
569  }
570  error_log.close();
571  fbFirstPackageError = kFALSE;
572  printf("Written file %llu_errorlog.txt\n", fulCurrentMsIdx);
573  }
574  }
575 
576  if (fulCurrentMsIdx != PsdReader.EvHdrAb.ulMicroSlice)
577  LOG(error) << "Wrong MS index!"
578  << " in microslice " << fulCurrentMsIdx << " by PsdReader "
579  << PsdReader.EvHdrAb.ulMicroSlice << "\n";
580 
581  fhMsgsCntEvo->AddBinContent(fdMsTime - fdStartTime, uNbMessages);
582  fhReadMsgsCntEvo->AddBinContent(fdMsTime - fdStartTime,
583  PsdReader.GetTotalGbtWordsRead());
584  fhLostMsgsCntEvo->AddBinContent(
585  fdMsTime - fdStartTime, uNbMessages - PsdReader.GetTotalGbtWordsRead());
586  fhReadEvtsCntEvo->AddBinContent(fdMsTime - fdStartTime, fuReadEvtCnt);
587 
588  fuMsgsCntInMs += uNbMessages;
589  fuReadMsgsCntInMs += PsdReader.GetTotalGbtWordsRead();
590  fuLostMsgsCntInMs += uNbMessages - PsdReader.GetTotalGbtWordsRead();
591 
592  } //if(uSize != 0)
593 
594  if (fdPrevMsTime < 0.)
595  fdPrevMsTime = fdMsTime;
596  else {
597  fhMsLengthEvo->Fill(fdMsTime - fdStartTime,
598  1e9 * (fdMsTime - fdPrevMsTime));
599  fdPrevMsTime = fdMsTime;
600  }
601 
603  FillHistograms();
604 
605  return kTRUE;
606 }
607 
608 Bool_t CbmMcbm2018MonitorAlgoPsd::CreateHistograms() {
609  std::string sFolder = "MoniPsd";
610  std::string sFitFolder = "PronyFit";
611  LOG(info) << "create Histos for PSD monitoring ";
612 
614  uint32_t iNbBinsLog = 0;
616  std::vector<double> dBinsLogVector = GenerateLogBinArray(4, 9, 1, iNbBinsLog);
617  double* dBinsLog = dBinsLogVector.data();
618 
619  fhChannelMap = new TH1I("hChannelMap",
620  "Map of hits in PSD detector; Chan; Hits Count []",
621  kuNbChanPsd,
622  0.,
623  kuNbChanPsd);
624  fhHitChargeMap =
625  new TH2I("hHitChargeMap",
626  "Map of hits charges in PSD detector; Chan; Charge [adc counts]",
627  kuNbChanPsd,
628  0.,
629  kuNbChanPsd,
630  fviHistoChargeArgs.at(0),
631  fviHistoChargeArgs.at(1),
632  fviHistoChargeArgs.at(2));
633  fhHitMapEvo = new TH2I("hHitMapEvo",
634  "Map of hits in PSD detector electronics vs time in "
635  "run; Chan; Time in run [s]; Hits Count []",
636  kuNbChanPsd,
637  0.,
638  kuNbChanPsd,
639  fuHistoryHistoSize,
640  0,
641  fuHistoryHistoSize);
642  fhChanHitMapEvo = new TH2I("hChanHitMapEvo",
643  "Map of hits in PSD detector vs time in run; "
644  "Chan; Time in run [s]; Hits Count []",
645  kuNbChanPsd,
646  0.,
647  kuNbChanPsd,
648  fuHistoryHistoSize,
649  0,
650  fuHistoryHistoSize);
651  for (UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill++) {
652  fvhChannelMapSpill.push_back(
653  new TH1I(Form("hChannelMapSpill%02u", uSpill),
654  Form("Map of hits in PSD detector in current spill %02u; Chan; "
655  "Hits Count []",
656  uSpill),
657  kuNbChanPsd,
658  0.,
659  kuNbChanPsd));
660  } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
661  fhHitsPerSpill = new TH1I("hHitsPerSpill",
662  "Hit count per spill; Spill; Hits Count []",
663  kuNbSpillPlots,
664  0,
665  kuNbSpillPlots);
666 
667  fhMsgsCntEvo = new TH1I("hMsgsCntEvo",
668  "Evolution of TotalMsgs counts vs time in run; Time "
669  "in run [s]; Msgs Count []",
670  fuHistoryHistoSize,
671  0,
672  fuHistoryHistoSize);
673  fhReadMsgsCntEvo = new TH1I("hReadMsgsCntEvo",
674  "Evolution of ReadMsgs counts vs time in run; "
675  "Time in run [s]; ReadMsgs Count []",
676  fuHistoryHistoSize,
677  0,
678  fuHistoryHistoSize);
679  fhLostMsgsCntEvo = new TH1I("hLostMsgsCntEvo",
680  "Evolution of LostMsgs counts vs time in run; "
681  "Time in run [s]; LostMsgs Count []",
682  fuHistoryHistoSize,
683  0,
684  fuHistoryHistoSize);
685  fhReadEvtsCntEvo = new TH1I("hReadEvtsCntEvo",
686  "Evolution of ReadEvents counts vs time in run; "
687  "Time in run [s]; ReadEvents Count []",
688  fuHistoryHistoSize,
689  0,
690  fuHistoryHistoSize);
691 
692  fhAdcTimeEvo = new TH2I(
693  "hAdcTimeEvo",
694  "Evolution of ADC time vs time in run; Time in run [s]; Adc time *12.5[ns]",
695  fuHistoryHistoSize,
696  0,
697  fuHistoryHistoSize,
698  500,
699  0,
700  9000);
701 
702  fhMsLengthEvo = new TH2I(
703  "hMsLengthEvo",
704  "Evolution of MS length vs time in run; Time in run [s]; MS length [ns]",
705  fuHistoryHistoSize,
706  0,
707  fuHistoryHistoSize,
708  (Int_t) 1e2,
709  0,
710  1e8);
711 
712  fhMsgsCntPerMsEvo =
713  new TH2I("hMsgsCntPerMsEvo",
714  "Evolution of TotalMsgs counts, per MS vs time in run; Time in "
715  "run [s]; TotalMsgs Count/MS []; MS",
716  fuHistoryHistoSize,
717  0,
718  fuHistoryHistoSize,
719  iNbBinsLog,
720  dBinsLog);
721  fhReadMsgsCntPerMsEvo =
722  new TH2I("ReadMsgsCntPerMsEvo",
723  "Evolution of ReadMsgs counts, per MS vs time in run; Time in run "
724  "[s]; ReadMsgs Count/MS []; MS",
725  fuHistoryHistoSize,
726  0,
727  fuHistoryHistoSize,
728  iNbBinsLog,
729  dBinsLog);
730  fhLostMsgsCntPerMsEvo =
731  new TH2I("hLostMsgsCntPerMsEvo",
732  "Evolution of LostMsgs counts, per MS vs time in run; Time in run "
733  "[s]; LostMsgs Count/MS []; MS",
734  fuHistoryHistoSize,
735  0,
736  fuHistoryHistoSize,
737  iNbBinsLog,
738  dBinsLog);
739  fhReadEvtsCntPerMsEvo =
740  new TH2I("hReadEvtCntPerMsEvo",
741  "Evolution of ReadEvents, per MS counts vs time in run; Time in "
742  "run [s]; ReadEvents Count/MS []; MS",
743  fuHistoryHistoSize,
744  0,
745  fuHistoryHistoSize,
746  iNbBinsLog,
747  dBinsLog);
748 
750  AddHistoToVector(fhChannelMap, sFolder);
751  AddHistoToVector(fhHitChargeMap, sFolder);
752  AddHistoToVector(fhHitMapEvo, sFolder);
753  AddHistoToVector(fhChanHitMapEvo, sFolder);
754  for (UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill++)
755  AddHistoToVector(fvhChannelMapSpill[uSpill], sFolder);
756  AddHistoToVector(fhHitsPerSpill, sFolder);
757 
758  AddHistoToVector(fhMsgsCntEvo, sFolder);
759  AddHistoToVector(fhReadMsgsCntEvo, sFolder);
760  AddHistoToVector(fhLostMsgsCntEvo, sFolder);
761  AddHistoToVector(fhReadEvtsCntEvo, sFolder);
762 
763  AddHistoToVector(fhAdcTimeEvo, sFolder);
764  AddHistoToVector(fhMsLengthEvo, sFolder);
765 
766  AddHistoToVector(fhMsgsCntPerMsEvo, sFolder);
767  AddHistoToVector(fhReadMsgsCntPerMsEvo, sFolder);
768  AddHistoToVector(fhLostMsgsCntPerMsEvo, sFolder);
769  AddHistoToVector(fhReadEvtsCntPerMsEvo, sFolder);
770 
771  /*******************************************************************/
772  for (UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan) {
773  fvhHitCntEvoChan[uChan] =
774  new TH1I(Form("hHitCntEvoChan%03u", uChan),
775  Form("Evolution of Hit counts vs time in run for channel %03u; "
776  "Time in run [s]; Hits Count []",
777  uChan),
778  fuHistoryHistoSize,
779  0,
780  fuHistoryHistoSize);
781 
782  fvhHitCntPerMsEvoChan[uChan] =
783  new TH2I(Form("hHitCntPerMsEvoChan%03u", uChan),
784  Form("Evolution of Hit counts per MS vs time in run for channel "
785  "%03u; Time in run [s]; Hits Count/MS []; MS",
786  uChan),
787  fuHistoryHistoSize,
788  0,
789  fuHistoryHistoSize,
790  iNbBinsLog,
791  dBinsLog);
792 
793  fvhHitChargeChan[uChan] = new TH1I(
794  Form("hHitChargeChan%03u", uChan),
795  Form("Hits charge distribution for channel %03u; Charge [adc counts]",
796  uChan),
797  fviHistoChargeArgs.at(0),
798  fviHistoChargeArgs.at(1),
799  fviHistoChargeArgs.at(2));
800 
801  fvhHitZeroLevelChan[uChan] = new TH1I(
802  Form("hHitZeroLevelChan%03u", uChan),
803  Form(
804  "Hits zero level distribution for channel %03u; ZeroLevel [adc counts]",
805  uChan),
806  fviHistoZLArgs.at(0),
807  fviHistoZLArgs.at(1),
808  fviHistoZLArgs.at(2));
809 
810  fvhHitAmplChan[uChan] = new TH1I(
811  Form("hHitAmplChan%03u", uChan),
812  Form(
813  "Hits amplitude distribution for channel %03u; Amplitude [adc counts]",
814  uChan),
815  fviHistoAmplArgs.at(0),
816  fviHistoAmplArgs.at(1),
817  fviHistoAmplArgs.at(2));
818 
819  fvhHitChargeByWfmChan[uChan] =
820  new TH1I(Form("hHitChargeByWfmChan%03u", uChan),
821  Form("Hits charge by waveform distribution for channel %03u; "
822  "Charge [adc counts]",
823  uChan),
824  fviHistoChargeArgs.at(0),
825  fviHistoChargeArgs.at(1),
826  fviHistoChargeArgs.at(2));
827 
828  fvhHitChargeEvoChan[uChan] =
829  new TH2I(Form("hHitChargeEvoChan%03u", uChan),
830  Form("Evolution of Hit charge vs time in run for channel %03u; "
831  "Time in run [s]; Charge [adc counts]",
832  uChan),
833  fuHistoryHistoSize,
834  0,
835  fuHistoryHistoSize,
836  fviHistoChargeArgs.at(0),
837  fviHistoChargeArgs.at(1),
838  fviHistoChargeArgs.at(2));
839 
840  fvhHitWfmChan[uChan] = new TH1I(
841  Form("hHitWfmChan%03u", uChan), Form("HitWfmChan%03u", uChan), 8, 0, 8);
842  fvhHitWfmChan[uChan]->SetMarkerStyle(31);
843  fvhHitWfmChan[uChan]->SetMarkerSize(0.5);
844 
845  fvhHitFitWfmChan[uChan] = new TH1I(Form("hHitFitWfmChan%03u", uChan),
846  Form("HitFitWfmChan%03u", uChan),
847  8,
848  0,
849  8);
850  fvhHitFitWfmChan[uChan]->SetLineColor(kRed);
851  fvhHitFitWfmChan[uChan]->SetLineWidth(2);
852 
853  for (UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges;
854  uWfmRangeIter++) {
855  for (UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples;
856  uWfmExampleIter++) {
857  UInt_t uFlatIndex = uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd
858  + uWfmRangeIter * kuNbChanPsd + uChan;
859  fv3hHitWfmFlattenedChan[uFlatIndex] =
860  new TH1I(Form("hHitWfmChan%03uRange%02uExample%02u",
861  uChan,
862  uWfmRangeIter,
863  uWfmExampleIter),
864  Form("HitWfmChan%03uRange%02uExample%02u",
865  uChan,
866  uWfmRangeIter,
867  uWfmExampleIter),
868  8,
869  0,
870  8);
871 
872  } // for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++)
873  } // for( UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples; uWfmExampleIter ++)
874 
875  fvhFitHarmonic1Chan[uChan] = new TH2I(
876  Form("hFitHarmonic1Chan%03u", uChan),
877  Form(
878  "Waveform fit harmonic 1 for channel %03u; Real part []; Imag part []",
879  uChan),
880  400,
881  -2,
882  2,
883  200,
884  -1,
885  1);
886  fvhFitHarmonic1Chan[uChan]->SetMarkerColor(kRed);
887 
888  fvhFitHarmonic2Chan[uChan] = new TH2I(
889  Form("hFitHarmonic2Chan%03u", uChan),
890  Form(
891  "Waveform fit harmonic 2 for channel %03u; Real part []; Imag part []",
892  uChan),
893  400,
894  -2,
895  2,
896  200,
897  -1,
898  1);
899  fvhFitHarmonic2Chan[uChan]->SetMarkerColor(kBlue);
900 
901  fvhFitQaChan[uChan] = new TH2I(
902  Form("hFitQaChan%03u", uChan),
903  Form("Waveform fit QA for channel %03u; Integral [adc counts]; R2 []",
904  uChan),
905  fviHistoChargeArgs.at(0),
906  fviHistoChargeArgs.at(1),
907  fviHistoChargeArgs.at(2),
908  500,
909  0,
910  1);
911 
912 
914  AddHistoToVector(fvhHitCntEvoChan[uChan], sFolder);
915  AddHistoToVector(fvhHitCntPerMsEvoChan[uChan], sFolder);
916  AddHistoToVector(fvhHitChargeChan[uChan], sFolder);
917  AddHistoToVector(fvhHitZeroLevelChan[uChan], sFolder);
918  AddHistoToVector(fvhHitAmplChan[uChan], sFolder);
919  AddHistoToVector(fvhHitChargeByWfmChan[uChan], sFolder);
920  AddHistoToVector(fvhHitChargeEvoChan[uChan], sFolder);
921 
922  AddHistoToVector(fvhFitHarmonic1Chan[uChan], sFitFolder);
923  AddHistoToVector(fvhFitHarmonic2Chan[uChan], sFitFolder);
924  AddHistoToVector(fvhFitQaChan[uChan], sFitFolder);
925 
926  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan )
927 
928 
929  /*******************************************************************/
930 
932  Double_t w = 10;
933  Double_t h = 10;
934 
935  /*******************************************************************/
937  fcHitMaps = new TCanvas("cHitMaps", "Hit maps", w, h);
938  fcHitMaps->Divide(2);
939 
940  fcHitMaps->cd(1);
941  gPad->SetGridx();
942  gPad->SetGridy();
943  gPad->SetLogy();
944  fhChannelMap->Draw();
945 
946  fcHitMaps->cd(2);
947  gPad->SetGridx();
948  gPad->SetGridy();
949  gPad->SetLogz();
950  fhChanHitMapEvo->Draw("colz");
951 
952  fcHitMaps->cd(3);
953  gPad->SetGridx();
954  gPad->SetGridy();
955  gPad->SetLogz();
956  fhHitChargeMap->Draw("colz");
957 
958  AddCanvasToVector(fcHitMaps, "canvases");
959  /*******************************************************************/
960 
961  /*******************************************************************/
963  fcSummary =
964  new TCanvas("cSummary", "Hit maps, Hit rate, Error fraction", w, h);
965  fcSummary->Divide(2, 2);
966 
967  fcSummary->cd(1);
968  gPad->SetGridx();
969  gPad->SetGridy();
970  gPad->SetLogy();
971  fhChannelMap->Draw();
972 
973  fcSummary->cd(2);
974  gPad->SetGridx();
975  gPad->SetGridy();
976  gPad->SetLogz();
977  fhChanHitMapEvo->Draw("colz");
978 
979  fcSummary->cd(3);
980  gPad->SetGridx();
981  gPad->SetGridy();
982  gPad->SetLogz();
983  fhHitChargeMap->Draw("colz");
984 
985  fcSummary->cd(4);
986  gPad->SetGridx();
987  gPad->SetGridy();
988  gPad->SetLogy();
989  gPad->SetLogz();
990  fhMsLengthEvo->Draw("colz");
991 
992  AddCanvasToVector(fcSummary, "canvases");
993  /*******************************************************************/
994 
995  /*******************************************************************/
997  fcChargesFPGA = new TCanvas(
998  "cChargesFPGA", "Charges spectra in all channels calculated by FPGA", w, h);
999  fcChargesFPGA->DivideSquare(kuNbChanPsd);
1000 
1001  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1002  fcChargesFPGA->cd(1 + uChan);
1003  fvhHitChargeChan[uChan]->Draw();
1004  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
1005 
1006  AddCanvasToVector(fcChargesFPGA, "canvases");
1007  /*******************************************************************/
1008 
1009  /*******************************************************************/
1011  fcChargesWfm =
1012  new TCanvas("cChargesWfm",
1013  "Charges spectra in all channels calculated over waveform",
1014  w,
1015  h);
1016  fcChargesWfm->DivideSquare(kuNbChanPsd);
1017 
1018  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1019  fcChargesWfm->cd(1 + uChan);
1020  fvhHitChargeByWfmChan[uChan]->Draw();
1021  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
1022 
1023  AddCanvasToVector(fcChargesWfm, "canvases");
1024  /*******************************************************************/
1025 
1026  /*******************************************************************/
1028  fcAmplitudes =
1029  new TCanvas("cAmplitudes", "Amplitude spectra in all channels", w, h);
1030  fcAmplitudes->DivideSquare(kuNbChanPsd);
1031 
1032  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1033  fcAmplitudes->cd(1 + uChan);
1034  fvhHitAmplChan[uChan]->Draw();
1035  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
1036 
1037  AddCanvasToVector(fcAmplitudes, "canvases");
1038  /*******************************************************************/
1039 
1040  /*******************************************************************/
1042  fcGenCntsPerMs = new TCanvas(
1043  "cGenCntsPerMs",
1044  "Messages and hit cnt per MS, Error and Evt Loss Fract. per MS ",
1045  w,
1046  h);
1047  fcGenCntsPerMs->Divide(2, 2);
1048 
1049  fcGenCntsPerMs->cd(1);
1050  gPad->SetGridx();
1051  gPad->SetGridy();
1052  gPad->SetLogy();
1053  gPad->SetLogz();
1054  fhMsgsCntPerMsEvo->Draw("colz");
1055 
1056  fcGenCntsPerMs->cd(2);
1057  gPad->SetGridx();
1058  gPad->SetGridy();
1059  gPad->SetLogy();
1060  gPad->SetLogz();
1061  fhReadMsgsCntPerMsEvo->Draw("colz");
1062 
1063  fcGenCntsPerMs->cd(3);
1064  gPad->SetGridx();
1065  gPad->SetGridy();
1066  gPad->SetLogy();
1067  gPad->SetLogz();
1068  fhReadEvtsCntPerMsEvo->Draw("colz");
1069 
1070  fcGenCntsPerMs->cd(4);
1071  gPad->SetGridx();
1072  gPad->SetGridy();
1073  gPad->SetLogy();
1074  gPad->SetLogz();
1075  fhLostMsgsCntPerMsEvo->Draw("colz");
1076 
1077  AddCanvasToVector(fcGenCntsPerMs, "canvases");
1078  /*******************************************************************/
1079 
1080  /*******************************************************************/
1082  fcSpillCounts =
1083  new TCanvas("cSpillCounts",
1084  "Counts per spill, last 5 spills including current one",
1085  w,
1086  h);
1087  fcSpillCounts->Divide(1, kuNbSpillPlots);
1088 
1089  for (UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill++) {
1090  fcSpillCounts->cd(1 + uSpill);
1091  gPad->SetGridx();
1092  gPad->SetGridy();
1093  fvhChannelMapSpill[uSpill]->Draw();
1094  } // for( UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill ++)
1095 
1096  AddCanvasToVector(fcSpillCounts, "canvases");
1097  /*******************************************************************/
1098 
1099  /*******************************************************************/
1101  fcWfmsAllChannels = new TCanvas(
1102  "cWfmsAllChannels", "Last waveforms in PSD fired channels", w, h);
1103  fcWfmsAllChannels->DivideSquare(kuNbChanPsd);
1104 
1105  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1106  fcWfmsAllChannels->cd(1 + uChan);
1107  fvhHitWfmChan[uChan]->Draw("HIST P");
1108  fvhHitFitWfmChan[uChan]->Draw("L SAME");
1109  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
1110 
1111  AddCanvasToVector(fcWfmsAllChannels, "waveforms");
1112  /*******************************************************************/
1113 
1114  /*******************************************************************/
1116  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1117  fvcWfmsChan[uChan] =
1118  new TCanvas(Form("cWfmsChan%03u", uChan),
1119  Form("Canvas with last waveforms in channel %03u", uChan),
1120  w,
1121  h);
1122  fvcWfmsChan[uChan]->Divide(kuNbWfmExamples, kuNbWfmRanges);
1123  UInt_t uHisto = 0;
1124 
1125  for (UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges;
1126  uWfmRangeIter++) {
1127  for (UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples;
1128  uWfmExampleIter++) {
1129  fvcWfmsChan[uChan]->cd(1 + uHisto);
1130  UInt_t uFlatIndex = uWfmExampleIter * kuNbWfmRanges * kuNbChanPsd
1131  + uWfmRangeIter * kuNbChanPsd + uChan;
1132  fv3hHitWfmFlattenedChan[uFlatIndex]->Draw("HIST LP");
1133  uHisto++;
1134  } // for( UInt_t uWfmRangeIter = 0; uWfmRangeIter < kuNbWfmRanges; uWfmRangeIter ++)
1135  } // for( UInt_t uWfmExampleIter = 0; uWfmExampleIter < kuNbWfmExamples; uWfmExampleIter ++)
1136 
1137  AddCanvasToVector(fvcWfmsChan[uChan], "waveforms");
1138  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; uChan ++)
1139 
1140  /*******************************************************************/
1141 
1142  fcPronyFit = new TCanvas("cPronyFit", "Prony wfm fitting", w, h);
1143  fcPronyFit->Divide(2);
1144 
1145  fcPronyFit->cd(1);
1146  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1147  fvhFitHarmonic1Chan[uChan]->Draw("same");
1148  fvhFitHarmonic2Chan[uChan]->Draw("same");
1149  }
1150 
1151  fcPronyFit->cd(2);
1152  for (UInt_t uChan = 0; uChan < kuNbChanPsd; uChan++) {
1153  fvhFitQaChan[uChan]->Draw("same");
1154  }
1155 
1156  AddCanvasToVector(fcPronyFit, "PronyFit");
1157 
1158  /*******************************************************************/
1159 
1160  return kTRUE;
1161 }
1162 
1163 Bool_t CbmMcbm2018MonitorAlgoPsd::FillHistograms() {
1164 
1165  for (UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan) {
1166  fvhHitCntPerMsEvoChan[uChan]->Fill(fdMsTime - fdStartTime,
1167  fvuHitCntChanMs[uChan]);
1168  fvuHitCntChanMs[uChan] = 0;
1169 
1170  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan )
1171 
1172  fhMsgsCntPerMsEvo->Fill(fdMsTime - fdStartTime, fuMsgsCntInMs);
1173  fhReadMsgsCntPerMsEvo->Fill(fdMsTime - fdStartTime, fuReadMsgsCntInMs);
1174  fhLostMsgsCntPerMsEvo->Fill(fdMsTime - fdStartTime, fuLostMsgsCntInMs);
1175  fhReadEvtsCntPerMsEvo->Fill(fdMsTime - fdStartTime, fuReadEvtCntInMs);
1176  fuMsgsCntInMs = 0;
1177  fuReadMsgsCntInMs = 0;
1178  fuLostMsgsCntInMs = 0;
1179  fuReadEvtCntInMs = 0;
1180 
1181  return kTRUE;
1182 }
1183 
1184 Bool_t CbmMcbm2018MonitorAlgoPsd::ResetHistograms() {
1185  for (UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan) {
1186  fvhHitCntEvoChan[uChan]->Reset();
1187  fvhHitCntPerMsEvoChan[uChan]->Reset();
1188  fvhHitChargeChan[uChan]->Reset();
1189  fvhHitZeroLevelChan[uChan]->Reset();
1190  fvhHitAmplChan[uChan]->Reset();
1191  fvhHitChargeByWfmChan[uChan]->Reset();
1192  fvhHitChargeEvoChan[uChan]->Reset();
1193  fvhHitWfmChan[uChan]->Reset();
1194  fvhHitFitWfmChan[uChan]->Reset();
1195 
1196  fvhFitHarmonic1Chan[uChan]->Reset();
1197  fvhFitHarmonic2Chan[uChan]->Reset();
1198  fvhFitQaChan[uChan]->Reset();
1199  } // for( UInt_t uChan = 0; uChan < kuNbChanPsd; ++uChan )
1200 
1201  for (UInt_t uFlatIndex = 0;
1202  uFlatIndex < kuNbChanPsd * kuNbWfmRanges * kuNbWfmExamples;
1203  ++uFlatIndex)
1204  fv3hHitWfmFlattenedChan[uFlatIndex]->Reset();
1205  for (UInt_t uWfmIndex = 0; uWfmIndex < kuNbChanPsd * kuNbWfmRanges;
1206  ++uWfmIndex)
1207  kvuWfmInRangeToChangeChan[uWfmIndex] = 0;
1208 
1209  fuCurrentSpillIdx = 0;
1210  fuCurrentSpillPlot = 0;
1211  fhChannelMap->Reset();
1212  fhHitChargeMap->Reset();
1213  fhHitMapEvo->Reset();
1214  fhChanHitMapEvo->Reset();
1215  for (UInt_t uSpill = 0; uSpill < kuNbSpillPlots; uSpill++)
1216  fvhChannelMapSpill[uSpill]->Reset();
1217  fhHitsPerSpill->Reset();
1218 
1219  fhMsgsCntEvo->Reset();
1220  fhReadMsgsCntEvo->Reset();
1221  fhLostMsgsCntEvo->Reset();
1222  fhReadEvtsCntEvo->Reset();
1223 
1224  fhAdcTimeEvo->Reset();
1225  fhMsLengthEvo->Reset();
1226 
1227  fhMsgsCntPerMsEvo->Reset();
1228  fhReadMsgsCntPerMsEvo->Reset();
1229  fhLostMsgsCntPerMsEvo->Reset();
1230  fhReadEvtsCntPerMsEvo->Reset();
1231 
1233  fdStartTime = -1.0;
1234 
1235 
1236  return kTRUE;
1237 }
1238 
1239 // -------------------------------------------------------------------------
CbmMcbm2018MonitorAlgoPsd::kuBytesPerMessage
static const UInt_t kuBytesPerMessage
Definition: CbmMcbm2018MonitorAlgoPsd.h:98
PsdSignalFitting::PronyFitter::SetSignalBegin
void SetSignalBegin(int SignalBeg)
Definition: PronyFitter.cxx:48
CbmMcbm2018MonitorAlgoPsd::fcChargesFPGA
TCanvas * fcChargesFPGA
Definition: CbmMcbm2018MonitorAlgoPsd.h:218
CbmStar2019Algo< CbmPsdDigi >::fdMsSizeInNs
Double_t fdMsSizeInNs
/‍** Ignore Overlap Ms: all fuOverlapMsNb MS at the end of timeslice **‍/
Definition: CbmStar2019Algo.h:117
CbmMcbm2018MonitorAlgoPsd::kvuWfmRanges
std::vector< UInt_t > kvuWfmRanges
Definition: CbmMcbm2018MonitorAlgoPsd.h:173
PsdData::PsdGbtReader::SetPrintOutMode
void SetPrintOutMode(bool mode)
Definition: PsdGbtReader.h:40
CbmMcbm2018MonitorAlgoPsd::fdMsTime
Double_t fdMsTime
End Time in ns of current TS Core from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoPsd.h:111
CbmMcbm2018MonitorAlgoPsd::fcAmplitudes
TCanvas * fcAmplitudes
Definition: CbmMcbm2018MonitorAlgoPsd.h:220
CbmMcbm2018PsdPar::GetNrOfChannelsPerFee
Int_t GetNrOfChannelsPerFee()
Definition: CbmMcbm2018PsdPar.h:64
CbmMcbm2018MonitorAlgoPsd::ProcessMs
Bool_t ProcessMs(const fles::Timeslice &ts, size_t uMsCompIdx, size_t uMsIdx)
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:279
CbmMcbm2018MonitorAlgoPsd::fhMsgsCntEvo
TH1 * fhMsgsCntEvo
Global Rate.
Definition: CbmMcbm2018MonitorAlgoPsd.h:197
CbmMcbm2018MonitorAlgoPsd::fuReadEvtCntInMs
UInt_t fuReadEvtCntInMs
Definition: CbmMcbm2018MonitorAlgoPsd.h:155
CbmMcbm2018MonitorAlgoPsd::ResetHistograms
Bool_t ResetHistograms()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:1184
CbmMcbm2018MonitorAlgoPsd::fuCurrentSpillPlot
UInt_t fuCurrentSpillPlot
Definition: CbmMcbm2018MonitorAlgoPsd.h:180
CbmMcbm2018MonitorAlgoPsd::fhReadEvtsCntPerMsEvo
TH2 * fhReadEvtsCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:208
CbmStar2019Algo< CbmPsdDigi >::fuNbMsLoop
size_t fuNbMsLoop
Definition: CbmStar2019Algo.h:114
CbmMcbm2018MonitorAlgoPsd::AddMsComponentToList
void AddMsComponentToList(size_t component, UShort_t usDetectorId)
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:200
CbmMcbm2018MonitorAlgoPsd::fhReadEvtsCntEvo
TH1 * fhReadEvtsCntEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:200
PsdData::PsdGbtReader::VectHitData
std::vector< PsdHitData > VectHitData
Definition: PsdGbtReader.h:34
PsdSignalFitting::PronyFitter::GetIntegral
float GetIntegral(int gate_beg, int gate_end)
Definition: PronyFitter.cxx:546
CbmMcbm2018MonitorAlgoPsd::fuCurrDpbIdx
UInt_t fuCurrDpbIdx
Temp holder until Current equipment ID is properly filled in MS.
Definition: CbmMcbm2018MonitorAlgoPsd.h:122
PsdSignalFitting::PronyFitter::GetFitWfm
std::vector< uint16_t > GetFitWfm()
Definition: PronyFitter.h:80
CbmMcbm2018MonitorAlgoPsd::fhReadMsgsCntEvo
TH1 * fhReadMsgsCntEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:198
CbmMcbm2018MonitorAlgoPsd::fdStartTime
Double_t fdStartTime
Epoch + Epoch Cycle.
Definition: CbmMcbm2018MonitorAlgoPsd.h:135
CbmMcbm2018MonitorAlgoPsd::fvhFitQaChan
std::vector< TH2 * > fvhFitQaChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:213
CbmMcbm2018PsdPar.h
CbmMcbm2018MonitorAlgoPsd::fvulCurrentEpochCycle
std::vector< ULong64_t > fvulCurrentEpochCycle
Current epoch index, per DPB.
Definition: CbmMcbm2018MonitorAlgoPsd.h:130
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMcbm2018MonitorAlgoPsd::fbSpillOn
Bool_t fbSpillOn
Channels map.
Definition: CbmMcbm2018MonitorAlgoPsd.h:178
PsdSignalFitting::PronyFitter::ChooseBestSignalBeginHarmonics
int ChooseBestSignalBeginHarmonics(int first_sample, int last_sample)
Definition: PronyFitter.cxx:760
CbmMcbm2018MonitorAlgoPsd::fuCurrentEquipmentId
UInt_t fuCurrentEquipmentId
Index of current MS within the TS.
Definition: CbmMcbm2018MonitorAlgoPsd.h:118
PsdSignalFitting::PronyFitter
Definition: PronyFitter.h:19
CbmStar2019Algo< CbmPsdDigi >::fuNbOverMsPerTs
size_t fuNbOverMsPerTs
Definition: CbmStar2019Algo.h:113
CbmMcbm2018MonitorAlgoPsd::fviHistoZLArgs
std::vector< Int_t > fviHistoZLArgs
Definition: CbmMcbm2018MonitorAlgoPsd.h:148
CbmStar2019Algo< CbmPsdDigi >::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
For monitor algos.
Definition: CbmStar2019Algo.h:80
CbmMcbm2018MonitorAlgoPsd::fdStartTimeSpill
Double_t fdStartTimeSpill
Definition: CbmMcbm2018MonitorAlgoPsd.h:181
CbmMcbm2018MonitorAlgoPsd::fuNrOfFeePerGdpb
UInt_t fuNrOfFeePerGdpb
gDPB ID to index map
Definition: CbmMcbm2018MonitorAlgoPsd.h:92
CbmStar2019Algo< CbmPsdDigi >::fuNbCoreMsPerTs
size_t fuNbCoreMsPerTs
Definition: CbmStar2019Algo.h:112
PsdData::PsdGbtReader::EvHdrAc
PsdEventHeaderAC EvHdrAc
Definition: PsdGbtReader.h:29
CbmMcbm2018MonitorAlgoPsd::fhMsLengthEvo
TH2 * fhMsLengthEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:203
PsdData::PsdGbtReader
Definition: PsdGbtReader.h:17
CbmMcbm2018MonitorAlgoPsd::fviHistoChargeArgs
std::vector< Int_t > fviHistoChargeArgs
Definition: CbmMcbm2018MonitorAlgoPsd.h:144
CbmStar2019Algo< CbmPsdDigi >::fdTsFullSizeInNs
Double_t fdTsFullSizeInNs
Total size of the core MS in a TS, [nanoseconds].
Definition: CbmStar2019Algo.h:121
CbmStar2019Algo< CbmPsdDigi >::fParCList
TList * fParCList
Parameter management.
Definition: CbmStar2019Algo.h:108
CbmMcbm2018MonitorAlgoPsd::kuOffSpillCountLimit
static const UInt_t kuOffSpillCountLimit
Definition: CbmMcbm2018MonitorAlgoPsd.h:185
CbmMcbm2018MonitorAlgoPsd::fcChargesWfm
TCanvas * fcChargesWfm
Definition: CbmMcbm2018MonitorAlgoPsd.h:219
CbmMcbm2018MonitorAlgoPsd::kvuWfmInRangeToChangeChan
std::vector< UInt_t > kvuWfmInRangeToChangeChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:174
CbmStar2019Algo< CbmPsdDigi >::fvMsComponentsList
std::vector< size_t > fvMsComponentsList
Parameters related to FLES containers.
Definition: CbmStar2019Algo.h:111
PsdData::PsdGbtReader::ReadEventFles
int ReadEventFles()
Definition: PsdGbtReader.cxx:98
CbmMcbm2018MonitorAlgoPsd::fuCurrentSpillIdx
UInt_t fuCurrentSpillIdx
Definition: CbmMcbm2018MonitorAlgoPsd.h:179
PsdData::PsdGbtReader::GetTotalGbtWordsRead
uint32_t GetTotalGbtWordsRead()
Definition: PsdGbtReader.h:48
CbmMcbm2018MonitorAlgoPsd::fulCurrentMsIdx
ULong64_t fulCurrentMsIdx
Definition: CbmMcbm2018MonitorAlgoPsd.h:105
CbmMcbm2018MonitorAlgoPsd::fuMsIndex
UInt_t fuMsIndex
Start Time in ns of previous MS from its index field in header.
Definition: CbmMcbm2018MonitorAlgoPsd.h:114
CbmMcbm2018MonitorAlgoPsd::GetNbChanPsd
static constexpr UInt_t GetNbChanPsd()
Definition: CbmMcbm2018MonitorAlgoPsd.h:101
CbmMcbm2018MonitorAlgoPsd::fuNrOfGdpbs
UInt_t fuNrOfGdpbs
Definition: CbmMcbm2018MonitorAlgoPsd.h:90
PsdSignalFitting::PronyFitter::SetWaveform
void SetWaveform(std::vector< uint16_t > &uWfm, uint16_t uZeroLevel)
Definition: PronyFitter.cxx:35
CbmMcbm2018MonitorAlgoPsd::fvuHitCntChanMs
std::vector< UInt_t > fvuHitCntChanMs
Channel rate plots.
Definition: CbmMcbm2018MonitorAlgoPsd.h:158
CbmMcbm2018MonitorAlgoPsd::fcWfmsAllChannels
TCanvas * fcWfmsAllChannels
Definition: CbmMcbm2018MonitorAlgoPsd.h:224
CbmMcbm2018MonitorAlgoPsd::fulCurrentTsIdx
ULong64_t fulCurrentTsIdx
Definition: CbmMcbm2018MonitorAlgoPsd.h:104
CbmMcbm2018MonitorAlgoPsd::fhLostMsgsCntEvo
TH1 * fhLostMsgsCntEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:199
CbmMcbm2018MonitorAlgoPsd::fbFirstPackageError
Bool_t fbFirstPackageError
Definition: CbmMcbm2018MonitorAlgoPsd.h:85
CbmMcbm2018MonitorAlgoPsd::fuReadMsgsCntInMs
UInt_t fuReadMsgsCntInMs
Definition: CbmMcbm2018MonitorAlgoPsd.h:153
CbmMcbm2018MonitorAlgoPsd::fhLostMsgsCntPerMsEvo
TH2 * fhLostMsgsCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:207
PsdData::PsdEventHeaderAC::uAdcTime
uint32_t uAdcTime
Empty bits.
Definition: PsdGbtDataFormat.h:58
CbmMcbm2018MonitorAlgoPsd::fhChannelMap
TH1 * fhChannelMap
Definition: CbmMcbm2018MonitorAlgoPsd.h:189
PsdData::PsdGbtReader::EvHdrAb
PsdEventHeaderAB EvHdrAb
Definition: PsdGbtReader.h:28
CbmMcbm2018MonitorAlgoPsd::ProcessTs
Bool_t ProcessTs(const fles::Timeslice &ts)
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:215
h
Data class with information on a STS local track.
CbmMcbm2018MonitorAlgoPsd::fvhFitHarmonic2Chan
std::vector< TH2 * > fvhFitHarmonic2Chan
Definition: CbmMcbm2018MonitorAlgoPsd.h:212
PsdSignalFitting::PronyFitter::GetRSquare
float GetRSquare(int gate_beg, int gate_end)
Definition: PronyFitter.cxx:656
CbmMcbm2018MonitorAlgoPsd::fhChanHitMapEvo
TH2 * fhChanHitMapEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:192
CbmMcbm2018MonitorAlgoPsd::kuNbWfmExamples
static const UInt_t kuNbWfmExamples
Definition: CbmMcbm2018MonitorAlgoPsd.h:172
CbmMcbm2018MonitorAlgoPsd::fvhHitCntPerMsEvoChan
std::vector< TH2 * > fvhHitCntPerMsEvoChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:162
CbmMcbm2018MonitorAlgoPsd::kuNbChanPsd
static const UInt_t kuNbChanPsd
Definition: CbmMcbm2018MonitorAlgoPsd.h:99
CbmMcbm2018MonitorAlgoPsd::kuNbSpillPlots
static const UInt_t kuNbSpillPlots
Definition: CbmMcbm2018MonitorAlgoPsd.h:184
CbmMcbm2018MonitorAlgoPsd::fuLostMsgsCntInMs
UInt_t fuLostMsgsCntInMs
Definition: CbmMcbm2018MonitorAlgoPsd.h:154
CbmMcbm2018MonitorAlgoPsd::fvhHitZeroLevelChan
std::vector< TH1 * > fvhHitZeroLevelChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:164
CbmStar2019Algo
Definition: CbmStar2019Algo.h:43
CbmMcbm2018PsdPar
Definition: CbmMcbm2018PsdPar.h:19
CbmMcbm2018MonitorAlgoPsd::FillHistograms
Bool_t FillHistograms()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:1163
CbmMcbm2018MonitorAlgoPsd::fdLastSecondTime
Double_t fdLastSecondTime
Definition: CbmMcbm2018MonitorAlgoPsd.h:182
CbmMcbm2018PsdPar::GetNrOfGdpbs
Int_t GetNrOfGdpbs()
Definition: CbmMcbm2018PsdPar.h:61
CbmMcbm2018MonitorAlgoPsd::fvhHitFitWfmChan
std::vector< TH1 * > fvhHitFitWfmChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:169
CbmMcbm2018MonitorAlgoPsd::fUnpackPar
CbmMcbm2018PsdPar * fUnpackPar
Settings from parameter file.
Definition: CbmMcbm2018MonitorAlgoPsd.h:88
CbmMcbm2018MonitorAlgoPsd::CbmMcbm2018MonitorAlgoPsd
CbmMcbm2018MonitorAlgoPsd()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:37
CbmStar2019Algo< CbmPsdDigi >::fdTsCoreSizeInNs
Double_t fdTsCoreSizeInNs
Size of a single MS, [nanoseconds].
Definition: CbmStar2019Algo.h:119
CbmMcbm2018MonitorAlgoPsd::fuHistoryHistoSize
UInt_t fuHistoryHistoSize
Histograms related variables.
Definition: CbmMcbm2018MonitorAlgoPsd.h:142
CbmMcbm2018MonitorAlgoPsd::CreateHistograms
Bool_t CreateHistograms()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:608
CbmMcbm2018MonitorAlgoPsd::fhHitsPerSpill
TH1 * fhHitsPerSpill
Definition: CbmMcbm2018MonitorAlgoPsd.h:194
CbmMcbm2018MonitorAlgoPsd::fvhHitCntEvoChan
std::vector< TH1 * > fvhHitCntEvoChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:161
CbmMcbm2018MonitorAlgoPsd::fvbMaskedComponents
std::vector< Bool_t > fvbMaskedComponents
Switch ON the filling of a additional set of histograms.
Definition: CbmMcbm2018MonitorAlgoPsd.h:84
CbmMcbm2018MonitorAlgoPsd::InitContainers
Bool_t InitContainers()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:147
CbmMcbm2018MonitorAlgoPsd::fuCountsLastSecond
UInt_t fuCountsLastSecond
Definition: CbmMcbm2018MonitorAlgoPsd.h:183
CbmMcbm2018MonitorAlgoPsd::fhHitChargeMap
TH1 * fhHitChargeMap
Definition: CbmMcbm2018MonitorAlgoPsd.h:190
CbmMcbm2018MonitorAlgoPsd::fhReadMsgsCntPerMsEvo
TH2 * fhReadMsgsCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:206
CbmMcbm2018MonitorAlgoPsd::fcSpillCounts
TCanvas * fcSpillCounts
Definition: CbmMcbm2018MonitorAlgoPsd.h:222
CbmMcbm2018MonitorAlgoPsd::fvhHitAmplChan
std::vector< TH1 * > fvhHitAmplChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:165
PsdData::PsdHitHeader::uWfmPoints
uint8_t uWfmPoints
Definition: PsdGbtDataFormat.h:88
CbmMcbm2018MonitorAlgoPsd::fvulCurrentEpochFull
std::vector< ULong64_t > fvulCurrentEpochFull
Epoch cycle from the Ms Start message and Epoch counter flip.
Definition: CbmMcbm2018MonitorAlgoPsd.h:131
FormatMsHeaderPrintout
std::string FormatMsHeaderPrintout(const fles::MicrosliceDescriptor &msDescriptor)
Definition: CbmFormatMsHeaderPrintout.cxx:5
CbmMcbm2018MonitorAlgoPsd::GetParList
TList * GetParList()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:164
PsdData::PsdEventHeaderAB::uHitsNumber
uint8_t uHitsNumber
Should be AB.
Definition: PsdGbtDataFormat.h:26
CbmMcbm2018MonitorAlgoPsd::fviHistoAmplArgs
std::vector< Int_t > fviHistoAmplArgs
Definition: CbmMcbm2018MonitorAlgoPsd.h:146
CbmMcbm2018MonitorAlgoPsd::fvulCurrentEpoch
std::vector< ULong64_t > fvulCurrentEpoch
Bin size in s for the plots with date as X axis.
Definition: CbmMcbm2018MonitorAlgoPsd.h:128
CbmMcbm2018PsdPar::GetNrOfFeesPerGdpb
Int_t GetNrOfFeesPerGdpb()
Definition: CbmMcbm2018PsdPar.h:63
CbmMcbm2018MonitorAlgoPsd::~CbmMcbm2018MonitorAlgoPsd
~CbmMcbm2018MonitorAlgoPsd()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:129
GenerateLogBinArray
std::vector< double > GenerateLogBinArray(uint32_t uNbDecadesLog, uint32_t uNbStepsDecade, uint32_t uNbSubStepsInStep, uint32_t &uNbBinsLog)
Definition: CbmFlesHistosTools.cxx:6
CbmMcbm2018MonitorAlgoPsd::fuNrOfChannelsPerGdpb
UInt_t fuNrOfChannelsPerGdpb
Number of channels in each FEE.
Definition: CbmMcbm2018MonitorAlgoPsd.h:94
CbmMcbm2018MonitorAlgoPsd::ReInitContainers
Bool_t ReInitContainers()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:153
CbmMcbm2018MonitorAlgoPsd::fuReadEvtCnt
UInt_t fuReadEvtCnt
Histograms.
Definition: CbmMcbm2018MonitorAlgoPsd.h:151
CbmMcbm2018MonitorAlgoPsd::fvhFitHarmonic1Chan
std::vector< TH2 * > fvhFitHarmonic1Chan
Waveform fitting.
Definition: CbmMcbm2018MonitorAlgoPsd.h:211
CbmMcbm2018MonitorAlgoPsd::fvhHitChargeByWfmChan
std::vector< TH1 * > fvhHitChargeByWfmChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:166
CbmFlesHistosTools.h
PsdData::PsdGbtReader::HitHdr
PsdHitHeader HitHdr
Definition: PsdGbtReader.h:30
PsdSignalFitting::PronyFitter::SetDebugMode
void SetDebugMode(bool IsDebug)
Definition: PronyFitter.h:56
CbmMcbm2018MonitorAlgoPsd::fvhHitChargeEvoChan
std::vector< TH2 * > fvhHitChargeEvoChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:167
CbmMcbm2018MonitorAlgoPsd::Finish
virtual void Finish()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:140
CbmMcbm2018MonitorAlgoPsd::InitParameters
Bool_t InitParameters()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:171
CbmMcbm2018MonitorAlgoPsd::fcGenCntsPerMs
TCanvas * fcGenCntsPerMs
Definition: CbmMcbm2018MonitorAlgoPsd.h:221
CbmMcbm2018MonitorAlgoPsd::fvcWfmsChan
std::vector< TCanvas * > fvcWfmsChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:225
CbmMcbm2018MonitorAlgoPsd::fdTsStartTime
Double_t fdTsStartTime
Definition: CbmMcbm2018MonitorAlgoPsd.h:107
CbmStar2019Algo< CbmPsdDigi >::AddCanvasToVector
void AddCanvasToVector(TCanvas *pointer, std::string sFolder="")
Definition: CbmStar2019Algo.h:87
CbmMcbm2018MonitorAlgoPsd::fuNrOfChannelsPerFee
UInt_t fuNrOfChannelsPerFee
Number of FEBs per GDPB.
Definition: CbmMcbm2018MonitorAlgoPsd.h:93
CbmMcbm2018MonitorAlgoPsd::fv3hHitWfmFlattenedChan
std::vector< TH1 * > fv3hHitWfmFlattenedChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:175
PsdSignalFitting::PronyFitter::CalculateFitAmplitudes
void CalculateFitAmplitudes()
Definition: PronyFitter.cxx:446
CbmMcbm2018MonitorAlgoPsd::fhMsgsCntPerMsEvo
TH2 * fhMsgsCntPerMsEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:205
CbmMcbm2018MonitorAlgoPsd::fuCurrDpbId
UInt_t fuCurrDpbId
Current equipment ID, tells from which DPB the current MS is originating.
Definition: CbmMcbm2018MonitorAlgoPsd.h:120
CbmMcbm2018MonitorAlgoPsd::Reset
virtual void Reset()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:139
CbmMcbm2018MonitorAlgoPsd::fcSummary
TCanvas * fcSummary
Canvases.
Definition: CbmMcbm2018MonitorAlgoPsd.h:216
PsdSignalFitting::PronyFitter::GetHarmonics
std::complex< float > * GetHarmonics()
Definition: PronyFitter.cxx:440
PsdSignalFitting::PronyFitter::CalculateFitHarmonics
void CalculateFitHarmonics()
Definition: PronyFitter.cxx:54
CbmMcbm2018MonitorAlgoPsd::fdPrevMsTime
Double_t fdPrevMsTime
Start Time in ns of current MS from its index field in header.
Definition: CbmMcbm2018MonitorAlgoPsd.h:113
CbmMcbm2018MonitorAlgoPsd::kuNbWfmRanges
static const UInt_t kuNbWfmRanges
Definition: CbmMcbm2018MonitorAlgoPsd.h:171
PairAnalysisStyler::Fill
static Int_t Fill[]
Definition: PairAnalysisStyleDefs.h:82
CbmMcbm2018MonitorAlgoPsd::fbMonitorMode
Bool_t fbMonitorMode
Control flags.
Definition: CbmMcbm2018MonitorAlgoPsd.h:81
CbmMcbm2018MonitorAlgoPsd::fvhHitChargeChan
std::vector< TH1 * > fvhHitChargeChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:163
CbmMcbm2018MonitorAlgoPsd.h
CbmMcbm2018MonitorAlgoPsd::fcHitMaps
TCanvas * fcHitMaps
Definition: CbmMcbm2018MonitorAlgoPsd.h:217
CbmMcbm2018MonitorAlgoPsd::Init
virtual Bool_t Init()
Definition: CbmMcbm2018MonitorAlgoPsd.cxx:134
CbmMcbm2018MonitorAlgoPsd::fhAdcTimeEvo
TH2 * fhAdcTimeEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:202
CbmMcbm2018MonitorAlgoPsd::fdTsStopTimeCore
Double_t fdTsStopTimeCore
Time in ns of current TS from the index of the first MS first component.
Definition: CbmMcbm2018MonitorAlgoPsd.h:109
CbmMcbm2018MonitorAlgoPsd::fuMsgsCntInMs
UInt_t fuMsgsCntInMs
Definition: CbmMcbm2018MonitorAlgoPsd.h:152
CbmMcbm2018MonitorAlgoPsd::fhHitMapEvo
TH1 * fhHitMapEvo
Definition: CbmMcbm2018MonitorAlgoPsd.h:191
PsdData::PsdEventHeaderAB::ulMicroSlice
uint64_t ulMicroSlice
Total number of hits.
Definition: PsdGbtDataFormat.h:27
CbmStar2019Algo< CbmPsdDigi >::fbIgnoreOverlapMs
Bool_t fbIgnoreOverlapMs
Definition: CbmStar2019Algo.h:116
CbmMcbm2018MonitorAlgoPsd::fvhHitWfmChan
std::vector< TH1 * > fvhHitWfmChan
Definition: CbmMcbm2018MonitorAlgoPsd.h:168
CbmMcbm2018MonitorAlgoPsd::fGdpbIdIndexMap
std::map< UInt_t, UInt_t > fGdpbIdIndexMap
Total number of GDPBs in the system.
Definition: CbmMcbm2018MonitorAlgoPsd.h:91
CbmMcbm2018PsdPar::GetGdpbId
Int_t GetGdpbId(Int_t i)
Definition: CbmMcbm2018PsdPar.h:62
CbmFormatMsHeaderPrintout.h
CbmMcbm2018MonitorAlgoPsd::fcPronyFit
TCanvas * fcPronyFit
Definition: CbmMcbm2018MonitorAlgoPsd.h:226
CbmMcbm2018MonitorAlgoPsd::fvhChannelMapSpill
std::vector< TH1 * > fvhChannelMapSpill
Definition: CbmMcbm2018MonitorAlgoPsd.h:193
PsdData::PsdGbtReader::VectHitHdr
std::vector< PsdHitHeader > VectHitHdr
Definition: PsdGbtReader.h:33