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