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