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