1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
16 /* $Id: AliTRDqaBlackEvents.cxx 23387 2008-01-17 17:25:16Z cblume $ */
18 ////////////////////////////////////////////////////////////////////////////
20 // QA of black events //
23 // Sylwester Radomski (radomski@physi.uni-heidelberg.de) //
25 ////////////////////////////////////////////////////////////////////////////
39 #include "AliRawReader.h"
41 #include "AliTRDrawStreamOld.h"
42 #include "AliTRDqaBlackEvents.h"
44 ClassImp(AliTRDqaBlackEvents)
46 ///////////////////////////////////////////////////////////////////////////////////////////////////
48 AliTRDqaBlackEvents::AliTRDqaBlackEvents()
84 // to create the histograms call Init()
87 strcpy(fRefFileName, "");
90 ///////////////////////////////////////////////////////////////////////////////////////////////////
92 AliTRDqaBlackEvents::AliTRDqaBlackEvents(const AliTRDqaBlackEvents &qa)
128 // to create the histograms call Init()
131 strcpy(fRefFileName, "");
134 ///////////////////////////////////////////////////////////////////////////////////////////////////
136 void AliTRDqaBlackEvents::Init()
139 // creates histograms
143 //Info("Init", "Statring");
147 // histograms for chambers
148 for(Int_t det=0; det<kDET; det++) {
150 fNPoint[det] = new TH2D(Form("entries_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
151 //fData[det] = new TH3F(Form("data_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5, 50, -0.5, 49.5);
153 // pedestal noise maps using RMS and Fit
154 fChPed[det] = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
155 fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
157 //fChPed[det] = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
158 //fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
160 // distribution per detector
161 fPed[det] = new TH1D(Form("pedDist_%d", det), ";pedestals (ADC counts)", 100, 5, 15);
162 fNoise[det] = new TH1D(Form("noiseDist_%d", det), ";noise (ADC counts)", 100, 0, 5);
163 fSignal[det] = new TH1D(Form("signal_%d", det), ";signal (ADC counts)", 100, -0.5, 99.5);
164 fChPP[det] = new TH1D(Form("pp_%d", det), ";pp (ADC)", 200, -0.5, 199.5);
166 fnEntriesRM[det] = new TH2D(Form("entriesRM_%d", det), ";ROB,MCM", 8, -0.5, 7.5, 16, -0.5, 15.5);
168 // histograms after reference subtraction
169 fChPedRes[det] = new TH2D(Form("pedRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
170 fChNoiseRes[det] = new TH2D(Form("noiseRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
174 fErrorLocMCM[det] = new TH2D(Form("errorLocMCM_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
175 fErrorLocADC[det] = new TH2D(Form("errorLocADC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
176 fErrorLocHC[det] = new TH2D(Form("errorLocHC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);
179 // histogram for each MCM
180 for(Int_t i=0; i < kDET * kROB * kMCM; i++)
183 // histograms from the whole detector
184 fOccupancy = new TH1D("occupancy", "", 20, -0.5, 19.5);
185 fDetRob = new TH2D("DetRob", ";detector;ROB", kDET, -0.5, 539.5, 8, -0.5, 7.5);
186 fTBEvent = new TH2D("tbEvent", ";event ID;time bin", 100, -0.5, 99.5, 30, -0.5, 29.5);
188 // errors statistics and location
189 fErrorHC = new TH1D("errorHC", ";error ID;", 18, -3.5, 14.5);
190 fErrorMCM = new TH1D("errorMCM", ";error ID;", 18, -3.5, 14.5);
191 fErrorADC = new TH1D("errorADC", ";error ID;", 18, -3.5, 14.5);
193 fErrorSMHC = new TH1D("errorSM_HC", ";SM id", 18, -0.5, 17.5);
194 fErrorSMMCM = new TH1D("errorSM_MCM", ";SM id", 18, -0.5, 17.5);
195 fErrorSMADC = new TH1D("errorSM_ADC", ";SM id", 18, -0.5, 17.5);
198 fErrorGraphHC = new TGraph();
199 fErrorGraphMCM = new TGraph();
200 fErrorGraphADC = new TGraph();
202 fGraphMCM = new TGraph();
204 for(Int_t i=0; i<3; i++) {
205 fGraphPP[i] = new TGraph();
209 fMapMCM = new TH2D("mapMCM", ";det;mcm", 540, -0.5, 539.5, kROB*kMCM, -0.5, kROB*kMCM-0.5);
210 fFracMCM = new TH1D("fracMCM", ";frequency", 100, 0, 1);
213 fErrorGraphHC->GetHistogram()->SetTitle("fraction of events with HC error;event number");
214 fErrorGraphMCM->GetHistogram()->SetTitle("fraction of events with MCM error;event number;");
215 fErrorGraphADC->GetHistogram()->SetTitle("fraction of events with ADC error;event number;");
218 fSMHCped = new TH2D("smHcPed", ";super module;half chamber", 18, -0.5, 17.5, 60, -0.5, 59.5);
221 const char *linkName[3] = {"smLink", "smBeaf", "smData"};
222 const char *linkGrName[3] = {"grSmLink", "grSmBeaf", "grSmData"};
223 for(Int_t i=0; i<3; i++) {
224 fSMLink[i] = new TH2D(linkName[i], ";super module;link", 18, -0.5, 17.5, 60, -0.5, 59.5);
225 fGrLink[i] = new TGraph();
226 fGrLink[i]->SetName(linkGrName[i]);
229 //fZSsize = new TH1D("zssizeSingle", ";threshold;nADC", 40, -0.5, 39.5);
232 //Info("Init", "Done");
234 // number of ADC channels fired per SM and in total
235 for(Int_t sm=0; sm<kSM+1; sm++)
236 fNumberADC[sm] = new TGraph();
239 fNoiseTotal = new TH1D("noiseTotal", "noise (ADC)", 250, 0, 10);
240 fPP = new TH1D("peakPeak", "p-p (ADC)", 200, -0.5, 199.5);
242 for(Int_t sm=0; sm<kSM; sm++) {
243 fSmNoiseRms[sm] = new TH1D(Form("noiseRms_sm%d", sm), ";noise from RMS (ADC)", 100, 0, 10);
244 fSmNoiseFit[sm] = new TH1D(Form("noiseFit_sm%d", sm), ";noise frim Fit (ADC)", 100, 0, 10);
245 fSmPP[sm] = new TH1D(Form("peakPeak_sm%d", sm), ";peak-peak (ADC)", 200, -0.5, 199.5);
248 // event number consistancy
249 for(Int_t i=0; i<1000; i++) {
250 fEvNoDist[i] = new TH1D(Form("mcmEvDist_%d", i), ";#Delta Events", 201, -100.5, 100.5);
254 fMcmTracks = new TObjArray();
257 for(Int_t det=0; det<kDET; det++)
258 for(Int_t row=0; row<kROW; row++)
259 for(Int_t pad=0; pad<kPAD; pad++)
260 for(Int_t ch=0; ch<kCH; ch++) {
261 fDataDirect[det][row][pad][ch] = 0;
262 fSignalDirect[det][ch] = 0; // overdone
267 ///////////////////////////////////////////////////////////////////////////////////////////////////
269 void AliTRDqaBlackEvents::Reset()
272 // Resets the histograms
275 for(Int_t i=0; i<kDET; i++) {
278 fChNoise[i]->Reset();
283 ///////////////////////////////////////////////////////////////////////////////////////////////////
285 void AliTRDqaBlackEvents::SetRefFile(const char *filename) {
287 strcpy(fRefFileName, filename);
290 ///////////////////////////////////////////////////////////////////////////////////////////////////
292 void AliTRDqaBlackEvents::ReadRefHists(Int_t det) {
294 // Read the reference histograms
301 if (fRefFileName) TFile::Open(fRefFileName);
304 fRefHistPed = (TH2D*)file->Get(Form("ped_%d",det));
305 fRefHistNoise = (TH2D*)file->Get(Form("noise_%d", det));
307 if (file) file->Close();
310 ///////////////////////////////////////////////////////////////////////////////////////////////////
312 void AliTRDqaBlackEvents::StartEvent()
318 // clear the mcm data
319 for(Int_t i=0; i < kDET * kROB * kMCM; i++) {
320 if (fFullSignal[i]) fFullSignal[i]->Reset();
324 for(Int_t i=0; i<2; i++) {
331 Int_t ppThresh[3] = {10, 20, 40};
332 for(Int_t i=0; i<3; i++) {
333 fppThresh[i] = ppThresh[i];
338 for(Int_t sm=0; sm<kSM+1; sm++) fnADCinSM[sm] = 0;
340 if (fRefEv > 0) fRefEv++;
341 fEvNoDist[999]->Reset(); // keep only the last event
345 ///////////////////////////////////////////////////////////////////////////////////////////////////
347 void AliTRDqaBlackEvents::AddBuffer(AliTRDrawStreamOld *data, AliRawReader * const reader)
350 //printf ("try to read data\n");
351 Int_t nextBuff = data->NextBuffer();
352 //printf("done ...\n");
354 if (nextBuff == 0) return;
356 Int_t sm = reader->GetEquipmentId() - 1024;
357 //printf("reading SM %d\n", sm);
358 AliInfo(Form("reading SM %d", sm));
360 if (sm < 0 || sm > 18) return;
362 // lopp over stacks, links ...
364 for (Int_t istack = 0; istack < 5; istack++) {
365 for (Int_t ilink = 0; ilink < 12; ilink++) {
367 //printf("HC = %d %d\n", istack, ilink);
369 Int_t det = sm * 30 + istack * 6 + ilink/2;
371 // check if data delivered
372 if (!(data->IsLinkActiveInStack(istack, ilink))) continue;
373 fSMLink[0]->Fill(sm, istack * 12 + ilink);
376 // check if beaf-beaf
377 if (data->GetLinkMonitorError(istack, ilink)) {
378 fSMLink[1]->Fill(sm, istack * 12 + ilink);
383 // fill histogram with HC header errors
387 nErrHc = FillBits(fErrorHC, data->GetH0ErrorCode(istack, ilink), 0);
388 if (!nErrHc) fErrorHC->Fill(-3);
391 nErrHc = FillBits(fErrorHC, data->GetH1ErrorCode(istack, ilink), 2);
392 if (!nErrHc) fErrorHC->Fill(-2);
395 nErrHc = FillBits(fErrorHC, data->GetHCErrorCode(istack, ilink), 4);
396 if (!nErrHc) fErrorHC->Fill(-1);
403 fErrorSMHC->Fill(sm);
406 // data integrity protection
408 //if (data->GetHCErrorCode(istack, ilink) > 0) continue;
409 if (data->GetH0ErrorCode(istack, ilink) > 0) continue;
410 if (data->GetH1ErrorCode(istack, ilink) > 0) continue;
412 fSMLink[2]->Fill(sm, istack * 12 + ilink);
416 for (Int_t imcm = 0; imcm < data->GetHCMCMmax(istack, ilink); imcm++ ){
418 //printf("mcm = %d %d %d\n", istack, ilink, imcm);
420 // fill MCM error code
423 Int_t nErrMcmTot = 0;
425 nErrMcm = FillBits(fErrorMCM, data->GetMCMhdErrorCode(istack, ilink, imcm), 0);
426 if (!nErrMcm) fErrorMCM->Fill(-3);
427 nErrMcmTot += nErrMcm;
429 nErrMcm = FillBits(fErrorMCM, data->GetMCMADCMaskErrorCode(istack, ilink, imcm), 5);
430 if (!nErrMcm) fErrorMCM->Fill(-2);
431 nErrMcmTot += nErrMcm;
433 nErrMcm = FillBits(fErrorMCM, data->GetMCMErrorCode(istack, ilink, imcm), 10);
434 if (!nErrMcm) fErrorMCM->Fill(-1);
435 nErrMcmTot += nErrMcm;
439 if (nErrMcmTot > 0) {
441 fErrorSMMCM->Fill(sm);
445 if ( (data->GetMCMhdErrorCode(istack,ilink,imcm)) & 2 ) continue;
446 //if ((data->GetMCMADCMaskErrorCode(istack,ilink,imcm))) continue;
447 //if ((data->GetMCMErrorCode(istack,ilink,imcm))) continue;
449 Int_t mcmEvent = data->GetEventNumber(istack, ilink, imcm);
451 // set the reference event number
454 printf("Reference Event Number = %d (%d %d %d)\n", fRefEv, istack, ilink, imcm);
457 // fill event distribution
458 if (!(fnEvents%10)) {
459 fEvNoDist[fnEvents/10]->Fill(mcmEvent - fRefEv);
462 fEvNoDist[999]->Fill(mcmEvent - fRefEv);
464 Int_t mcm = data->GetMCM(istack, ilink, imcm);
465 Int_t rob = data->GetROB(istack, ilink, imcm);
467 // create a structure for an MCM if needed
468 Int_t mcmIndex = det * (kMCM * kROB) + rob * kMCM + mcm;
469 if (fCreateFull && !fFullSignal[mcmIndex])
470 fFullSignal[mcmIndex] =
471 new TH2S(Form("mcm_%d_%d_%d_%d_%d", sm, istack, ilink/2, rob, mcm),
472 Form("mcm-%d-%d-%d-%d-%d;ADC;time bin", sm, istack, ilink/2, rob, mcm),
473 21, -0.5, 20.5, 30, -0.5, 29.5);
476 //Int_t zsADC[21][40];
478 for(Int_t ina=0; ina<21; ina++)
479 for(Int_t th=0; th<40; th++)
483 // first loop over ADC chanels
485 for (Int_t iadc=0; iadc < data->GetADCcount(istack, ilink, imcm); iadc++) {
487 //printf("ADC = %d\n", iadc);
490 // fill ADC error bits
491 Int_t nErrAdc = FillBits(fErrorADC, data->GetADCErrorCode(), 0);
492 if (!nErrAdc) fErrorADC->Fill(-1);
497 fErrorSMADC->Fill(sm);
501 if ((data->GetADCErrorCode(istack,ilink,imcm,iadc))) continue;
506 Int_t *sig = data->GetSignalDirect(istack, ilink, imcm, iadc);
508 //Int_t adc = data->GetADCnumber(istack, ilink, imcm, iadc);
509 Int_t row = data->GetRow(istack, ilink, imcm);
510 Int_t col = data->GetCol(istack, ilink, imcm, iadc);
512 // loop over Time Bins and fill histograms
513 for(Int_t k=0; k < data->GetNumberOfTimeBins(istack, ilink); k++) {
515 //fSignal[det]->Fill(sig[k]);
516 //fData[det]->Fill(row, col, sig[k]); // slow
519 fSignalDirect[det][sig[k]]++;
520 fDataDirect[det][row][col][sig[k]]++; // direct data
524 minV = (minV < sig[k]) ? minV : sig[k];
525 maxV = (maxV > sig[k]) ? maxV : sig[k];
527 // check for active MCMs
528 if (fCreateFull && fFullSignal[mcmIndex]) {
529 if (sig[k] > fThresh || sig[k] < 0) fFullCounter[mcmIndex]++;
530 //if (sm == 0 && istack == 0 && ilink/2 == 1 && rob == 1 && mcm == 15) fFullCounter[mcmIndex]++; // special
531 //fFullSignal[mcmIndex]->Fill(adc, k, sig[k]); // slow
534 // zero suppresion tests
536 for(Int_t th=0; th<40; th++) {
539 if (iadc > 0) zsADC[iadc-1][th] = 1;
540 if (iadc < 10) zsADC[iadc+1][th] = 1;
552 Int_t adcPP = maxV - minV;
553 //if (adcPP == 100) fFullCounter[mcmIndex] += 10;
556 fChPP[det]->Fill(adcPP);
557 fSmPP[sm]->Fill(adcPP);
559 for(Int_t i=0; i<3; i++) {
560 if ((adcPP) > fppThresh[i]) fnPP[i]++;
568 for(Int_t th=0; th<40; th++) {
570 for(Int_t ins=0; ins<21; ins++)
571 nnADC += zsADC[ins][th];
572 fZSsize->Fill(th, nnADC);
578 if (fCreateFull && fFullSignal[mcmIndex] && (fFullCounter[mcmIndex] > fCount)) {
580 for (Int_t iadc=0; iadc < data->GetADCcount(istack, ilink, imcm); iadc++) {
583 if ((data->GetADCErrorCode(istack,ilink,imcm,iadc))) continue;
585 //Int_t row = data->GetRow(istack, ilink, imcm);
586 //Int_t col = data->GetCol(istack, ilink, imcm, iadc);
587 Int_t adc = data->GetADCnumber(istack, ilink, imcm, iadc);
589 Int_t *sig = data->GetSignalDirect(istack, ilink, imcm, iadc);
591 // loop over Time Bins and fill histograms
592 for(Int_t k=0; k < data->GetNumberOfTimeBins(istack, ilink); k++) {
593 fFullSignal[mcmIndex]->Fill(adc, k, sig[k]); // slow
602 // printf("end of loops\n");
606 ///////////////////////////////////////////////////////////////////////////////////////////////////
608 void AliTRDqaBlackEvents::FinishEvent()
611 // Processing at the end of the current event
614 for(Int_t i=0; i<3; i++) {
615 fGraphPP[i]->SetPoint(fnEvents, fnEvents, fnPP[i]);
618 // trend of the number of links
619 for(Int_t i=0; i<3; i++) {
620 fGrLink[i]->SetPoint(fnEvents, fnEvents, fnLink[i]);
623 // save interesting histos
624 Int_t mcmTrackCandidate = 0;
625 for(Int_t i = 0; i < kDET * kROB * kMCM; i++) {
626 if ((fFullCounter[i] > fCount) && fFullSignal[i] && CheckMCM(i) ) {
628 fMcmTracks->AddLast(fFullSignal[i]->Clone(Form("event_%d_%s", fnEvents, fFullSignal[i]->GetName())));
631 Int_t mcmTrackletDet = i/(kROB * kMCM);
632 Int_t mcmTrackletMcm = i%(kROB * kMCM);
633 fMapMCM->Fill(mcmTrackletDet, mcmTrackletMcm);
637 fGraphMCM->SetPoint(fnEvents, fnEvents, mcmTrackCandidate);
638 AliInfo(Form("Number of MCM track candidates = %d\n", mcmTrackCandidate));
641 // update fraction of error graphs
644 err = (fnErrorHC[0] > 0)? 100.*fnErrorHC[1]/fnErrorHC[0] : -1;
645 fErrorGraphHC->SetPoint(fnEvents, fnEvents, err);
647 err = (fnErrorMCM[0] > 0)? 100.*fnErrorMCM[1]/fnErrorMCM[0] : -1;
648 fErrorGraphMCM->SetPoint(fnEvents, fnEvents, err);
650 err = (fnErrorADC[0] > 0)? 100.*fnErrorADC[1]/fnErrorADC[0] : -1;
651 fErrorGraphADC->SetPoint(fnEvents, fnEvents, err);
653 // number of fired ADC per SM
654 for(Int_t sm=0; sm<kSM+1; sm++)
655 fNumberADC[sm]->SetPoint(fnEvents, fnEvents, fnADCinSM[sm]);
660 ///////////////////////////////////////////////////////////////////////////////////////////////////
662 void AliTRDqaBlackEvents::Process(const char *filename)
669 strcpy(fn, filename);
671 //AliInfo(Form("FILENAME = %s (%s)\n", filename, fn));
675 TH1D *hist = new TH1D("fitSignal", "", 50, -0.5, 49.5);
676 TF1 *fit = new TF1("fit", "gaus(0)", 0, 20);
677 fit->SetParameters(1e3, 10, 1);
679 for(Int_t det=0; det<kDET; det++) {
681 //AliInfo(Form("processing chamber %d\n", det));
684 //if (fData[det]->GetSum() < 10) continue;
685 //if (fDataDirect[det][10][10][10] < 20) continue;
689 // rewrite signal-direct
690 for(Int_t ch=0; ch<kCH; ch++) {
691 fSignal[det]->Fill(ch, fSignalDirect[det][ch]);
694 // read reference distributions
697 //for(Int_t row=0; row<fData[det]->GetXaxis()->GetNbins(); row++) {
698 //for(Int_t pad=0; pad<fData[det]->GetYaxis()->GetNbins(); pad++) {
700 for(Int_t row=0; row<kROW; row++) {
701 for(Int_t pad=0; pad<kPAD; pad++) {
703 // project the histogramm
705 //for(Int_t bb=0; bb<50; bb++) {
706 for(Int_t bb=0; bb<kCH; bb++) {
707 //Int_t dataBin = fData[det]->FindBin(row, pad, bb);
708 //Double_t v = fData[det]->GetBinContent(dataBin);
709 hist->SetBinContent(bb+1, fDataDirect[det][row][pad][bb]);
712 Int_t bin = fChPed[det]->FindBin(row, pad);
714 if (hist->GetSum() > 1) {
717 Double_t ped = 0, noise = 0;
720 fit->SetParameters(1e3, 10, 1);
721 hist->Fit(fit, "q0", "goff", 0, 20);
722 TF1 *f = hist->GetFunction("fit");
723 ped = TMath::Abs(f->GetParameter(1));
724 noise = TMath::Abs(f->GetParameter(2));
725 fSmNoiseFit[det/30]->Fill(noise);
727 ped = hist->GetMean();
728 noise = hist->GetRMS();
729 fSmNoiseRms[det/30]->Fill(noise);
731 // AliInfo(Form("data %f %f %f\n", hist->GetSum(), ped, noise));
734 fChPed[det]->SetBinContent(bin, ped);
735 fChNoise[det]->SetBinContent(bin, noise);
736 fNoiseTotal->Fill(noise);
738 // subtract reference values
740 Double_t refnoise = 0;
742 if (fRefHistPed) refped = fRefHistPed->GetBinContent(bin);
743 if (fRefHistNoise) refnoise = fRefHistPed->GetBinContent(bin);
745 fChPedRes[det]->SetBinContent(bin, ped-refped);
746 fChNoiseRes[det]->SetBinContent(bin, noise-refnoise);
748 fPed[det]->Fill(ped);
749 fNoise[det]->Fill(noise);
753 Int_t hc = (pad < kPAD/2) ? 2* (det % 30) : 2* (det % 30) + 1;
754 if (ped > 9. && ped < 11) fSMHCped->Fill(sm, hc, 1./1152.); // number of pads in HC
758 // not enought data found
759 fChPed[det]->SetBinContent(bin, 0);
760 fChNoise[det]->SetBinContent(bin, 0);
761 fChPedRes[det]->SetBinContent(bin, 0);
762 fChNoiseRes[det]->SetBinContent(bin, 0);
771 //AliInfo(Form("Number of events = %d\n", fnEvents));
773 // normalize number of entries histos
775 for(Int_t i=0; i<kDET; i++) {
776 if (!map[i]) continue;
777 for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) {
778 for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) {
779 Int_t dataBin = fNPoint[i]->FindBin(j, k);
780 Double_t v = fNPoint[i]->GetBinContent(dataBin);
781 if (v > max) max = (Int_t)v;
786 char entriesDistName[100];
788 for(Int_t i=0; i<kDET; i++) {
790 if (!map[i]) continue;
792 sprintf(entriesDistName, "entriesDist_%d", i);
793 fNPointDist[i] = new TH1D(entriesDistName, ";number of events", max+2, -0.5, max+1.5);
795 for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) {
796 for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) {
797 Int_t dataBin = fNPoint[i]->FindBin(j, k);
798 Double_t v = fNPoint[i]->GetBinContent(dataBin);
799 //if (v > fnEvents) AliInfo(Form("N = %d V = %lf\n", fnEvents, v));
800 fNPointDist[i]->Fill(v);
804 fNPoint[i]->Scale(1./fnEvents);
808 for(Int_t i=0; i<kDET; i++) {
809 fnEntriesRM[i]->SetMaximum(fnEvents * 1.5);
814 //AliInfo(Form("FILENAME 2 = %s (%d)\n", fn, fn));
815 TFile *file = new TFile(fn, "recreate");
816 for(Int_t det = 0; det < kDET; det++) {
817 if (!map[det]) continue;
818 fChPed[det]->Write();
819 fChNoise[det]->Write();
820 fNPoint[det]->Write();
821 fNPointDist[det]->Write();
823 fNoise[det]->Write();
824 fSignal[det]->Write();
825 fnEntriesRM[det]->Write();
828 fChPedRes[det]->Write();
829 fChNoiseRes[det]->Write();
832 fErrorLocMCM[det]->SetMinimum(0);
833 fErrorLocMCM[det]->SetMaximum(fnEvents);
834 fErrorLocMCM[det]->Write();
836 fErrorLocADC[det]->SetMinimum(0);
837 fErrorLocADC[det]->SetMaximum(fnEvents);
838 fErrorLocADC[det]->Write();
841 for(Int_t sm=0; sm<kSM; sm++) {
842 fSmNoiseRms[sm]->Write();
843 fSmNoiseFit[sm]->Write();
850 for(Int_t i=0; i < kDET * kROB * kMCM; i++) {
851 if (fFullSignal[i] && fFullCounter[i] > fCount) {
852 fFullSignal[i]->Write();
857 AliInfo(Form("Number of saved MCMs = %d\n", nMcm));
860 AliInfo(Form("Number of tracks = %d\n", fMcmTracks->GetEntries()));
862 // permanently problematic MCMs
863 for(Int_t det=0; det<kDET; det++) {
864 for(Int_t mcm=0; mcm<kROB*kMCM; mcm++) {
866 Int_t mRob = mcm / kMCM;
867 Int_t mMcm = mcm % kMCM;
868 Int_t bin = fMapMCM->FindBin(det, mcm);
869 Double_t frac = 1. * fMapMCM->GetBinContent(bin) / fnEvents;
870 fFracMCM->Fill(frac);
873 AliInfo(Form("{%d, %d, %d, %f}, \n", det, mRob, mMcm, frac));
889 fErrorSMMCM->Write();
890 fErrorSMADC->Write();
893 fErrorGraphHC->Write("trendErrorHC");
894 fErrorGraphMCM->Write("trendErrorMCM");
895 fErrorGraphADC->Write("trendErrorADC");
897 fGraphMCM->Write("trendMCM");
899 for(Int_t i=0; i<3; i++) {
900 fGraphPP[i]->Write(Form("fracPP_%d", i));
903 //fZSsize->Scale(1./fnEvents);
906 fMapMCM->SetMaximum(fnEvents);
912 for(Int_t i=0; i<3; i++ ) {
917 for(Int_t sm=0; sm<kSM; sm++)
918 fNumberADC[sm]->Write(Form("nADCinSM%d",sm));
920 fNumberADC[kSM]->Write("nADCinEvent");
922 fNoiseTotal->Write();
925 for(Int_t i=0; i<1000; i++) {
926 if (fEvNoDist[i]->GetSum() > 0) fEvNoDist[i]->Write();
934 ///////////////////////////////////////////////////////////////////////////////////////////////////
936 Int_t AliTRDqaBlackEvents::CheckMCM(Int_t index) const {
938 // Checks a single MCM
943 static Int_t data[21][3] = {
967 for(Int_t i=0; i<21; i++) {
968 Int_t wIndex = data[i][0] * kROB*kMCM + data[i][1] * kMCM + data[i][2];
969 if (index == wIndex) return 0;
975 ///////////////////////////////////////////////////////////////////////////////////////////////////
983 void AliTRDqaBlackEvents::DrawChamber(const char *filename, Int_t det, Int_t w, Int_t h)
986 // Draw raport for one chamber:
987 // pedestal map, noise map, distribution of pedestal and noise
990 // name of the file with histograms (created with Process())
991 // detector Id (0 - 539)
994 // setup global style
995 gStyle->SetPalette(1);
996 gStyle->SetOptStat(0);
997 gStyle->SetPadTopMargin(0.02);
998 gStyle->SetPadBottomMargin(0.05);
1000 TFile *file = new TFile(filename, "READ");
1002 TCanvas *c = new TCanvas("blackEvents",Form("blackEvents %d",det), w, h);
1003 c->SetVertical(kFALSE);
1004 c->Divide(3,1, 0.01, 0.01);
1007 TPad *mPad = (TPad*) gPad;
1008 mPad->Divide(1,2,0.01,0.01);
1011 TH2D *h2 = (TH2D*)file->Get(Form("ped_%d",det));
1014 h2->SetTitle(";Z direction;#phi direction");
1018 h2 = (TH2D*)file->Get(Form("noise_%d",det));
1019 h2->SetMinimum(fMinNoise);
1020 h2->SetMaximum(fMaxNoise);
1021 h2->SetTitle(";Z direction;#phi direction");
1026 TH1D *h1 = (TH1D*)file->Get(Form("pedDist_%d", det));
1031 h1 = (TH1D*)file->Get(Form("noiseDist_%d", det));
1035 TF1 *f = h1->GetFunction("gaus");
1036 const char *tt = Form("#mu = %.2f #sigma = %0.2f ", f->GetParameter(1),f->GetParameter(2));
1037 TLatex *ll = new TLatex(2, 100, tt);
1038 ll->SetTextSize(0.06);
1042 ///////////////////////////////////////////////////////////////////////////////////////////////////
1044 void AliTRDqaBlackEvents::DrawSm(const char *filename, Int_t sm, Int_t w, Int_t h)
1050 gStyle->SetPalette(1);
1051 gStyle->SetOptStat(0);
1053 gStyle->SetPadTopMargin(0.02);
1054 //gStyle->SetPadBottomMargin(0.05);
1055 //gStyle->SetPadLeftMargin(0.02);
1056 //gStyle->SetPadRightMargin(0.02);
1058 TFile *file = new TFile(filename, "READ");
1060 TCanvas *c = new TCanvas("blackEventsSM",Form("blackEvents SM %d",sm), w, h);
1061 c->SetVertical(kFALSE);
1062 c->Divide(5, 6, 0.001, 0.01);
1064 for(Int_t i=0; i<30; i++) {
1066 TH2D *h2 = (TH2D*)file->Get(Form("noise_%d",i+30*sm));
1068 h2->SetMinimum(fMinNoise);
1069 h2->SetMaximum(fMaxNoise);
1071 // to be replaced by the official calculation
1074 Int_t index = (5-layer)*5 + stack + 1;
1075 //AliInfo(Form("%d %d %d %d\n", i, stack, layer, index));
1077 gPad->SetBottomMargin(0.02);
1078 gPad->SetTopMargin(0.02);
1084 ///////////////////////////////////////////////////////////////////////////////////////////////////
1086 Int_t AliTRDqaBlackEvents::FillBits(TH1D *hist, Int_t code, Int_t offset) {
1093 for(Int_t i=0; i<8; i++) {
1095 hist->Fill(i+offset);
1104 ///////////////////////////////////////////////////////////////////////////////////////////////////