CbmRoot
Loading...
Searching...
No Matches
CbmCheckDigisNbCorr.cxx
Go to the documentation of this file.
1/* Copyright (C) 2019-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
2 SPDX-License-Identifier: GPL-3.0-only
3 Authors: Pierre-Alain Loizeau [committer] */
4
5#include "CbmCheckDigisNbCorr.h"
6
7#include "CbmDigiManager.h"
8#include "CbmMuchBeamTimeDigi.h"
9#include "CbmMuchDigi.h"
10#include "CbmRichDigi.h"
11#include "CbmStsDigi.h"
12#include "CbmTofDigi.h"
13
14#include "TimesliceMetaData.h"
15
16#include "FairRootManager.h"
17#include "FairRunOnline.h"
18#include <Logger.h>
19
20#include "TClonesArray.h"
21#include "TH1.h"
22#include "TH2.h"
23#include "THttpServer.h"
24#include "TProfile.h"
25#include <TDirectory.h>
26#include <TFile.h>
27
28#include <iomanip>
29using std::fixed;
30using std::setprecision;
31
32// ---- Default constructor -------------------------------------------
33CbmCheckDigisNbCorr::CbmCheckDigisNbCorr()
34 : FairTask("CbmCheckDigisNbCorr")
35 , fuMinTotPulserBmon(90)
36 , fuMaxTotPulserBmon(100)
37
38{
39}
40
41// ---- Destructor ----------------------------------------------------
42CbmCheckDigisNbCorr::~CbmCheckDigisNbCorr() {}
43
44// ---- Initialisation ----------------------------------------------
45void CbmCheckDigisNbCorr::SetParContainers()
46{
47 // Load all necessary parameter containers from the runtime data base
48 /*
49 FairRunAna* ana = FairRunAna::Instance();
50 FairRuntimeDb* rtdb=ana->GetRuntimeDb();
51
52 <CbmCheckDigisNbCorrDataMember> = (<ClassPointer>*)
53 (rtdb->getContainer("<ContainerName>"));
54 */
55}
56
57// ---- Init ----------------------------------------------------------
58InitStatus CbmCheckDigisNbCorr::Init()
59{
60
61 // Get a handle from the IO manager
62 FairRootManager* ioman = FairRootManager::Instance();
63
64 // Get a pointer to the previous already existing data level
65 fTsMetaData = static_cast<TClonesArray*>(ioman->GetObject("TimesliceMetaData"));
66 if (!fTsMetaData) { LOG(info) << "No TClonesArray with TS meta data found."; }
67 // DigiManager
68 fDigiMan = CbmDigiManager::Instance();
69 fDigiMan->Init();
70
71 // Get a pointer to the previous already existing data level
72 fBmonDigiVec = ioman->InitObjectAs<std::vector<CbmTofDigi> const*>("BmonDigi");
73 if (!fBmonDigiVec) {
74 fBmonDigiArr = dynamic_cast<TClonesArray*>(ioman->GetObject("BmonDigi"));
75 if (!fBmonDigiArr) { LOG(fatal) << "No TClonesArray with Bmon digis found."; }
76 }
77
78 if (!fDigiMan->IsPresent(ECbmModuleId::kSts)) { LOG(info) << "No TClonesArray with STS digis found."; }
79
80 if (!fDigiMan->IsPresent(ECbmModuleId::kMuch)) { LOG(info) << "No TClonesArray with MUCH digis found."; }
81
82 if (!fDigiMan->IsPresent(ECbmModuleId::kTof)) { LOG(info) << "No TClonesArray with TOF digis found."; }
83
84 if (!fDigiMan->IsPresent(ECbmModuleId::kRich)) { LOG(info) << "No TClonesArray with RICH digis found."; }
85
86 CreateHistos();
87
88 return kSUCCESS;
89}
90
91void CbmCheckDigisNbCorr::CalcNrBins() { fiBinNb = fdTsLengthNs / fdBinWidthNs; }
92
93void CbmCheckDigisNbCorr::CreateHistos()
94{
96 CalcNrBins();
97 fvuNbDigisPerBinBmon.resize(fiBinNb, 0);
98 fvuNbDigisPerBinSts.resize(fiBinNb, 0);
99 fvuNbDigisPerBinMuch.resize(fiBinNb, 0);
100 fvuNbDigisPerBinTof.resize(fiBinNb, 0);
101 fvuNbDigisPerBinRich.resize(fiBinNb, 0);
102
103 fvuNbDigisPerBinStsDpb.resize(kuMaxNbStsDpbs);
104 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb)
105 fvuNbDigisPerBinStsDpb[uStsDpb].resize(fiBinNb, 0);
106
108 // Bmon vs. TST
109 fBmonStsCorr = new TH2F("fBmonStsCorr",
110 Form("Bmon - STS digis Nb correlation per %.0f ns time interval; Nb "
111 "Bmon Digis []; Nb STS Digis []; Counts",
112 fdBinWidthNs),
113 1000, 0, 1000, 1000, 0, 1000);
114 // Bmon vs. MUCH
115 fBmonMuchCorr = new TH2F("fBmonMuchCorr",
116 Form("Bmon - MUCH digis Nb correlation per %.0f ns time interval; "
117 "Nb Bmon Digis []; Nb MUCH Digis []; Counts",
118 fdBinWidthNs),
119 1000, 0, 1000, 1000, 0, 1000);
120 // Bmon vs. TOF
121 fBmonTofCorr = new TH2F("fBmonTofCorr",
122 Form("Bmon - TOF digis Nb correlation per %.0f ns time interval; Nb "
123 "Bmon Digis []; Nb TOF Digis []; Counts",
124 fdBinWidthNs),
125 1000, 0, 1000, 1000, 0, 1000);
126 // Bmon vs. RICH
127 fBmonRichCorr = new TH2F("fBmonRichCorr",
128 Form("Bmon - RICH digis Nb correlation per %.0f ns time interval; "
129 "Nb Bmon Digis []; Nb RICH Digis []; Counts",
130 fdBinWidthNs),
131 1000, 0, 1000, 1000, 0, 1000);
132
133 // STS vs. MUCH
134 fStsMuchCorr = new TH2F("fStsMuchCorr",
135 Form("STS - MUCH digis Nb correlation per %.0f ns time interval; "
136 "Nb STS Digis []; Nb STS Digis []; Counts",
137 fdBinWidthNs),
138 1000, 0, 1000, 1000, 0, 1000);
139 // STS vs. TOF
140 fStsTofCorr = new TH2F("fStsTofCorr",
141 Form("STS - TOF digis Nb correlation per %.0f ns time interval; "
142 "Nb STS Digis []; Nb TOF Digis []; Counts",
143 fdBinWidthNs),
144 1000, 0, 1000, 1000, 0, 1000);
145 // STS vs. RICH
146 fStsRichCorr = new TH2F("fStsRichCorr",
147 Form("STS - RICH digis Nb correlation per %.0f ns time interval; "
148 "Nb STS Digis []; Nb RICH Digis []; Counts",
149 fdBinWidthNs),
150 1000, 0, 1000, 1000, 0, 1000);
151
152 // MUCH vs. TOF
153 fMuchTofCorr = new TH2F("fMuchTofCorr",
154 Form("MUCH - TOF digis Nb correlation per %.0f ns time interval; "
155 "Nb MUCH Digis []; Nb TOF Digis []; Counts",
156 fdBinWidthNs),
157 1000, 0, 1000, 1000, 0, 1000);
158 // MUCH vs. RICH
159 fMuchRichCorr = new TH2F("fMuchRichCorr",
160 Form("MUCH - RICH digis Nb correlation per %.0f ns time interval; "
161 "Nb MUCH Digis []; Nb RICH Digis []; Counts",
162 fdBinWidthNs),
163 1000, 0, 1000, 1000, 0, 1000);
164
165 // TOF vs. RICH
166 fTofRichCorr = new TH2F("fTofRichCorr",
167 Form("TOF - RICH digis Nb correlation per %.0f ns time interval; "
168 "Nb TOF Digis []; Nb RICH Digis []; Counts",
169 fdBinWidthNs),
170 1000, 0, 1000, 1000, 0, 1000);
171
173 // Bmon vs. TST
174 fBmonStsCorrProf = new TProfile("fBmonStsCorrProf",
175 Form("Bmon - STS digis Nb correlation per %.0f ns time "
176 "interval; Nb Bmon Digis []; Nb STS Digis []",
177 fdBinWidthNs),
178 1000, 0, 1000);
179 // Bmon vs. MUCH
180 fBmonMuchCorrProf = new TProfile("fBmonMuchCorrProf",
181 Form("Bmon - MUCH digis Nb correlation per %.0f ns time "
182 "interval; Nb Bmon Digis []; Nb MUCH Digis []",
183 fdBinWidthNs),
184 1000, 0, 1000);
185 // Bmon vs. TOF
186 fBmonTofCorrProf = new TProfile("fBmonTofCorrProf",
187 Form("Bmon - TOF digis Nb correlation per %.0f ns time "
188 "interval; Nb Bmon Digis []; Nb TOF Digis []",
189 fdBinWidthNs),
190 1000, 0, 1000);
191 // Bmon vs. RICH
192 fBmonRichCorrProf = new TProfile("fBmonRichCorrProf",
193 Form("Bmon - RICH digis Nb correlation per %.0f ns time "
194 "interval; Nb Bmon Digis []; Nb RICH Digis []",
195 fdBinWidthNs),
196 1000, 0, 1000);
197
198 // STS vs. MUCH
199 fStsMuchCorrProf = new TProfile("fStsMuchCorrProf",
200 Form("STS - MUCH digis Nb correlation per %.0f ns time "
201 "interval; Nb STS Digis []; Nb STS Digis []",
202 fdBinWidthNs),
203 1000, 0, 1000);
204 // STS vs. TOF
205 fStsTofCorrProf = new TProfile("fStsTofCorrProf",
206 Form("STS - TOF digis Nb correlation per %.0f ns time "
207 "interval; Nb STS Digis []; Nb TOF Digis []",
208 fdBinWidthNs),
209 1000, 0, 1000);
210 // STS vs. RICH
211 fStsRichCorrProf = new TProfile("fStsRichCorrProf",
212 Form("STS - RICH digis Nb correlation per %.0f ns time "
213 "interval; Nb STS Digis []; Nb RICH Digis []",
214 fdBinWidthNs),
215 1000, 0, 1000);
216
217 // MUCH vs. TOF
218 fMuchTofCorrProf = new TProfile("fMuchTofCorrProf",
219 Form("MUCH - TOF digis Nb correlation per %.0f ns time "
220 "interval; Nb MUCH Digis []; Nb TOF Digis []",
221 fdBinWidthNs),
222 1000, 0, 1000);
223 // MUCH vs. RICH
224 fMuchRichCorrProf = new TProfile("fMuchRichCorrProf",
225 Form("MUCH - RICH digis Nb correlation per %.0f ns time "
226 "interval; Nb MUCH Digis []; Nb RICH Digis []",
227 fdBinWidthNs),
228 1000, 0, 1000);
229
230 // TOF vs. RICH
231 fTofRichCorrProf = new TProfile("fTofRichCorrProf",
232 Form("TOF - RICH digis Nb correlation per %.0f ns time "
233 "interval; Nb TOF Digis []; Nb RICH Digis []",
234 fdBinWidthNs),
235 1000, 0, 1000);
236
237 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb) {
238 fBmonStsDpbCorr[uStsDpb] = new TH2F(Form("fBmonStsDpbCorr%02u", uStsDpb),
239 Form("Bmon - STS digis Nb correlation per %.0f ns time interval, "
240 "DPB %02u; Nb Bmon Digis []; Nb STS Digis []; Counts",
241 fdBinWidthNs, uStsDpb),
242 1000, 0, 1000, 1000, 0, 1000);
243 fStsMuchDpbCorr[uStsDpb] = new TH2F(Form("fStsMuchDpbCorr%02u", uStsDpb),
244 Form("STS - MUCH digis Nb correlation per %.0f ns time interval, DPB "
245 "%02u; Nb STS Digis []; Nb STS Digis []; Counts",
246 fdBinWidthNs, uStsDpb),
247 1000, 0, 1000, 1000, 0, 1000);
248 fStsTofDpbCorr[uStsDpb] = new TH2F(Form("fStsTofDpbCorr%02u", uStsDpb),
249 Form("STS - TOF digis Nb correlation per %.0f ns time interval, "
250 "DPB %02u; Nb STS Digis []; Nb TOF Digis []; Counts",
251 fdBinWidthNs, uStsDpb),
252 1000, 0, 1000, 1000, 0, 1000);
253 fStsRichDpbCorr[uStsDpb] = new TH2F(Form("fStsRichDpbCorr%02u", uStsDpb),
254 Form("STS - RICH digis Nb correlation per %.0f ns time interval, DPB "
255 "%02u; Nb STS Digis []; Nb RICH Digis []; Counts",
256 fdBinWidthNs, uStsDpb),
257 1000, 0, 1000, 1000, 0, 1000);
258
259 fBmonStsDpbCorrProf[uStsDpb] = new TProfile(Form("fBmonStsDpbCorrProf%02u", uStsDpb),
260 Form("Bmon - STS digis Nb correlation per %.0f ns time "
261 "interval, DPB %02u; Nb Bmon Digis []; Nb STS Digis []",
262 fdBinWidthNs, uStsDpb),
263 1000, 0, 1000);
264 fStsMuchDpbCorrProf[uStsDpb] = new TProfile(Form("fStsMuchDpbCorrProf%02u", uStsDpb),
265 Form("STS - MUCH digis Nb correlation per %.0f ns time "
266 "interval, DPB %02u; Nb STS Digis []; Nb STS Digis []",
267 fdBinWidthNs, uStsDpb),
268 1000, 0, 1000);
269 fStsTofDpbCorrProf[uStsDpb] = new TProfile(Form("fStsTofDpbCorrProf%02u", uStsDpb),
270 Form("STS - TOF digis Nb correlation per %.0f ns time "
271 "interval, DPB %02u; Nb STS Digis []; Nb TOF Digis []",
272 fdBinWidthNs, uStsDpb),
273 1000, 0, 1000);
274 fStsRichDpbCorrProf[uStsDpb] = new TProfile(Form("fStsRichDpbCorrProf%02u", uStsDpb),
275 Form("STS - RICH digis Nb correlation per %.0f ns time "
276 "interval, DPB %02u; Nb STS Digis []; Nb RICH Digis []",
277 fdBinWidthNs, uStsDpb),
278 1000, 0, 1000);
279 } // for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
280
282 FairRunOnline* run = FairRunOnline::Instance();
283 if (run) {
284 THttpServer* server = run->GetHttpServer();
285 if (nullptr != server) {
287 server->Register("CheckDigisNbCorr", fBmonStsCorr);
288 server->Register("CheckDigisNbCorr", fBmonMuchCorr);
289 server->Register("CheckDigisNbCorr", fBmonTofCorr);
290 server->Register("CheckDigisNbCorr", fBmonRichCorr);
291
292 server->Register("CheckDigisNbCorr", fStsMuchCorr);
293 server->Register("CheckDigisNbCorr", fStsTofCorr);
294 server->Register("CheckDigisNbCorr", fStsRichCorr);
295
296 server->Register("CheckDigisNbCorr", fMuchTofCorr);
297 server->Register("CheckDigisNbCorr", fMuchRichCorr);
298
299 server->Register("CheckDigisNbCorr", fTofRichCorr);
300
302 server->Register("CheckDigisNbCorr", fBmonStsCorrProf);
303 server->Register("CheckDigisNbCorr", fBmonMuchCorrProf);
304 server->Register("CheckDigisNbCorr", fBmonTofCorrProf);
305 server->Register("CheckDigisNbCorr", fBmonRichCorrProf);
306
307 server->Register("CheckDigisNbCorr", fStsMuchCorrProf);
308 server->Register("CheckDigisNbCorr", fStsTofCorrProf);
309 server->Register("CheckDigisNbCorr", fStsRichCorrProf);
310
311 server->Register("CheckDigisNbCorr", fMuchTofCorrProf);
312 server->Register("CheckDigisNbCorr", fMuchRichCorrProf);
313
314 server->Register("CheckDigisNbCorr", fTofRichCorrProf);
315
316 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb) {
317 server->Register("CheckDigisNbCorr", fBmonStsDpbCorr[uStsDpb]);
318 server->Register("CheckDigisNbCorr", fStsMuchDpbCorr[uStsDpb]);
319 server->Register("CheckDigisNbCorr", fStsTofDpbCorr[uStsDpb]);
320 server->Register("CheckDigisNbCorr", fStsRichDpbCorr[uStsDpb]);
321
322 server->Register("CheckDigisNbCorr", fBmonStsDpbCorrProf[uStsDpb]);
323 server->Register("CheckDigisNbCorr", fStsMuchDpbCorrProf[uStsDpb]);
324 server->Register("CheckDigisNbCorr", fStsTofDpbCorrProf[uStsDpb]);
325 server->Register("CheckDigisNbCorr", fStsRichDpbCorrProf[uStsDpb]);
326 } // for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
327 } // if( nullptr != server )
328 } // if (run)
329}
330// ---- ReInit -------------------------------------------------------
331InitStatus CbmCheckDigisNbCorr::ReInit() { return kSUCCESS; }
332
333// ---- Exec ----------------------------------------------------------
334void CbmCheckDigisNbCorr::Exec(Option_t* /*option*/)
335{
337 for (Int_t uBin = 0; uBin < fiBinNb; ++uBin) {
338 fvuNbDigisPerBinBmon[uBin] = 0;
339 fvuNbDigisPerBinSts[uBin] = 0;
340 fvuNbDigisPerBinMuch[uBin] = 0;
341 fvuNbDigisPerBinTof[uBin] = 0;
342 fvuNbDigisPerBinRich[uBin] = 0;
343 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb)
344 fvuNbDigisPerBinStsDpb[uStsDpb][uBin] = 0;
345 } // for( UInt_t uBin = 0; uBin < fiBinNb; ++uBin )
346
347 LOG(debug) << "executing TS " << fNrTs;
348 Double_t dTsStart = fNrTs * fdTsLengthNs + 20393267200. - fdTsLengthNs;
349 if (1 == fTsMetaData->GetEntriesFast())
350 dTsStart = static_cast<TimesliceMetaData*>(fTsMetaData->At(0))->GetStartTime();
351
352 LOG(debug) << "Begin";
353 Int_t nrBmonDigis = -1;
354 if (fBmonDigiVec) nrBmonDigis = fBmonDigiVec->size();
355 else if (fBmonDigiArr)
356 nrBmonDigis = fBmonDigiArr->GetEntriesFast();
357 Int_t nrStsDigis = fDigiMan->GetNofDigis(ECbmModuleId::kSts);
358 Int_t nrMuchDigis = fDigiMan->GetNofDigis(ECbmModuleId::kMuch);
359 Int_t nrTofDigis = fDigiMan->GetNofDigis(ECbmModuleId::kTof);
360 Int_t nrRichDigis = fDigiMan->GetNofDigis(ECbmModuleId::kRich);
361
362 LOG(debug) << "BmonDigis: " << nrBmonDigis;
363 LOG(debug) << "StsDigis: " << nrStsDigis;
364 LOG(debug) << "MuchDigis: " << nrMuchDigis;
365 LOG(debug) << "TofDigis: " << nrTofDigis;
366 LOG(debug) << "RichDigis: " << nrRichDigis;
367
370 for (Int_t iDigi = 0; iDigi < nrBmonDigis; ++iDigi) {
371 const CbmTofDigi* pDigi = nullptr;
372 if (fBmonDigiVec) pDigi = &(fBmonDigiVec->at(iDigi));
373 else if (fBmonDigiArr)
374 pDigi = dynamic_cast<const CbmTofDigi*>(fBmonDigiArr->At(iDigi));
375 assert(pDigi);
376
378 if (fuMinTotPulserBmon < pDigi->GetCharge() && pDigi->GetCharge() < fuMaxTotPulserBmon) continue;
379
380 Double_t dTime = pDigi->GetTime() - dTsStart;
382 if (dTime < 0) continue;
384 if (fdTsLengthNs <= dTime) break;
385
387 UInt_t uBin = dTime / fdBinWidthNs;
388 fvuNbDigisPerBinBmon[uBin]++;
389 } // for( Int_t iDigi = 0; iDigi < nrBmonDigis; ++iDigi )
390
392 for (Int_t iDigi = 0; iDigi < nrStsDigis; ++iDigi) {
393 const CbmStsDigi* pDigi = fDigiMan->Get<CbmStsDigi>(iDigi);
394
395 Double_t dTime = pDigi->GetTime() - dTsStart - fdStsOffset;
397 if (dTime < 0) continue;
399 if (fdTsLengthNs <= dTime) break;
400
402 UInt_t uBin = dTime / fdBinWidthNs;
403 fvuNbDigisPerBinSts[uBin]++;
404
405 UInt_t uDPB = (0 < (pDigi->GetAddress() & 0x00000400));
406 fvuNbDigisPerBinStsDpb[uDPB][uBin]++;
407 } // for( Int_t iDigi = 0; iDigi < nrStsDigis; ++iDigi )
408
410 for (Int_t iDigi = 0; iDigi < nrMuchDigis; ++iDigi) {
411 const CbmMuchDigi* pDigi = fDigiMan->Get<CbmMuchDigi>(iDigi);
412
413 Double_t dTime = pDigi->GetTime() - dTsStart - fdMuchOffset;
415 if (dTime < 0) continue;
417 if (fdTsLengthNs <= dTime) break;
418
420 UInt_t uBin = dTime / fdBinWidthNs;
421 fvuNbDigisPerBinMuch[uBin]++;
422 } // for( Int_t iDigi = 0; iDigi < nrMuchDigis; ++iDigi )
423
425 for (Int_t iDigi = 0; iDigi < nrTofDigis; ++iDigi) {
426 const CbmTofDigi* pDigi = fDigiMan->Get<CbmTofDigi>(iDigi);
427
429 if (92 < pDigi->GetCharge() && pDigi->GetCharge() < 96) continue;
430
431 Double_t dTime = pDigi->GetTime() - dTsStart - fdTofOffset;
433 if (dTime < 0) continue;
435 if (fdTsLengthNs <= dTime) break;
436
438 UInt_t uBin = dTime / fdBinWidthNs;
439 fvuNbDigisPerBinTof[uBin]++;
440 } // for( Int_t iDigi = 0; iDigi < nrTofDigis; ++iDigi )
441
443 for (Int_t iDigi = 0; iDigi < nrRichDigis; ++iDigi) {
444 const CbmRichDigi* pDigi = fDigiMan->Get<CbmRichDigi>(iDigi);
445
446 Double_t dTime = pDigi->GetTime() - dTsStart - fdRichOffset;
448 if (dTime < 0) continue;
450 if (fdTsLengthNs <= dTime) break;
451
453 UInt_t uBin = dTime / fdBinWidthNs;
454 fvuNbDigisPerBinRich[uBin]++;
455 } // for( Int_t iDigi = 0; iDigi < nrRichDigis; ++iDigi )
456
458 for (Int_t uBin = 0; uBin < fiBinNb; ++uBin) {
460 if (0 < fvuNbDigisPerBinBmon[uBin] || 0 < fvuNbDigisPerBinSts[uBin]) {
461 fBmonStsCorr->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinSts[uBin]);
462 fBmonStsCorrProf->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinSts[uBin]);
463 } // if( 0 < fvuNbDigisPerBinBmon[ uBin ] || 0 < fvuNbDigisPerBinSts[ uBin ] )
464 if (0 < fvuNbDigisPerBinBmon[uBin] || 0 < fvuNbDigisPerBinMuch[uBin]) {
465 fBmonMuchCorr->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinMuch[uBin]);
466 fBmonMuchCorrProf->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinMuch[uBin]);
467 } // if( 0 < fvuNbDigisPerBinBmon[ uBin ] || 0 < fvuNbDigisPerBinMuch[ uBin ] )
468 if (0 < fvuNbDigisPerBinBmon[uBin] || 0 < fvuNbDigisPerBinTof[uBin]) {
469 fBmonTofCorr->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinTof[uBin]);
470 fBmonTofCorrProf->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinTof[uBin]);
471 } // if( 0 < fvuNbDigisPerBinBmon[ uBin ] || 0 < fvuNbDigisPerBinTof[ uBin ] )
472 if (0 < fvuNbDigisPerBinBmon[uBin] || 0 < fvuNbDigisPerBinRich[uBin]) {
473 fBmonRichCorr->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinRich[uBin]);
474 fBmonRichCorrProf->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinRich[uBin]);
475 } // if( 0 < fvuNbDigisPerBinBmon[ uBin ] || 0 < fvuNbDigisPerBinRich[ uBin ] )
476
477 if (0 < fvuNbDigisPerBinSts[uBin] || 0 < fvuNbDigisPerBinMuch[uBin]) {
478 fStsMuchCorr->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinMuch[uBin]);
479 fStsMuchCorrProf->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinMuch[uBin]);
480 } // if( 0 < fvuNbDigisPerBinSts[ uBin ] || 0 < fvuNbDigisPerBinMuch[ uBin ] )
481 if (0 < fvuNbDigisPerBinSts[uBin] || 0 < fvuNbDigisPerBinTof[uBin]) {
482 fStsTofCorr->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinTof[uBin]);
483 fStsTofCorrProf->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinTof[uBin]);
484 } // if( 0 < fvuNbDigisPerBinSts[ uBin ] || 0 < fvuNbDigisPerBinTof[ uBin ] )
485 if (0 < fvuNbDigisPerBinSts[uBin] || 0 < fvuNbDigisPerBinRich[uBin]) {
486 fStsRichCorr->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinRich[uBin]);
487 fStsRichCorrProf->Fill(fvuNbDigisPerBinSts[uBin], fvuNbDigisPerBinRich[uBin]);
488 } // if( 0 < fvuNbDigisPerBinSts[ uBin ] || 0 < fvuNbDigisPerBinRich[ uBin ] )
489
490 if (0 < fvuNbDigisPerBinMuch[uBin] || 0 < fvuNbDigisPerBinTof[uBin]) {
491 fMuchTofCorr->Fill(fvuNbDigisPerBinMuch[uBin], fvuNbDigisPerBinTof[uBin]);
492 fMuchTofCorrProf->Fill(fvuNbDigisPerBinMuch[uBin], fvuNbDigisPerBinTof[uBin]);
493 } // if( 0 < fvuNbDigisPerBinMuch[ uBin ] || 0 < fvuNbDigisPerBinTof[ uBin ] )
494 if (0 < fvuNbDigisPerBinMuch[uBin] || 0 < fvuNbDigisPerBinRich[uBin]) {
495 fMuchRichCorr->Fill(fvuNbDigisPerBinMuch[uBin], fvuNbDigisPerBinRich[uBin]);
496 fMuchRichCorrProf->Fill(fvuNbDigisPerBinMuch[uBin], fvuNbDigisPerBinRich[uBin]);
497 } // if( 0 < fvuNbDigisPerBinMuch[ uBin ] || 0 < fvuNbDigisPerBinRich[ uBin ] )
498
499 if (0 < fvuNbDigisPerBinTof[uBin] || 0 < fvuNbDigisPerBinRich[uBin]) {
500 fTofRichCorr->Fill(fvuNbDigisPerBinTof[uBin], fvuNbDigisPerBinRich[uBin]);
501 fTofRichCorrProf->Fill(fvuNbDigisPerBinTof[uBin], fvuNbDigisPerBinRich[uBin]);
502 } // if( 0 < fvuNbDigisPerBinTof[ uBin ] || 0 < fvuNbDigisPerBinRich[ uBin ] )
503
504 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb) {
505 if (0 < fvuNbDigisPerBinBmon[uBin] || 0 < fvuNbDigisPerBinStsDpb[uStsDpb][uBin]) {
506 fBmonStsDpbCorr[uStsDpb]->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinStsDpb[uStsDpb][uBin]);
507 fBmonStsDpbCorrProf[uStsDpb]->Fill(fvuNbDigisPerBinBmon[uBin], fvuNbDigisPerBinStsDpb[uStsDpb][uBin]);
508 } // if( 0 < fvuNbDigisPerBinBmon[ uBin ] || 0 < fvuNbDigisPerBinStsDpb[uStsDpb][ uBin ] )
509
510 if (0 < fvuNbDigisPerBinStsDpb[uStsDpb][uBin] || 0 < fvuNbDigisPerBinMuch[uBin]) {
511 fStsMuchDpbCorr[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinMuch[uBin]);
512 fStsMuchDpbCorrProf[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinMuch[uBin]);
513 } // if( 0 < fvuNbDigisPerBinStsDpb[uStsDpb][ uBin ] || 0 < fvuNbDigisPerBinMuch[ uBin ] )
514 if (0 < fvuNbDigisPerBinStsDpb[uStsDpb][uBin] || 0 < fvuNbDigisPerBinTof[uBin]) {
515 fStsTofDpbCorr[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinTof[uBin]);
516 fStsTofDpbCorrProf[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinTof[uBin]);
517 } // if( 0 < fvuNbDigisPerBinStsDpb[uStsDpb][ uBin ] || 0 < fvuNbDigisPerBinTof[ uBin ] )
518 if (0 < fvuNbDigisPerBinStsDpb[uStsDpb][uBin] || 0 < fvuNbDigisPerBinRich[uBin]) {
519 fStsRichDpbCorr[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinRich[uBin]);
520 fStsRichDpbCorrProf[uStsDpb]->Fill(fvuNbDigisPerBinStsDpb[uStsDpb][uBin], fvuNbDigisPerBinRich[uBin]);
521 } // if( 0 < fvuNbDigisPerBinStsDpb[uStsDpb][ uBin ] || 0 < fvuNbDigisPerBinRich[ uBin ] )
522 } // for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
523 } // for( UInt_t uBin = 0; uBin < fiBinNb; ++uBin )
524
525 fNrTs++;
526}
527
528
529// ---- Finish --------------------------------------------------------
530void CbmCheckDigisNbCorr::Finish() { WriteHistos(); }
531
532void CbmCheckDigisNbCorr::WriteHistos()
533{
534 TFile* oldFile = gFile;
535 TDirectory* oldDir = gDirectory;
536
537 TFile* outfile = TFile::Open(fOutFileName, "RECREATE");
538
539
541 fBmonStsCorr->Write();
542 fBmonMuchCorr->Write();
543 fBmonTofCorr->Write();
544 fBmonRichCorr->Write();
545 fStsMuchCorr->Write();
546 fStsTofCorr->Write();
547 fStsRichCorr->Write();
548 fMuchTofCorr->Write();
549 fMuchRichCorr->Write();
550 fTofRichCorr->Write();
551
553 fBmonStsCorrProf->Write();
554 fBmonMuchCorrProf->Write();
555 fBmonTofCorrProf->Write();
556 fBmonRichCorrProf->Write();
557 fStsMuchCorrProf->Write();
558 fStsTofCorrProf->Write();
559 fStsRichCorrProf->Write();
560 fMuchTofCorrProf->Write();
561 fMuchRichCorrProf->Write();
562 fTofRichCorrProf->Write();
563
564 for (UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb) {
565 fBmonStsDpbCorr[uStsDpb]->Write();
566 fStsMuchDpbCorr[uStsDpb]->Write();
567 fStsTofDpbCorr[uStsDpb]->Write();
568 fStsRichDpbCorr[uStsDpb]->Write();
569
570 fBmonStsDpbCorrProf[uStsDpb]->Write();
571 fStsMuchDpbCorrProf[uStsDpb]->Write();
572 fStsTofDpbCorrProf[uStsDpb]->Write();
573 fStsRichDpbCorrProf[uStsDpb]->Write();
574 } // for( UInt_t uStsDpb = 0; uStsDpb < kuMaxNbStsDpbs; ++uStsDpb )
575
576 outfile->Close();
577 delete outfile;
578
579 gFile = oldFile;
580 gDirectory = oldDir;
581}
582
583ClassImp(CbmCheckDigisNbCorr)
ClassImp
ClassImp(CbmConverterManager)
ECbmModuleId::kTof
@ kTof
Time-of-flight Detector.
ECbmModuleId::kSts
@ kSts
Silicon Tracking System.
ECbmModuleId::kMuch
@ kMuch
Muon detection system.
ECbmModuleId::kRich
@ kRich
Ring-Imaging Cherenkov Detector.
CbmCheckDigisNbCorr::fStsMuchDpbCorr
TH2 * fStsMuchDpbCorr[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:154
CbmCheckDigisNbCorr::fvuNbDigisPerBinTof
std::vector< UInt_t > fvuNbDigisPerBinTof
Definition CbmCheckDigisNbCorr.h:120
CbmCheckDigisNbCorr::fStsTofDpbCorrProf
TProfile * fStsTofDpbCorrProf[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:159
CbmCheckDigisNbCorr::kuMaxNbStsDpbs
static const UInt_t kuMaxNbStsDpbs
Definition CbmCheckDigisNbCorr.h:151
CbmCheckDigisNbCorr::fStsRichDpbCorr
TH2 * fStsRichDpbCorr[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:156
CbmCheckDigisNbCorr::fBmonStsDpbCorr
TH2 * fBmonStsDpbCorr[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:153
CbmCheckDigisNbCorr::Exec
virtual void Exec(Option_t *)
Definition CbmCheckDigisNbCorr.cxx:334
CbmCheckDigisNbCorr::SetParContainers
virtual void SetParContainers()
Definition CbmCheckDigisNbCorr.cxx:45
CbmCheckDigisNbCorr::fuMinTotPulserBmon
UInt_t fuMinTotPulserBmon
User settings: Data correction parameters.
Definition CbmCheckDigisNbCorr.h:90
CbmCheckDigisNbCorr::fBmonDigiVec
const std::vector< CbmTofDigi > * fBmonDigiVec
Interface to digi data.
Definition CbmCheckDigisNbCorr.h:86
CbmCheckDigisNbCorr::fStsMuchDpbCorrProf
TProfile * fStsMuchDpbCorrProf[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:158
CbmCheckDigisNbCorr::ReInit
virtual InitStatus ReInit()
Definition CbmCheckDigisNbCorr.cxx:331
CbmCheckDigisNbCorr::fStsTofDpbCorr
TH2 * fStsTofDpbCorr[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:155
CbmCheckDigisNbCorr::fvuNbDigisPerBinSts
std::vector< UInt_t > fvuNbDigisPerBinSts
Definition CbmCheckDigisNbCorr.h:118
CbmCheckDigisNbCorr::fStsRichDpbCorrProf
TProfile * fStsRichDpbCorrProf[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:160
CbmCheckDigisNbCorr::Init
virtual InitStatus Init()
Definition CbmCheckDigisNbCorr.cxx:58
CbmCheckDigisNbCorr::fvuNbDigisPerBinMuch
std::vector< UInt_t > fvuNbDigisPerBinMuch
Definition CbmCheckDigisNbCorr.h:119
CbmCheckDigisNbCorr::fDigiMan
CbmDigiManager * fDigiMan
Definition CbmCheckDigisNbCorr.h:84
CbmCheckDigisNbCorr::fvuNbDigisPerBinStsDpb
std::vector< std::vector< UInt_t > > fvuNbDigisPerBinStsDpb
Definition CbmCheckDigisNbCorr.h:152
CbmCheckDigisNbCorr::fvuNbDigisPerBinRich
std::vector< UInt_t > fvuNbDigisPerBinRich
Definition CbmCheckDigisNbCorr.h:121
CbmCheckDigisNbCorr::fBmonStsDpbCorrProf
TProfile * fBmonStsDpbCorrProf[kuMaxNbStsDpbs]
Definition CbmCheckDigisNbCorr.h:157
CbmCheckDigisNbCorr::fBmonDigiArr
TClonesArray * fBmonDigiArr
Definition CbmCheckDigisNbCorr.h:87
CbmCheckDigisNbCorr::fvuNbDigisPerBinBmon
std::vector< UInt_t > fvuNbDigisPerBinBmon
Definition CbmCheckDigisNbCorr.h:117
CbmDigiManager::GetNofDigis
static Int_t GetNofDigis(ECbmModuleId systemId)
Definition CbmDigiManager.cxx:67
CbmDigiManager::IsPresent
static Bool_t IsPresent(ECbmModuleId systemId)
Presence of a digi branch.
Definition CbmDigiManager.cxx:121
CbmDigiManager::Init
InitStatus Init()
Initialisation.
Definition CbmDigiManager.cxx:77
CbmDigiManager::Get
const Digi * Get(Int_t index) const
Get a digi object.
Definition CbmDigiManager.h:57
CbmDigiManager::Instance
static CbmDigiManager * Instance()
Static instance.
Definition CbmDigiManager.h:126
CbmMuchDigi::GetTime
double GetTime() const
Definition CbmMuchDigi.h:94
CbmRichDigi::GetTime
double GetTime() const
Definition CbmRichDigi.h:72
CbmStsDigi
Data class for a single-channel message in the STS.
Definition CbmStsDigi.h:40
CbmStsDigi::GetAddress
XPU_D int32_t GetAddress() const
Definition CbmStsDigi.h:74
CbmTofDigi
Data class for expanded digital TOF information.
Definition CbmTofDigi.h:47
CbmTofDigi::GetTime
double GetTime() const
Inherited from CbmDigi.
Definition CbmTofDigi.h:131
CbmTofDigi::GetCharge
double GetCharge() const
Inherited from CbmDigi.
Definition CbmTofDigi.h:136
TimesliceMetaData::GetStartTime
uint64_t GetStartTime() const
Definition TimesliceMetaData.h:31