ESDCheck/AliTRDQATask.cxx

   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  * without fee, provided that the above 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 // An analysis task to check the TRD data in simulated data
  17 //
  18 //*-- Sylwester Radomski
  19 //////////////////////////////////////////////////////////////////////////////
  20 // track type codding
  21 //
  22 // tpci = kTPCin
  23 // tpco = kTPCout
  24 // tpcz = kTPCout && !kTRDout
  25 // trdo = kTRDout
  26 // trdr = kTRDref
  27 // trdz = kTRDout && !kTRDref
  28 //
  29
  30 #include "AliTRDQATask.h"
  31
  32 #include "TChain.h"
  33 #include "TH1D.h"
  34 #include "TH2D.h"
  35 #include "TFile.h"
  36 #include "TStyle.h"
  37 #include "TGaxis.h"
  38 #include "TCanvas.h"
  39
  40 #include "AliESD.h"
  41 #include "AliLog.h"
  42
  43 //______________________________________________________________________________
  44 AliTRDQATask::AliTRDQATask(const char *name) :
  45   AliAnalysisTask(name,""),
  46   fChain(0),
  47   fESD(0)
  48 {
  49   // Constructor.
  50   // Input slot #0 works with an Ntuple
  51   DefineInput(0, TChain::Class());
  52   // Output slot #0 writes into a TH1 container
  53   DefineOutput(0,  TObjArray::Class()) ;
  54 }
  55
  56 //______________________________________________________________________________
  57 void AliTRDQATask::Init(const Option_t *)
  58 {
  59   // Initialisation of branch container and histograms
  60
  61   AliInfo(Form("*** Initialization of %s", GetName())) ;
  62
  63   // Get input data
  64   fChain = dynamic_cast<TChain *>(GetInputData(0)) ;
  65   if (!fChain) {
  66     AliError(Form("Input 0 for %s not found\n", GetName()));
  67     return ;
  68   }
  69
  70   if (!fESD) {
  71     // One should first check if the branch address was taken by some other task
  72     char ** address = (char **)GetBranchAddress(0, "ESD");
  73     if (address) {
  74       fESD = (AliESD *)(*address);
  75       AliInfo("Old ESD found.");
  76     }
  77     if (!fESD) {
  78       fESD = new AliESD();
  79       SetBranchAddress(0, "ESD", &fESD);
  80       if (fESD) AliInfo("ESD connected.");
  81     }
  82   }
  83   // The output objects will be written to
  84   TDirectory * cdir = gDirectory ;
  85   OpenFile(0, Form("%s.root", GetName()), "RECREATE");
  86   if (cdir)
  87     cdir->cd() ;
  88
  89   // create histograms
  90
  91   fNTracks     = new TH1D("ntracks", ";number of all tracks", 500, -0.5, 499.5);
  92   fEventSize   = new TH1D("evSize", ";event size (MB)", 100, 0, 5);
  93
  94   fTrackStatus = new TH1D("trackStatus", ";status bit", 32, -0.5, 31.5);
  95   fKinkIndex   = new TH1D("kinkIndex", ";kink index", 41, -20.5, 20.5);
  96
  97   fParIn  = new TH1D("parIn", "Inner Plane", 2, -0.5, 1.5);
  98   fParOut = new TH1D("parOut", "Outer Plane", 2, -0.5, 1.5);
  99
 100   fXIn  = new TH1D("xIn", ";X at the inner plane (cm)", 200, 50, 250);
 101   fXOut = new TH1D("xOut", ";X at the outer plane (cm)", 300, 50, 400);
 102
 103   const int nNameAlpha = 4;
 104   const char *namesAlpha[nNameAlpha] = {"alphaTPCi", "alphaTPCo", "alphaTRDo", "alphaTRDr"};
 105   //TH1D *fAlpha[4];
 106   for(int i=0; i<nNameAlpha; i++) {
 107     fAlpha[i] = new TH1D(namesAlpha[i], "alpha", 100, -4, 4);
 108   }
 109   fSectorTRD = new TH1D ("sectorTRD", ";sector TRD", 20, -0.5, 19.5);
 110
 111
 112   // track parameters
 113   const int nbits = 6;
 114   const char *suf[nbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
 115   for(int i=0; i<nbits; i++) {
 116     fPt[i]      = new TH1D(Form("pt%s",suf[i]), ";p_{T} (GeV/c);entries TPC", 50, 0, 10);
 117     fTheta[i]   = new TH1D(Form("theta%s", suf[i]), "theta (rad)", 100, -4, 4);
 118     fSigmaY[i]  = new TH1D(Form("sigmaY%s",suf[i]),  ";sigma Y (cm)", 200, 0, 1);
 119     fChi2[i]    = new TH1D(Form("Chi2%s", suf[i]), ";#chi2 / ndf", 100, 0, 10);
 120     fPlaneYZ[i] = new TH2D(Form("planeYZ%s", suf[i]), Form("%sy (cm);z (cm)", suf[i]),
 121                            100, -60, 60, 500, -500, 500);
 122   }
 123
 124   // efficiency
 125   fEffPt[0] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[0], suf[1]));
 126   fEffPt[1] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[1], suf[3]));
 127   fEffPt[2] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[3], suf[4]));
 128   fEffPt[3] = (TH1D*) fPt[0]->Clone(Form("eff_%s_%s", suf[1], suf[4]));
 129
 130   for(int i=0; i<4; i++) {
 131     fEffPt[i]->Sumw2();
 132     fEffPt[i]->SetMarkerStyle(20);
 133     fEffPt[i]->SetMinimum(0);
 134     fEffPt[i]->SetMaximum(1.1);
 135   }
 136
 137   // track features
 138   fClustersTRD[0] = new TH1D("clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
 139   fClustersTRD[1] = new TH1D("clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
 140   fClustersTRD[2] = new TH1D("clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
 141
 142   // for good refitted tracks only
 143   fTime    = new TH1D("time", ";time bin", 25, -0.5, 24.5);
 144   fBudget  = new TH1D("budget", ";material budget", 100, 0, 100);
 145   fQuality = new TH1D("quality", ";track quality", 100, 0, 1.1);
 146   fSignal  = new TH1D("signal", ";signal", 100, 0, 1e3);
 147
 148   // dEdX and PID
 149   fTrdSigMom = new TH2D("trdSigMom", ";momentum (GeV/c);signal", 100, 0, 3, 100, 0, 1e3);
 150   fTpcSigMom = new TH2D("tpcSigMom", ";momentum (GeV/c);signal", 100, 0, 3, 100, 0, 200);
 151
 152   const char *pidName[6] = {"El", "Mu", "Pi", "K", "P", "Ch"};
 153   for(int i=0; i<6; i++) {
 154
 155     // TPC
 156     fTpcPID[i] = new TH1D(Form("tpcPid%s",pidName[i]), pidName[i], 100, 0, 1.5);
 157     fTpcPID[i]->GetXaxis()->SetTitle("probability");
 158
 159     fTpcSigMomPID[i] = new TH2D(Form("tpcSigMom%s",pidName[i]), "", 100, 0, 3, 100, 0, 200);
 160     fTpcSigMomPID[i]->SetTitle(Form("%s;momentum (GeV/c);signal",pidName[i]));
 161
 162     // TRD
 163     fTrdPID[i] = new TH1D(Form("trdPid%s",pidName[i]), pidName[i], 100, 0, 1.5);
 164     fTrdPID[i]->GetXaxis()->SetTitle("probability");
 165
 166     fTrdSigMomPID[i] = new TH2D(Form("trdSigMom%s",pidName[i]), "", 100, 0, 3, 100, 0, 1e3);
 167     fTrdSigMomPID[i]->SetTitle(Form("%s;momentum (GeV/c);signal",pidName[i]));
 168   }
 169
 170
 171   // create output container
 172   fOutputContainer = new TObjArray(80);
 173
 174   // register histograms to the container
 175   TIter next(gDirectory->GetList());
 176   TObject *obj;
 177   int counter = 0;
 178
 179   while (obj = next.Next()) {
 180     if (obj->InheritsFrom("TH1"))  fOutputContainer->AddAt(obj, counter++);
 181   }
 182
 183   AliInfo(Form("Number of histograms = %d", counter));
 184
 185  }
 186
 187 //______________________________________________________________________________
 188 void AliTRDQATask::Exec(Option_t *)
 189 {
 190   // Process one event
 191
 192    Long64_t entry = fChain->GetReadEntry() ;
 193
 194   // Processing of one event
 195
 196   if (!fESD) {
 197     AliError("fESD is not connected to the input!") ;
 198     return ;
 199   }
 200
 201   if ( !((entry-1)%100) )
 202     AliInfo(Form("%s ----> Processing event # %lld",  (dynamic_cast<TChain *>(fChain))->GetFile()->GetName(), entry)) ;
 203
 204   int nTracks = fESD->GetNumberOfTracks();
 205   fNTracks->Fill(nTracks);
 206
 207   // track loop
 208   for(int i=0; i<nTracks; i++) {
 209
 210     AliESDtrack *track = fESD->GetTrack(i);
 211     const AliExternalTrackParam *paramOut = track->GetOuterParam();
 212     const AliExternalTrackParam *paramIn = track->GetInnerParam();
 213
 214     fParIn->Fill(!!paramIn);
 215     if (!paramIn) continue;
 216     fXIn->Fill(paramIn->GetX());
 217
 218     fParOut->Fill(!!paramOut);
 219     if (!paramOut) continue;
 220     fXOut->Fill(paramOut->GetX());
 221
 222     int sector = GetSector(paramOut->GetAlpha());
 223     if (!CheckSector(sector)) continue;
 224     fSectorTRD->Fill(sector);
 225
 226     fKinkIndex->Fill(track->GetKinkIndex(0));
 227     if (track->GetKinkIndex(0)) continue;
 228
 229     UInt_t u = 1;
 230     UInt_t status = track->GetStatus();
 231     for(int bit=0; bit<32; bit++)
 232       if (u<<bit & status) fTrackStatus->Fill(bit);
 233
 234     const int nbits = 6;
 235     int bit[6] = {0,0,0,0,0,0};
 236     bit[0] = status & AliESDtrack::kTPCin;
 237     bit[1] = status & AliESDtrack::kTPCout;
 238     bit[2] = (status & AliESDtrack::kTPCout) && !(status & AliESDtrack::kTRDout);
 239     bit[3] = status & AliESDtrack::kTRDout;
 240     bit[4] = status & AliESDtrack::kTRDrefit;
 241     bit[5] = (status & AliESDtrack::kTRDout) && !(status & AliESDtrack::kTRDrefit);
 242
 243
 244     // transverse momentum
 245     const double *val = track->GetParameter(); // parameters at the vertex
 246     double pt = 1./TMath::Abs(val[4]);
 247
 248     for(int b=0; b<nbits; b++) {
 249       if (bit[b]) {
 250         fPt[b]->Fill(pt);
 251         fTheta[b]->Fill(val[3]);
 252         fSigmaY[b]->Fill(TMath::Sqrt(paramOut->GetSigmaY2()));
 253         fChi2[b]->Fill(track->GetTRDchi2()/track->GetTRDncls());
 254         fPlaneYZ[b]->Fill(paramOut->GetY(), paramOut->GetZ());
 255       }
 256     }
 257
 258     // sectors
 259     if (bit[1]) {
 260       fAlpha[0]->Fill(paramIn->GetAlpha());
 261       fAlpha[1]->Fill(paramOut->GetAlpha());
 262     }
 263
 264     if (bit[3]) fAlpha[2]->Fill(paramOut->GetAlpha());
 265     if (bit[4]) fAlpha[3]->Fill(paramOut->GetAlpha());
 266
 267     // clusters
 268     for(int b=0; b<3; b++)
 269       if (bit[3+b]) fClustersTRD[b]->Fill(track->GetTRDncls());
 270
 271     // refitted only
 272     if (!bit[4]) continue;
 273
 274     fQuality->Fill(track->GetTRDQuality());
 275     fBudget->Fill(track->GetTRDBudget());
 276     fSignal->Fill(track->GetTRDsignal());
 277
 278     fTrdSigMom->Fill(track->GetP(), track->GetTRDsignal());
 279     fTpcSigMom->Fill(track->GetP(), track->GetTPCsignal());
 280
 281     // PID only
 282     if (status & AliESDtrack::kTRDpid) {
 283
 284       for(int l=0; l<6; l++) fTime->Fill(track->GetTRDTimBin(l));
 285
 286       // fill pid histograms
 287       double trdr0 = 0, tpcr0 = 0;
 288       int trdBestPid = 5, tpcBestPid = 5;  // charged
 289       const double minPidValue =  0.9;
 290
 291       double pp[5];
 292       track->GetTPCpid(pp); // ESD inconsequence
 293
 294       for(int pid=0; pid<5; pid++) {
 295
 296         trdr0 += track->GetTRDpid(pid);
 297         tpcr0 += pp[pid];
 298
 299         fTrdPID[pid]->Fill(track->GetTRDpid(pid));
 300         fTpcPID[pid]->Fill(pp[pid]);
 301
 302         if (track->GetTRDpid(pid) > minPidValue) trdBestPid = pid;
 303         if (pp[pid] > minPidValue) tpcBestPid = pid;
 304       }
 305
 306       fTrdPID[5]->Fill(trdr0); // check unitarity
 307       fTrdSigMomPID[trdBestPid]->Fill(track->GetP(), track->GetTRDsignal());
 308
 309       fTpcPID[5]->Fill(tpcr0); // check unitarity
 310       fTpcSigMomPID[tpcBestPid]->Fill(track->GetP(), track->GetTPCsignal());
 311     }
 312
 313   }
 314
 315   CalculateEff();
 316   PostData(0, fOutputContainer);
 317 }
 318
 319 //______________________________________________________________________________
 320 void AliTRDQATask::Terminate(Option_t *)
 321 {
 322   // Processing when the event loop is ended
 323   AliInfo("TRD QA module");
 324
 325   // create efficiency histograms
 326
 327   CalculateEff();
 328   PostData(0, fOutputContainer);
 329
 330   DrawESD() ;
 331   DrawGeoESD() ;
 332   //DrawConvESD() ;
 333   DrawPidESD() ;
 334 }
 335
 336 //______________________________________________________________________________
 337 int AliTRDQATask::GetSector(double alpha)
 338 {
 339   // Gets the sector number
 340
 341   double size = TMath::DegToRad() * 20.;
 342   int sector = (int)((alpha + TMath::Pi())/size);
 343   return sector;
 344 }
 345
 346 //______________________________________________________________________________
 347 int AliTRDQATask::CheckSector(int sector)
 348 {
 349   // Checks the sector number
 350   const int nSec = 8;
 351   int sec[] = {2,3,5,6,11,12,13,15};
 352
 353   for(int i=0; i<nSec; i++)
 354     if (sector == sec[i]) return 1;
 355
 356   return 0;
 357 }
 358
 359 //______________________________________________________________________________
 360 void AliTRDQATask::CalculateEff()
 361 {
 362   // calculates the efficiency
 363
 364   for(int i=0; i<4; i++) fEffPt[i]->Reset();
 365
 366   fEffPt[0]->Add(fPt[1]);
 367   fEffPt[0]->Divide(fPt[0]);
 368
 369   fEffPt[1]->Add(fPt[3]);
 370   fEffPt[1]->Divide(fPt[1]);
 371
 372   fEffPt[2]->Add(fPt[4]);
 373   fEffPt[2]->Divide(fPt[3]);
 374
 375   fEffPt[3]->Add(fPt[4]);
 376   fEffPt[3]->Divide(fPt[1]);
 377 }
 378
 379 //______________________________________________________________________________
 380 void AliTRDQATask::DrawESD()
 381 {
 382   // Makes a few plots
 383
 384   AliInfo("Plotting....") ;
 385
 386   TCanvas * cTRD = new TCanvas("cTRD", "TRD ESD Test", 400, 10, 600, 700) ;
 387   cTRD->Divide(6,3) ;
 388
 389   gROOT->SetStyle("Plain");
 390   gStyle->SetPalette(1);
 391   gStyle->SetOptStat(0);
 392
 393   TGaxis::SetMaxDigits(3);
 394
 395   gStyle->SetLabelFont(52, "XYZ");
 396   gStyle->SetTitleFont(62, "XYZ");
 397   gStyle->SetPadRightMargin(0.02);
 398
 399   // draw all
 400
 401   const int nplots = 18;
 402   const int nover[nplots] = {1,1,1,4,1,1,1,1,1,1,2,1,1,3,1,1,1,1};
 403   const int nnames = 24;
 404   const char *names[nnames] = {
 405     "ntracks", "kinkIndex", "trackStatus",
 406     "ptTPCi", "ptTPCo", "ptTRDo", "ptTRDr",  "ptTPCz", "ptTRDz",
 407     "eff_TPCi_TPCo",  "eff_TPCo_TRDo", "eff_TRDo_TRDr",  "eff_TPCo_TRDr",
 408     "clsTRDo", "clsTRDr", "clsTRDz",
 409     "alphaTPCi", "alphaTPCo", "alphaTRDo", "alphaTRDr", "sectorTRD",
 410     "time", "budget", "signal"
 411   };
 412
 413   const int logy[nnames] = {
 414     1,1,1,
 415     1,1,1,
 416     0,0,0,0,
 417     1,1,
 418     0,0,0,0,0,
 419     0,1,1
 420   };
 421
 422   int nhist=0;
 423   for(int i=0; i<nplots; i++) {
 424   cTRD->cd(i+1) ;
 425
 426   //  new TCanvas(names[i], names[nhist], 500, 300);
 427     gPad->SetLogy(logy[i]);
 428
 429     for(int j=0; j<nover[i]; j++) {
 430       TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[nhist++]));
 431       if (!hist) continue;
 432
 433       if (strstr(hist->GetName(), "eff")) {
 434         hist->SetMarkerStyle(20);
 435         hist->SetMinimum(0);
 436         hist->SetMaximum(1.2);
 437       }
 438
 439       if (!j) hist->Draw();
 440       else hist->Draw("SAME");
 441     }
 442   }
 443   cTRD->Print("TRD_ESD.gif");
 444 }
 445
 446 //______________________________________________________________________________
 447 void AliTRDQATask::DrawGeoESD()
 448 {
 449   // Makes a few plots
 450
 451   AliInfo("Plotting....") ;
 452
 453   TCanvas * cTRDGeo = new TCanvas("cTRDGeo", "TRD ESDGeo Test", 400, 10, 600, 700) ;
 454   cTRDGeo->Divide(4,2) ;
 455
 456   gStyle->SetOptStat(0);
 457   TGaxis::SetMaxDigits(3);
 458
 459   gStyle->SetLabelFont(52, "XYZ");
 460   gStyle->SetTitleFont(62, "XYZ");
 461
 462   gStyle->SetPadTopMargin(0.06);
 463   gStyle->SetTitleBorderSize(0);
 464
 465   // draw all
 466   const int nnames = 7;
 467   const char *names[nnames] = {
 468     "xIn", "xOut",
 469     "planeYZTPCo", "planeYZTPCz", "planeYZTRDo", "planeYZTRDr", "planeYZTRDz",
 470   };
 471
 472   const char *opt[nnames] = {
 473     "", "",
 474     "colz","colz", "colz", "colz", "colz"
 475   };
 476
 477   const int logy[nnames] = {
 478     1,1,
 479     0,0,0,0,0
 480   };
 481
 482   for(int i=0; i<nnames; i++) {
 483   cTRDGeo->cd(i+1) ;
 484     TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[i]));
 485     if (!hist) continue;
 486
 487     //if (i<2) new TCanvas(names[i], names[i], 500, 300);
 488     //else new TCanvas(names[i], names[i], 300, 900);
 489
 490     gPad->SetLogy(logy[i]);
 491     if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
 492
 493     hist->Draw(opt[i]);
 494     AliInfo(Form("%s\t%d", names[i], hist->GetEntries()));
 495   }
 496
 497   cTRDGeo->Print("TRD_Geo.gif");
 498 }
 499
 500 //______________________________________________________________________________
 501 void AliTRDQATask::DrawConvESD()
 502 {
 503   // Makes a few plots
 504
 505   AliInfo("Plotting....") ;
 506   TCanvas * cTRDConv = new TCanvas("cTRDConv", "TRD ESDConv Test", 400, 10, 600, 700) ;
 507   cTRDConv->Divide(3,2) ;
 508
 509   gROOT->SetStyle("Plain");
 510   gROOT->ForceStyle();
 511   gStyle->SetPalette(1);
 512
 513   TGaxis::SetMaxDigits(3);
 514
 515   gStyle->SetLabelFont(52, "XYZ");
 516   gStyle->SetTitleFont(62, "XYZ");
 517   gStyle->SetPadRightMargin(0.02);
 518
 519   const int nnames = 9;
 520   const int nplots = 5;
 521   const int nover[nplots] = {3,1,1,3,1};
 522
 523   const char *names[nnames] = {
 524     "sigmaYTPCo","sigmaYTRDo", "sigmaYTRDr", "sigmaYTPCz", "sigmaYTRDz",
 525     "Chi2TPCo", "Chi2TRDo", "Chi2TRDr", "Chi2TRDz"
 526   };
 527
 528   const char *opt[nplots] = {
 529     "", "", "","","",
 530   };
 531
 532   const int logy[nplots] = {
 533     0,0,0,1,1
 534   };
 535
 536   int nhist = 0;
 537   for(int i=0; i<nplots; i++) {
 538     cTRDConv->cd(i+1) ;
 539     //new TCanvas(names[i], names[i], 500, 300);
 540     gPad->SetLogy(logy[i]);
 541     if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
 542
 543     for(int j=0; j<nover[i]; j++) {
 544       TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[nhist++]));
 545       if (!j) hist->Draw(opt[i]);
 546       else hist->Draw("same");
 547     }
 548
 549   }
 550     cTRDConv->Print("TRD_Conv.eps");
 551 }
 552
 553 //______________________________________________________________________________
 554 void AliTRDQATask::DrawPidESD()
 555 {
 556   // Makes a few plots
 557
 558   AliInfo("Plotting....") ;
 559   TCanvas * cTRDPid = new TCanvas("cTRDPid", "TRD ESDPid Test", 400, 10, 600, 700) ;
 560   cTRDPid->Divide(9,3) ;
 561
 562   gROOT->SetStyle("Plain");
 563   gROOT->ForceStyle();
 564   gStyle->SetPalette(1);
 565   gStyle->SetOptStat(0);
 566
 567   TGaxis::SetMaxDigits(3);
 568
 569   gStyle->SetLabelFont(52, "XYZ");
 570   gStyle->SetTitleFont(62, "XYZ");
 571
 572   gStyle->SetPadTopMargin(0.05);
 573   gStyle->SetPadRightMargin(0.02);
 574
 575   // draw all
 576
 577   const int nnames = 27;
 578   const char *names[nnames] = {
 579
 580     "signal", "trdSigMom", "tpcSigMom",
 581
 582     "trdPidEl", "trdPidMu", "trdPidPi", "trdPidK", "trdPidP", "trdPidCh",
 583     "trdSigMomEl", "trdSigMomMu", "trdSigMomPi", "trdSigMomK", "trdSigMomP", "trdSigMomCh",
 584
 585     "tpcPidEl", "tpcPidMu", "tpcPidPi", "tpcPidK", "tpcPidP", "tpcPidCh",
 586     "tpcSigMomEl", "tpcSigMomMu", "tpcSigMomPi", "tpcSigMomK", "tpcSigMomP", "tpcSigMomCh"
 587
 588   };
 589
 590   const char *opt[nnames] = {
 591
 592     "", "colz", "colz",
 593
 594     "", "", "", "", "", "" ,
 595     "colz", "colz", "colz", "colz", "colz", "colz",
 596
 597     "", "", "", "", "", "" ,
 598     "colz", "colz", "colz", "colz", "colz", "colz"
 599   };
 600
 601   const int logy[nnames] = {
 602
 603     0,0,0,
 604
 605     1,1,1,1,1,1,
 606     0,0,0,0,0,0,
 607
 608     1,1,1,1,1,1,
 609     0,0,0,0,0,0
 610   };
 611
 612   for(int i=0; i<nnames; i++) {
 613     cTRDPid->cd(i+1) ;
 614
 615     TH1D *hist = dynamic_cast<TH1D*>(gDirectory->FindObject(names[i]));
 616     if (!hist) continue;
 617
 618     //new TCanvas(names[i], names[i], 500, 300);
 619     gPad->SetLogy(logy[i]);
 620     if (strstr(opt[i],"colz")) gPad->SetRightMargin(0.1);
 621
 622     if (strstr(names[i],"sigMom")) gPad->SetLogz(1);
 623     if (strstr(names[i],"SigMom")) gPad->SetLogz(1);
 624
 625     hist->Draw(opt[i]);
 626     AliInfo(Form("%s\t%d", names[i], hist->GetEntries()));
 627   }
 628    cTRDPid->Print("TRD_Pid.gif");
 629 }