TRD/AliTRDqaBlackEvents.cxx

   1 /**************************************************************************\r
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
   3  *                                                                        *\r
   4  * Author: The ALICE Off-line Project.                                    *\r
   5  * Contributors are mentioned in the code where appropriate.              *\r
   6  *                                                                        *\r
   7  * Permission to use, copy, modify and distribute this software and its   *\r
   8  * documentation strictly for non-commercial purposes is hereby granted   *\r
   9  * withount fee, provided that the abov copyright notice appears in all   *\r
  10  * copies and that both the copyright notice and this permission notice   *\r
  11  * appear in the supporting documentation. The authors make no claims     *\r
  12  * about the suitability of this software for any purpose. It is          *\r
  13  * provided "as is without express or implied warranty.                  *\r
  14  **************************************************************************/\r
  15 \r
  16 /* $Id: AliTRDqaBlackEvents.cxx 23387 2008-01-17 17:25:16Z cblume $ */\r
  17 \r
  18 ////////////////////////////////////////////////////////////////////////////\r
  19 //                                                                        //\r
  20 //  QA of black events                                                    //\r
  21 //                                                                        //\r
  22 //  Author:                                                               //\r
  23 //    Sylwester Radomski (radomski@physi.uni-heidelberg.de)               //\r
  24 //                                                                        //\r
  25 ////////////////////////////////////////////////////////////////////////////\r
  26 \r
  27 #include "TH1D.h"\r
  28 #include "TH2D.h"\r
  29 #include "TH2S.h"\r
  30 #include "TH3F.h"\r
  31 #include "TF1.h"\r
  32 #include "TFile.h"\r
  33 #include "TCanvas.h"\r
  34 #include "TPad.h"\r
  35 #include "TLatex.h"\r
  36 #include "TStyle.h"\r
  37 #include "TGraph.h"\r
  38 \r
  39 #include "AliTRDgeometry.h"\r
  40 #include "AliTRDrawStreamTB.h"\r
  41 #include "AliTRDqaBlackEvents.h"\r
  42 \r
  43 ClassImp(AliTRDqaBlackEvents)\r
  44 \r
  45 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
  46 \r
  47 AliTRDqaBlackEvents::AliTRDqaBlackEvents() \r
  48   :TObject() \r
  49   ,fnEvents(0)\r
  50   ,fCreateFull(0)\r
  51   ,fThresh(0)\r
  52   ,fCount(0)\r
  53   ,fOccupancy(0)\r
  54   ,fDetRob(0)\r
  55   ,fTBEvent(0)\r
  56   ,fRefHistPed(0)\r
  57   ,fRefHistNoise(0)\r
  58   ,fErrorHC(0)\r
  59   ,fErrorMCM(0)\r
  60   ,fErrorADC(0)\r
  61   ,fErrorSMHC(0)\r
  62   ,fErrorSMMCM(0)\r
  63   ,fErrorSMADC(0)\r
  64   ,fErrorGraphHC(0)\r
  65   ,fErrorGraphMCM(0)\r
  66   ,fErrorGraphADC(0)\r
  67   ,fGraphMCM(0)\r
  68   ,fMcmTracks(0)\r
  69   ,fMapMCM(0)\r
  70   ,fFracMCM(0)\r
  71   ,fSMHCped(0)\r
  72   ,fSMHCerr(0)\r
  73   ,fNoiseTotal(0)\r
  74   ,fPP(0)\r
  75   ,fMinNoise(0.5)\r
  76   ,fMaxNoise(2)\r
  77   ,fFitType(0) \r
  78   //  ,fRefFileName("")\r
  79 {\r
  80   //\r
  81   // Constructor \r
  82   // to create the histograms call Init()\r
  83   //\r
  84 \r
  85   strcpy(fRefFileName, "");\r
  86 }\r
  87 \r
  88 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
  89 \r
  90 AliTRDqaBlackEvents::AliTRDqaBlackEvents(const AliTRDqaBlackEvents &qa) \r
  91   :TObject(qa) \r
  92   ,fnEvents(0)\r
  93   ,fCreateFull(0)\r
  94   ,fThresh(0)\r
  95   ,fCount(0)\r
  96   ,fOccupancy(0)\r
  97   ,fDetRob(0)\r
  98   ,fTBEvent(0)\r
  99   ,fRefHistNoise(0)\r
 100   ,fErrorHC(0)\r
 101   ,fErrorMCM(0)\r
 102   ,fErrorADC(0)\r
 103   ,fErrorSMHC(0)\r
 104   ,fErrorSMMCM(0)\r
 105   ,fErrorSMADC(0)\r
 106   ,fErrorGraphHC(0)\r
 107   ,fErrorGraphMCM(0)\r
 108   ,fErrorGraphADC(0)\r
 109   ,fGraphMCM(0)\r
 110   ,fMcmTracks(0)\r
 111   ,fMapMCM(0)\r
 112   ,fFracMCM(0)\r
 113   ,fSMHCped(0)\r
 114   ,fSMHCerr(0)\r
 115   ,fNoiseTotal(0)\r
 116   ,fPP(0)\r
 117   ,fMinNoise(0.5)\r
 118   ,fMaxNoise(2) \r
 119   ,fFitType(0)\r
 120    //,fRefFileName("")\r
 121 {\r
 122   //\r
 123   // Copy constructor \r
 124   // to create the histograms call Init()\r
 125   //\r
 126   \r
 127   strcpy(fRefFileName, "");\r
 128 }\r
 129 \r
 130 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 131 \r
 132 void AliTRDqaBlackEvents::Init() \r
 133 {\r
 134   //\r
 135   // creates histograms \r
 136   // \r
 137 \r
 138   //TFile *file = new \r
 139   //Info("Init", "Statring");\r
 140 \r
 141   fnEvents = 0;\r
 142 \r
 143   // histograms for chambers\r
 144   for(Int_t det=0; det<kDET; det++) {\r
 145 \r
 146     fNPoint[det]  = new TH2D(Form("entries_%d", det), "",  16, -0.5, 15.5, 144, -0.5, 143.5);\r
 147     fData[det]    = new TH3F(Form("data_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5, 50, -0.5, 49.5);\r
 148 \r
 149     // pedestal noise maps using RMS and Fit\r
 150     fChPed[det]   = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 151     fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 152     \r
 153     //fChPed[det]   = new TH2D(Form("ped_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 154     //fChNoise[det] = new TH2D(Form("noise_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);    \r
 155 \r
 156     // distribution per detector\r
 157     fPed[det]     = new TH1D(Form("pedDist_%d", det), ";pedestals (ADC counts)", 100, 5, 15);\r
 158     fNoise[det]   = new TH1D(Form("noiseDist_%d", det), ";noise (ADC counts)", 100, 0, 5); \r
 159     fSignal[det]  = new TH1D(Form("signal_%d", det), ";signal (ADC counts)", 100, -0.5, 99.5);\r
 160     fChPP[det]    = new TH1D(Form("pp_%d", det), ";pp (ADC)", 200, -0.5, 199.5);\r
 161 \r
 162     fnEntriesRM[det] = new TH2D(Form("entriesRM_%d", det), ";ROB,MCM", 8, -0.5, 7.5, 16, -0.5, 15.5);\r
 163     \r
 164     // histograms after reference subtraction\r
 165     fChPedRes[det]    = new TH2D(Form("pedRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 166     fChNoiseRes[det]  = new TH2D(Form("noiseRef_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 167 \r
 168 \r
 169     // error codes\r
 170     fErrorLocMCM[det] = new TH2D(Form("errorLocMCM_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 171     fErrorLocADC[det] = new TH2D(Form("errorLocADC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);    \r
 172     fErrorLocHC[det]  = new TH2D(Form("errorLocHC_%d", det), "", 16, -0.5, 15.5, 144, -0.5, 143.5);\r
 173   }\r
 174 \r
 175   // histogram for each MCM\r
 176   for(Int_t i=0; i < kDET * kROB * kMCM; i++)\r
 177     fFullCounter[i] = 0;\r
 178 \r
 179   // histograms from the whole detector\r
 180   fOccupancy = new TH1D("occupancy", "", 20, -0.5, 19.5);\r
 181   fDetRob    = new TH2D("DetRob", ";detector;ROB", kDET, -0.5, 539.5, 8, -0.5, 7.5);\r
 182   fTBEvent   = new TH2D("tbEvent", ";event ID;time bin", 100, -0.5, 99.5, 30, -0.5, 29.5);\r
 183 \r
 184   // errors statistics and location\r
 185   fErrorHC  = new TH1D("errorHC", ";error ID;", 7, -0.5, 6.5);\r
 186   fErrorMCM = new TH1D("errorMCM", ";error ID;", 7, -0.5, 6.5);\r
 187   fErrorADC = new TH1D("errorADC", ";error ID;", 7, -0.5, 6.5);\r
 188   \r
 189   fErrorSMHC  = new TH1D("errorSM_HC", ";SM id", 18, -0.5, 17.5);\r
 190   fErrorSMMCM = new TH1D("errorSM_MCM", ";SM id", 18, -0.5, 17.5);\r
 191   fErrorSMADC = new TH1D("errorSM_ADC", ";SM id", 18, -0.5, 17.5);\r
 192 \r
 193 \r
 194   fErrorGraphHC  = new TGraph();\r
 195   fErrorGraphMCM = new TGraph();\r
 196   fErrorGraphADC = new TGraph();\r
 197 \r
 198   fGraphMCM = new TGraph();\r
 199   \r
 200   fMapMCM = new TH2D("mapMCM", ";det;mcm", 540, -0.5, 539.5, kROB*kMCM, -0.5, kROB*kMCM-0.5);\r
 201   fFracMCM = new TH1D("fracMCM", ";frequency", 100, 0, 1);\r
 202   \r
 203 \r
 204   fErrorGraphHC->GetHistogram()->SetTitle("Error HC;event number;fraction with error (%)");\r
 205   fErrorGraphMCM->GetHistogram()->SetTitle("Error MCM;event number;fraction with error (%)");\r
 206   fErrorGraphADC->GetHistogram()->SetTitle("Error ADC;event number;fraction with error (%)"); \r
 207 \r
 208 \r
 209   fSMHCped = new TH2D("smHcPed", ";super module;half chamber", 18, -0.5, 17.5, 60, -0.5, 59.5);\r
 210   //fSMHCerr = 0;\r
 211 \r
 212   //Info("Init", "Done");\r
 213 \r
 214   // number of ADC channels fired per SM and in total\r
 215   for(Int_t sm=0; sm<kSM+1; sm++)\r
 216     fNumberADC[sm] = new TGraph();\r
 217 \r
 218   //\r
 219   fNoiseTotal = new TH1D("noiseTotal", "noise (ADC)", 250, 0, 10);\r
 220   fPP = new TH1D("peakPeak", "p-p (ADC)", 200, -0.5, 199.5);\r
 221 \r
 222   for(Int_t sm=0; sm<kSM; sm++) {\r
 223     fSmNoiseRms[sm] = new TH1D(Form("noiseRms_sm%d", sm), ";noise from RMS (ADC)", 100, 0, 10);\r
 224     fSmNoiseFit[sm] = new TH1D(Form("noiseFit_sm%d", sm), ";noise frim Fit (ADC)", 100, 0, 10);\r
 225     fSmPP[sm] = new TH1D(Form("peakPeak_sm%d", sm), ";peak-peak (ADC)", 200, -0.5, 199.5); \r
 226   }\r
 227 \r
 228   fMcmTracks = new TObjArray();\r
 229 }\r
 230 \r
 231 \r
 232 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 233 \r
 234 void AliTRDqaBlackEvents::Reset() \r
 235 {\r
 236   //\r
 237   // Resets the histograms\r
 238   //\r
 239 \r
 240   for(Int_t i=0; i<kDET; i++) {\r
 241     fData[i]->Reset();\r
 242     fChPed[i]->Reset();\r
 243     fChNoise[i]->Reset();\r
 244   }\r
 245 }\r
 246 \r
 247 \r
 248 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 249 \r
 250 void AliTRDqaBlackEvents::SetRefFile(const char *filename) {\r
 251   \r
 252   strcpy(fRefFileName, filename);\r
 253 }\r
 254 \r
 255 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 256 \r
 257 void AliTRDqaBlackEvents::ReadRefHists(Int_t det) {\r
 258   \r
 259   fRefHistPed = 0;\r
 260   fRefHistNoise = 0;\r
 261   \r
 262   TFile *file = 0;\r
 263   if (fRefFileName) TFile::Open(fRefFileName);\r
 264   if (!file) return;\r
 265 \r
 266   fRefHistPed   = (TH2D*)file->Get(Form("ped_%d",det));\r
 267   fRefHistNoise = (TH2D*)file->Get(Form("noise_%d", det));\r
 268 \r
 269   if (file) file->Close();\r
 270 }\r
 271 \r
 272 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 273 \r
 274 Int_t AliTRDqaBlackEvents::AddEvent(AliTRDrawStreamTB *data) \r
 275 {\r
 276   //\r
 277   // Add an event\r
 278   //\r
 279 \r
 280   // structure to keep track if particular chanel is used\r
 281   Char_t isUsed[kDET][kCOL][kPAD]; \r
 282   for(Int_t i=0; i<kDET; i++)\r
 283     for(Int_t j=0; j<kCOL; j++)\r
 284       for(Int_t k=0; k<kPAD; k++)\r
 285         isUsed[i][j][k] = 0;\r
 286   \r
 287 \r
 288   // clear the mcm data\r
 289   for(Int_t i=0; i < kDET * kROB * kMCM; i++) {\r
 290     if (fFullSignal[i]) fFullSignal[i]->Reset();\r
 291     fFullCounter[i] = 0;\r
 292   }\r
 293 \r
 294   Int_t nb = 0;\r
 295   \r
 296   Int_t lastdet  = -1;\r
 297   Int_t lastside = -1;\r
 298   Int_t lastmcm  = -1;\r
 299 \r
 300   Int_t rob_last  = -1;\r
 301   Int_t mcm_last  = -1;\r
 302 \r
 303   Int_t nGoodHC  = 0;\r
 304   Int_t nGoodMCM = 0;\r
 305   Int_t nGoodADC = 0;\r
 306 \r
 307   Int_t nErrorHC  = 0;\r
 308   Int_t nErrorMCM = 0;\r
 309   Int_t nErrorADC = 0;\r
 310   \r
 311 \r
 312   //Int_t adc_last  = -1;\r
 313   // Int_t sm_01  = -1;\r
 314   \r
 315   // number of ADCs per SM\r
 316   Int_t nADCinSM[kSM+1];\r
 317   for(Int_t sm=0; sm<kSM+1; sm++) nADCinSM[sm] = 0;\r
 318 \r
 319 \r
 320 \r
 321   while (data->Next()) {\r
 322 \r
 323     Int_t sm  = data->GetSM();\r
 324     Int_t layer = data->GetLayer();\r
 325     Int_t stack = data->GetStack();\r
 326 \r
 327     Int_t det = data->GetDet();\r
 328     Int_t side = data->GetSide();\r
 329 \r
 330     Int_t row = data->GetRow();\r
 331     Int_t col = data->GetCol();\r
 332 \r
 333     Int_t rob = data->GetROB();\r
 334     Int_t mcm = data->GetMCM();\r
 335     Int_t adc = data->GetADC();\r
 336 \r
 337  \r
 338     Int_t *sig = data->GetSignals();\r
 339     nb++;\r
 340 \r
 341     nADCinSM[sm]++;\r
 342     nADCinSM[kSM]++;\r
 343     \r
 344     // memory coruption protection\r
 345     if (det<0 || det>=kDET) continue;\r
 346     \r
 347     // check errors\r
 348    \r
 349     // tests\r
 350     //fErrorHC->Fill(data->GetHCErrorCode());\r
 351     if (data->GetMCMErrorCode() > 0) fErrorLocMCM[det]->Fill(row, col);\r
 352     if (data->GetADCErrorCode() > 0) fErrorLocADC[det]->Fill(row, col);    \r
 353 \r
 354     // new HC found\r
 355     if ((det + side*kDET) != (lastdet + lastside*kDET)) {\r
 356       Int_t code = data->GetHCErrorCode();\r
 357       // if (code) { \r
 358       fErrorHC->Fill(code);\r
 359       \r
 360       if (code) fErrorSMHC->Fill(sm);\r
 361       if (code) nErrorHC++;\r
 362       nGoodHC++;\r
 363 \r
 364       //Int_t mask = 1;\r
 365       //for(Int_t cc = 0; cc < 3; cc++) {\r
 366       //  if (code & mask) fErrorHC->Fill(cc);\r
 367       //  cc *= 2;\r
 368       //        }\r
 369       //}\r
 370     }\r
 371     lastdet  = det;\r
 372     lastside = side;\r
 373     \r
 374     // new MCM found  \r
 375     if (mcm != lastmcm){\r
 376       Int_t code = data->GetMCMErrorCode();\r
 377       fErrorMCM->Fill(code);\r
 378 \r
 379       if (code) fErrorSMMCM->Fill(sm);\r
 380       if (code) nErrorMCM++;\r
 381       nGoodMCM++;\r
 382     }\r
 383     lastmcm = mcm;\r
 384     \r
 385     // new ADC channel found\r
 386     Int_t code = data->GetADCErrorCode();\r
 387     fErrorADC->Fill(code);\r
 388     if (code) fErrorSMADC->Fill(sm);\r
 389     if (code) nErrorADC++;\r
 390     nGoodADC++;\r
 391 \r
 392     // end of error checking\r
 393     \r
 394     // check the ROBs\r
 395     fDetRob->Fill(det, rob, 1./(kMCM*18));\r
 396     isUsed[det][row][col]++;\r
 397 \r
 398     // check if mcm signal is continuus\r
 399     if ((rob_last != rob) || (mcm_last != mcm)) {\r
 400       rob_last = rob;\r
 401       mcm_last = mcm;\r
 402       fnEntriesRM[det]->Fill(rob,mcm);\r
 403     }\r
 404     \r
 405     // number of entries for each channels\r
 406     fNPoint[det]->Fill(row, col);\r
 407     \r
 408 \r
 409     // create a structure for an MCM if needed\r
 410     Int_t mcmIndex = det * (kMCM * kROB) + rob * kMCM + mcm;\r
 411     if (fCreateFull && !fFullSignal[mcmIndex])\r
 412       fFullSignal[mcmIndex] = new TH2S(Form("mcm_%d_%d_%d_%d_%d", sm, stack, layer, rob, mcm), \r
 413                                        Form("mcm-%d-%d-%d-%d-%d;ADC;time bin", sm, stack, layer, rob, mcm),\r
 414                                        21, -0.5, 20.5, 30, -0.5, 29.5);\r
 415     \r
 416 \r
 417     // loop over Time Bins and fill histograms\r
 418     Int_t minV = 1024;\r
 419     Int_t maxV = 0;\r
 420 \r
 421     for(Int_t k=0; k<kTB; k++) { /// to be corrected\r
 422 \r
 423       //if (data->GetADCErrorCode() > 0) continue;\r
 424 \r
 425       //if (col == 0 || col == 143)\r
 426       //printf("TB: %d %d %d\n", row, col, sig[k]);\r
 427 \r
 428       //if (sig[k] < 1) \r
 429       //printf("det = %d rob = %d mcm = %d adc = %d k = %d S = %d\n", det, rob, mcm, adc, k, sig[k]);\r
 430       \r
 431       fSignal[det]->Fill(sig[k]);\r
 432       fData[det]->Fill(row, col, sig[k]);\r
 433       \r
 434       minV = (minV < sig[k]) ? minV : sig[k];\r
 435       maxV = (maxV > sig[k]) ? maxV : sig[k];\r
 436 \r
 437 \r
 438       // check if data strange enought\r
 439       if (fCreateFull && fFullSignal[mcmIndex]) {\r
 440         //if (sm == 17 && )\r
 441         //if (det != 29) {\r
 442         if (sig[k] > fThresh || sig[k] < 1) fFullCounter[mcmIndex]++;\r
 443         //if (sig[k] < 1) fFullCounter[mcmIndex] = 0; // remove austrian flag \r
 444         //}\r
 445         fFullSignal[mcmIndex]->Fill(adc, k, sig[k]);\r
 446       }\r
 447       \r
 448       // noisy chamber\r
 449       if (det == 29 && col > 7) {\r
 450         fTBEvent->Fill(fnEvents, k, sig[k]);\r
 451       }\r
 452     }\r
 453     \r
 454     fPP->Fill(maxV-minV);\r
 455     fChPP[det]->Fill(maxV-minV);\r
 456     fSmPP[sm]->Fill(maxV-minV);\r
 457   }\r
 458   \r
 459   // is the dead-alive status changing during the run\r
 460   for(Int_t i=0; i<kDET; i++) {\r
 461     for(Int_t j=0; j<kCOL; j++)\r
 462       for(Int_t k=0; k<kPAD; k++)\r
 463         fOccupancy->Fill(isUsed[i][j][k]);\r
 464   }\r
 465 \r
 466   // save interesting histos\r
 467   Int_t mcmTrackCandidate = 0;\r
 468   for(Int_t i = 0; i < kDET * kROB * kMCM; i++) { \r
 469     if (fFullCounter[i] && fFullSignal[i] && CheckMCM(i) )  {\r
 470       \r
 471       fMcmTracks->AddLast(fFullSignal[i]->Clone(Form("event_%d_%s", fnEvents, fFullSignal[i]->GetName())));\r
 472       mcmTrackCandidate++;\r
 473       \r
 474       Int_t mcmTrackletDet = i/(kROB * kMCM);   \r
 475       Int_t mcmTrackletMcm = i%(kROB * kMCM);\r
 476       fMapMCM->Fill(mcmTrackletDet, mcmTrackletMcm);\r
 477     }\r
 478   }\r
 479   \r
 480   fGraphMCM->SetPoint(fnEvents, fnEvents, mcmTrackCandidate);\r
 481   printf("Number of MCM track candidates = %d\n", mcmTrackCandidate);\r
 482   \r
 483 \r
 484   // update fraction of error graphs\r
 485   Double_t err;\r
 486 \r
 487   err = (nGoodHC > 0)? 100.*nErrorHC/nGoodHC : -1;\r
 488   fErrorGraphHC->SetPoint(fnEvents, fnEvents, err);\r
 489   \r
 490   err = (nGoodMCM > 0)? 100.*nErrorMCM/nGoodMCM : -1;\r
 491   fErrorGraphMCM->SetPoint(fnEvents, fnEvents, err);\r
 492   \r
 493   err = (nGoodADC > 0)? 100.*nErrorADC/nGoodADC : -1;\r
 494   fErrorGraphADC->SetPoint(fnEvents, fnEvents, err);\r
 495 \r
 496   // number of fired ADC per SM\r
 497   for(Int_t sm=0; sm<kSM+1; sm++) \r
 498     fNumberADC[sm]->SetPoint(fnEvents, fnEvents, nADCinSM[sm]);\r
 499 \r
 500 \r
 501   fnEvents++;\r
 502   return nb;\r
 503 }\r
 504 \r
 505 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 506 \r
 507 void AliTRDqaBlackEvents::Process(const char *filename) \r
 508 {\r
 509   //\r
 510   // Process something\r
 511   //\r
 512   \r
 513   char fn[256];\r
 514   strcpy(fn, filename);\r
 515   \r
 516   //printf("FILENAME = %s (%s)\n", filename, fn);\r
 517 \r
 518   Int_t map[kDET];\r
 519   \r
 520   TH1D *hist = new TH1D("fitSignal", "", 50, -0.5, 49.5);\r
 521   TF1 *fit = new TF1("fit", "gaus(0)", 0, 20);\r
 522   fit->SetParameters(1e3, 10, 1);\r
 523     \r
 524   for(Int_t det=0; det<kDET; det++) {\r
 525 \r
 526     //printf("processing chamber %d\n", det);   \r
 527 \r
 528     map[det] = 0;\r
 529     if (fData[det]->GetSum() < 10) continue;\r
 530     map[det] = 1;\r
 531 \r
 532     // read reference distributions\r
 533     ReadRefHists(det);\r
 534 \r
 535     for(Int_t row=0; row<fData[det]->GetXaxis()->GetNbins(); row++) {\r
 536       for(Int_t pad=0; pad<fData[det]->GetYaxis()->GetNbins(); pad++) {\r
 537         \r
 538         // project the histogramm\r
 539         hist->Reset();\r
 540         for(Int_t bb=0; bb<50; bb++) {\r
 541           Int_t dataBin = fData[det]->FindBin(row, pad, bb);\r
 542           Double_t v = fData[det]->GetBinContent(dataBin);\r
 543           hist->SetBinContent(bb+1, v);\r
 544         }\r
 545 \r
 546         Int_t bin = fChPed[det]->FindBin(row, pad);\r
 547 \r
 548         if (hist->GetSum() > 1) {\r
 549           \r
 550           Double_t ped = 0, noise = 0;\r
 551 \r
 552           if (fFitType == 0) {\r
 553             fit->SetParameters(1e3, 10, 1);\r
 554             hist->Fit(fit, "q0", "goff", 0, 20);\r
 555             TF1 *f = hist->GetFunction("fit");\r
 556             ped = TMath::Abs(f->GetParameter(1));\r
 557             noise = TMath::Abs(f->GetParameter(2));\r
 558             fSmNoiseFit[det/30]->Fill(noise);\r
 559           } else {\r
 560             ped = hist->GetMean();\r
 561             noise = hist->GetRMS();\r
 562             fSmNoiseRms[det/30]->Fill(noise);\r
 563             //if (pad == 0)\r
 564             //  printf("data %f %f %f\n", hist->GetSum(), ped, noise);\r
 565           }\r
 566 \r
 567           fChPed[det]->SetBinContent(bin, ped);\r
 568           fChNoise[det]->SetBinContent(bin, noise);\r
 569           fNoiseTotal->Fill(noise);\r
 570 \r
 571           // subtract reference values\r
 572           Double_t refped = 0;\r
 573           Double_t refnoise = 0;\r
 574           \r
 575           if (fRefHistPed)   refped   = fRefHistPed->GetBinContent(bin);\r
 576           if (fRefHistNoise) refnoise = fRefHistPed->GetBinContent(bin);\r
 577 \r
 578           fChPedRes[det]->SetBinContent(bin, ped-refped);\r
 579           fChNoiseRes[det]->SetBinContent(bin, noise-refnoise);\r
 580           \r
 581           fPed[det]->Fill(ped);\r
 582           fNoise[det]->Fill(noise);\r
 583 \r
 584           // fill SM-HC plot\r
 585           Int_t sm = det / 30;\r
 586           Int_t hc = (pad < kPAD/2) ? 2* (det % 30) : 2* (det % 30) + 1;\r
 587           if (ped > 9. && ped < 11) fSMHCped->Fill(sm, hc, 1./1152.); // number of pads in HC\r
 588 \r
 589         } else {\r
 590           \r
 591           // not enought data found \r
 592           fChPed[det]->SetBinContent(bin, 0);\r
 593           fChNoise[det]->SetBinContent(bin, 0);\r
 594           fChPedRes[det]->SetBinContent(bin, 0);\r
 595           fChNoiseRes[det]->SetBinContent(bin, 0);\r
 596         }\r
 597         \r
 598         //delete hist;\r
 599       }\r
 600     }\r
 601   }\r
 602 \r
 603 \r
 604   //printf("Number of events = %d\n", fnEvents);\r
 605 \r
 606   // normalize number of entries histos\r
 607   Int_t max = 0;\r
 608   for(Int_t i=0; i<kDET; i++) { \r
 609     if (!map[i]) continue;\r
 610     for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) {\r
 611       for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) {\r
 612         Int_t dataBin = fNPoint[i]->FindBin(j, k);\r
 613         Double_t v = fNPoint[i]->GetBinContent(dataBin);\r
 614         if (v > max) max = (Int_t)v;\r
 615       }\r
 616     }\r
 617   }\r
 618   \r
 619   char entriesDistName[100];\r
 620 \r
 621   for(Int_t i=0; i<kDET; i++) {\r
 622     \r
 623     if (!map[i]) continue;\r
 624     \r
 625     sprintf(entriesDistName, "entriesDist_%d", i);\r
 626     fNPointDist[i] = new TH1D(entriesDistName, ";number of events", max+2, -0.5, max+1.5);\r
 627     \r
 628     for(Int_t j=0; j<fNPoint[i]->GetXaxis()->GetNbins(); j++) {\r
 629       for(Int_t k=0; k<fNPoint[i]->GetYaxis()->GetNbins(); k++) {\r
 630         Int_t dataBin = fNPoint[i]->FindBin(j, k);\r
 631         Double_t v = fNPoint[i]->GetBinContent(dataBin);\r
 632         //if (v > fnEvents) printf("N = %d V = %lf\n", fnEvents, v);\r
 633         fNPointDist[i]->Fill(v); \r
 634       }\r
 635     }\r
 636     \r
 637     fNPoint[i]->Scale(1./fnEvents);\r
 638   }\r
 639   \r
 640 \r
 641   for(Int_t i=0; i<kDET; i++) {\r
 642     fnEntriesRM[i]->SetMaximum(fnEvents * 1.5);\r
 643   }\r
 644 \r
 645   // save histograms\r
 646 \r
 647   //printf("FILENAME 2 = %s (%d)\n", fn, fn);\r
 648   TFile *file = new TFile(fn, "recreate");\r
 649   for(Int_t det = 0; det < kDET; det++) {\r
 650     if (!map[det]) continue; \r
 651     fChPed[det]->Write();\r
 652     fChNoise[det]->Write();\r
 653     fNPoint[det]->Write();\r
 654     fNPointDist[det]->Write();\r
 655     fPed[det]->Write();\r
 656     fNoise[det]->Write();\r
 657     fSignal[det]->Write();\r
 658     fnEntriesRM[det]->Write();\r
 659     fChPP[det]->Write();\r
 660 \r
 661     fChPedRes[det]->Write();\r
 662     fChNoiseRes[det]->Write();\r
 663 \r
 664     // save error hists\r
 665     fErrorLocMCM[det]->SetMinimum(0);\r
 666     fErrorLocMCM[det]->SetMaximum(fnEvents);\r
 667     fErrorLocMCM[det]->Write();\r
 668 \r
 669     fErrorLocADC[det]->SetMinimum(0);\r
 670     fErrorLocADC[det]->SetMaximum(fnEvents);\r
 671     fErrorLocADC[det]->Write();\r
 672   }\r
 673 \r
 674   for(Int_t sm=0; sm<kSM; sm++) {\r
 675     fSmNoiseRms[sm]->Write();\r
 676     fSmNoiseFit[sm]->Write();\r
 677     fSmPP[sm]->Write();\r
 678   }\r
 679 \r
 680 \r
 681 \r
 682   Int_t nMcm = 0;\r
 683   for(Int_t i=0; i < kDET * kROB * kMCM; i++) {\r
 684     if (fFullSignal[i] && fFullCounter[i] > fCount) {\r
 685       fFullSignal[i]->Write();\r
 686       nMcm++;\r
 687     }\r
 688   }\r
 689 \r
 690   printf("Number of saved MCMs = %d\n", nMcm);\r
 691   \r
 692   fMcmTracks->Write();\r
 693   printf("Number of tracks = %d\n", fMcmTracks->GetEntries());\r
 694   \r
 695   // permanently problematic MCMs\r
 696   for(Int_t det=0; det<kDET; det++) {\r
 697     for(Int_t mcm=0; mcm<kROB*kMCM; mcm++) {\r
 698       \r
 699       Int_t mRob = mcm / kMCM;\r
 700       Int_t mMcm = mcm % kMCM;\r
 701       Int_t bin = fMapMCM->FindBin(det, mcm);\r
 702       Double_t frac = 1. * fMapMCM->GetBinContent(bin) / fnEvents;      \r
 703       fFracMCM->Fill(frac);\r
 704       \r
 705       if (frac > 0.7) {\r
 706         printf("{%d, %d, %d}, \n", det, mRob, mMcm, frac);\r
 707       }      \r
 708     }\r
 709   }\r
 710 \r
 711 \r
 712 \r
 713   fOccupancy->Write();\r
 714   fDetRob->Write();\r
 715   fTBEvent->Write();\r
 716   \r
 717   // error hists\r
 718   fErrorHC->Write();\r
 719   fErrorMCM->Write();\r
 720   fErrorADC->Write();\r
 721 \r
 722   fErrorSMHC->Write();\r
 723   fErrorSMMCM->Write();\r
 724   fErrorSMADC->Write();  \r
 725   \r
 726   // write graphs\r
 727   fErrorGraphHC->Write("trendErrorHC");\r
 728   fErrorGraphMCM->Write("trendErrorMCM");\r
 729   fErrorGraphADC->Write("trendErrorADC");\r
 730   \r
 731   fGraphMCM->Write("trendMCM");\r
 732 \r
 733   fMapMCM->SetMaximum(fnEvents);\r
 734   fMapMCM->Write();\r
 735   fFracMCM->Write();\r
 736   \r
 737   fSMHCped->Write();\r
 738 \r
 739   for(Int_t sm=0; sm<kSM; sm++)\r
 740     fNumberADC[sm]->Write(Form("nADCinSM%d",sm));\r
 741   \r
 742   fNumberADC[kSM]->Write("nADCinEvent");\r
 743 \r
 744   fNoiseTotal->Write();\r
 745   fPP->Write();\r
 746 \r
 747   file->Close();\r
 748   delete file;\r
 749 }\r
 750 \r
 751 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 752 \r
 753 Int_t AliTRDqaBlackEvents::CheckMCM(Int_t index) {\r
 754   \r
 755   return 1;\r
 756   \r
 757   static Int_t data[21][3] = {\r
 758     {1, 0, 1}, \r
 759     {242, 0, 0}, \r
 760     {242, 0, 1}, \r
 761     {242, 0, 2}, \r
 762     {242, 0, 4}, \r
 763     {242, 0, 5}, \r
 764     {242, 0, 6}, \r
 765     {242, 0, 8}, \r
 766     {242, 0, 12}, \r
 767     {251, 7, 7}, \r
 768     {254, 3, 11}, \r
 769     {259, 3, 14}, \r
 770     {260, 1, 9}, \r
 771     {260, 3, 15}, \r
 772     {273, 1, 7}, \r
 773     {273, 1, 15}, \r
 774     {276, 5, 11}, \r
 775     {280, 6, 2}, \r
 776     {299, 6, 4}, \r
 777     {511, 2, 9}, \r
 778     {517, 7, 15}\r
 779   };\r
 780   \r
 781   for(Int_t i=0; i<21; i++) {\r
 782     Int_t wIndex = data[i][0] * kROB*kMCM + data[i][1] * kMCM + data[i][2];\r
 783     if (index == wIndex) return 0;\r
 784   }\r
 785 \r
 786   return 1;\r
 787 }\r
 788 \r
 789 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 790 \r
 791 \r
 792 \r
 793 \r
 794 \r
 795 \r
 796 \r
 797 void AliTRDqaBlackEvents::DrawChamber(const char *filename, Int_t det, Int_t w, Int_t h) \r
 798 {\r
 799   //\r
 800   // Draw raport for one chamber: \r
 801   // pedestal map, noise map, distribution of pedestal and noise\r
 802   // \r
 803   // input:\r
 804   // name of the file with histograms (created with Process())\r
 805   // detector Id (0 - 539)\r
 806   // \r
 807 \r
 808   // setup global style\r
 809   gStyle->SetPalette(1);\r
 810   gStyle->SetOptStat(0);\r
 811   gStyle->SetPadTopMargin(0.02);\r
 812   gStyle->SetPadBottomMargin(0.05);\r
 813 \r
 814   TFile *file = new TFile(filename, "READ");\r
 815 \r
 816   TCanvas *c = new TCanvas("blackEvents",Form("blackEvents %d",det), w, h);\r
 817   c->SetVertical(kFALSE);\r
 818   c->Divide(3,1, 0.01, 0.01);\r
 819   c->cd(3);\r
 820   \r
 821   TPad *mPad = (TPad*) gPad;\r
 822   mPad->Divide(1,2,0.01,0.01);\r
 823   \r
 824   c->cd(1);\r
 825   TH2D *h2 = (TH2D*)file->Get(Form("ped_%d",det));\r
 826   h2->SetMinimum(5);\r
 827   h2->SetMaximum(15);\r
 828   h2->SetTitle(";Z direction;#phi direction");\r
 829   h2->Draw("colz");\r
 830   \r
 831   c->cd(2);\r
 832   h2 = (TH2D*)file->Get(Form("noise_%d",det));\r
 833   h2->SetMinimum(fMinNoise);\r
 834   h2->SetMaximum(fMaxNoise);\r
 835   h2->SetTitle(";Z direction;#phi direction");\r
 836   h2->Draw("colz");\r
 837   \r
 838   mPad->cd(1);\r
 839   //gPad->SetLogy();\r
 840   TH1D *h1 = (TH1D*)file->Get(Form("pedDist_%d", det));\r
 841   h1->Draw();\r
 842   \r
 843   mPad->cd(2);\r
 844   gPad->SetLogy();\r
 845   h1 = (TH1D*)file->Get(Form("noiseDist_%d", det));\r
 846   h1->Draw();                    \r
 847   \r
 848   h1->Fit("gaus");\r
 849   TF1 *f = h1->GetFunction("gaus");\r
 850   const char *tt = Form("#mu = %.2f #sigma = %0.2f ", f->GetParameter(1),f->GetParameter(2));\r
 851   TLatex *ll = new TLatex(2, 100, tt);\r
 852   ll->SetTextSize(0.06);\r
 853   ll->Draw();\r
 854 }\r
 855 \r
 856 ///////////////////////////////////////////////////////////////////////////////////////////////////\r
 857 \r
 858 void AliTRDqaBlackEvents::DrawSm(const char *filename, Int_t sm, Int_t w, Int_t h) \r
 859 {\r
 860   //\r
 861   // ????????????\r
 862   //\r
 863   \r
 864   gStyle->SetPalette(1);\r
 865   gStyle->SetOptStat(0);\r
 866   \r
 867   gStyle->SetPadTopMargin(0.02);\r
 868   //gStyle->SetPadBottomMargin(0.05);  \r
 869   //gStyle->SetPadLeftMargin(0.02);  \r
 870   //gStyle->SetPadRightMargin(0.02);\r
 871 \r
 872   TFile *file = new TFile(filename, "READ");\r
 873 \r
 874   TCanvas *c = new TCanvas("blackEventsSM",Form("blackEvents SM %d",sm), w, h);\r
 875   c->SetVertical(kFALSE);\r
 876   c->Divide(5, 6, 0.001, 0.01);\r
 877   \r
 878   for(Int_t i=0; i<30; i++) {\r
 879     \r
 880     TH2D *h2 = (TH2D*)file->Get(Form("noise_%d",i+30*sm));\r
 881     if (!h2) continue;\r
 882     h2->SetMinimum(fMinNoise);\r
 883     h2->SetMaximum(fMaxNoise);\r
 884 \r
 885     // to be replaced by the official calculation\r
 886     Int_t stack = i/6;\r
 887     Int_t layer = i%6;\r
 888     Int_t index = (5-layer)*5 + stack + 1;\r
 889     //printf("%d %d %d %d\n", i, stack, layer, index);\r
 890     c->cd(index);\r
 891     gPad->SetBottomMargin(0.02);\r
 892     gPad->SetTopMargin(0.02);\r
 893 \r
 894     h2->Draw("col");\r
 895   }\r
 896 }\r
 897 \r
 898 ///////////////////////////////////////////////////////////////////////////////////////////////////\r