CbmRoot
Loading...
Searching...
No Matches
CbmTofUnpackMonitorTestFee.cxx
Go to the documentation of this file.
1/* Copyright (C) 2025 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Pierre-Alain Loizeau [committer] */
4
5#include "CbmTofUnpackMonitorTestFee.h"
6
7#include "CbmFlesHistosTools.h"
8#include "CriGet4Mess001.h"
9#include "MicrosliceDescriptor.hpp"
10
11#include <FairRunOnline.h>
12#include <Logger.h>
13
14#include <RtypesCore.h>
15#include <TCanvas.h>
16#include <TF1.h>
17#include <TFile.h>
18#include <TH1.h>
19#include <TH2.h>
20#include <THttpServer.h>
21#include <TMath.h>
22#include <TPaveStats.h>
23#include <TProfile.h>
24#include <TROOT.h>
25
35
36CbmTofUnpackMonitorTestFee::~CbmTofUnpackMonitorTestFee() {}
37
39Bool_t CbmTofUnpackMonitorTestFee::Init(CbmMcbm2018TofPar* digiParSet)
40{
41 // Get Infos from the parset
42 fUnpackPar = digiParSet;
43
44 fuNbOfComps = fUnpackPar->GetNrOfGdpbs();
46 // FIXME: Start using again the parameter class accessors once a new CRI oriented class is brought into use
47 fuNbOfGet4PerComp = 80;
48 fuNbOfChannelsPerGet4 = 4;
49 fuNbOfChannelsPerComp = fuNbOfGet4PerComp * fuNbOfChannelsPerGet4;
50 fuNbOfGet4InSyst = fuNbOfComps * fuNbOfGet4PerComp;
51 fuNbOfChannelsPerFee = fuNbOfGet4PerFee * fuNbOfChannelsPerGet4;
52
54 fuGlobalIdxFeeA = fuNbOfFeePerComp * fuCompA + fUnpackPar->GetNrOfFeePerGbtx() * fuGbtxA + fuFeeA;
55 fuGlobalIdxFeeB = fuNbOfFeePerComp * fuCompB + fUnpackPar->GetNrOfFeePerGbtx() * fuGbtxB + fuFeeB;
56
57 fvuFeeChanNbHitsLastMs.resize(fuNbOfFeePerComp * fuNbOfComps);
58 fvdFeeChanMsLastPulserHit.resize(fuNbOfFeePerComp * fuNbOfComps);
59 for (UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; ++uFee) {
60 fvuFeeChanNbHitsLastMs[uFee].resize(fuNbOfChannelsPerFee, 0);
61 fvdFeeChanMsLastPulserHit[uFee].resize(fuNbOfChannelsPerFee, 0.0);
62 } // for( UInt_t uFee = 0; uFee < fuNbOfFeePerComp * fuNbOfComps; ++uFee );
63
65 TFile* oldFile = gFile;
66 TDirectory* oldDir = gDirectory;
67 gROOT->cd();
68
70 CreateHistograms();
71 DrawCanvases();
72
74 gFile = oldFile;
75 gDirectory = oldDir;
76
78 std::vector<std::pair<TNamed*, std::string>> vHistos = GetHistoVector();
79
81 std::vector<std::pair<TCanvas*, std::string>> vCanvases = GetCanvasVector();
82
84 std::string sSystem = "tof";
85 if (fBmonMode || fBmonMicroSpillMode || fBmonQfactorsMode) {
86 //
87 sSystem = "bmon";
88 }
89
90 if (fbInternalHttp) {
91 THttpServer* server = FairRunOnline::Instance()->GetHttpServer();
92 if (nullptr != server) {
93 for (UInt_t uCanvas = 0; uCanvas < vCanvases.size(); ++uCanvas) {
94 server->Register(Form("/%s/%s", sSystem.data(), vCanvases[uCanvas].second.data()), vCanvases[uCanvas].first);
95 }
96 for (UInt_t uHisto = 0; uHisto < vHistos.size(); ++uHisto) {
97 server->Register(Form("/%s/%s", sSystem.data(), vHistos[uHisto].second.data()), vHistos[uHisto].first);
98 }
99 /*
100 server->RegisterCommand(Form("/Reset_%s_Hist", sSystem.data()), "bMcbm2018UnpackerTaskStsResetHistos=kTRUE");
101 server->Restrict("/Reset_UnpSts_Hist", "allow=admin");
102 */
103 }
104 }
105
106 return kTRUE;
107}
108
109Bool_t CbmTofUnpackMonitorTestFee::CreateHistograms()
110{
112 std::string sSystem = "tof";
113
114 // Full Fee time difference test
115 UInt_t uNbBinsDt = kuNbBinsDt + 1; // To account for extra bin due to shift by 1/2 bin of both ranges
116
117 fuNbFeePlotsPerComp = fuNbOfFeePerComp / fuNbFeePlot + (0 != fuNbOfFeePerComp % fuNbFeePlot ? 1 : 0);
118 dMinDt = -1. * (kuNbBinsDt * critof001::kdBinSize / 2.) - critof001::kdBinSize / 2.;
119 dMaxDt = 1. * (kuNbBinsDt * critof001::kdBinSize / 2.) + critof001::kdBinSize / 2.;
120
121 /*******************************************************************/
123 // clang-format off
124 /*******************************************************************/
126 fvhTimeDiffPulserFeeA.resize(fuNbOfChannelsPerFee);
127 fvhTimeDiffPulserFeeB.resize(fuNbOfChannelsPerFee);
128 fvhTimeDiffPulserFeeFee.resize(fuNbOfChannelsPerFee);
129 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++) {
130 fvhTimeDiffPulserFeeA[uChanA].resize(fuNbOfChannelsPerFee);
131 fvhTimeDiffPulserFeeB[uChanA].resize(fuNbOfChannelsPerFee);
132 fvhTimeDiffPulserFeeFee[uChanA].resize(fuNbOfChannelsPerFee);
133 for (UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++) {
134 if (uChanA < uChanB) {
135 fvhTimeDiffPulserFeeA[uChanA][uChanB] =
136 new TH1I(Form("hTimeDiffPulser_g%02u_gbt%1u_f%1u_ch%02u_ch%02u", fuCompA, fuGbtxA, fuFeeA, uChanA, uChanB),
137 Form("Time difference for pulser on gDPB %02u GBTx %02u FEE "
138 "%1u channels %02u and %02u; DeltaT [ps]; Counts",
139 fuCompA, fuGbtxA, fuFeeA, uChanA, uChanB),
140 uNbBinsDt, dMinDt, dMaxDt);
141
142 fvhTimeDiffPulserFeeB[uChanA][uChanB] =
143 new TH1I(Form("hTimeDiffPulser_g%02u_gbt%1u_f%1u_ch%02u_ch%02u", fuCompB, fuGbtxB, fuFeeB, uChanA, uChanB),
144 Form("Time difference for pulser on gDPB %02u GBTx %02u FEE "
145 "%1u channels %02u and %02u; DeltaT [ps]; Counts",
146 fuCompB, fuGbtxB, fuFeeB, uChanA, uChanB),
147 uNbBinsDt, dMinDt, dMaxDt);
148 } // if( uChanA < uFeeB )
149 else {
150 fvhTimeDiffPulserFeeA[uChanA][uChanB] = NULL;
151 fvhTimeDiffPulserFeeB[uChanA][uChanB] = NULL;
152 } // else of if( uChanA < uChanB )
153
154 fvhTimeDiffPulserFeeFee[uChanA][uChanB] =
155 new TH1I(Form("hTimeDiffPulser_g%02u_gbt%1u_f%1u_ch%02u_g%02u_gbt%1u_f%1u_ch%02u", fuCompA, fuGbtxA, fuFeeA,
156 uChanA, fuCompB, fuGbtxB, fuFeeB, uChanB),
157 Form("Time difference for pulser on gDPB %02u GBTx %02u FEE %1u "
158 "channel %02u and gDPB %02u GBTx %02u FEE %1u channel %02u; "
159 "DeltaT [ps]; Counts",
160 fuCompA, fuGbtxA, fuFeeA, uChanA, fuCompB, fuGbtxB, fuFeeB, uChanB),
161 uNbBinsDt, dMinDt, dMaxDt);
162 } // for( UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++)
163 } // for( UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++)
164
166 fhTimeMeanPulserFeeA = new TH2D("hTimeMeanPulserFeeA",
167 "Time difference Mean for each channel pairs "
168 "in FEE A; Chan A; Chan B ; Mean [ps]",
169 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
170 0.5, fuNbOfChannelsPerFee - 0.5);
171 fhTimeRmsPulserFeeA = new TH2D("hTimeRmsPulserFeeA",
172 "Time difference RMS for each channel pairs "
173 "in FEE A; Chan A; Chan B; RMS [ps]",
174 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
175 0.5, fuNbOfChannelsPerFee - 0.5);
176 fhTimeRmsZoomFitPulsFeeA = new TH2D("hTimeRmsZoomFitPulsFeeA",
177 "Time difference RMS after zoom for each channel pairs in FEE A; "
178 "Chan A; Chan B; RMS [ps]",
179 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5,
180 fuNbOfChannelsPerFee - 1, 0.5, fuNbOfChannelsPerFee - 0.5);
181 fhTimeResFitPulsFeeA = new TH2D("hTimeResFitPulsFeeA",
182 "Time difference Res from fit for each channel pairs in FEE A; "
183 "Chan A; Chan B; Sigma [ps]",
184 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
185 0.5, fuNbOfChannelsPerFee - 0.5);
186
188 fhTimeMeanPulserFeeB = new TH2D("hTimeMeanPulserFeeB",
189 "Time difference Mean for each channel pairs "
190 "in FEE B; Chan A; Chan B ; Mean [ps]",
191 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
192 0.5, fuNbOfChannelsPerFee - 0.5);
193 fhTimeRmsPulserFeeB = new TH2D("hTimeRmsPulserFeeB",
194 "Time difference RMS for each channel pairs "
195 "in FEE B; Chan A; Chan B; RMS [ps]",
196 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
197 0.5, fuNbOfChannelsPerFee - 0.5);
198 fhTimeRmsZoomFitPulsFeeB = new TH2D("hTimeRmsZoomFitPulsFeeB",
199 "Time difference RMS after zoom for each channel pairs in FEE B; "
200 "Chan A; Chan B; RMS [ps]",
201 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5,
202 fuNbOfChannelsPerFee - 1, 0.5, fuNbOfChannelsPerFee - 0.5);
203 fhTimeResFitPulsFeeB = new TH2D("hTimeResFitPulsFeeB",
204 "Time difference Res from fit for each channel pairs in FEE B; "
205 "Chan A; Chan B; Sigma [ps]",
206 fuNbOfChannelsPerFee - 1, -0.5, fuNbOfChannelsPerFee - 1.5, fuNbOfChannelsPerFee - 1,
207 0.5, fuNbOfChannelsPerFee - 0.5);
208
210 fhTimeMeanPulserFeeFee = new TH2D("hTimeMeanPulserFeeFee",
211 "Time difference Mean for each channel pairs in FEE A & B; Chan "
212 "FEE A; Chan FEE B ; Mean [ps]",
213 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5, fuNbOfChannelsPerFee, -0.5,
214 fuNbOfChannelsPerFee - 0.5);
215 fhTimeRmsPulserFeeFee = new TH2D("hTimeRmsPulserFeeFee",
216 "Time difference RMS for each channel pairs in FEE A & B; Chan "
217 "FEE A; Chan FEE B; RMS [ps]",
218 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5, fuNbOfChannelsPerFee, -0.5,
219 fuNbOfChannelsPerFee - 0.5);
220 fhTimeRmsZoomFitPulsFeeFee = new TH2D("hTimeRmsZoomFitPulsFeeFee",
221 "Time difference RMS after zoom for each channel pairs in FEE A & "
222 "B; Chan FEE A; Chan FEE B; RMS [ps]",
223 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5, fuNbOfChannelsPerFee,
224 -0.5, fuNbOfChannelsPerFee - 0.5);
225 fhTimeResFitPulsFeeFee = new TH2D("hTimeResFitPulsFeeFee",
226 "Time difference Res from fit for each channel pairs in FEE A & "
227 "B; Chan FEE A; Chan FEE B; Sigma [ps]",
228 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5, fuNbOfChannelsPerFee, -0.5,
229 fuNbOfChannelsPerFee - 0.5);
230
232 fhChanTotFeeA = new TH2D("hChanTotFeeA", "TOT distribution per channel in FEE A; Chan FEE A; TOT [bin]; Counts []",
233 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5,
234 critof001::kuTotCounterSize, -0.5, critof001::kuTotCounterSize - 0.5);
235 fhChanTotFeeB = new TH2D("hChanTotFeeB", "TOT distribution per channel in FEE B; Chan FEE B; TOT [bin]; Counts []",
236 fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5,
237 critof001::kuTotCounterSize, -0.5, critof001::kuTotCounterSize - 0.5);
238
241 uint32_t iNbBinsLog = 0;
243 std::vector<double> dBinsLogVector = GenerateLogBinArray(9, 9, 10, iNbBinsLog);
244 double* dBinsLog = dBinsLogVector.data();
245 // double * dBinsLog = GenerateLogBinArray( 9, 9, 10, iNbBinsLog );
246 fhChanPulseIntervalFeeA = new TH2D("hChanPulseIntervalFeeA",
247 "Pulses time interval per channel in FEE A; Time interval [ns]; "
248 "Chan FEE A; Counts []",
249 iNbBinsLog, dBinsLog, fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5);
250 fhChanPulseIntervalFeeB = new TH2D("hChanPulseIntervalFeeB",
251 "Pulses time interval per channel in FEE B; Time interval [ns]; "
252 "Chan FEE B; Counts []",
253 iNbBinsLog, dBinsLog, fuNbOfChannelsPerFee, -0.5, fuNbOfChannelsPerFee - 0.5);
254
255 for (UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp) {
256 fvhPulserCountEvoPerFeeComp.push_back(
257 new TH2D(Form("hPulserCountEvoPerFeeComp%02u", uComp),
258 Form("Pulser count per FEE in gDPB %02u; time in run [s]; FEE []", uComp),
259 fuHistoryHistoSize, 0, fuHistoryHistoSize, fuNbOfFeePerComp, -0.5, fuNbOfFeePerComp));
260 } // for( UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp )
262 // clang-format on
263
265 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++) {
266 for (UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++) {
267 AddHistoToVector(fvhTimeDiffPulserFeeFee[uChanA][uChanB], "TofDtFeeFee");
268 if (nullptr != fvhTimeDiffPulserFeeA[uChanA][uChanB]) {
269 AddHistoToVector(fvhTimeDiffPulserFeeA[uChanA][uChanB], "TofDtFeeA");
270 }
271 if (nullptr != fvhTimeDiffPulserFeeB[uChanA][uChanB]) {
272 AddHistoToVector(fvhTimeDiffPulserFeeB[uChanA][uChanB], "TofDtFeeB");
273 }
274 } // Loop anc channels A and B
275 }
276
277 std::string sFolder = "TofDt";
278 AddHistoToVector(fhTimeMeanPulserFeeA, sFolder);
279 AddHistoToVector(fhTimeRmsPulserFeeA, sFolder);
280 AddHistoToVector(fhTimeRmsZoomFitPulsFeeA, sFolder);
281 AddHistoToVector(fhTimeResFitPulsFeeA, sFolder);
282
283 AddHistoToVector(fhTimeMeanPulserFeeB, sFolder);
284 AddHistoToVector(fhTimeRmsPulserFeeB, sFolder);
285 AddHistoToVector(fhTimeRmsZoomFitPulsFeeB, sFolder);
286 AddHistoToVector(fhTimeResFitPulsFeeB, sFolder);
287
288 AddHistoToVector(fhTimeMeanPulserFeeFee, sFolder);
289 AddHistoToVector(fhTimeRmsPulserFeeFee, sFolder);
290 AddHistoToVector(fhTimeRmsZoomFitPulsFeeFee, sFolder);
291 AddHistoToVector(fhTimeResFitPulsFeeFee, sFolder);
292
293 sFolder = "TofPulse";
294 AddHistoToVector(fhChanTotFeeA, sFolder);
295 AddHistoToVector(fhChanTotFeeB, sFolder);
296 AddHistoToVector(fhChanPulseIntervalFeeA, sFolder);
297 AddHistoToVector(fhChanPulseIntervalFeeB, sFolder);
298
299 sFolder = "TofCnt";
300 for (UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp) {
301 AddHistoToVector(fvhPulserCountEvoPerFeeComp[uComp], sFolder);
302 } // for( UInt_t uComp = 0; uComp < fuNbOfComps; ++uComp )
303
304 return kTRUE;
305}
306
307void CbmTofUnpackMonitorTestFee::DrawCanvases()
308{
309 std::string sFolder = "canvases";
310
312 fcPulserFeeA = new TCanvas("cPulserFeeA", "Time difference RMS for channels on FEE A");
313 fcPulserFeeA->Divide(2, 2);
314
315 fcPulserFeeA->cd(1);
316 gPad->SetGridx();
317 gPad->SetGridy();
318 fhTimeRmsPulserFeeA->Draw("colz");
319
320 fcPulserFeeA->cd(2);
321 gPad->SetGridx();
322 gPad->SetGridy();
323 fhTimeMeanPulserFeeA->Draw("colz");
324
325 fcPulserFeeA->cd(3);
326 gPad->SetGridx();
327 gPad->SetGridy();
328 fhTimeRmsZoomFitPulsFeeA->Draw("colz");
329
330 fcPulserFeeA->cd(4);
331 gPad->SetGridx();
332 gPad->SetGridy();
333 fhTimeResFitPulsFeeA->Draw("colz");
334
335 AddCanvasToVector(fcPulserFeeA, sFolder);
336 /*****************************/
337
339 fcPulserFeeB = new TCanvas("cPulserFeeB", "Time difference RMS for channels on FEE A");
340 fcPulserFeeB->Divide(2, 2);
341
342 fcPulserFeeB->cd(1);
343 gPad->SetGridx();
344 gPad->SetGridy();
345 fhTimeRmsPulserFeeB->Draw("colz");
346
347 fcPulserFeeB->cd(2);
348 gPad->SetGridx();
349 gPad->SetGridy();
350 fhTimeMeanPulserFeeB->Draw("colz");
351
352 fcPulserFeeB->cd(3);
353 gPad->SetGridx();
354 gPad->SetGridy();
355 fhTimeRmsZoomFitPulsFeeB->Draw("colz");
356
357 fcPulserFeeB->cd(4);
358 gPad->SetGridx();
359 gPad->SetGridy();
360 fhTimeResFitPulsFeeB->Draw("colz");
361
362 AddCanvasToVector(fcPulserFeeB, sFolder);
363 /*****************************/
364
366 fcPulserFeeFee = new TCanvas("cPulserFeeFee", "Time difference RMS for channels on FEE A VS FEE B");
367 fcPulserFeeFee->Divide(2, 2);
368
369 fcPulserFeeFee->cd(1);
370 gPad->SetGridx();
371 gPad->SetGridy();
372 fhTimeRmsPulserFeeFee->Draw("colz");
373
374 fcPulserFeeFee->cd(2);
375 gPad->SetGridx();
376 gPad->SetGridy();
377 fhTimeMeanPulserFeeFee->Draw("colz");
378
379 fcPulserFeeFee->cd(3);
380 gPad->SetGridx();
381 gPad->SetGridy();
382 fhTimeRmsZoomFitPulsFeeFee->Draw("colz");
383
384 fcPulserFeeFee->cd(4);
385 gPad->SetGridx();
386 gPad->SetGridy();
387 fhTimeResFitPulsFeeFee->Draw("colz");
388
389 AddCanvasToVector(fcPulserFeeFee, sFolder);
390 /*****************************/
391
393 fcPulseProp = new TCanvas("cPulseProp", "Pulse properties for each channel on FEE A and FEE B");
394 fcPulseProp->Divide(2, 2);
395
396 fcPulseProp->cd(1);
397 gPad->SetGridx();
398 gPad->SetGridy();
399 gPad->SetLogz();
400 fhChanTotFeeA->Draw("colz");
401
402 fcPulseProp->cd(2);
403 gPad->SetGridx();
404 gPad->SetGridy();
405 gPad->SetLogz();
406 fhChanTotFeeB->Draw("colz");
407
408 fcPulseProp->cd(3);
409 gPad->SetGridx();
410 gPad->SetGridy();
411 gPad->SetLogx();
412 gPad->SetLogz();
413 fhChanPulseIntervalFeeA->Draw("colz");
414
415 fcPulseProp->cd(4);
416 gPad->SetGridx();
417 gPad->SetGridy();
418 gPad->SetLogx();
419 gPad->SetLogz();
420 fhChanPulseIntervalFeeB->Draw("colz");
421
422 AddCanvasToVector(fcPulseProp, sFolder);
423 /*****************************/
424}
425
431
443
445void CbmTofUnpackMonitorTestFee::FillHitMonitoringHistos(const double_t& dMsTime, const uint32_t& uCurrCompIdx,
446 const uint32_t& uGet4Id, const uint32_t& /*uRawCh*/,
447 const uint32_t& uRemapCh, const uint32_t& uTot,
448 const double_t& dHitTime, const uint32_t& /*uFts*/,
449 bool /*bDiamond*/)
450{
451 if (-1 == fdStartTime) {
453 fdStartTime = dMsTime;
454 }
456 // uint32_t uGet4InSys = uGet4Id + uCurrCompIdx * fuNbOfGet4PerComp;
457
458 // uint32_t uChannelNrInFee = uRawCh % (fuNbOfGet4PerFee * fuNbOfChannelsPerGet4);
459 uint32_t uFeeNr = (uGet4Id / fuNbOfGet4PerFee);
460 uint32_t uFeeNrInSys = uCurrCompIdx * fuNbOfFeePerComp + uFeeNr;
461
465 if (fuMinTotPulser < uTot && uTot < fuMaxTotPulser) {
466 /*
467 LOG(info) << "CbmTofUnpackMonitorTestFee::FillHitMonitoringHistos => Pulser hit "
468 << Form( "%3u %2u %3u %3u %1u", uTot, uCurrCompIdx, uGet4Id, uRawCh, bDiamond);
469 LOG(info) << " => "
470 << Form( "%3u %3u", uFeeNrInSys, uChannelNrInFee);
471 */
472 uint32_t uRemappedChannelNrInFee = uRemapCh % fuNbOfChannelsPerFee;
473
474 if (fuGlobalIdxFeeA == uFeeNrInSys) {
475 fhChanTotFeeA->Fill(uRemappedChannelNrInFee, uTot);
476 fhChanPulseIntervalFeeA->Fill(dHitTime - fvdFeeChanMsLastPulserHit[uFeeNrInSys][uRemappedChannelNrInFee],
477 uRemappedChannelNrInFee);
478 } // if( fuGlobalIdxFeeA == uFeeNrInSys )
479 else if (fuGlobalIdxFeeB == uFeeNrInSys) {
480 fhChanTotFeeB->Fill(uRemappedChannelNrInFee, uTot);
481 fhChanPulseIntervalFeeB->Fill(dHitTime - fvdFeeChanMsLastPulserHit[uFeeNrInSys][uRemappedChannelNrInFee],
482 uRemappedChannelNrInFee);
483 } // if( fuGlobalIdxFeeB == uFeeNrInSys )
484 fvdFeeChanMsLastPulserHit[uFeeNrInSys][uRemappedChannelNrInFee] = dHitTime;
485 fvuFeeChanNbHitsLastMs[uFeeNrInSys][uRemappedChannelNrInFee]++;
486 } // if( fuMinTotPulser < uTot && uTot < fuMaxTotPulser )
487}
488
490void CbmTofUnpackMonitorTestFee::FinalizeMsHistos()
491{
495 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++) {
497 Bool_t bChanOkFeeA = kFALSE;
498 Bool_t bChanOkFeeB = kFALSE;
499 if (1 == fvuFeeChanNbHitsLastMs[fuGlobalIdxFeeA][uChanA]) {
500 bChanOkFeeA = kTRUE;
501 }
502 if (1 == fvuFeeChanNbHitsLastMs[fuGlobalIdxFeeB][uChanA]) {
503 bChanOkFeeB = kTRUE;
504 }
505
507 for (UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++) {
508 if (bChanOkFeeA) {
510 if (uChanA < uChanB && 1 == fvuFeeChanNbHitsLastMs[fuGlobalIdxFeeA][uChanB]) {
511 Double_t dTimeDiff =
512 1e3
513 * (fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeA][uChanB] - fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeA][uChanA]);
514 if (TMath::Abs(dTimeDiff) < kdMaxDtPulserPs) fvhTimeDiffPulserFeeA[uChanA][uChanB]->Fill(dTimeDiff);
515 } // if( uChanA < uChanB && 1 == fvuFeeChanNbHitsLastMs[ fuGlobalIdxFeeA ][ uChanB ] )
516
518 if (1 == fvuFeeChanNbHitsLastMs[fuGlobalIdxFeeB][uChanB]) {
519 Double_t dTimeDiff =
520 1e3
521 * (fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeB][uChanB] - fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeA][uChanA]);
522 if (TMath::Abs(dTimeDiff) < kdMaxDtPulserPs) fvhTimeDiffPulserFeeFee[uChanA][uChanB]->Fill(dTimeDiff);
523 } // if( 1 == fvuFeeChanNbHitsLastMs[ fuGlobalIdxFeeB ][ uChanB ] )
524 } // if( bChanOkFeeA )
525
526 if (bChanOkFeeB) {
528 if (uChanA < uChanB && 1 == fvuFeeChanNbHitsLastMs[fuGlobalIdxFeeB][uChanB]) {
529 Double_t dTimeDiff =
530 1e3
531 * (fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeB][uChanB] - fvdFeeChanMsLastPulserHit[fuGlobalIdxFeeB][uChanA]);
532 if (TMath::Abs(dTimeDiff) < kdMaxDtPulserPs) fvhTimeDiffPulserFeeB[uChanA][uChanB]->Fill(dTimeDiff);
533 } // if( uChanA < uChanB && 1 == fvuFeeChanNbHitsLastMs[ fuGlobalIdxFeeB ][ uChanB ] )
534 } // if( bChanOkFeeB )
535 } // for( UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++)
536 } // for( UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++)
537
539 for (UInt_t uFeeA = 0; uFeeA < fuNbOfFeePerComp * fuNbOfComps; ++uFeeA) {
540 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++) {
541 fvuFeeChanNbHitsLastMs[uFeeA][uChanA] = 0;
542 }
543 }
544}
545
547void CbmTofUnpackMonitorTestFee::FinalizeTsHistos(double_t dTsStartTime)
548{
549 // Update RMS plots only every 10s in data
550 if (10.0 < dTsStartTime * 1e-9 - fdLastRmsUpdateTime) {
551 LOG(info) << "CbmTofUnpackMonitorTestFee::FinalizeTsHistos => Update pulser statistics ";
552 // Reset summary histograms for safety
553 fhTimeMeanPulserFeeA->Reset();
554 fhTimeRmsPulserFeeA->Reset();
555
556 fhTimeMeanPulserFeeB->Reset();
557 fhTimeRmsPulserFeeB->Reset();
558
559 fhTimeMeanPulserFeeFee->Reset();
560 fhTimeRmsPulserFeeFee->Reset();
561
562 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++)
563 for (UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++) {
564 if (nullptr != fvhTimeDiffPulserFeeA[uChanA][uChanB]) {
565 fhTimeMeanPulserFeeA->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeA[uChanA][uChanB]->GetMean());
566 fhTimeRmsPulserFeeA->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeA[uChanA][uChanB]->GetRMS());
567 } // if( NULL != fvhTimeDiffPulserFeeA[ uChanA ][ uChanB ] )
568
569 if (nullptr != fvhTimeDiffPulserFeeB[uChanA][uChanB]) {
570 fhTimeMeanPulserFeeB->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeB[uChanA][uChanB]->GetMean());
571 fhTimeRmsPulserFeeB->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeB[uChanA][uChanB]->GetRMS());
572 } // if( NULL != fvhTimeDiffPulserFeeB[ uChanA ][ uChanB ] )
573
574 if (nullptr != fvhTimeDiffPulserFeeFee[uChanA][uChanB]) {
575 fhTimeMeanPulserFeeFee->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeFee[uChanA][uChanB]->GetMean());
576 fhTimeRmsPulserFeeFee->Fill(uChanA, uChanB, fvhTimeDiffPulserFeeFee[uChanA][uChanB]->GetRMS());
577 } // if( NULL != fvhTimeDiffPulserFeeFee[ uChanA ][ uChanB ] )
578 } // Loop on both channels
579 fdLastRmsUpdateTime = dTsStartTime * 1e-9;
580 fuNbRmsUpdates++;
581
582 // Update zoomed plots only every 60s as no http UI commands in this version of monitor
583 if (6 == fuNbRmsUpdates) { //
585 UpdateZoomedFit(fvhTimeDiffPulserFeeA, fhTimeRmsZoomFitPulsFeeA, fhTimeResFitPulsFeeA);
586 UpdateZoomedFit(fvhTimeDiffPulserFeeB, fhTimeRmsZoomFitPulsFeeB, fhTimeResFitPulsFeeB);
587 UpdateZoomedFit(fvhTimeDiffPulserFeeFee, fhTimeRmsZoomFitPulsFeeFee, fhTimeResFitPulsFeeFee);
588
589 fuNbRmsUpdates = 0;
590 } // if (6 == fuNbRmsUpdates)
591 } // if( 10.0 < dTsStartTime - fdLastRmsUpdateTime )
592}
593
594void CbmTofUnpackMonitorTestFee::UpdateZoomedFit(std::vector<std::vector<TH1*>> phTimeDiff, TH2* phTimeRmsZoom,
595 TH2* phTimeResFit)
596{
597 // Only do something if the user defined the width he wants for the zoom
598 if (0.0 < fdFitZoomWidthPs) {
599 // Reset summary histograms for safety
600 phTimeRmsZoom->Reset();
601 phTimeResFit->Reset();
602
603 Double_t dRes = 0;
604 TF1* fitFuncPairs[fuNbOfChannelsPerFee][fuNbOfChannelsPerFee];
605
606 for (UInt_t uChanA = 0; uChanA < fuNbOfChannelsPerFee; uChanA++)
607 for (UInt_t uChanB = 0; uChanB < fuNbOfChannelsPerFee; uChanB++)
608 if (NULL != phTimeDiff[uChanA][uChanB]) {
609 // Check that we have at least 1 entry
610 if (0 == phTimeDiff[uChanA][uChanB]->GetEntries()) {
611 phTimeRmsZoom->Fill(uChanA, uChanB, 0.0);
612 phTimeResFit->Fill(uChanA, uChanB, 0.0);
613 LOG(debug) << "CbmTofUnpackMonitorTestFee::UpdateZoomedFit => Empty input "
614 << "for Chan pair " << uChanA << " and " << uChanB << " !!! ";
615 continue;
616 } // if( 0 == phTimeDiff[ uChanA ][ uChanB ]->GetEntries() )
617
618 // Read the peak position (bin with max counts) + total nb of entries
619 Int_t iBinWithMax = phTimeDiff[uChanA][uChanB]->GetMaximumBin();
620 Double_t dNbCounts = phTimeDiff[uChanA][uChanB]->Integral();
621
622 // Zoom the X axis to +/- ZoomWidth around the peak position
623 Double_t dPeakPos = phTimeDiff[uChanA][uChanB]->GetXaxis()->GetBinCenter(iBinWithMax);
624 phTimeDiff[uChanA][uChanB]->GetXaxis()->SetRangeUser(dPeakPos - fdFitZoomWidthPs,
625 dPeakPos + fdFitZoomWidthPs);
626
627 // Read integral and check how much we lost due to the zoom (% loss allowed)
628 Double_t dZoomCounts = phTimeDiff[uChanA][uChanB]->Integral();
629 if ((dZoomCounts / dNbCounts) < 0.99) {
630 phTimeRmsZoom->Fill(uChanA, uChanB, 0.0);
631 phTimeResFit->Fill(uChanA, uChanB, 0.0);
632 LOG(warning) << "CbmTofUnpackMonitorTestFee::UpdateZoomedFit => Zoom too strong, "
633 << "more than 1% loss for Chan pair " << uChanA << " and " << uChanB << " !!! ";
634 continue;
635 } // if( ( dZoomCounts / dNbCounts ) < 0.99 )
636
637 // Fill new RMS after zoom into summary histo
638 phTimeRmsZoom->Fill(uChanA, uChanB, phTimeDiff[uChanA][uChanB]->GetRMS());
639
640
641 // Fit using zoomed boundaries + starting gaussian width, store into summary histo
642 dRes = 0;
643 fitFuncPairs[uChanA][uChanB] = new TF1(Form("fPair_%02d_%02d", uChanA, uChanB), "gaus",
644 dPeakPos - fdFitZoomWidthPs, dPeakPos + fdFitZoomWidthPs);
645 // Fix the Mean fit value around the Histogram Mean
646 fitFuncPairs[uChanA][uChanB]->SetParameter(0, dZoomCounts);
647 fitFuncPairs[uChanA][uChanB]->SetParameter(1, dPeakPos);
648 fitFuncPairs[uChanA][uChanB]->SetParameter(2, 200.0); // Hardcode start with ~4*BinWidth, do better later
649 // Using integral instead of bin center seems to lead to unrealistic values => no "I"
650 phTimeDiff[uChanA][uChanB]->Fit(Form("fPair_%02d_%02d", uChanA, uChanB), "QRM0");
651 // Get Sigma
652 dRes = fitFuncPairs[uChanA][uChanB]->GetParameter(2);
653 // Cleanup memory
654 delete fitFuncPairs[uChanA][uChanB];
655 // Fill summary
656 phTimeResFit->Fill(uChanA, uChanB, dRes / TMath::Sqrt2());
657
658
659 LOG(debug) << "CbmTofUnpackMonitorTestFee::UpdateZoomedFit => "
660 << "For chan pair " << uChanA << " and " << uChanB
661 << " we have zoomed RMS = " << phTimeDiff[uChanA][uChanB]->GetRMS() << " and a resolution of "
662 << dRes / TMath::Sqrt2();
663
664 // Restore original axis state?
665 phTimeDiff[uChanA][uChanB]->GetXaxis()->UnZoom();
666 } // loop on chanA and chanB + check if corresponding fvhTimeDiffPulser exists
667 } // if( 0.0 < fdFitZoomWidthPs )
668 else {
669 LOG(error) << "CbmTofUnpackMonitorTestFee::UpdateZoomedFit => Zoom width not defined, "
670 << "please use SetFitZoomWidthPs, e.g. in macro, before trying this "
671 "update !!!";
672 } // else of if( 0.0 < fdFitZoomWidthPs )
673}
674
675/**********************************************************************************************************************/
677void CbmTofUnpackMonitorTestFee::SetBmonMode(bool /*value*/)
678{
679 LOG(fatal) << "SetBmonMode mode not available in CbmTofUnpackMonitorTestFee (forced off)";
680}
681
682void CbmTofUnpackMonitorTestFee::SetBmonMicroSpillMode(bool /*value*/)
683{
684 LOG(fatal) << "SetBmonMicroSpillMode mode not available in CbmTofUnpackMonitorTestFee (forced off)";
685}
686
687void CbmTofUnpackMonitorTestFee::SetBmonScvdMode(bool /*value*/)
688{
689 LOG(fatal) << "SetBmonScvdMode mode not available in CbmTofUnpackMonitorTestFee (forced off)";
690}
691
692void CbmTofUnpackMonitorTestFee::SetBmonQFactorMode(bool /*value*/)
693{
694 LOG(fatal) << "SetBmonQFactorMode mode not available in CbmTofUnpackMonitorTestFee (forced off)";
695}
696
697void CbmTofUnpackMonitorTestFee::SetTofQFactorMode(bool /*value*/)
698{
699 LOG(fatal) << "SetTofQFactorMode mode not available in CbmTofUnpackMonitorTestFee (forced off)";
700}
701/**********************************************************************************************************************/
702
703ClassImp(CbmTofUnpackMonitorTestFee)
ClassImp
ClassImp(CbmConverterManager)
GenerateLogBinArray
std::vector< double > GenerateLogBinArray(uint32_t uNbDecadesLog, uint32_t uNbStepsDecade, uint32_t uNbSubStepsInStep, uint32_t &uNbBinsLog, int32_t iStartExp, bool bAddZeroStart)
Definition CbmFlesHistosTools.cxx:10
dTsStartTime
static double dTsStartTime
Definition CbmTofEventClusterizer.cxx:91
Int_t
int Int_t
Definition RootTypesDef.h:16
Bool_t
bool Bool_t
Definition RootTypesDef.h:15
CbmTofUnpackMonitorTestFee::fhTimeMeanPulserFeeFee
TH2 * fhTimeMeanPulserFeeFee
[ Ch FEE A ][ Ch FEE B ]
Definition CbmTofUnpackMonitorTestFee.h:137
CbmTofUnpackMonitorTestFee::Init
virtual Bool_t Init(CbmMcbm2018TofPar *digiParSet)
Init all required parameter informations and histograms.
Definition CbmTofUnpackMonitorTestFee.cxx:39
CbmTofUnpackMonitorTestFee::fvuFeeChanNbHitsLastMs
std::vector< std::vector< UInt_t > > fvuFeeChanNbHitsLastMs
Buffer for pulser channels.
Definition CbmTofUnpackMonitorTestFee.h:120
CbmTofUnpackMonitorTestFee::fvhTimeDiffPulserFeeB
std::vector< std::vector< TH1 * > > fvhTimeDiffPulserFeeB
Definition CbmTofUnpackMonitorTestFee.h:130
CbmTofUnpackMonitorTestFee::fvhPulserCountEvoPerFeeComp
std::vector< TH2 * > fvhPulserCountEvoPerFeeComp
Definition CbmTofUnpackMonitorTestFee.h:148
CbmTofUnpackMonitorTestFee::Finish
virtual void Finish()
Write all histograms and canvases to file.
Definition CbmTofUnpackMonitorTestFee.cxx:433
CbmTofUnpackMonitorTestFee::fuNbOfFeePerComp
uint32_t fuNbOfFeePerComp
FIXME: recheck if OK and if not conflicting with fuNbOfFeePerComp!
Definition CbmTofUnpackMonitorTestFee.h:106
CbmTofUnpackMonitorTestFee::fuNbOfGet4PerFee
uint32_t fuNbOfGet4PerFee
Max number of FEE per component.
Definition CbmTofUnpackMonitorTestFee.h:107
CbmTofUnpackMonitorTestFee::UpdateZoomedFit
void UpdateZoomedFit(std::vector< std::vector< TH1 * > > phTimeDiff, TH2 *phTimeRmsZoom, TH2 *phTimeResFit)
Definition CbmTofUnpackMonitorTestFee.cxx:594
CbmTofUnpackMonitorTestFee::fdFitZoomWidthPs
double_t fdFitZoomWidthPs
Settings and tracers.
Definition CbmTofUnpackMonitorTestFee.h:94
CbmTofUnpackMonitorTestFee::FinalizeMsHistos
virtual void FinalizeMsHistos()
Finalize pulser histograms.
Definition CbmTofUnpackMonitorTestFee.cxx:490
CbmTofUnpackMonitorTestFee::FinalizeTsHistos
virtual void FinalizeTsHistos(double_t dTsStartTime)
Finalize pulser histograms.
Definition CbmTofUnpackMonitorTestFee.cxx:547
CbmTofUnpackMonitorTestFee::FillHitMonitoringHistos
virtual void FillHitMonitoringHistos(const double_t &dMsTime, const uint32_t &uCurrCompIdx, const uint32_t &uGet4Id, const uint32_t &uRawCh, const uint32_t &uRemapCh, const uint32_t &uTot, const double_t &dHitTime, const uint32_t &uFts, bool bDiamond=false)
Fill pulser histograms.
Definition CbmTofUnpackMonitorTestFee.cxx:445
CbmTofUnpackMonitorTestFee::fuCompA
uint32_t fuCompA
Number of channels in each FEE.
Definition CbmTofUnpackMonitorTestFee.h:110
CbmTofUnpackMonitorTestFee::fuNbOfChannelsPerFee
uint32_t fuNbOfChannelsPerFee
Max number of Get4 per FEE (has to match nb FEE and GET4 per comp)
Definition CbmTofUnpackMonitorTestFee.h:108
CbmTofUnpackMonitorTestFee::fvhTimeDiffPulserFeeA
std::vector< std::vector< TH1 * > > fvhTimeDiffPulserFeeA
[ fuFeeNr ][ ChanNr ]
Definition CbmTofUnpackMonitorTestFee.h:124
CbmTofUnpackMonitorTestFee::fvhTimeDiffPulserFeeFee
std::vector< std::vector< TH1 * > > fvhTimeDiffPulserFeeFee
Definition CbmTofUnpackMonitorTestFee.h:136
CbmTofUnpackMonitorTestFee::fvdFeeChanMsLastPulserHit
std::vector< std::vector< Double_t > > fvdFeeChanMsLastPulserHit
[ fuFeeNr ][ ChanNr ]
Definition CbmTofUnpackMonitorTestFee.h:121
CbmTofUnpackMonitor::SetBmonMicroSpillMode
void SetBmonMicroSpillMode(bool value)
Activate the BMon mode.
Definition CbmTofUnpackMonitor.h:134
CbmTofUnpackMonitor::fUnpackPar
CbmMcbm2018TofPar * fUnpackPar
Settings from parameter file.
Definition CbmTofUnpackMonitor.h:180
CbmTofUnpackMonitor::AddHistoToVector
void AddHistoToVector(TNamed *pointer, std::string sFolder="")
Definition CbmTofUnpackMonitor.h:73
CbmTofUnpackMonitor::GetCanvasVector
std::vector< std::pair< TCanvas *, std::string > > GetCanvasVector()
Definition CbmTofUnpackMonitor.h:83
CbmTofUnpackMonitor::AddCanvasToVector
void AddCanvasToVector(TCanvas *pointer, std::string sFolder="")
Definition CbmTofUnpackMonitor.h:79
CbmTofUnpackMonitor::SetBmonMode
void SetBmonMode(bool value)
Activate the BMon mode.
Definition CbmTofUnpackMonitor.h:118
CbmTofUnpackMonitor::GetHistoVector
std::vector< std::pair< TNamed *, std::string > > GetHistoVector()
Definition CbmTofUnpackMonitor.h:77
CbmTofUnpackMonitor::fdStartTime
Double_t fdStartTime
Total/maximum number of Get4 in system.
Definition CbmTofUnpackMonitor.h:189
CbmTofUnpackMonitor::SetBmonQFactorMode
void SetBmonQFactorMode(bool value)
Activate the Bmon QFactor mode.
Definition CbmTofUnpackMonitor.h:146
CbmTofUnpackMonitor::fuNbOfComps
UInt_t fuNbOfComps
Readout chain dimensions and mapping.
Definition CbmTofUnpackMonitor.h:182
CbmTofUnpackMonitor::fuNbOfGet4PerComp
UInt_t fuNbOfGet4PerComp
Total number of Components in the system.
Definition CbmTofUnpackMonitor.h:183
CbmTofUnpackMonitor::fBmonMode
bool fBmonMode
Flag if debug mode is active or not.
Definition CbmTofUnpackMonitor.h:198
CbmTofUnpackMonitor::fuMinTotPulser
UInt_t fuMinTotPulser
---> User settings: Data correction parameters
Definition CbmTofUnpackMonitor.h:213
CbmTofUnpackMonitor::fuNbOfChannelsPerComp
UInt_t fuNbOfChannelsPerComp
Number of channels per Get4, constant.
Definition CbmTofUnpackMonitor.h:185
CbmTofUnpackMonitor::SetBmonScvdMode
void SetBmonScvdMode(bool value)
Activate the BMon sCVD mode.
Definition CbmTofUnpackMonitor.h:140
CbmTofUnpackMonitor::SetTofQFactorMode
void SetTofQFactorMode(bool value)
Activate the Tof QFactor mode.
Definition CbmTofUnpackMonitor.h:159
CbmTofUnpackMonitor::fuNbOfChannelsPerGet4
UInt_t fuNbOfChannelsPerGet4
Max number of Get4 per component.
Definition CbmTofUnpackMonitor.h:184
CbmTofUnpackMonitor::Finish
void Finish()
Write all histograms and canvases to file.
Definition CbmTofUnpackMonitor.cxx:1936
CbmTofUnpackMonitor::fuNbOfGet4InSyst
UInt_t fuNbOfGet4InSyst
Number of channels per Component, recalculated.
Definition CbmTofUnpackMonitor.h:186
critof001::kuTotCounterSize
const uint32_t kuTotCounterSize
Definition CriGet4Mess001.h:28
critof001::kdBinSize
const double kdBinSize
Definition CriGet4Mess001.h:34