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