Class implements interface AliAnalysisCuts.
[u/mrichter/AliRoot.git] / PWG0 / esdTrackCuts / AliESDtrackCuts.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 #include "AliESDtrackCuts.h"
19
20
21 #include <AliESDtrack.h>
22 #include <AliESD.h>
23 #include <AliLog.h>
24
25 #include <TTree.h>
26 #include <TCanvas.h>
27 #include <TDirectory.h>
28
29 //____________________________________________________________________
30 ClassImp(AliESDtrackCuts)
31
32 // Cut names
33 const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
34  "require TPC refit",
35  "require ITS refit",
36  "n clusters TPC",
37  "n clusters ITS",
38  "#Chi^{2}/clusters TPC",
39  "#Chi^{2}/clusters ITS",
40  "cov 11",
41  "cov 22",
42  "cov 33",
43  "cov 44",
44  "cov 55",
45  "trk-to-vtx",
46  "trk-to-vtx failed",
47  "kink daughters",
48  "p",
49  "p_{T}",
50  "p_{x}",
51  "p_{y}",
52  "p_{z}",
53  "y",
54  "eta"
55 };
56
57 //____________________________________________________________________
58 AliESDtrackCuts::AliESDtrackCuts() : AliAnalysisCuts(),
59   fCutMinNClusterTPC(0),
60   fCutMinNClusterITS(0),
61   fCutMaxChi2PerClusterTPC(0),
62   fCutMaxChi2PerClusterITS(0),
63   fCutMaxC11(0),
64   fCutMaxC22(0),
65   fCutMaxC33(0),
66   fCutMaxC44(0),
67   fCutMaxC55(0),
68   fCutAcceptKinkDaughters(0),
69   fCutRequireTPCRefit(0),
70   fCutRequireITSRefit(0),
71   fCutNsigmaToVertex(0),
72   fCutSigmaToVertexRequired(0),
73   fPMin(0),
74   fPMax(0),
75   fPtMin(0),
76   fPtMax(0),
77   fPxMin(0),
78   fPxMax(0),
79   fPyMin(0),
80   fPyMax(0),
81   fPzMin(0),
82   fPzMax(0),
83   fEtaMin(0),
84   fEtaMax(0),
85   fRapMin(0),
86   fRapMax(0),
87   fHistogramsOn(0),
88   ffDTheoretical(0),                                 
89   fhCutStatistics(0),         
90   fhCutCorrelation(0)
91 {
92   //
93   // default constructor
94   //
95
96   Init();
97 }
98
99 //____________________________________________________________________
100 AliESDtrackCuts::AliESDtrackCuts(Char_t* name, Char_t* title) : AliAnalysisCuts(name,title),
101   fCutMinNClusterTPC(0),
102   fCutMinNClusterITS(0),
103   fCutMaxChi2PerClusterTPC(0),
104   fCutMaxChi2PerClusterITS(0),
105   fCutMaxC11(0),
106   fCutMaxC22(0),
107   fCutMaxC33(0),
108   fCutMaxC44(0),
109   fCutMaxC55(0),
110   fCutAcceptKinkDaughters(0),
111   fCutRequireTPCRefit(0),
112   fCutRequireITSRefit(0),
113   fCutNsigmaToVertex(0),
114   fCutSigmaToVertexRequired(0),
115   fPMin(0),
116   fPMax(0),
117   fPtMin(0),
118   fPtMax(0),
119   fPxMin(0),
120   fPxMax(0),
121   fPyMin(0),
122   fPyMax(0),
123   fPzMin(0),
124   fPzMax(0),
125   fEtaMin(0),
126   fEtaMax(0),
127   fRapMin(0),
128   fRapMax(0),
129   fHistogramsOn(0),
130   fhCutStatistics(0),         
131   fhCutCorrelation(0)
132 {
133   //
134   // constructor
135   //
136
137   Init();
138
139   //##############################################################################
140   // setting default cuts
141   SetMinNClustersTPC();
142   SetMinNClustersITS();
143   SetMaxChi2PerClusterTPC();
144   SetMaxChi2PerClusterITS();                                
145   SetMaxCovDiagonalElements();                                      
146   SetRequireTPCRefit();
147   SetRequireITSRefit();
148   SetAcceptKingDaughters();
149   SetMinNsigmaToVertex();
150   SetRequireSigmaToVertex();
151   SetPRange();
152   SetPtRange();
153   SetPxRange();
154   SetPyRange();
155   SetPzRange();
156   SetEtaRange();
157   SetRapRange();
158
159   SetHistogramsOn();
160 }
161
162 //_____________________________________________________________________________
163 AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
164   fCutMinNClusterTPC(0),
165   fCutMinNClusterITS(0),
166   fCutMaxChi2PerClusterTPC(0),
167   fCutMaxChi2PerClusterITS(0),
168   fCutMaxC11(0),
169   fCutMaxC22(0),
170   fCutMaxC33(0),
171   fCutMaxC44(0),
172   fCutMaxC55(0),
173   fCutAcceptKinkDaughters(0),
174   fCutRequireTPCRefit(0),
175   fCutRequireITSRefit(0),
176   fCutNsigmaToVertex(0),
177   fCutSigmaToVertexRequired(0),
178   fPMin(0),
179   fPMax(0),
180   fPtMin(0),
181   fPtMax(0),
182   fPxMin(0),
183   fPxMax(0),
184   fPyMin(0),
185   fPyMax(0),
186   fPzMin(0),
187   fPzMax(0),
188   fEtaMin(0),
189   fEtaMax(0),
190   fRapMin(0),
191   fRapMax(0),
192   fHistogramsOn(0),
193   ffDTheoretical(0),                                 
194   fhCutStatistics(0),         
195   fhCutCorrelation(0)
196 {
197   //
198   // copy constructor
199   //
200
201   ((AliESDtrackCuts &) c).Copy(*this);
202 }
203
204 AliESDtrackCuts::~AliESDtrackCuts()
205 {
206   //
207   // destructor
208   //
209
210   for (Int_t i=0; i<2; i++) {
211     
212     if (fhNClustersITS[i])
213       delete fhNClustersITS[i];            
214     if (fhNClustersTPC[i])
215       delete fhNClustersTPC[i];                
216     if (fhChi2PerClusterITS[i])
217       delete fhChi2PerClusterITS[i];       
218     if (fhChi2PerClusterTPC[i])
219       delete fhChi2PerClusterTPC[i];       
220     if (fhC11[i])
221       delete fhC11[i];                     
222     if (fhC22[i])
223       delete fhC22[i];                     
224     if (fhC33[i])
225       delete fhC33[i];                     
226     if (fhC44[i])
227       delete fhC44[i];                     
228     if (fhC55[i])
229     delete fhC55[i];                     
230     
231     if (fhDXY[i])
232       delete fhDXY[i];                     
233     if (fhDZ[i])
234       delete fhDZ[i];                      
235     if (fhDXYvsDZ[i])
236       delete fhDXYvsDZ[i];                 
237     
238     if (fhDXYNormalized[i])
239       delete fhDXYNormalized[i];           
240     if (fhDZNormalized[i])
241       delete fhDZNormalized[i];
242     if (fhDXYvsDZNormalized[i])
243       delete fhDXYvsDZNormalized[i];       
244     if (fhNSigmaToVertex[i])
245       delete fhNSigmaToVertex[i];
246   }
247
248   if (ffDTheoretical)
249     delete ffDTheoretical;
250
251   if (fhCutStatistics)
252     delete fhCutStatistics;             
253   if (fhCutCorrelation)
254     delete fhCutCorrelation;            
255 }
256
257 void AliESDtrackCuts::Init()
258 {
259   //
260   // sets everything to zero
261   //
262
263   fCutMinNClusterTPC = 0;
264   fCutMinNClusterITS = 0;
265
266   fCutMaxChi2PerClusterTPC = 0;
267   fCutMaxChi2PerClusterITS = 0;
268
269   fCutMaxC11 = 0;
270   fCutMaxC22 = 0;
271   fCutMaxC33 = 0;
272   fCutMaxC44 = 0;
273   fCutMaxC55 = 0;
274
275   fCutAcceptKinkDaughters = 0;
276   fCutRequireTPCRefit = 0;
277   fCutRequireITSRefit = 0;
278
279   fCutNsigmaToVertex = 0;
280   fCutSigmaToVertexRequired = 0;
281
282   fPMin = 0;
283   fPMax = 0;
284   fPtMin = 0;
285   fPtMax = 0;
286   fPxMin = 0;
287   fPxMax = 0;
288   fPyMin = 0;
289   fPyMax = 0;
290   fPzMin = 0;
291   fPzMax = 0;
292   fEtaMin = 0;
293   fEtaMax = 0;
294   fRapMin = 0;
295   fRapMax = 0;
296
297   fHistogramsOn = kFALSE;
298
299   for (Int_t i=0; i<2; ++i)
300   {
301     fhNClustersITS[i] = 0;
302     fhNClustersTPC[i] = 0;
303
304     fhChi2PerClusterITS[i] = 0;
305     fhChi2PerClusterTPC[i] = 0;
306
307     fhC11[i] = 0;
308     fhC22[i] = 0;
309     fhC33[i] = 0;
310     fhC44[i] = 0;
311     fhC55[i] = 0;
312
313     fhDXY[i] = 0;
314     fhDZ[i] = 0;
315     fhDXYvsDZ[i] = 0;
316
317     fhDXYNormalized[i] = 0;
318     fhDZNormalized[i] = 0;
319     fhDXYvsDZNormalized[i] = 0;
320     fhNSigmaToVertex[i] = 0;
321   }
322   ffDTheoretical = 0;
323
324   fhCutStatistics = 0;
325   fhCutCorrelation = 0;
326 }
327
328 //_____________________________________________________________________________
329 AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
330 {
331   //
332   // Assignment operator
333   //
334
335   if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
336   return *this;
337 }
338
339 //_____________________________________________________________________________
340 void AliESDtrackCuts::Copy(TObject &c) const
341 {
342   //
343   // Copy function
344   //
345
346   AliESDtrackCuts& target = (AliESDtrackCuts &) c;
347
348   target.Init();
349
350   target.fCutMinNClusterTPC = fCutMinNClusterTPC;
351   target.fCutMinNClusterITS = fCutMinNClusterITS;
352
353   target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
354   target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
355
356   target.fCutMaxC11 = fCutMaxC11;
357   target.fCutMaxC22 = fCutMaxC22;
358   target.fCutMaxC33 = fCutMaxC33;
359   target.fCutMaxC44 = fCutMaxC44;
360   target.fCutMaxC55 = fCutMaxC55;
361
362   target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
363   target.fCutRequireTPCRefit = fCutRequireTPCRefit;
364   target.fCutRequireITSRefit = fCutRequireITSRefit;
365
366   target.fCutNsigmaToVertex = fCutNsigmaToVertex;
367   target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
368
369   target.fPMin = fPMin;
370   target.fPMax = fPMax;
371   target.fPtMin = fPtMin;
372   target.fPtMax = fPtMax;
373   target.fPxMin = fPxMin;
374   target.fPxMax = fPxMax;
375   target.fPyMin = fPyMin;
376   target.fPyMax = fPyMax;
377   target.fPzMin = fPzMin;
378   target.fPzMax = fPzMax;
379   target.fEtaMin = fEtaMin;
380   target.fEtaMax = fEtaMax;
381   target.fRapMin = fRapMin;
382   target.fRapMax = fRapMax;
383
384   target.fHistogramsOn = fHistogramsOn;
385
386   for (Int_t i=0; i<2; ++i)
387   {
388     if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
389     if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
390
391     if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
392     if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
393
394     if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
395     if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
396     if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
397     if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
398     if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
399
400     if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
401     if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
402     if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
403
404     if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
405     if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
406     if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
407     if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
408   }
409   if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
410
411   if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
412   if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
413
414   TNamed::Copy(c);
415 }
416
417 //_____________________________________________________________________________
418 Long64_t AliESDtrackCuts::Merge(TCollection* list) {
419   // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
420   // Returns the number of merged objects (including this)
421
422   if (!list)
423     return 0;
424   
425   if (list->IsEmpty())
426     return 1;
427
428   if (!fHistogramsOn)
429     return 0;
430
431   TIterator* iter = list->MakeIterator();
432   TObject* obj;
433
434
435   // collection of measured and generated histograms
436   Int_t count = 0;
437   while ((obj = iter->Next())) {
438
439     AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
440     if (entry == 0)
441       continue;
442
443     if (!entry->fHistogramsOn)
444       continue;
445     
446     for (Int_t i=0; i<2; i++) {
447       
448       fhNClustersITS[i]      ->Add(entry->fhNClustersITS[i]     );      
449       fhNClustersTPC[i]      ->Add(entry->fhNClustersTPC[i]     ); 
450                                                                     
451       fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]); 
452       fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]); 
453                                                                     
454       fhC11[i]               ->Add(entry->fhC11[i]              ); 
455       fhC22[i]               ->Add(entry->fhC22[i]              ); 
456       fhC33[i]               ->Add(entry->fhC33[i]              ); 
457       fhC44[i]               ->Add(entry->fhC44[i]              ); 
458       fhC55[i]               ->Add(entry->fhC55[i]              ); 
459                                                                     
460       fhDXY[i]               ->Add(entry->fhDXY[i]              ); 
461       fhDZ[i]                ->Add(entry->fhDZ[i]               ); 
462       fhDXYvsDZ[i]           ->Add(entry->fhDXYvsDZ[i]          ); 
463                                                                     
464       fhDXYNormalized[i]     ->Add(entry->fhDXYNormalized[i]    ); 
465       fhDZNormalized[i]      ->Add(entry->fhDZNormalized[i]     );
466       fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]); 
467       fhNSigmaToVertex[i]    ->Add(entry->fhNSigmaToVertex[i]); 
468
469     }      
470
471     fhCutStatistics  ->Add(entry->fhCutStatistics);        
472     fhCutCorrelation ->Add(entry->fhCutCorrelation);      
473
474     count++;
475   }
476
477   return count+1;
478 }
479
480
481 //____________________________________________________________________
482 Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
483 {
484   // Calculates the number of sigma to the vertex.
485
486   Float_t b[2];
487   Float_t bRes[2];
488   Float_t bCov[3];
489   esdTrack->GetImpactParameters(b,bCov);
490   if (bCov[0]<=0 || bCov[2]<=0) {
491     AliDebug(1, "Estimated b resolution lower or equal zero!");
492     bCov[0]=0; bCov[2]=0;
493   }
494   bRes[0] = TMath::Sqrt(bCov[0]);
495   bRes[1] = TMath::Sqrt(bCov[2]);
496
497   // -----------------------------------
498   // How to get to a n-sigma cut?
499   //
500   // The accumulated statistics from 0 to d is
501   //
502   // ->  Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
503   // ->  1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
504   //
505   // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
506   // Can this be expressed in a different way?
507
508   if (bRes[0] == 0 || bRes[1] ==0)
509     return -1;
510
511   Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
512
513   // stupid rounding problem screws up everything:
514   // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
515   if (TMath::Exp(-d * d / 2) < 1e-10)
516     return 1000;
517
518   d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
519   return d;
520 }
521
522 void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
523 {
524   // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
525
526   tree->SetBranchStatus("fTracks.fFlags", 1);
527   tree->SetBranchStatus("fTracks.fITSncls", 1);
528   tree->SetBranchStatus("fTracks.fTPCncls", 1);
529   tree->SetBranchStatus("fTracks.fITSchi2", 1);
530   tree->SetBranchStatus("fTracks.fTPCchi2", 1);
531   tree->SetBranchStatus("fTracks.fC*", 1);
532   tree->SetBranchStatus("fTracks.fD", 1);
533   tree->SetBranchStatus("fTracks.fZ", 1);
534   tree->SetBranchStatus("fTracks.fCdd", 1);
535   tree->SetBranchStatus("fTracks.fCdz", 1);
536   tree->SetBranchStatus("fTracks.fCzz", 1);
537   tree->SetBranchStatus("fTracks.fP*", 1);
538   tree->SetBranchStatus("fTracks.fR*", 1);
539   tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
540 }
541
542 //____________________________________________________________________
543 Bool_t
544 AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
545   // 
546   // figure out if the tracks survives all the track cuts defined
547   //
548   // the different quality parameter and kinematic values are first
549   // retrieved from the track. then it is found out what cuts the
550   // track did not survive and finally the cuts are imposed.
551
552   // this function needs the following branches:
553   // fTracks.fFlags
554   // fTracks.fITSncls
555   // fTracks.fTPCncls
556   // fTracks.fITSchi2
557   // fTracks.fTPCchi2
558   // fTracks.fC   //GetExternalCovariance
559   // fTracks.fD   //GetImpactParameters
560   // fTracks.fZ   //GetImpactParameters
561   // fTracks.fCdd //GetImpactParameters
562   // fTracks.fCdz //GetImpactParameters
563   // fTracks.fCzz //GetImpactParameters
564   // fTracks.fP   //GetPxPyPz
565   // fTracks.fR   //GetMass
566   // fTracks.fP   //GetMass
567   // fTracks.fKinkIndexes
568
569   UInt_t status = esdTrack->GetStatus();
570
571   // dummy array
572   Int_t  fIdxInt[200];
573
574   // getting quality parameters from the ESD track
575   Int_t nClustersITS = esdTrack->GetITSclusters(fIdxInt);
576   Int_t nClustersTPC = esdTrack->GetTPCclusters(fIdxInt);
577   
578
579
580   Float_t chi2PerClusterITS = -1;
581   Float_t chi2PerClusterTPC = -1;
582   if (nClustersITS!=0)
583     chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
584   if (nClustersTPC!=0)
585     chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
586
587   Double_t extCov[15];
588   esdTrack->GetExternalCovariance(extCov);
589
590   // getting the track to vertex parameters
591   Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
592
593   // getting the kinematic variables of the track
594   // (assuming the mass is known)
595   Double_t p[3];
596   esdTrack->GetPxPyPz(p);
597   Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
598   Float_t pt       = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
599   Float_t energy   = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
600
601
602   //y-eta related calculations
603   Float_t eta = -100.;
604   Float_t y   = -100.;
605   if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
606     eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
607   if((energy != TMath::Abs(p[2]))&&(momentum != 0))
608     y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
609
610   
611   //########################################################################
612   // cut the track?
613   
614   Bool_t cuts[kNCuts];
615   for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
616   
617   // track quality cuts
618   if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
619     cuts[0]=kTRUE;
620   if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
621     cuts[1]=kTRUE;
622   if (nClustersTPC<fCutMinNClusterTPC)
623     cuts[2]=kTRUE;
624   if (nClustersITS<fCutMinNClusterITS) 
625     cuts[3]=kTRUE;
626   if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC) 
627     cuts[4]=kTRUE; 
628   if (chi2PerClusterITS>fCutMaxChi2PerClusterITS) 
629     cuts[5]=kTRUE;
630   if (extCov[0]  > fCutMaxC11) 
631     cuts[6]=kTRUE;  
632   if (extCov[2]  > fCutMaxC22) 
633     cuts[7]=kTRUE;  
634   if (extCov[5]  > fCutMaxC33) 
635     cuts[8]=kTRUE;  
636   if (extCov[9]  > fCutMaxC44) 
637     cuts[9]=kTRUE;  
638   if (extCov[14]  > fCutMaxC55) 
639     cuts[10]=kTRUE;  
640   if (nSigmaToVertex > fCutNsigmaToVertex)
641     cuts[11] = kTRUE;
642   // if n sigma could not be calculated
643   if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
644     cuts[12]=kTRUE;
645   if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
646     cuts[13]=kTRUE;
647   // track kinematics cut
648   if((momentum < fPMin) || (momentum > fPMax)) 
649     cuts[14]=kTRUE;
650   if((pt < fPtMin) || (pt > fPtMax)) 
651     cuts[15] = kTRUE;
652   if((p[0] < fPxMin) || (p[0] > fPxMax)) 
653     cuts[16] = kTRUE;
654   if((p[1] < fPyMin) || (p[1] > fPyMax)) 
655     cuts[17] = kTRUE;
656   if((p[2] < fPzMin) || (p[2] > fPzMax))
657     cuts[18] = kTRUE;
658   if((eta < fEtaMin) || (eta > fEtaMax)) 
659     cuts[19] = kTRUE;
660   if((y < fRapMin) || (y > fRapMax)) 
661     cuts[20] = kTRUE;
662
663   Bool_t cut=kFALSE;
664   for (Int_t i=0; i<kNCuts; i++) 
665     if (cuts[i]) cut = kTRUE;
666   
667   //########################################################################
668   // filling histograms
669   if (fHistogramsOn) {
670     fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
671     
672     if (cut)
673       fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
674     
675     for (Int_t i=0; i<kNCuts; i++) {
676       if (cuts[i])
677         fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
678       
679       for (Int_t j=i; j<kNCuts; j++) {
680         if (cuts[i] && cuts[j]) {
681           Float_t x = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
682           Float_t y = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
683           fhCutCorrelation->Fill(x,y);
684         }
685       }
686     }
687     
688
689     fhNClustersITS[0]->Fill(nClustersITS);
690     fhNClustersTPC[0]->Fill(nClustersTPC);
691     fhChi2PerClusterITS[0]->Fill(chi2PerClusterITS);
692     fhChi2PerClusterTPC[0]->Fill(chi2PerClusterTPC);
693
694     fhC11[0]->Fill(extCov[0]);
695     fhC22[0]->Fill(extCov[2]);
696     fhC33[0]->Fill(extCov[5]);
697     fhC44[0]->Fill(extCov[9]);
698     fhC55[0]->Fill(extCov[14]);
699
700     Float_t b[2];
701     Float_t bRes[2];
702     Float_t bCov[3];
703     esdTrack->GetImpactParameters(b,bCov);
704     if (bCov[0]<=0 || bCov[2]<=0) {
705       AliDebug(1, "Estimated b resolution lower or equal zero!");
706       bCov[0]=0; bCov[2]=0;
707     }
708     bRes[0] = TMath::Sqrt(bCov[0]);
709     bRes[1] = TMath::Sqrt(bCov[2]);
710
711     fhDZ[0]->Fill(b[1]);
712     fhDXY[0]->Fill(b[0]);
713     fhDXYvsDZ[0]->Fill(b[1],b[0]);
714
715     if (bRes[0]!=0 && bRes[1]!=0) {
716       fhDZNormalized[0]->Fill(b[1]/bRes[1]);
717       fhDXYNormalized[0]->Fill(b[0]/bRes[0]);
718       fhDXYvsDZNormalized[0]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
719       fhNSigmaToVertex[0]->Fill(nSigmaToVertex);
720     }
721   }
722
723   //########################################################################
724   // cut the track!
725   if (cut) return kFALSE;
726
727   //########################################################################
728   // filling histograms after cut
729   if (fHistogramsOn) {
730     fhNClustersITS[1]->Fill(nClustersITS);
731     fhNClustersTPC[1]->Fill(nClustersTPC);
732     fhChi2PerClusterITS[1]->Fill(chi2PerClusterITS);
733     fhChi2PerClusterTPC[1]->Fill(chi2PerClusterTPC);
734
735     fhC11[1]->Fill(extCov[0]);
736     fhC22[1]->Fill(extCov[2]);
737     fhC33[1]->Fill(extCov[5]);
738     fhC44[1]->Fill(extCov[9]);
739     fhC55[1]->Fill(extCov[14]);
740
741     Float_t b[2];
742     Float_t bRes[2];
743     Float_t bCov[3];
744     esdTrack->GetImpactParameters(b,bCov);
745     if (bCov[0]<=0 || bCov[2]<=0) {
746       AliDebug(1, "Estimated b resolution lower or equal zero!");
747       bCov[0]=0; bCov[2]=0;
748     }
749     bRes[0] = TMath::Sqrt(bCov[0]);
750     bRes[1] = TMath::Sqrt(bCov[2]);
751
752     fhDZ[1]->Fill(b[1]);
753     fhDXY[1]->Fill(b[0]);
754     fhDXYvsDZ[1]->Fill(b[1],b[0]);
755
756     if (bRes[0]!=0 && bRes[1]!=0)
757     {
758       fhDZNormalized[1]->Fill(b[1]/bRes[1]);
759       fhDXYNormalized[1]->Fill(b[0]/bRes[0]);
760       fhDXYvsDZNormalized[1]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
761       fhNSigmaToVertex[1]->Fill(nSigmaToVertex);
762     }
763   }
764
765   return kTRUE;
766 }
767
768 //____________________________________________________________________
769 TObjArray*
770 AliESDtrackCuts::GetAcceptedTracks(AliESD* esd)
771 {
772   //
773   // returns an array of all tracks that pass the cuts
774   //
775
776   TObjArray* acceptedTracks = new TObjArray();
777
778   // loop over esd tracks
779   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
780     AliESDtrack* track = esd->GetTrack(iTrack);
781
782     if (AcceptTrack(track))
783       acceptedTracks->Add(track);
784   }
785
786   return acceptedTracks;
787 }
788
789 //____________________________________________________________________
790 Int_t
791 AliESDtrackCuts::CountAcceptedTracks(AliESD* esd)
792 {
793   //
794   // returns an the number of tracks that pass the cuts
795   //
796
797   Int_t count = 0;
798
799   // loop over esd tracks
800   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
801     AliESDtrack* track = esd->GetTrack(iTrack);
802
803     if (AcceptTrack(track))
804       count++;
805   }
806
807   return count;
808 }
809
810 //____________________________________________________________________
811  void AliESDtrackCuts::DefineHistograms(Int_t color) {
812    // 
813    // diagnostics histograms are defined
814    // 
815
816    fHistogramsOn=kTRUE;
817    
818    Bool_t oldStatus = TH1::AddDirectoryStatus();
819    TH1::AddDirectory(kFALSE);
820    
821    //###################################################################################
822    // defining histograms
823
824    fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
825
826    fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
827    fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
828
829    fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
830   
831    for (Int_t i=0; i<kNCuts; i++) {
832      fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
833      fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
834      fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
835    } 
836
837   fhCutStatistics  ->SetLineColor(color);
838   fhCutCorrelation ->SetLineColor(color);
839   fhCutStatistics  ->SetLineWidth(2);
840   fhCutCorrelation ->SetLineWidth(2);
841
842   Char_t str[256];
843   for (Int_t i=0; i<2; i++) {
844     if (i==0) sprintf(str," ");
845     else sprintf(str,"_cut");
846
847     fhNClustersITS[i]        = new TH1F(Form("nClustersITS%s",str)     ,"",8,-0.5,7.5);
848     fhNClustersTPC[i]        = new TH1F(Form("nClustersTPC%s",str)     ,"",165,-0.5,164.5);
849     fhChi2PerClusterITS[i]   = new TH1F(Form("chi2PerClusterITS%s",str),"",500,0,10);
850     fhChi2PerClusterTPC[i]   = new TH1F(Form("chi2PerClusterTPC%s",str),"",500,0,10);
851
852     fhC11[i]                 = new  TH1F(Form("covMatrixDiagonal11%s",str),"",2000,0,20);
853     fhC22[i]                 = new  TH1F(Form("covMatrixDiagonal22%s",str),"",2000,0,20);
854     fhC33[i]                 = new  TH1F(Form("covMatrixDiagonal33%s",str),"",1000,0,1);
855     fhC44[i]                 = new  TH1F(Form("covMatrixDiagonal44%s",str),"",1000,0,5);
856     fhC55[i]                 = new  TH1F(Form("covMatrixDiagonal55%s",str),"",1000,0,5);
857
858     fhDXY[i]                 = new  TH1F(Form("dXY%s",str)    ,"",500,-10,10);
859     fhDZ[i]                  = new  TH1F(Form("dZ%s",str)     ,"",500,-10,10);
860     fhDXYvsDZ[i]             = new  TH2F(Form("dXYvsDZ%s",str),"",200,-10,10,200,-10,10);
861
862     fhDXYNormalized[i]       = new  TH1F(Form("dXYNormalized%s",str)    ,"",500,-10,10);
863     fhDZNormalized[i]        = new  TH1F(Form("dZNormalized%s",str)     ,"",500,-10,10);
864     fhDXYvsDZNormalized[i]   = new  TH2F(Form("dXYvsDZNormalized%s",str),"",200,-10,10,200,-10,10);
865
866     fhNSigmaToVertex[i]         = new  TH1F(Form("nSigmaToVertex%s",str),"",500,0,50);
867
868     fhNClustersITS[i]->SetTitle("n ITS clusters");
869     fhNClustersTPC[i]->SetTitle("n TPC clusters");
870     fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
871     fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
872
873     fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
874     fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
875     fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
876     fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
877     fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
878
879     fhDXY[i]->SetTitle("transverse impact parameter");
880     fhDZ[i]->SetTitle("longitudinal impact parameter");
881     fhDXYvsDZ[i]->SetTitle("longitudinal impact parameter");
882     fhDXYvsDZ[i]->SetYTitle("transverse impact parameter");
883
884     fhDXYNormalized[i]->SetTitle("normalized trans impact par");
885     fhDZNormalized[i]->SetTitle("normalized long impact par");
886     fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par");
887     fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par");
888     fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
889
890     fhNClustersITS[i]->SetLineColor(color);   fhNClustersITS[i]->SetLineWidth(2);
891     fhNClustersTPC[i]->SetLineColor(color);   fhNClustersTPC[i]->SetLineWidth(2);
892     fhChi2PerClusterITS[i]->SetLineColor(color);   fhChi2PerClusterITS[i]->SetLineWidth(2);
893     fhChi2PerClusterTPC[i]->SetLineColor(color);   fhChi2PerClusterTPC[i]->SetLineWidth(2);
894
895     fhC11[i]->SetLineColor(color);   fhC11[i]->SetLineWidth(2);
896     fhC22[i]->SetLineColor(color);   fhC22[i]->SetLineWidth(2);
897     fhC33[i]->SetLineColor(color);   fhC33[i]->SetLineWidth(2);
898     fhC44[i]->SetLineColor(color);   fhC44[i]->SetLineWidth(2);
899     fhC55[i]->SetLineColor(color);   fhC55[i]->SetLineWidth(2);
900
901     fhDXY[i]->SetLineColor(color);   fhDXY[i]->SetLineWidth(2);
902     fhDZ[i]->SetLineColor(color);   fhDZ[i]->SetLineWidth(2);
903
904     fhDXYNormalized[i]->SetLineColor(color);   fhDXYNormalized[i]->SetLineWidth(2);
905     fhDZNormalized[i]->SetLineColor(color);    fhDZNormalized[i]->SetLineWidth(2);
906     fhNSigmaToVertex[i]->SetLineColor(color);  fhNSigmaToVertex[i]->SetLineWidth(2); 
907   }
908
909   // The number of sigmas to the vertex is per definition gaussian
910   ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
911   ffDTheoretical->SetParameter(0,1);
912   
913   TH1::AddDirectory(oldStatus);
914 }
915
916 //____________________________________________________________________
917 Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
918 {
919   //
920   // loads the histograms from a file
921   // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
922   //
923
924   if (!dir)
925     dir = GetName();
926
927   if (!gDirectory->cd(dir))
928     return kFALSE;
929
930   ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
931
932   fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
933   fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
934
935   Char_t str[5];
936   for (Int_t i=0; i<2; i++) {
937     if (i==0)
938     {
939       gDirectory->cd("before_cuts");
940       str[0] = 0;
941     }
942     else
943     {
944       gDirectory->cd("after_cuts");
945       sprintf(str,"_cut");
946     }
947
948     fhNClustersITS[i]      = dynamic_cast<TH1F*> (gDirectory->Get(Form("nClustersITS%s",str)     ));
949     fhNClustersTPC[i]      = dynamic_cast<TH1F*> (gDirectory->Get(Form("nClustersTPC%s",str)     ));
950     fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("chi2PerClusterITS%s",str)));
951     fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("chi2PerClusterTPC%s",str)));
952
953     fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal11%s",str)));
954     fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal22%s",str)));
955     fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal33%s",str)));
956     fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal44%s",str)));
957     fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal55%s",str)));
958
959     fhDXY[i] =     dynamic_cast<TH1F*> (gDirectory->Get(Form("dXY%s",str)    ));
960     fhDZ[i] =      dynamic_cast<TH1F*> (gDirectory->Get(Form("dZ%s",str)     ));
961     fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get(Form("dXYvsDZ%s",str)));
962
963     fhDXYNormalized[i] =     dynamic_cast<TH1F*> (gDirectory->Get(Form("dXYNormalized%s",str)    ));
964     fhDZNormalized[i] =      dynamic_cast<TH1F*> (gDirectory->Get(Form("dZNormalized%s",str)     ));
965     fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get(Form("dXYvsDZNormalized%s",str)));
966
967     fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("nSigmaToVertex%s",str)));
968
969     // TODO only temporary
970     /*fhNClustersITS[i]->SetTitle("n ITS clusters");
971     fhNClustersTPC[i]->SetTitle("n TPC clusters");
972     fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
973     fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
974
975     fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
976     fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
977     fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
978     fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
979     fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
980
981     fhDXY[i]->SetTitle("transverse impact parameter");
982     fhDZ[i]->SetTitle("longitudinal impact parameter");
983     fhDXYvsDZ[i]->SetTitle("longitudinal impact parameter");
984     fhDXYvsDZ[i]->SetYTitle("transverse impact parameter");
985
986     fhDXYNormalized[i]->SetTitle("normalized trans impact par");
987     fhDZNormalized[i]->SetTitle("normalized long impact par");
988     fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par");
989     fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par");
990     fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");*/
991
992     gDirectory->cd("../");
993   }
994
995   gDirectory->cd("..");
996
997   return kTRUE;
998 }
999
1000 //____________________________________________________________________
1001 void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1002   //
1003   // saves the histograms in a directory (dir)
1004   //
1005
1006   if (!fHistogramsOn) {
1007     AliDebug(0, "Histograms not on - cannot save histograms!!!");
1008     return;
1009   }
1010
1011   if (!dir)
1012     dir = GetName();
1013
1014   gDirectory->mkdir(dir);
1015   gDirectory->cd(dir);
1016
1017   gDirectory->mkdir("before_cuts");
1018   gDirectory->mkdir("after_cuts");
1019  
1020   // a factor of 2 is needed since n sigma is positive
1021   ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1022   ffDTheoretical->Write("nSigmaToVertexTheory");
1023
1024   fhCutStatistics->Write();
1025   fhCutCorrelation->Write();
1026
1027   for (Int_t i=0; i<2; i++) {
1028     if (i==0)
1029       gDirectory->cd("before_cuts");
1030     else
1031       gDirectory->cd("after_cuts");
1032
1033     fhNClustersITS[i]        ->Write();
1034     fhNClustersTPC[i]        ->Write();
1035     fhChi2PerClusterITS[i]   ->Write();
1036     fhChi2PerClusterTPC[i]   ->Write();
1037
1038     fhC11[i]                 ->Write();
1039     fhC22[i]                 ->Write();
1040     fhC33[i]                 ->Write();
1041     fhC44[i]                 ->Write();
1042     fhC55[i]                 ->Write();
1043
1044     fhDXY[i]                 ->Write();
1045     fhDZ[i]                  ->Write();
1046     fhDXYvsDZ[i]             ->Write();
1047
1048     fhDXYNormalized[i]       ->Write();
1049     fhDZNormalized[i]        ->Write();
1050     fhDXYvsDZNormalized[i]   ->Write();
1051     fhNSigmaToVertex[i]      ->Write();
1052
1053     gDirectory->cd("../");
1054   }
1055
1056   gDirectory->cd("../");
1057 }
1058
1059 //____________________________________________________________________
1060 void AliESDtrackCuts::DrawHistograms()
1061 {
1062   // draws some histograms
1063
1064   TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1065   canvas1->Divide(2, 2);
1066
1067   canvas1->cd(1);
1068   fhNClustersTPC[0]->SetStats(kFALSE);
1069   fhNClustersTPC[0]->Draw();
1070
1071   canvas1->cd(2);
1072   fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1073   fhChi2PerClusterTPC[0]->Draw();
1074
1075   canvas1->cd(3);
1076   fhNSigmaToVertex[0]->SetStats(kFALSE);
1077   fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1078   fhNSigmaToVertex[0]->Draw();
1079
1080   canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1081
1082   TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1083   canvas2->Divide(3, 2);
1084
1085   canvas2->cd(1);
1086   fhC11[0]->SetStats(kFALSE);
1087   gPad->SetLogy();
1088   fhC11[0]->Draw();
1089
1090   canvas2->cd(2);
1091   fhC22[0]->SetStats(kFALSE);
1092   gPad->SetLogy();
1093   fhC22[0]->Draw();
1094
1095   canvas2->cd(3);
1096   fhC33[0]->SetStats(kFALSE);
1097   gPad->SetLogy();
1098   fhC33[0]->Draw();
1099
1100   canvas2->cd(4);
1101   fhC44[0]->SetStats(kFALSE);
1102   gPad->SetLogy();
1103   fhC44[0]->Draw();
1104
1105   canvas2->cd(5);
1106   fhC55[0]->SetStats(kFALSE);
1107   gPad->SetLogy();
1108   fhC55[0]->Draw();
1109
1110   canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1111
1112   TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1113   canvas3->Divide(3, 2);
1114
1115   canvas3->cd(1);
1116   fhDXY[0]->SetStats(kFALSE);
1117   gPad->SetLogy();
1118   fhDXY[0]->Draw();
1119
1120   canvas3->cd(2);
1121   fhDZ[0]->SetStats(kFALSE);
1122   gPad->SetLogy();
1123   fhDZ[0]->Draw();
1124
1125   canvas3->cd(3);
1126   fhDXYvsDZ[0]->SetStats(kFALSE);
1127   gPad->SetLogz();
1128   gPad->SetRightMargin(0.15);
1129   fhDXYvsDZ[0]->Draw("COLZ");
1130
1131   canvas3->cd(4);
1132   fhDXYNormalized[0]->SetStats(kFALSE);
1133   gPad->SetLogy();
1134   fhDXYNormalized[0]->Draw();
1135
1136   canvas3->cd(5);
1137   fhDZNormalized[0]->SetStats(kFALSE);
1138   gPad->SetLogy();
1139   fhDZNormalized[0]->Draw();
1140
1141   canvas3->cd(6);
1142   fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1143   gPad->SetLogz();
1144   gPad->SetRightMargin(0.15);
1145   fhDXYvsDZNormalized[0]->Draw("COLZ");
1146
1147   canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1148
1149   TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1150   canvas4->Divide(2, 1);
1151
1152   canvas4->cd(1);
1153   fhCutStatistics->SetStats(kFALSE);
1154   fhCutStatistics->LabelsOption("v");
1155   gPad->SetBottomMargin(0.3);
1156   fhCutStatistics->Draw();
1157
1158   canvas4->cd(2);
1159   fhCutCorrelation->SetStats(kFALSE);
1160   fhCutCorrelation->LabelsOption("v");
1161   gPad->SetBottomMargin(0.3);
1162   gPad->SetLeftMargin(0.3);
1163   fhCutCorrelation->Draw("COLZ");
1164
1165   canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1166
1167   /*canvas->cd(1);
1168   fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1169   fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1170
1171   canvas->cd(2);
1172   fhNClustersTPC[0]->SetStats(kFALSE);
1173   fhNClustersTPC[0]->DrawCopy();
1174
1175   canvas->cd(3);
1176   fhChi2PerClusterITS[0]->SetStats(kFALSE);
1177   fhChi2PerClusterITS[0]->DrawCopy();
1178   fhChi2PerClusterITS[1]->SetLineColor(2);
1179   fhChi2PerClusterITS[1]->DrawCopy("SAME");
1180
1181   canvas->cd(4);
1182   fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1183   fhChi2PerClusterTPC[0]->DrawCopy();
1184   fhChi2PerClusterTPC[1]->SetLineColor(2);
1185   fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1186 }
1187