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