48ccaa07 |
1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
3 | * * |
4 | * Author: The ALICE Off-line Project. * |
5 | * Contributors are mentioned in the code where appropriate. * |
6 | * * |
7 | * Permission to use, copy, modify and distribute this software and its * |
8 | * documentation strictly for non-commercial purposes is hereby granted * |
9 | * withount fee, provided thats the abov copyright notice appears in all * |
10 | * copies and that both the copyright notice and this permission notice * |
11 | * appear in the supporting documentation. The authors make no claims * |
12 | * about the suitability of this software for any purpose. It is * |
13 | * provided "as is without express or implied warranty. * |
14 | **************************************************************************/ |
15 | |
16 | /* $Id: AliTRDqaBlackEvents.cxx 23387 2008-01-17 17:25:16Z cblume $ */ |
17 | |
18 | //////////////////////////////////////////////////////////////////////////// |
19 | // // |
20 | // QA of black events // |
21 | // // |
22 | // Author: // |
23 | // Sylwester Radomski (radomski@physi.uni-heidelberg.de) // |
24 | // // |
25 | //////////////////////////////////////////////////////////////////////////// |
26 | |
27 | #include "TH1D.h" |
28 | #include "TH2D.h" |
29 | #include "TH2S.h" |
48ccaa07 |
30 | #include "TF1.h" |
31 | #include "TFile.h" |
32 | #include "TCanvas.h" |
33 | #include "TPad.h" |
34 | #include "TLatex.h" |
35 | #include "TStyle.h" |
36 | #include "TGraph.h" |
37 | |
c87495af |
38 | #include "AliRawReader.h" |
48ccaa07 |
39 | |
ef1860eb |
40 | #include "AliTRDrawStreamOld.h" |
48ccaa07 |
41 | #include "AliTRDqaBlackEvents.h" |
42 | |
48ccaa07 |
43 | ClassImp(AliTRDqaBlackEvents) |
44 | |
45 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
46 | |
47 | AliTRDqaBlackEvents::AliTRDqaBlackEvents() |
48 | :TObject() |
49 | ,fnEvents(0) |
50 | ,fCreateFull(0) |
51 | ,fThresh(0) |
52 | ,fCount(0) |
53 | ,fRefEv(0) |
2a097c72 |
54 | ,fRefFileName(0x0) |
48ccaa07 |
55 | ,fOccupancy(0) |
56 | ,fDetRob(0) |
57 | ,fTBEvent(0) |
58 | ,fRefHistPed(0) |
59 | ,fRefHistNoise(0) |
60 | ,fErrorHC(0) |
61 | ,fErrorMCM(0) |
62 | ,fErrorADC(0) |
63 | ,fErrorSMHC(0) |
64 | ,fErrorSMMCM(0) |
65 | ,fErrorSMADC(0) |
66 | ,fErrorGraphHC(0) |
67 | ,fErrorGraphMCM(0) |
68 | ,fErrorGraphADC(0) |
69 | ,fGraphMCM(0) |
70 | ,fMcmTracks(0) |
71 | ,fMapMCM(0) |
72 | ,fFracMCM(0) |
73 | ,fSMHCped(0) |
74 | ,fSMHCerr(0) |
75 | ,fNoiseTotal(0) |
76 | ,fPP(0) |
77 | ,fMinNoise(0.5) |
78 | ,fMaxNoise(2) |
79 | ,fFitType(0) |
48ccaa07 |
80 | { |
81 | // |
82 | // Constructor |
83 | // to create the histograms call Init() |
84 | // |
85 | |
8d3a4626 |
86 | for (Int_t i = 0; i < kDET; i++) { |
87 | fPed[i] = 0x0; |
88 | fNoise[i] = 0x0; |
89 | fChPP[i] = 0x0; |
90 | fNPointDist[i] = 0x0; |
91 | fChPed[i] = 0x0; |
92 | fChNoise[i] = 0x0; |
93 | fNPoint[i] = 0x0; |
94 | fData[i] = 0x0; |
95 | fSignal[i] = 0x0; |
96 | fnEntriesRM[i] = 0x0; |
97 | fnEntriesRMDist[i] = 0x0; |
98 | fChPedRes[i] = 0x0; |
99 | fChNoiseRes[i] = 0x0; |
100 | fErrorLocHC[i] = 0x0; |
101 | fErrorLocMCM[i] = 0x0; |
102 | fErrorLocADC[i] = 0x0; |
103 | } |
104 | for (Int_t i = 0; i < 3; i++) { |
105 | fGraphPP[i] = 0x0; |
106 | fSMLink[i] = 0x0; |
107 | fGrLink[i] = 0x0; |
108 | fppThresh[i] = 0; |
109 | fnPP[i] = 0; |
110 | fnLink[i] = 0; |
111 | } |
112 | for (Int_t i = 0; i < 2; i++) { |
113 | fnErrorHC[i] = 0; |
114 | fnErrorMCM[i] = 0; |
115 | fnErrorADC[i] = 0; |
116 | } |
117 | for (Int_t i = 0; i < kSM; i++) { |
118 | fSmNoiseRms[i] = 0x0; |
119 | fSmNoiseFit[i] = 0x0; |
120 | fSmPP[i] = 0x0; |
121 | } |
122 | for (Int_t i = 0; i < kSM+1; i++) { |
123 | fNumberADC[i] = 0x0; |
124 | fnADCinSM[i] = 0; |
125 | } |
126 | for (Int_t i = 0; i < 1000; i++) { |
127 | fEvNoDist[i] = 0; |
128 | } |
2a097c72 |
129 | for (Int_t i = 0; i < kDET*kROB*kMCM; i++) { |
130 | fFullSignal[i] = 0x0; |
131 | fFullCounter[i] = 0; |
132 | } |
133 | //strncpy(fRefFileName,"",256); |
8d3a4626 |
134 | |
48ccaa07 |
135 | } |
136 | |
137 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
138 | |
139 | AliTRDqaBlackEvents::AliTRDqaBlackEvents(const AliTRDqaBlackEvents &qa) |
140 | :TObject(qa) |
141 | ,fnEvents(0) |
142 | ,fCreateFull(0) |
143 | ,fThresh(0) |
144 | ,fCount(0) |
145 | ,fRefEv(0) |
2a097c72 |
146 | ,fRefFileName(0x0) |
48ccaa07 |
147 | ,fOccupancy(0) |
148 | ,fDetRob(0) |
149 | ,fTBEvent(0) |
150 | ,fRefHistPed(0) |
151 | ,fRefHistNoise(0) |
152 | ,fErrorHC(0) |
153 | ,fErrorMCM(0) |
154 | ,fErrorADC(0) |
155 | ,fErrorSMHC(0) |
156 | ,fErrorSMMCM(0) |
157 | ,fErrorSMADC(0) |
158 | ,fErrorGraphHC(0) |
159 | ,fErrorGraphMCM(0) |
160 | ,fErrorGraphADC(0) |
161 | ,fGraphMCM(0) |
162 | ,fMcmTracks(0) |
163 | ,fMapMCM(0) |
164 | ,fFracMCM(0) |
165 | ,fSMHCped(0) |
166 | ,fSMHCerr(0) |
167 | ,fNoiseTotal(0) |
168 | ,fPP(0) |
169 | ,fMinNoise(0.5) |
170 | ,fMaxNoise(2) |
171 | ,fFitType(0) |
48ccaa07 |
172 | { |
173 | // |
174 | // Copy constructor |
175 | // to create the histograms call Init() |
176 | // |
177 | |
8d3a4626 |
178 | for (Int_t i = 0; i < kDET; i++) { |
179 | fPed[i] = 0x0; |
180 | fNoise[i] = 0x0; |
181 | fChPP[i] = 0x0; |
182 | fNPointDist[i] = 0x0; |
183 | fChPed[i] = 0x0; |
184 | fChNoise[i] = 0x0; |
185 | fNPoint[i] = 0x0; |
186 | fData[i] = 0x0; |
187 | fSignal[i] = 0x0; |
188 | fnEntriesRM[i] = 0x0; |
189 | fnEntriesRMDist[i] = 0x0; |
190 | fChPedRes[i] = 0x0; |
191 | fChNoiseRes[i] = 0x0; |
192 | fErrorLocHC[i] = 0x0; |
193 | fErrorLocMCM[i] = 0x0; |
194 | fErrorLocADC[i] = 0x0; |
195 | } |
196 | for (Int_t i = 0; i < 3; i++) { |
197 | fGraphPP[i] = 0x0; |
198 | fSMLink[i] = 0x0; |
199 | fGrLink[i] = 0x0; |
200 | fppThresh[i] = 0; |
201 | fnPP[i] = 0; |
202 | fnLink[i] = 0; |
203 | } |
204 | for (Int_t i = 0; i < 2; i++) { |
205 | fnErrorHC[i] = 0; |
206 | fnErrorMCM[i] = 0; |
207 | fnErrorADC[i] = 0; |
208 | } |
209 | for (Int_t i = 0; i < kSM; i++) { |
210 | fSmNoiseRms[i] = 0x0; |
211 | fSmNoiseFit[i] = 0x0; |
212 | fSmPP[i] = 0x0; |
213 | } |
214 | for (Int_t i = 0; i < kSM+1; i++) { |
215 | fNumberADC[i] = 0x0; |
216 | fnADCinSM[i] = 0; |
217 | } |
218 | for (Int_t i = 0; i < 1000; i++) { |
219 | fEvNoDist[i] = 0; |
220 | } |
2a097c72 |
221 | for (Int_t i = 0; i < kDET*kROB*kMCM; i++) { |
222 | fFullSignal[i] = 0x0; |
223 | fFullCounter[i] = 0; |
224 | } |
225 | //strncpy(fRefFileName,"",256); |
8d3a4626 |
226 | |
48ccaa07 |
227 | } |
228 | |
229 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
230 | |
231 | void AliTRDqaBlackEvents::Init() |
232 | { |
233 | // |
234 | // creates histograms |
235 | // |
236 | |
237 | //TFile *file = new |
238 | //Info("Init", "Statring"); |
239 | |
240 | fnEvents = 0; |
241 | |
242 | // histograms for chambers |
243 | for(Int_t det=0; det<kDET; det++) { |
244 | |
245 | fNPoint[det] = new TH2D(Form("entries_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
246 | //fData[det] = new TH3F(Form("data_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5, 50, -0.5, 49.5); |
247 | |
248 | // pedestal noise maps using RMS and Fit |
249 | fChPed[det] = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
250 | fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
251 | |
252 | //fChPed[det] = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
253 | //fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
254 | |
255 | // distribution per detector |
256 | fPed[det] = new TH1D(Form("pedDist_%d", det), ";pedestals (ADC counts)", 100, 5, 15); |
257 | fNoise[det] = new TH1D(Form("noiseDist_%d", det), ";noise (ADC counts)", 100, 0, 5); |
258 | fSignal[det] = new TH1D(Form("signal_%d", det), ";signal (ADC counts)", 100, -0.5, 99.5); |
259 | fChPP[det] = new TH1D(Form("pp_%d", det), ";pp (ADC)", 200, -0.5, 199.5); |
260 | |
261 | fnEntriesRM[det] = new TH2D(Form("entriesRM_%d", det), ";ROB,MCM", 8, -0.5, 7.5, 16, -0.5, 15.5); |
262 | |
263 | // histograms after reference subtraction |
264 | fChPedRes[det] = new TH2D(Form("pedRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
265 | fChNoiseRes[det] = new TH2D(Form("noiseRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
266 | |
267 | |
268 | // error codes |
269 | fErrorLocMCM[det] = new TH2D(Form("errorLocMCM_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
270 | fErrorLocADC[det] = new TH2D(Form("errorLocADC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
271 | fErrorLocHC[det] = new TH2D(Form("errorLocHC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5); |
272 | } |
273 | |
274 | // histogram for each MCM |
275 | for(Int_t i=0; i < kDET * kROB * kMCM; i++) |
276 | fFullCounter[i] = 0; |
277 | |
278 | // histograms from the whole detector |
279 | fOccupancy = new TH1D("occupancy", "", 20, -0.5, 19.5); |
280 | fDetRob = new TH2D("DetRob", ";detector;ROB", kDET, -0.5, 539.5, 8, -0.5, 7.5); |
281 | fTBEvent = new TH2D("tbEvent", ";event ID;time bin", 100, -0.5, 99.5, 30, -0.5, 29.5); |
282 | |
283 | // errors statistics and location |
284 | fErrorHC = new TH1D("errorHC", ";error ID;", 18, -3.5, 14.5); |
285 | fErrorMCM = new TH1D("errorMCM", ";error ID;", 18, -3.5, 14.5); |
286 | fErrorADC = new TH1D("errorADC", ";error ID;", 18, -3.5, 14.5); |
287 | |
288 | fErrorSMHC = new TH1D("errorSM_HC", ";SM id", 18, -0.5, 17.5); |
289 | fErrorSMMCM = new TH1D("errorSM_MCM", ";SM id", 18, -0.5, 17.5); |
290 | fErrorSMADC = new TH1D("errorSM_ADC", ";SM id", 18, -0.5, 17.5); |
291 | |
292 | |
293 | fErrorGraphHC = new TGraph(); |
294 | fErrorGraphMCM = new TGraph(); |
295 | fErrorGraphADC = new TGraph(); |
296 | |
297 | fGraphMCM = new TGraph(); |
298 | |
299 | for(Int_t i=0; i<3; i++) { |
300 | fGraphPP[i] = new TGraph(); |
301 | } |
302 | |
303 | |
304 | fMapMCM = new TH2D("mapMCM", ";det;mcm", 540, -0.5, 539.5, kROB*kMCM, -0.5, kROB*kMCM-0.5); |
305 | fFracMCM = new TH1D("fracMCM", ";frequency", 100, 0, 1); |
306 | |
307 | |
308 | fErrorGraphHC->GetHistogram()->SetTitle("fraction of events with HC error;event number"); |
309 | fErrorGraphMCM->GetHistogram()->SetTitle("fraction of events with MCM error;event number;"); |
310 | fErrorGraphADC->GetHistogram()->SetTitle("fraction of events with ADC error;event number;"); |
311 | |
312 | |
313 | fSMHCped = new TH2D("smHcPed", ";super module;half chamber", 18, -0.5, 17.5, 60, -0.5, 59.5); |
314 | |
315 | // link monitor |
316 | const char *linkName[3] = {"smLink", "smBeaf", "smData"}; |
317 | const char *linkGrName[3] = {"grSmLink", "grSmBeaf", "grSmData"}; |
318 | for(Int_t i=0; i<3; i++) { |
319 | fSMLink[i] = new TH2D(linkName[i], ";super module;link", 18, -0.5, 17.5, 60, -0.5, 59.5); |
320 | fGrLink[i] = new TGraph(); |
321 | fGrLink[i]->SetName(linkGrName[i]); |
322 | } |
323 | |
324 | //fZSsize = new TH1D("zssizeSingle", ";threshold;nADC", 40, -0.5, 39.5); |
325 | |
326 | |
327 | //Info("Init", "Done"); |
328 | |
329 | // number of ADC channels fired per SM and in total |
330 | for(Int_t sm=0; sm<kSM+1; sm++) |
331 | fNumberADC[sm] = new TGraph(); |
332 | |
333 | // |
334 | fNoiseTotal = new TH1D("noiseTotal", "noise (ADC)", 250, 0, 10); |
335 | fPP = new TH1D("peakPeak", "p-p (ADC)", 200, -0.5, 199.5); |
336 | |
337 | for(Int_t sm=0; sm<kSM; sm++) { |
338 | fSmNoiseRms[sm] = new TH1D(Form("noiseRms_sm%d", sm), ";noise from RMS (ADC)", 100, 0, 10); |
339 | fSmNoiseFit[sm] = new TH1D(Form("noiseFit_sm%d", sm), ";noise frim Fit (ADC)", 100, 0, 10); |
340 | fSmPP[sm] = new TH1D(Form("peakPeak_sm%d", sm), ";peak-peak (ADC)", 200, -0.5, 199.5); |
341 | } |
342 | |
343 | // event number consistancy |
344 | for(Int_t i=0; i<1000; i++) { |
345 | fEvNoDist[i] = new TH1D(Form("mcmEvDist_%d", i), ";#Delta Events", 201, -100.5, 100.5); |
346 | } |
347 | fRefEv = -1; |
348 | |
349 | fMcmTracks = new TObjArray(); |
350 | |
351 | // clean data direct |
352 | for(Int_t det=0; det<kDET; det++) |
353 | for(Int_t row=0; row<kROW; row++) |
354 | for(Int_t pad=0; pad<kPAD; pad++) |
355 | for(Int_t ch=0; ch<kCH; ch++) { |
356 | fDataDirect[det][row][pad][ch] = 0; |
357 | fSignalDirect[det][ch] = 0; // overdone |
358 | } |
359 | } |
360 | |
361 | |
362 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
363 | |
364 | void AliTRDqaBlackEvents::Reset() |
365 | { |
366 | // |
367 | // Resets the histograms |
368 | // |
369 | |
370 | for(Int_t i=0; i<kDET; i++) { |
371 | //fData[i]->Reset(); |
372 | fChPed[i]->Reset(); |
373 | fChNoise[i]->Reset(); |
374 | } |
375 | } |
376 | |
377 | |
378 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
379 | |
380 | void AliTRDqaBlackEvents::SetRefFile(const char *filename) { |
381 | |
2a097c72 |
382 | //strncpy(fRefFileName,filename,256); |
383 | fRefFileName = filename; |
8d3a4626 |
384 | |
48ccaa07 |
385 | } |
386 | |
387 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
388 | |
389 | void AliTRDqaBlackEvents::ReadRefHists(Int_t det) { |
c87495af |
390 | // |
391 | // Read the reference histograms |
392 | // |
393 | |
48ccaa07 |
394 | fRefHistPed = 0; |
395 | fRefHistNoise = 0; |
396 | |
2a097c72 |
397 | TFile *file = 0x0; |
398 | if (fRefFileName) file = TFile::Open(fRefFileName); |
48ccaa07 |
399 | if (!file) return; |
400 | |
401 | fRefHistPed = (TH2D*)file->Get(Form("ped_%d",det)); |
402 | fRefHistNoise = (TH2D*)file->Get(Form("noise_%d", det)); |
403 | |
404 | if (file) file->Close(); |
405 | } |
406 | |
407 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
408 | |
409 | void AliTRDqaBlackEvents::StartEvent() |
410 | { |
411 | // |
412 | // start an event |
413 | // |
414 | |
415 | // clear the mcm data |
416 | for(Int_t i=0; i < kDET * kROB * kMCM; i++) { |
417 | if (fFullSignal[i]) fFullSignal[i]->Reset(); |
418 | fFullCounter[i] = 0; |
419 | } |
420 | |
421 | for(Int_t i=0; i<2; i++) { |
422 | fnErrorHC[i] = 0; |
423 | fnErrorMCM[i] = 0; |
424 | fnErrorADC[i] = 0; |
425 | } |
426 | |
427 | |
428 | Int_t ppThresh[3] = {10, 20, 40}; |
429 | for(Int_t i=0; i<3; i++) { |
430 | fppThresh[i] = ppThresh[i]; |
431 | fnPP[i] = 0; |
432 | fnLink[i] = 0; |
433 | } |
434 | |
435 | for(Int_t sm=0; sm<kSM+1; sm++) fnADCinSM[sm] = 0; |
436 | |
437 | if (fRefEv > 0) fRefEv++; |
438 | fEvNoDist[999]->Reset(); // keep only the last event |
439 | |
440 | } |
441 | |
442 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
443 | |
ef1860eb |
444 | void AliTRDqaBlackEvents::AddBuffer(AliTRDrawStreamOld *data, AliRawReader * const reader) |
48ccaa07 |
445 | { |
446 | |
447 | //printf ("try to read data\n"); |
448 | Int_t nextBuff = data->NextBuffer(); |
449 | //printf("done ...\n"); |
450 | |
451 | if (nextBuff == 0) return; |
452 | |
453 | Int_t sm = reader->GetEquipmentId() - 1024; |
454 | //printf("reading SM %d\n", sm); |
455 | AliInfo(Form("reading SM %d", sm)); |
456 | |
2a097c72 |
457 | if (sm < 0 || sm > 17) return; |
48ccaa07 |
458 | |
459 | // lopp over stacks, links ... |
460 | |
461 | for (Int_t istack = 0; istack < 5; istack++) { |
462 | for (Int_t ilink = 0; ilink < 12; ilink++) { |
463 | |
464 | //printf("HC = %d %d\n", istack, ilink); |
465 | |
466 | Int_t det = sm * 30 + istack * 6 + ilink/2; |
467 | |
468 | // check if data delivered |
469 | if (!(data->IsLinkActiveInStack(istack, ilink))) continue; |
470 | fSMLink[0]->Fill(sm, istack * 12 + ilink); |
471 | fnLink[0]++; |
472 | |
473 | // check if beaf-beaf |
474 | if (data->GetLinkMonitorError(istack, ilink)) { |
475 | fSMLink[1]->Fill(sm, istack * 12 + ilink); |
476 | fnLink[1]++; |
477 | continue; |
478 | } |
479 | |
480 | // fill histogram with HC header errors |
481 | Int_t nErrHc = 0; |
482 | Int_t nErrHcTot = 0; |
483 | |
484 | nErrHc = FillBits(fErrorHC, data->GetH0ErrorCode(istack, ilink), 0); |
485 | if (!nErrHc) fErrorHC->Fill(-3); |
486 | nErrHcTot += nErrHc; |
487 | |
488 | nErrHc = FillBits(fErrorHC, data->GetH1ErrorCode(istack, ilink), 2); |
489 | if (!nErrHc) fErrorHC->Fill(-2); |
490 | nErrHcTot += nErrHc; |
491 | |
492 | nErrHc = FillBits(fErrorHC, data->GetHCErrorCode(istack, ilink), 4); |
493 | if (!nErrHc) fErrorHC->Fill(-1); |
494 | nErrHcTot += nErrHc; |
495 | |
496 | // trending |
497 | fnErrorHC[0]++; |
498 | if (nErrHcTot > 0) { |
499 | fnErrorHC[1]++; |
500 | fErrorSMHC->Fill(sm); |
501 | } |
502 | |
503 | // data integrity protection |
504 | |
505 | //if (data->GetHCErrorCode(istack, ilink) > 0) continue; |
506 | if (data->GetH0ErrorCode(istack, ilink) > 0) continue; |
507 | if (data->GetH1ErrorCode(istack, ilink) > 0) continue; |
508 | |
509 | fSMLink[2]->Fill(sm, istack * 12 + ilink); |
510 | fnLink[2]++; |
511 | |
512 | |
513 | for (Int_t imcm = 0; imcm < data->GetHCMCMmax(istack, ilink); imcm++ ){ |
514 | |
515 | //printf("mcm = %d %d %d\n", istack, ilink, imcm); |
516 | |
517 | // fill MCM error code |
518 | |
519 | Int_t nErrMcm = 0; |
520 | Int_t nErrMcmTot = 0; |
521 | |
522 | nErrMcm = FillBits(fErrorMCM, data->GetMCMhdErrorCode(istack, ilink, imcm), 0); |
523 | if (!nErrMcm) fErrorMCM->Fill(-3); |
524 | nErrMcmTot += nErrMcm; |
525 | |
526 | nErrMcm = FillBits(fErrorMCM, data->GetMCMADCMaskErrorCode(istack, ilink, imcm), 5); |
527 | if (!nErrMcm) fErrorMCM->Fill(-2); |
528 | nErrMcmTot += nErrMcm; |
529 | |
530 | nErrMcm = FillBits(fErrorMCM, data->GetMCMErrorCode(istack, ilink, imcm), 10); |
531 | if (!nErrMcm) fErrorMCM->Fill(-1); |
532 | nErrMcmTot += nErrMcm; |
533 | |
534 | // trending |
535 | fnErrorMCM[0]++; |
536 | if (nErrMcmTot > 0) { |
537 | fnErrorMCM[1]++; |
538 | fErrorSMMCM->Fill(sm); |
539 | } |
540 | |
541 | // MCM protection |
542 | if ( (data->GetMCMhdErrorCode(istack,ilink,imcm)) & 2 ) continue; |
543 | //if ((data->GetMCMADCMaskErrorCode(istack,ilink,imcm))) continue; |
544 | //if ((data->GetMCMErrorCode(istack,ilink,imcm))) continue; |
545 | |
546 | Int_t mcmEvent = data->GetEventNumber(istack, ilink, imcm); |
547 | |
548 | // set the reference event number |
549 | if (fRefEv < 0) { |
550 | fRefEv = mcmEvent; |
551 | printf("Reference Event Number = %d (%d %d %d)\n", fRefEv, istack, ilink, imcm); |
552 | } |
553 | |
554 | // fill event distribution |
555 | if (!(fnEvents%10)) { |
556 | fEvNoDist[fnEvents/10]->Fill(mcmEvent - fRefEv); |
557 | } |
558 | |
559 | fEvNoDist[999]->Fill(mcmEvent - fRefEv); |
560 | |
561 | Int_t mcm = data->GetMCM(istack, ilink, imcm); |
562 | Int_t rob = data->GetROB(istack, ilink, imcm); |
563 | |
564 | // create a structure for an MCM if needed |
565 | Int_t mcmIndex = det * (kMCM * kROB) + rob * kMCM + mcm; |
566 | if (fCreateFull && !fFullSignal[mcmIndex]) |
567 | fFullSignal[mcmIndex] = |
568 | new TH2S(Form("mcm_%d_%d_%d_%d_%d", sm, istack, ilink/2, rob, mcm), |
569 | Form("mcm-%d-%d-%d-%d-%d;ADC;time bin", sm, istack, ilink/2, rob, mcm), |
570 | 21, -0.5, 20.5, 30, -0.5, 29.5); |
571 | |
572 | |
573 | //Int_t zsADC[21][40]; |
574 | /* |
575 | for(Int_t ina=0; ina<21; ina++) |
576 | for(Int_t th=0; th<40; th++) |
577 | zsADC[ina][th] = 0; |
578 | */ |
579 | |
580 | // first loop over ADC chanels |
581 | |
582 | for (Int_t iadc=0; iadc < data->GetADCcount(istack, ilink, imcm); iadc++) { |
583 | |
584 | //printf("ADC = %d\n", iadc); |
585 | |
586 | |
587 | // fill ADC error bits |
588 | Int_t nErrAdc = FillBits(fErrorADC, data->GetADCErrorCode(), 0); |
589 | if (!nErrAdc) fErrorADC->Fill(-1); |
590 | |
591 | fnErrorADC[0]++; |
592 | if (nErrAdc > 0) { |
593 | fnErrorADC[1]++; |
594 | fErrorSMADC->Fill(sm); |
595 | } |
596 | |
597 | // ADC protection |
598 | if ((data->GetADCErrorCode(istack,ilink,imcm,iadc))) continue; |
599 | |
600 | Int_t minV = 1024; |
601 | Int_t maxV = 0; |
602 | |
603 | Int_t *sig = data->GetSignalDirect(istack, ilink, imcm, iadc); |
604 | |
605 | //Int_t adc = data->GetADCnumber(istack, ilink, imcm, iadc); |
606 | Int_t row = data->GetRow(istack, ilink, imcm); |
607 | Int_t col = data->GetCol(istack, ilink, imcm, iadc); |
608 | |
609 | // loop over Time Bins and fill histograms |
610 | for(Int_t k=0; k < data->GetNumberOfTimeBins(istack, ilink); k++) { |
611 | |
612 | //fSignal[det]->Fill(sig[k]); |
613 | //fData[det]->Fill(row, col, sig[k]); // slow |
614 | |
2a097c72 |
615 | if ((sig[k] >=0) && (sig[k] < kCH)) { |
48ccaa07 |
616 | fSignalDirect[det][sig[k]]++; |
617 | fDataDirect[det][row][col][sig[k]]++; // direct data |
618 | } |
619 | |
620 | // peak-peak |
621 | minV = (minV < sig[k]) ? minV : sig[k]; |
622 | maxV = (maxV > sig[k]) ? maxV : sig[k]; |
623 | |
624 | // check for active MCMs |
625 | if (fCreateFull && fFullSignal[mcmIndex]) { |
626 | if (sig[k] > fThresh || sig[k] < 0) fFullCounter[mcmIndex]++; |
627 | //if (sm == 0 && istack == 0 && ilink/2 == 1 && rob == 1 && mcm == 15) fFullCounter[mcmIndex]++; // special |
628 | //fFullSignal[mcmIndex]->Fill(adc, k, sig[k]); // slow |
629 | } |
630 | |
631 | // zero suppresion tests |
632 | /* |
633 | for(Int_t th=0; th<40; th++) { |
634 | if (sig[k] > th) { |
635 | zsADC[iadc][th] = 1; |
636 | if (iadc > 0) zsADC[iadc-1][th] = 1; |
637 | if (iadc < 10) zsADC[iadc+1][th] = 1; |
638 | } |
639 | } |
640 | */ |
641 | |
642 | } // tb |
643 | |
644 | if (maxV > 0) { |
645 | fnADCinSM[sm]++; |
646 | fnADCinSM[kSM]++; |
647 | } |
648 | |
649 | Int_t adcPP = maxV - minV; |
650 | //if (adcPP == 100) fFullCounter[mcmIndex] += 10; |
651 | |
652 | fPP->Fill(adcPP); |
653 | fChPP[det]->Fill(adcPP); |
654 | fSmPP[sm]->Fill(adcPP); |
655 | |
656 | for(Int_t i=0; i<3; i++) { |
657 | if ((adcPP) > fppThresh[i]) fnPP[i]++; |
658 | } |
659 | |
660 | |
661 | } // adc |
662 | |
663 | // fill ZS histos |
664 | /* |
665 | for(Int_t th=0; th<40; th++) { |
666 | Int_t nnADC = 0; |
667 | for(Int_t ins=0; ins<21; ins++) |
668 | nnADC += zsADC[ins][th]; |
669 | fZSsize->Fill(th, nnADC); |
670 | } |
671 | */ |
672 | |
673 | // fill active MCMs |
674 | |
675 | if (fCreateFull && fFullSignal[mcmIndex] && (fFullCounter[mcmIndex] > fCount)) { |
676 | |
677 | for (Int_t iadc=0; iadc < data->GetADCcount(istack, ilink, imcm); iadc++) { |
678 | |
679 | // ADC protection |
680 | if ((data->GetADCErrorCode(istack,ilink,imcm,iadc))) continue; |
681 | |
682 | //Int_t row = data->GetRow(istack, ilink, imcm); |
683 | //Int_t col = data->GetCol(istack, ilink, imcm, iadc); |
684 | Int_t adc = data->GetADCnumber(istack, ilink, imcm, iadc); |
685 | |
686 | Int_t *sig = data->GetSignalDirect(istack, ilink, imcm, iadc); |
687 | |
688 | // loop over Time Bins and fill histograms |
689 | for(Int_t k=0; k < data->GetNumberOfTimeBins(istack, ilink); k++) { |
690 | fFullSignal[mcmIndex]->Fill(adc, k, sig[k]); // slow |
691 | } |
692 | } // tb |
693 | } |
694 | |
695 | } // mcm |
696 | } // link |
697 | } // stack |
698 | |
699 | // printf("end of loops\n"); |
700 | } |
701 | |
702 | |
703 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
704 | |
705 | void AliTRDqaBlackEvents::FinishEvent() |
706 | { |
c87495af |
707 | // |
708 | // Processing at the end of the current event |
709 | // |
48ccaa07 |
710 | |
711 | for(Int_t i=0; i<3; i++) { |
712 | fGraphPP[i]->SetPoint(fnEvents, fnEvents, fnPP[i]); |
713 | } |
714 | |
715 | // trend of the number of links |
716 | for(Int_t i=0; i<3; i++) { |
717 | fGrLink[i]->SetPoint(fnEvents, fnEvents, fnLink[i]); |
718 | } |
719 | |
720 | // save interesting histos |
721 | Int_t mcmTrackCandidate = 0; |
722 | for(Int_t i = 0; i < kDET * kROB * kMCM; i++) { |
723 | if ((fFullCounter[i] > fCount) && fFullSignal[i] && CheckMCM(i) ) { |
724 | |
725 | fMcmTracks->AddLast(fFullSignal[i]->Clone(Form("event_%d_%s", fnEvents, fFullSignal[i]->GetName()))); |
726 | mcmTrackCandidate++; |
727 | |
728 | Int_t mcmTrackletDet = i/(kROB * kMCM); |
729 | Int_t mcmTrackletMcm = i%(kROB * kMCM); |
730 | fMapMCM->Fill(mcmTrackletDet, mcmTrackletMcm); |
731 | } |
732 | } |
733 | |
734 | fGraphMCM->SetPoint(fnEvents, fnEvents, mcmTrackCandidate); |
735 | AliInfo(Form("Number of MCM track candidates = %d\n", mcmTrackCandidate)); |
736 | |
737 | |
738 | // update fraction of error graphs |
739 | Double_t err; |
740 | |
741 | err = (fnErrorHC[0] > 0)? 100.*fnErrorHC[1]/fnErrorHC[0] : -1; |
742 | fErrorGraphHC->SetPoint(fnEvents, fnEvents, err); |
743 | |
744 | err = (fnErrorMCM[0] > 0)? 100.*fnErrorMCM[1]/fnErrorMCM[0] : -1; |
745 | fErrorGraphMCM->SetPoint(fnEvents, fnEvents, err); |
746 | |
747 | err = (fnErrorADC[0] > 0)? 100.*fnErrorADC[1]/fnErrorADC[0] : -1; |
748 | fErrorGraphADC->SetPoint(fnEvents, fnEvents, err); |
749 | |
750 | // number of fired ADC per SM |
751 | for(Int_t sm=0; sm<kSM+1; sm++) |
752 | fNumberADC[sm]->SetPoint(fnEvents, fnEvents, fnADCinSM[sm]); |
753 | |
754 | fnEvents++; |
755 | } |
756 | |
757 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
758 | |
759 | void AliTRDqaBlackEvents::Process(const char *filename) |
760 | { |
761 | // |
762 | // Process something |
763 | // |
764 | |
9e74dcc2 |
765 | //char fn[256]; |
766 | //strncpy(fn,filename,256); |
48ccaa07 |
767 | |
768 | //AliInfo(Form("FILENAME = %s (%s)\n", filename, fn)); |
769 | |
770 | Int_t map[kDET]; |
771 | |
772 | TH1D *hist = new TH1D("fitSignal", "", 50, -0.5, 49.5); |
773 | TF1 *fit = new TF1("fit", "gaus(0)", 0, 20); |
774 | fit->SetParameters(1e3, 10, 1); |
775 | |
776 | for(Int_t det=0; det<kDET; det++) { |
777 | |
778 | //AliInfo(Form("processing chamber %d\n", det)); |
779 | |
780 | map[det] = 0; |
781 | //if (fData[det]->GetSum() < 10) continue; |
782 | //if (fDataDirect[det][10][10][10] < 20) continue; |
783 | //map[det] = 1; |
784 | |
785 | |
786 | // rewrite signal-direct |
787 | for(Int_t ch=0; ch<kCH; ch++) { |
788 | fSignal[det]->Fill(ch, fSignalDirect[det][ch]); |
789 | } |
790 | |
791 | // read reference distributions |
792 | ReadRefHists(det); |
793 | |
794 | //for(Int_t row=0; row<fData[det]->GetXaxis()->GetNbins(); row++) { |
795 | //for(Int_t pad=0; pad<fData[det]->GetYaxis()->GetNbins(); pad++) { |
796 | |
797 | for(Int_t row=0; row<kROW; row++) { |
798 | for(Int_t pad=0; pad<kPAD; pad++) { |
799 | |
800 | // project the histogramm |
801 | hist->Reset(); |
802 | //for(Int_t bb=0; bb<50; bb++) { |
803 | for(Int_t bb=0; bb<kCH; bb++) { |
804 | //Int_t dataBin = fData[det]->FindBin(row, pad, bb); |
805 | //Double_t v = fData[det]->GetBinContent(dataBin); |
806 | hist->SetBinContent(bb+1, fDataDirect[det][row][pad][bb]); |
807 | } |
808 | |
809 | Int_t bin = fChPed[det]->FindBin(row, pad); |
810 | |
811 | if (hist->GetSum() > 1) { |
812 | |
813 | map[det] = 1; |
814 | Double_t ped = 0, noise = 0; |
815 | |
816 | if (fFitType == 0) { |
817 | fit->SetParameters(1e3, 10, 1); |
818 | hist->Fit(fit, "q0", "goff", 0, 20); |
819 | TF1 *f = hist->GetFunction("fit"); |
820 | ped = TMath::Abs(f->GetParameter(1)); |
821 | noise = TMath::Abs(f->GetParameter(2)); |
822 | fSmNoiseFit[det/30]->Fill(noise); |
823 | } else { |
824 | ped = hist->GetMean(); |
825 | noise = hist->GetRMS(); |
826 | fSmNoiseRms[det/30]->Fill(noise); |
827 | //if (pad == 0) |
828 | // AliInfo(Form("data %f %f %f\n", hist->GetSum(), ped, noise)); |
829 | } |
830 | |
831 | fChPed[det]->SetBinContent(bin, ped); |
832 | fChNoise[det]->SetBinContent(bin, noise); |
833 | fNoiseTotal->Fill(noise); |
834 | |
835 | // subtract reference values |
836 | Double_t refped = 0; |
837 | Double_t refnoise = 0; |
838 | |
839 | if (fRefHistPed) refped = fRefHistPed->GetBinContent(bin); |
2a097c72 |
840 | if (fRefHistPed) refnoise = fRefHistPed->GetBinContent(bin); |
841 | // Original code, should it not be fRefHistNoise->GetBinContent(bin) |
842 | // instead of fRefHistPed->GetBinContent(bin) (CBL) ??? |
843 | //if (fRefHistNoise) refnoise = fRefHistPed->GetBinContent(bin); |
48ccaa07 |
844 | |
845 | fChPedRes[det]->SetBinContent(bin, ped-refped); |
846 | fChNoiseRes[det]->SetBinContent(bin, noise-refnoise); |
847 | |
848 | fPed[det]->Fill(ped); |
849 | fNoise[det]->Fill(noise); |
850 | |
851 | // fill SM-HC plot |
852 | Int_t sm = det / 30; |
853 | Int_t hc = (pad < kPAD/2) ? 2* (det % 30) : 2* (det % 30) + 1; |
854 | if (ped > 9. && ped < 11) fSMHCped->Fill(sm, hc, 1./1152.); // number of pads in HC |
855 | |
856 | } else { |
857 | |
858 | // not enought data found |
859 | fChPed[det]->SetBinContent(bin, 0); |
860 | fChNoise[det]->SetBinContent(bin, 0); |
861 | fChPedRes[det]->SetBinContent(bin, 0); |
862 | fChNoiseRes[det]->SetBinContent(bin, 0); |
863 | } |
864 | |
865 | //delete hist; |
866 | } |
867 | } |
868 | } |
869 | |
870 | |
871 | //AliInfo(Form("Number of events = %d\n", fnEvents)); |
872 | |
873 | // normalize number of entries histos |
874 | Int_t max = 0; |
875 | for(Int_t i=0; i<kDET; i++) { |
876 | if (!map[i]) continue; |
877 | for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) { |
878 | for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) { |
879 | Int_t dataBin = fNPoint[i]->FindBin(j, k); |
880 | Double_t v = fNPoint[i]->GetBinContent(dataBin); |
881 | if (v > max) max = (Int_t)v; |
882 | } |
883 | } |
884 | } |
885 | |
886 | char entriesDistName[100]; |
887 | |
888 | for(Int_t i=0; i<kDET; i++) { |
889 | |
890 | if (!map[i]) continue; |
891 | |
2a097c72 |
892 | snprintf(entriesDistName,100,"entriesDist_%d",i); |
48ccaa07 |
893 | fNPointDist[i] = new TH1D(entriesDistName, ";number of events", max+2, -0.5, max+1.5); |
894 | |
895 | for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) { |
896 | for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) { |
897 | Int_t dataBin = fNPoint[i]->FindBin(j, k); |
898 | Double_t v = fNPoint[i]->GetBinContent(dataBin); |
899 | //if (v > fnEvents) AliInfo(Form("N = %d V = %lf\n", fnEvents, v)); |
900 | fNPointDist[i]->Fill(v); |
901 | } |
902 | } |
903 | |
904 | fNPoint[i]->Scale(1./fnEvents); |
905 | } |
906 | |
907 | |
908 | for(Int_t i=0; i<kDET; i++) { |
909 | fnEntriesRM[i]->SetMaximum(fnEvents * 1.5); |
910 | } |
911 | |
912 | // save histograms |
913 | |
914 | //AliInfo(Form("FILENAME 2 = %s (%d)\n", fn, fn)); |
9e74dcc2 |
915 | TFile *file = new TFile(filename, "recreate"); |
48ccaa07 |
916 | for(Int_t det = 0; det < kDET; det++) { |
917 | if (!map[det]) continue; |
918 | fChPed[det]->Write(); |
919 | fChNoise[det]->Write(); |
920 | fNPoint[det]->Write(); |
921 | fNPointDist[det]->Write(); |
922 | fPed[det]->Write(); |
923 | fNoise[det]->Write(); |
924 | fSignal[det]->Write(); |
925 | fnEntriesRM[det]->Write(); |
926 | fChPP[det]->Write(); |
927 | |
928 | fChPedRes[det]->Write(); |
929 | fChNoiseRes[det]->Write(); |
930 | |
931 | // save error hists |
932 | fErrorLocMCM[det]->SetMinimum(0); |
933 | fErrorLocMCM[det]->SetMaximum(fnEvents); |
934 | fErrorLocMCM[det]->Write(); |
935 | |
936 | fErrorLocADC[det]->SetMinimum(0); |
937 | fErrorLocADC[det]->SetMaximum(fnEvents); |
938 | fErrorLocADC[det]->Write(); |
939 | } |
940 | |
941 | for(Int_t sm=0; sm<kSM; sm++) { |
942 | fSmNoiseRms[sm]->Write(); |
943 | fSmNoiseFit[sm]->Write(); |
944 | fSmPP[sm]->Write(); |
945 | } |
946 | |
947 | |
948 | |
949 | Int_t nMcm = 0; |
950 | for(Int_t i=0; i < kDET * kROB * kMCM; i++) { |
951 | if (fFullSignal[i] && fFullCounter[i] > fCount) { |
952 | fFullSignal[i]->Write(); |
953 | nMcm++; |
954 | } |
955 | } |
956 | |
957 | AliInfo(Form("Number of saved MCMs = %d\n", nMcm)); |
958 | |
959 | fMcmTracks->Write(); |
960 | AliInfo(Form("Number of tracks = %d\n", fMcmTracks->GetEntries())); |
961 | |
962 | // permanently problematic MCMs |
963 | for(Int_t det=0; det<kDET; det++) { |
964 | for(Int_t mcm=0; mcm<kROB*kMCM; mcm++) { |
965 | |
966 | Int_t mRob = mcm / kMCM; |
967 | Int_t mMcm = mcm % kMCM; |
968 | Int_t bin = fMapMCM->FindBin(det, mcm); |
969 | Double_t frac = 1. * fMapMCM->GetBinContent(bin) / fnEvents; |
970 | fFracMCM->Fill(frac); |
971 | |
972 | if (frac > 0.7) { |
973 | AliInfo(Form("{%d, %d, %d, %f}, \n", det, mRob, mMcm, frac)); |
974 | } |
975 | } |
976 | } |
977 | |
978 | |
979 | fOccupancy->Write(); |
980 | fDetRob->Write(); |
981 | fTBEvent->Write(); |
982 | |
983 | // error hists |
984 | fErrorHC->Write(); |
985 | fErrorMCM->Write(); |
986 | fErrorADC->Write(); |
987 | |
988 | fErrorSMHC->Write(); |
989 | fErrorSMMCM->Write(); |
990 | fErrorSMADC->Write(); |
991 | |
992 | // write graphs |
993 | fErrorGraphHC->Write("trendErrorHC"); |
994 | fErrorGraphMCM->Write("trendErrorMCM"); |
995 | fErrorGraphADC->Write("trendErrorADC"); |
996 | |
997 | fGraphMCM->Write("trendMCM"); |
998 | |
999 | for(Int_t i=0; i<3; i++) { |
1000 | fGraphPP[i]->Write(Form("fracPP_%d", i)); |
1001 | } |
1002 | |
1003 | //fZSsize->Scale(1./fnEvents); |
1004 | //fZSsize->Write(); |
1005 | |
1006 | fMapMCM->SetMaximum(fnEvents); |
1007 | fMapMCM->Write(); |
1008 | fFracMCM->Write(); |
1009 | |
1010 | fSMHCped->Write(); |
1011 | |
1012 | for(Int_t i=0; i<3; i++ ) { |
1013 | fSMLink[i]->Write(); |
1014 | fGrLink[i]->Write(); |
1015 | } |
1016 | |
1017 | for(Int_t sm=0; sm<kSM; sm++) |
1018 | fNumberADC[sm]->Write(Form("nADCinSM%d",sm)); |
1019 | |
1020 | fNumberADC[kSM]->Write("nADCinEvent"); |
1021 | |
1022 | fNoiseTotal->Write(); |
1023 | fPP->Write(); |
1024 | |
1025 | for(Int_t i=0; i<1000; i++) { |
1026 | if (fEvNoDist[i]->GetSum() > 0) fEvNoDist[i]->Write(); |
1027 | } |
1028 | |
1029 | |
1030 | file->Close(); |
1031 | delete file; |
1032 | } |
1033 | |
1034 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
1035 | |
2a097c72 |
1036 | Int_t AliTRDqaBlackEvents::CheckMCM(Int_t /*index*/) const { |
c87495af |
1037 | // |
1038 | // Checks a single MCM |
1039 | // |
1040 | |
48ccaa07 |
1041 | return 1; |
1042 | |
2a097c72 |
1043 | // static Int_t data[21][3] = { |
1044 | // {1, 0, 1}, |
1045 | // {242, 0, 0}, |
1046 | // {242, 0, 1}, |
1047 | // {242, 0, 2}, |
1048 | // {242, 0, 4}, |
1049 | // {242, 0, 5}, |
1050 | // {242, 0, 6}, |
1051 | // {242, 0, 8}, |
1052 | // {242, 0, 12}, |
1053 | // {251, 7, 7}, |
1054 | // {254, 3, 11}, |
1055 | // {259, 3, 14}, |
1056 | // {260, 1, 9}, |
1057 | // {260, 3, 15}, |
1058 | // {273, 1, 7}, |
1059 | // {273, 1, 15}, |
1060 | // {276, 5, 11}, |
1061 | // {280, 6, 2}, |
1062 | // {299, 6, 4}, |
1063 | // {511, 2, 9}, |
1064 | // {517, 7, 15} |
1065 | // }; |
48ccaa07 |
1066 | |
2a097c72 |
1067 | // for(Int_t i=0; i<21; i++) { |
1068 | // Int_t wIndex = data[i][0] * kROB*kMCM + data[i][1] * kMCM + data[i][2]; |
1069 | // if (index == wIndex) return 0; |
1070 | // } |
48ccaa07 |
1071 | |
1072 | return 1; |
1073 | } |
1074 | |
1075 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
1076 | |
1077 | |
1078 | |
1079 | |
1080 | |
1081 | |
1082 | |
1083 | void AliTRDqaBlackEvents::DrawChamber(const char *filename, Int_t det, Int_t w, Int_t h) |
1084 | { |
1085 | // |
1086 | // Draw raport for one chamber: |
1087 | // pedestal map, noise map, distribution of pedestal and noise |
1088 | // |
1089 | // input: |
1090 | // name of the file with histograms (created with Process()) |
1091 | // detector Id (0 - 539) |
1092 | // |
1093 | |
1094 | // setup global style |
1095 | gStyle->SetPalette(1); |
1096 | gStyle->SetOptStat(0); |
1097 | gStyle->SetPadTopMargin(0.02); |
1098 | gStyle->SetPadBottomMargin(0.05); |
1099 | |
1100 | TFile *file = new TFile(filename, "READ"); |
1101 | |
1102 | TCanvas *c = new TCanvas("blackEvents",Form("blackEvents %d",det), w, h); |
1103 | c->SetVertical(kFALSE); |
1104 | c->Divide(3,1, 0.01, 0.01); |
1105 | c->cd(3); |
1106 | |
1107 | TPad *mPad = (TPad*) gPad; |
1108 | mPad->Divide(1,2,0.01,0.01); |
1109 | |
1110 | c->cd(1); |
1111 | TH2D *h2 = (TH2D*)file->Get(Form("ped_%d",det)); |
1112 | h2->SetMinimum(5); |
1113 | h2->SetMaximum(15); |
1114 | h2->SetTitle(";Z direction;#phi direction"); |
1115 | h2->Draw("colz"); |
1116 | |
1117 | c->cd(2); |
1118 | h2 = (TH2D*)file->Get(Form("noise_%d",det)); |
1119 | h2->SetMinimum(fMinNoise); |
1120 | h2->SetMaximum(fMaxNoise); |
1121 | h2->SetTitle(";Z direction;#phi direction"); |
1122 | h2->Draw("colz"); |
1123 | |
1124 | mPad->cd(1); |
1125 | //gPad->SetLogy(); |
1126 | TH1D *h1 = (TH1D*)file->Get(Form("pedDist_%d", det)); |
1127 | h1->Draw(); |
1128 | |
1129 | mPad->cd(2); |
1130 | gPad->SetLogy(); |
1131 | h1 = (TH1D*)file->Get(Form("noiseDist_%d", det)); |
1132 | h1->Draw(); |
1133 | |
1134 | h1->Fit("gaus"); |
1135 | TF1 *f = h1->GetFunction("gaus"); |
1136 | const char *tt = Form("#mu = %.2f #sigma = %0.2f ", f->GetParameter(1),f->GetParameter(2)); |
1137 | TLatex *ll = new TLatex(2, 100, tt); |
1138 | ll->SetTextSize(0.06); |
1139 | ll->Draw(); |
1140 | } |
1141 | |
1142 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
1143 | |
1144 | void AliTRDqaBlackEvents::DrawSm(const char *filename, Int_t sm, Int_t w, Int_t h) |
1145 | { |
1146 | // |
1147 | // ???????????? |
1148 | // |
1149 | |
1150 | gStyle->SetPalette(1); |
1151 | gStyle->SetOptStat(0); |
1152 | |
1153 | gStyle->SetPadTopMargin(0.02); |
1154 | //gStyle->SetPadBottomMargin(0.05); |
1155 | //gStyle->SetPadLeftMargin(0.02); |
1156 | //gStyle->SetPadRightMargin(0.02); |
1157 | |
1158 | TFile *file = new TFile(filename, "READ"); |
1159 | |
1160 | TCanvas *c = new TCanvas("blackEventsSM",Form("blackEvents SM %d",sm), w, h); |
1161 | c->SetVertical(kFALSE); |
1162 | c->Divide(5, 6, 0.001, 0.01); |
1163 | |
1164 | for(Int_t i=0; i<30; i++) { |
1165 | |
1166 | TH2D *h2 = (TH2D*)file->Get(Form("noise_%d",i+30*sm)); |
1167 | if (!h2) continue; |
1168 | h2->SetMinimum(fMinNoise); |
1169 | h2->SetMaximum(fMaxNoise); |
1170 | |
1171 | // to be replaced by the official calculation |
1172 | Int_t stack = i/6; |
1173 | Int_t layer = i%6; |
1174 | Int_t index = (5-layer)*5 + stack + 1; |
1175 | //AliInfo(Form("%d %d %d %d\n", i, stack, layer, index)); |
1176 | c->cd(index); |
1177 | gPad->SetBottomMargin(0.02); |
1178 | gPad->SetTopMargin(0.02); |
1179 | |
1180 | h2->Draw("col"); |
1181 | } |
1182 | } |
1183 | |
1184 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
1185 | |
1186 | Int_t AliTRDqaBlackEvents::FillBits(TH1D *hist, Int_t code, Int_t offset) { |
c87495af |
1187 | // |
1188 | // Fill bits |
1189 | // |
48ccaa07 |
1190 | |
1191 | Int_t nb = 0; |
1192 | UInt_t test = 1; |
1193 | for(Int_t i=0; i<8; i++) { |
1194 | if (code & test) { |
1195 | hist->Fill(i+offset); |
1196 | nb++; |
1197 | } |
1198 | test *= 2; |
1199 | } |
1200 | |
1201 | return nb; |
1202 | } |
1203 | |
1204 | /////////////////////////////////////////////////////////////////////////////////////////////////// |