]> 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
Added posibility to add V0 tender, by default this is off
[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 *
74687314 8 * documentation strictly for non-commercial purposes is hereby granted *
73318471 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>
91c88f16 21#include <AliESDVertex.h>
73318471 22#include <AliESDEvent.h>
23#include <AliLog.h>
24
25#include <TTree.h>
26#include <TCanvas.h>
27#include <TDirectory.h>
d95684c0 28#include <TH2F.h>
29#include <TF1.h>
73318471 30
31//____________________________________________________________________
32ClassImp(AliESDtrackCuts)
33
34// Cut names
35const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
36 "require TPC refit",
a86cf7f4 37 "require TPC standalone",
73318471 38 "require ITS refit",
39 "n clusters TPC",
40 "n clusters ITS",
86f0e195 41 "#Chi^{2}/cluster TPC",
42 "#Chi^{2}/cluster ITS",
73318471 43 "cov 11",
44 "cov 22",
45 "cov 33",
46 "cov 44",
47 "cov 55",
48 "trk-to-vtx",
49 "trk-to-vtx failed",
50 "kink daughters",
51 "p",
52 "p_{T}",
53 "p_{x}",
54 "p_{y}",
55 "p_{z}",
524916f0 56 "eta",
86f0e195 57 "y",
133a5e00 58 "trk-to-vtx max dca 2D absolute",
59 "trk-to-vtx max dca xy absolute",
60 "trk-to-vtx max dca z absolute",
61 "trk-to-vtx min dca 2D absolute",
62 "trk-to-vtx min dca xy absolute",
63 "trk-to-vtx min dca z absolute",
94c06b89 64 "SPD cluster requirement",
65 "SDD cluster requirement",
d95684c0 66 "SSD cluster requirement",
025fb458 67 "require ITS stand-alone",
0274b76f 68 "rel 1/pt uncertainty",
69 "require ITS Pid"
73318471 70};
71
72//____________________________________________________________________
73AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliAnalysisCuts(name,title),
74 fCutMinNClusterTPC(0),
75 fCutMinNClusterITS(0),
76 fCutMaxChi2PerClusterTPC(0),
77 fCutMaxChi2PerClusterITS(0),
78 fCutMaxC11(0),
79 fCutMaxC22(0),
80 fCutMaxC33(0),
81 fCutMaxC44(0),
82 fCutMaxC55(0),
025fb458 83 fCutMaxRel1PtUncertainty(0),
73318471 84 fCutAcceptKinkDaughters(0),
3128582b 85 fCutAcceptSharedTPCClusters(0),
86 fCutMaxFractionSharedTPCClusters(0),
73318471 87 fCutRequireTPCRefit(0),
a86cf7f4 88 fCutRequireTPCStandAlone(0),
0274b76f 89 fCutRequireITSRefit(0),
90 fCutRequireITSPid(0),
d95684c0 91 fCutRequireITSStandAlone(0),
0274b76f 92 fCutRequireITSpureSA(0),
73318471 93 fCutNsigmaToVertex(0),
94 fCutSigmaToVertexRequired(0),
133a5e00 95 fCutMaxDCAToVertexXY(0),
96 fCutMaxDCAToVertexZ(0),
97 fCutMinDCAToVertexXY(0),
98 fCutMinDCAToVertexZ(0),
f4e7aa32 99 fCutMaxDCAToVertexXYPtDep(""),
100 fCutMaxDCAToVertexZPtDep(""),
101 fCutMinDCAToVertexXYPtDep(""),
102 fCutMinDCAToVertexZPtDep(""),
f328399b 103 f1CutMaxDCAToVertexXYPtDep(0x0),
104 f1CutMaxDCAToVertexZPtDep(0x0),
105 f1CutMinDCAToVertexXYPtDep(0x0),
106 f1CutMinDCAToVertexZPtDep(0x0),
86f0e195 107 fCutDCAToVertex2D(0),
73318471 108 fPMin(0),
109 fPMax(0),
110 fPtMin(0),
111 fPtMax(0),
112 fPxMin(0),
113 fPxMax(0),
114 fPyMin(0),
115 fPyMax(0),
116 fPzMin(0),
117 fPzMax(0),
118 fEtaMin(0),
119 fEtaMax(0),
120 fRapMin(0),
121 fRapMax(0),
122 fHistogramsOn(0),
123 ffDTheoretical(0),
124 fhCutStatistics(0),
125 fhCutCorrelation(0)
126{
127 //
128 // constructor
129 //
130
131 Init();
132
133 //##############################################################################
134 // setting default cuts
135 SetMinNClustersTPC();
136 SetMinNClustersITS();
137 SetMaxChi2PerClusterTPC();
138 SetMaxChi2PerClusterITS();
025fb458 139 SetMaxCovDiagonalElements();
140 SetMaxRel1PtUncertainty();
73318471 141 SetRequireTPCRefit();
a86cf7f4 142 SetRequireTPCStandAlone();
73318471 143 SetRequireITSRefit();
0274b76f 144 SetRequireITSPid(kFALSE);
d95684c0 145 SetRequireITSStandAlone(kFALSE);
0274b76f 146 SetRequireITSPureStandAlone(kFALSE);
58c4f3fb 147 SetAcceptKinkDaughters();
94c06b89 148 SetMaxNsigmaToVertex();
94c06b89 149 SetMaxDCAToVertexXY();
150 SetMaxDCAToVertexZ();
86f0e195 151 SetDCAToVertex2D();
133a5e00 152 SetMinDCAToVertexXY();
153 SetMinDCAToVertexZ();
73318471 154 SetPRange();
155 SetPtRange();
156 SetPxRange();
157 SetPyRange();
158 SetPzRange();
159 SetEtaRange();
160 SetRapRange();
94c06b89 161 SetClusterRequirementITS(kSPD);
162 SetClusterRequirementITS(kSDD);
163 SetClusterRequirementITS(kSSD);
73318471 164
165 SetHistogramsOn();
166}
167
168//_____________________________________________________________________________
169AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
170 fCutMinNClusterTPC(0),
171 fCutMinNClusterITS(0),
172 fCutMaxChi2PerClusterTPC(0),
173 fCutMaxChi2PerClusterITS(0),
174 fCutMaxC11(0),
175 fCutMaxC22(0),
176 fCutMaxC33(0),
177 fCutMaxC44(0),
178 fCutMaxC55(0),
025fb458 179 fCutMaxRel1PtUncertainty(0),
73318471 180 fCutAcceptKinkDaughters(0),
3128582b 181 fCutAcceptSharedTPCClusters(0),
182 fCutMaxFractionSharedTPCClusters(0),
73318471 183 fCutRequireTPCRefit(0),
a86cf7f4 184 fCutRequireTPCStandAlone(0),
73318471 185 fCutRequireITSRefit(0),
0274b76f 186 fCutRequireITSPid(0),
d95684c0 187 fCutRequireITSStandAlone(0),
0274b76f 188 fCutRequireITSpureSA(0),
73318471 189 fCutNsigmaToVertex(0),
190 fCutSigmaToVertexRequired(0),
133a5e00 191 fCutMaxDCAToVertexXY(0),
192 fCutMaxDCAToVertexZ(0),
193 fCutMinDCAToVertexXY(0),
194 fCutMinDCAToVertexZ(0),
f4e7aa32 195 fCutMaxDCAToVertexXYPtDep(""),
196 fCutMaxDCAToVertexZPtDep(""),
197 fCutMinDCAToVertexXYPtDep(""),
198 fCutMinDCAToVertexZPtDep(""),
f328399b 199 f1CutMaxDCAToVertexXYPtDep(0x0),
200 f1CutMaxDCAToVertexZPtDep(0x0),
201 f1CutMinDCAToVertexXYPtDep(0x0),
202 f1CutMinDCAToVertexZPtDep(0x0),
86f0e195 203 fCutDCAToVertex2D(0),
73318471 204 fPMin(0),
205 fPMax(0),
206 fPtMin(0),
207 fPtMax(0),
208 fPxMin(0),
209 fPxMax(0),
210 fPyMin(0),
211 fPyMax(0),
212 fPzMin(0),
213 fPzMax(0),
214 fEtaMin(0),
215 fEtaMax(0),
216 fRapMin(0),
217 fRapMax(0),
218 fHistogramsOn(0),
219 ffDTheoretical(0),
220 fhCutStatistics(0),
221 fhCutCorrelation(0)
222{
223 //
224 // copy constructor
225 //
226
227 ((AliESDtrackCuts &) c).Copy(*this);
228}
229
230AliESDtrackCuts::~AliESDtrackCuts()
231{
232 //
233 // destructor
234 //
235
236 for (Int_t i=0; i<2; i++) {
237
238 if (fhNClustersITS[i])
239 delete fhNClustersITS[i];
240 if (fhNClustersTPC[i])
241 delete fhNClustersTPC[i];
242 if (fhChi2PerClusterITS[i])
243 delete fhChi2PerClusterITS[i];
244 if (fhChi2PerClusterTPC[i])
245 delete fhChi2PerClusterTPC[i];
246 if (fhC11[i])
247 delete fhC11[i];
248 if (fhC22[i])
249 delete fhC22[i];
250 if (fhC33[i])
251 delete fhC33[i];
252 if (fhC44[i])
253 delete fhC44[i];
254 if (fhC55[i])
025fb458 255 delete fhC55[i];
256
257 if (fhRel1PtUncertainty[i])
258 delete fhRel1PtUncertainty[i];
73318471 259
260 if (fhDXY[i])
261 delete fhDXY[i];
262 if (fhDZ[i])
524916f0 263 delete fhDZ[i];
264 if (fhDXYDZ[i])
265 delete fhDXYDZ[i];
73318471 266 if (fhDXYvsDZ[i])
524916f0 267 delete fhDXYvsDZ[i];
268
73318471 269 if (fhDXYNormalized[i])
270 delete fhDXYNormalized[i];
271 if (fhDZNormalized[i])
272 delete fhDZNormalized[i];
273 if (fhDXYvsDZNormalized[i])
524916f0 274 delete fhDXYvsDZNormalized[i];
73318471 275 if (fhNSigmaToVertex[i])
276 delete fhNSigmaToVertex[i];
277 if (fhPt[i])
278 delete fhPt[i];
279 if (fhEta[i])
280 delete fhEta[i];
281 }
282
f328399b 283 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
284 f1CutMaxDCAToVertexXYPtDep = 0;
285 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
286 f1CutMaxDCAToVertexZPtDep = 0;
287 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
288 f1CutMinDCAToVertexXYPtDep = 0;
289 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
290 f1CutMinDCAToVertexZPtDep = 0;
291
292
73318471 293 if (ffDTheoretical)
294 delete ffDTheoretical;
295
296 if (fhCutStatistics)
297 delete fhCutStatistics;
298 if (fhCutCorrelation)
299 delete fhCutCorrelation;
300}
301
302void AliESDtrackCuts::Init()
303{
304 //
305 // sets everything to zero
306 //
307
308 fCutMinNClusterTPC = 0;
309 fCutMinNClusterITS = 0;
310
311 fCutMaxChi2PerClusterTPC = 0;
312 fCutMaxChi2PerClusterITS = 0;
94c06b89 313
314 for (Int_t i = 0; i < 3; i++)
315 fCutClusterRequirementITS[i] = kOff;
73318471 316
317 fCutMaxC11 = 0;
318 fCutMaxC22 = 0;
319 fCutMaxC33 = 0;
320 fCutMaxC44 = 0;
321 fCutMaxC55 = 0;
025fb458 322
323 fCutMaxRel1PtUncertainty = 0;
73318471 324
325 fCutAcceptKinkDaughters = 0;
3128582b 326 fCutAcceptSharedTPCClusters = 0;
327 fCutMaxFractionSharedTPCClusters = 0;
73318471 328 fCutRequireTPCRefit = 0;
a86cf7f4 329 fCutRequireTPCStandAlone = 0;
73318471 330 fCutRequireITSRefit = 0;
0274b76f 331 fCutRequireITSPid = 0;
d95684c0 332 fCutRequireITSStandAlone = 0;
0274b76f 333 fCutRequireITSpureSA = 0;
73318471 334
335 fCutNsigmaToVertex = 0;
336 fCutSigmaToVertexRequired = 0;
133a5e00 337 fCutMaxDCAToVertexXY = 0;
338 fCutMaxDCAToVertexZ = 0;
86f0e195 339 fCutDCAToVertex2D = 0;
133a5e00 340 fCutMinDCAToVertexXY = 0;
341 fCutMinDCAToVertexZ = 0;
f4e7aa32 342 fCutMaxDCAToVertexXYPtDep = "";
343 fCutMaxDCAToVertexZPtDep = "";
344 fCutMinDCAToVertexXYPtDep = "";
345 fCutMinDCAToVertexZPtDep = "";
133a5e00 346
f328399b 347 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
348 f1CutMaxDCAToVertexXYPtDep = 0;
349 if( f1CutMaxDCAToVertexXYPtDep) delete f1CutMaxDCAToVertexXYPtDep;
350 f1CutMaxDCAToVertexXYPtDep = 0;
351 if( f1CutMaxDCAToVertexZPtDep) delete f1CutMaxDCAToVertexZPtDep;
352 f1CutMaxDCAToVertexZPtDep = 0;
353 if( f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
354 f1CutMinDCAToVertexXYPtDep = 0;
355 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
356 f1CutMinDCAToVertexZPtDep = 0;
357
86f0e195 358
73318471 359 fPMin = 0;
360 fPMax = 0;
361 fPtMin = 0;
362 fPtMax = 0;
363 fPxMin = 0;
364 fPxMax = 0;
365 fPyMin = 0;
366 fPyMax = 0;
367 fPzMin = 0;
368 fPzMax = 0;
369 fEtaMin = 0;
370 fEtaMax = 0;
371 fRapMin = 0;
372 fRapMax = 0;
373
374 fHistogramsOn = kFALSE;
375
376 for (Int_t i=0; i<2; ++i)
377 {
378 fhNClustersITS[i] = 0;
379 fhNClustersTPC[i] = 0;
380
381 fhChi2PerClusterITS[i] = 0;
382 fhChi2PerClusterTPC[i] = 0;
383
384 fhC11[i] = 0;
385 fhC22[i] = 0;
386 fhC33[i] = 0;
387 fhC44[i] = 0;
388 fhC55[i] = 0;
389
025fb458 390 fhRel1PtUncertainty[i] = 0;
391
73318471 392 fhDXY[i] = 0;
393 fhDZ[i] = 0;
524916f0 394 fhDXYDZ[i] = 0;
73318471 395 fhDXYvsDZ[i] = 0;
396
397 fhDXYNormalized[i] = 0;
398 fhDZNormalized[i] = 0;
399 fhDXYvsDZNormalized[i] = 0;
400 fhNSigmaToVertex[i] = 0;
401
402 fhPt[i] = 0;
403 fhEta[i] = 0;
404 }
405 ffDTheoretical = 0;
406
407 fhCutStatistics = 0;
408 fhCutCorrelation = 0;
409}
410
411//_____________________________________________________________________________
412AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
413{
414 //
415 // Assignment operator
416 //
417
418 if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
419 return *this;
420}
421
422//_____________________________________________________________________________
423void AliESDtrackCuts::Copy(TObject &c) const
424{
425 //
426 // Copy function
427 //
428
429 AliESDtrackCuts& target = (AliESDtrackCuts &) c;
430
431 target.Init();
432
433 target.fCutMinNClusterTPC = fCutMinNClusterTPC;
434 target.fCutMinNClusterITS = fCutMinNClusterITS;
435
436 target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
437 target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
438
94c06b89 439 for (Int_t i = 0; i < 3; i++)
440 target.fCutClusterRequirementITS[i] = fCutClusterRequirementITS[i];
441
73318471 442 target.fCutMaxC11 = fCutMaxC11;
443 target.fCutMaxC22 = fCutMaxC22;
444 target.fCutMaxC33 = fCutMaxC33;
445 target.fCutMaxC44 = fCutMaxC44;
446 target.fCutMaxC55 = fCutMaxC55;
447
025fb458 448 target.fCutMaxRel1PtUncertainty = fCutMaxRel1PtUncertainty;
449
73318471 450 target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
3128582b 451 target.fCutAcceptSharedTPCClusters = fCutAcceptSharedTPCClusters;
452 target.fCutMaxFractionSharedTPCClusters = fCutMaxFractionSharedTPCClusters;
73318471 453 target.fCutRequireTPCRefit = fCutRequireTPCRefit;
a86cf7f4 454 target.fCutRequireTPCStandAlone = fCutRequireTPCStandAlone;
73318471 455 target.fCutRequireITSRefit = fCutRequireITSRefit;
0274b76f 456 target.fCutRequireITSPid = fCutRequireITSPid;
d95684c0 457 target.fCutRequireITSStandAlone = fCutRequireITSStandAlone;
0274b76f 458 target.fCutRequireITSpureSA = fCutRequireITSpureSA;
73318471 459
460 target.fCutNsigmaToVertex = fCutNsigmaToVertex;
461 target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
133a5e00 462 target.fCutMaxDCAToVertexXY = fCutMaxDCAToVertexXY;
463 target.fCutMaxDCAToVertexZ = fCutMaxDCAToVertexZ;
86f0e195 464 target.fCutDCAToVertex2D = fCutDCAToVertex2D;
133a5e00 465 target.fCutMinDCAToVertexXY = fCutMinDCAToVertexXY;
466 target.fCutMinDCAToVertexZ = fCutMinDCAToVertexZ;
f328399b 467
f4e7aa32 468 target.fCutMaxDCAToVertexXYPtDep = fCutMaxDCAToVertexXYPtDep;
f328399b 469 target.SetMaxDCAToVertexXYPtDep(fCutMaxDCAToVertexXYPtDep.Data());
470
f4e7aa32 471 target.fCutMaxDCAToVertexZPtDep = fCutMaxDCAToVertexZPtDep;
f328399b 472 target.SetMaxDCAToVertexZPtDep(fCutMaxDCAToVertexZPtDep.Data());
473
f4e7aa32 474 target.fCutMinDCAToVertexXYPtDep = fCutMinDCAToVertexXYPtDep;
f328399b 475 target.SetMinDCAToVertexXYPtDep(fCutMinDCAToVertexXYPtDep.Data());
476
f4e7aa32 477 target.fCutMinDCAToVertexZPtDep = fCutMinDCAToVertexZPtDep;
f328399b 478 target.SetMinDCAToVertexZPtDep(fCutMinDCAToVertexZPtDep.Data());
73318471 479
480 target.fPMin = fPMin;
481 target.fPMax = fPMax;
482 target.fPtMin = fPtMin;
483 target.fPtMax = fPtMax;
484 target.fPxMin = fPxMin;
485 target.fPxMax = fPxMax;
486 target.fPyMin = fPyMin;
487 target.fPyMax = fPyMax;
488 target.fPzMin = fPzMin;
489 target.fPzMax = fPzMax;
490 target.fEtaMin = fEtaMin;
491 target.fEtaMax = fEtaMax;
492 target.fRapMin = fRapMin;
493 target.fRapMax = fRapMax;
494
495 target.fHistogramsOn = fHistogramsOn;
496
497 for (Int_t i=0; i<2; ++i)
498 {
499 if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
500 if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
501
502 if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
503 if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
504
505 if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
506 if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
507 if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
508 if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
509 if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
510
025fb458 511 if (fhRel1PtUncertainty[i]) target.fhRel1PtUncertainty[i] = (TH1F*) fhRel1PtUncertainty[i]->Clone();
512
73318471 513 if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
514 if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
524916f0 515 if (fhDXYDZ[i]) target.fhDXYDZ[i] = (TH1F*) fhDXYDZ[i]->Clone();
73318471 516 if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
517
518 if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
519 if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
520 if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
521 if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
522
523 if (fhPt[i]) target.fhPt[i] = (TH1F*) fhPt[i]->Clone();
524 if (fhEta[i]) target.fhEta[i] = (TH1F*) fhEta[i]->Clone();
525 }
526 if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
527
528 if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
529 if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
530
531 TNamed::Copy(c);
532}
533
534//_____________________________________________________________________________
535Long64_t AliESDtrackCuts::Merge(TCollection* list) {
536 // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
537 // Returns the number of merged objects (including this)
73318471 538 if (!list)
539 return 0;
73318471 540 if (list->IsEmpty())
541 return 1;
73318471 542 if (!fHistogramsOn)
543 return 0;
73318471 544 TIterator* iter = list->MakeIterator();
545 TObject* obj;
546
73318471 547 // collection of measured and generated histograms
548 Int_t count = 0;
549 while ((obj = iter->Next())) {
550
551 AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
552 if (entry == 0)
553 continue;
554
555 if (!entry->fHistogramsOn)
556 continue;
524916f0 557
73318471 558 for (Int_t i=0; i<2; i++) {
559
560 fhNClustersITS[i] ->Add(entry->fhNClustersITS[i] );
561 fhNClustersTPC[i] ->Add(entry->fhNClustersTPC[i] );
562
563 fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
564 fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
565
566 fhC11[i] ->Add(entry->fhC11[i] );
567 fhC22[i] ->Add(entry->fhC22[i] );
568 fhC33[i] ->Add(entry->fhC33[i] );
569 fhC44[i] ->Add(entry->fhC44[i] );
025fb458 570 fhC55[i] ->Add(entry->fhC55[i] );
571
572 fhRel1PtUncertainty[i] ->Add(entry->fhRel1PtUncertainty[i]);
73318471 573
574 fhDXY[i] ->Add(entry->fhDXY[i] );
575 fhDZ[i] ->Add(entry->fhDZ[i] );
524916f0 576 fhDXYDZ[i] ->Add(entry->fhDXYDZ[i] );
577 fhDXYvsDZ[i] ->Add(entry->fhDXYvsDZ[i] );
578
579 fhDXYNormalized[i] ->Add(entry->fhDXYNormalized[i] );
73318471 580 fhDZNormalized[i] ->Add(entry->fhDZNormalized[i] );
524916f0 581 fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
73318471 582 fhNSigmaToVertex[i] ->Add(entry->fhNSigmaToVertex[i]);
583
584 fhPt[i] ->Add(entry->fhPt[i]);
585 fhEta[i] ->Add(entry->fhEta[i]);
586 }
587
588 fhCutStatistics ->Add(entry->fhCutStatistics);
589 fhCutCorrelation ->Add(entry->fhCutCorrelation);
590
591 count++;
592 }
73318471 593 return count+1;
594}
595
1bf80d20 596//____________________________________________________________________
597AliESDtrackCuts* AliESDtrackCuts::GetStandardTPCOnlyTrackCuts()
598{
ce3be819 599 // creates an AliESDtrackCuts object and fills it with standard (pre data-taking) values for TPC-only cuts
1bf80d20 600
601 Printf("AliESDtrackCuts::GetStandardTPCOnlyTrackCuts: Creating track cuts for TPC-only.");
602
603 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
604
605 esdTrackCuts->SetMinNClustersTPC(50);
606 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
607 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
608
609 esdTrackCuts->SetMaxDCAToVertexZ(3.2);
610 esdTrackCuts->SetMaxDCAToVertexXY(2.4);
611 esdTrackCuts->SetDCAToVertex2D(kTRUE);
612
613 return esdTrackCuts;
614}
615
f4e7aa32 616//____________________________________________________________________
617AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2009(Bool_t selPrimaries)
618{
619 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2009 data
620
621 Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC.");
622
623 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
624
625 // TPC
2dc88643 626 esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin
f4e7aa32 627 esdTrackCuts->SetMinNClustersTPC(70);
628 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
629 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
ce3be819 630 esdTrackCuts->SetRequireTPCRefit(kTRUE);
f4e7aa32 631 // ITS
632 esdTrackCuts->SetRequireITSRefit(kTRUE);
633 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
634 AliESDtrackCuts::kAny);
635 if(selPrimaries) {
636 // 7*(0.0050+0.0060/pt^0.9)
637 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0350+0.0420/pt^0.9");
638 }
639 esdTrackCuts->SetMaxDCAToVertexZ(1.e6);
640 esdTrackCuts->SetDCAToVertex2D(kFALSE);
641 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
642 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
643
644 return esdTrackCuts;
645}
ccfc2389 646
647//____________________________________________________________________
648AliESDtrackCuts* AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(Bool_t selPrimaries)
649{
650 // creates an AliESDtrackCuts object and fills it with standard values for ITS-TPC cuts for pp 2010 data
651
652 Printf("AliESDtrackCuts::GetStandardITSTPCTrackCuts: Creating track cuts for ITS+TPC.");
653
654 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
655
656 // TPC
657 esdTrackCuts->SetRequireTPCStandAlone(kTRUE); // to get chi2 and ncls of kTPCin
658 esdTrackCuts->SetMinNClustersTPC(70);
659 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
660 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
661 esdTrackCuts->SetRequireTPCRefit(kTRUE);
662 // ITS
663 esdTrackCuts->SetRequireITSRefit(kTRUE);
664 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
665 AliESDtrackCuts::kAny);
666 if(selPrimaries) {
667 // 7*(0.0026+0.0050/pt^1.01)
668 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
669 }
670 esdTrackCuts->SetMaxDCAToVertexZ(2);
671 esdTrackCuts->SetDCAToVertex2D(kFALSE);
672 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
673 //esdTrackCuts->SetEtaRange(-0.8,+0.8);
674
675 return esdTrackCuts;
676}
677
0274b76f 678//____________________________________________________________________
679AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
680{
681 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
682
683 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
684 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
685 esdTrackCuts->SetRequireITSRefit(kTRUE);
686 esdTrackCuts->SetMinNClustersITS(4);
687 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
688 AliESDtrackCuts::kAny);
689 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
690
691 if(selPrimaries) {
692 // 7*(0.0085+0.0026/pt^1.55)
693 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
694 }
695 if(useForPid){
696 esdTrackCuts->SetRequireITSPid(kTRUE);
697 }
698 return esdTrackCuts;
699}
ccfc2389 700
0274b76f 701//____________________________________________________________________
702AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
703{
704 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
705
706 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
707 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
708 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
709 esdTrackCuts->SetRequireITSRefit(kTRUE);
710 esdTrackCuts->SetMinNClustersITS(4);
711 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
712 AliESDtrackCuts::kAny);
713 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
714
715 if(selPrimaries) {
716 // 7*(0.0085+0.0026/pt^1.55)
717 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
718 }
719 if(useForPid){
720 esdTrackCuts->SetRequireITSPid(kTRUE);
721 }
722 return esdTrackCuts;
723}
724
f4e7aa32 725
1bf80d20 726//____________________________________________________________________
727Int_t AliESDtrackCuts::GetReferenceMultiplicity(AliESDEvent* esd, Bool_t tpcOnly)
728{
729 // Gets reference multiplicity following the standard cuts and a defined fiducial volume
730 // tpcOnly = kTRUE -> consider TPC-only tracks
731 // = kFALSE -> consider global tracks
732
733 if (!tpcOnly)
734 {
735 Printf("AliESDtrackCuts::GetReferenceMultiplicity: Not implemented for global tracks!");
736 return -1;
737 }
738
739 AliESDtrackCuts* esdTrackCuts = GetStandardTPCOnlyTrackCuts();
740 esdTrackCuts->SetEtaRange(-0.8, 0.8);
741 esdTrackCuts->SetPtRange(0.15);
742
743 Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd);
744
745 delete esdTrackCuts;
746 esdTrackCuts = 0;
747
748 return nTracks;
749}
73318471 750
751//____________________________________________________________________
752Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
753{
754 // Calculates the number of sigma to the vertex.
755
756 Float_t b[2];
757 Float_t bRes[2];
758 Float_t bCov[3];
759 esdTrack->GetImpactParameters(b,bCov);
36853ddd 760
73318471 761 if (bCov[0]<=0 || bCov[2]<=0) {
57fddfbc 762 AliDebugClass(1, "Estimated b resolution lower or equal zero!");
73318471 763 bCov[0]=0; bCov[2]=0;
764 }
765 bRes[0] = TMath::Sqrt(bCov[0]);
766 bRes[1] = TMath::Sqrt(bCov[2]);
767
768 // -----------------------------------
769 // How to get to a n-sigma cut?
770 //
771 // The accumulated statistics from 0 to d is
772 //
773 // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
774 // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
775 //
cae2c21a 776 // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
73318471 777 // Can this be expressed in a different way?
778
779 if (bRes[0] == 0 || bRes[1] ==0)
780 return -1;
781
782 Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
783
0f712a2e 784 // work around precision problem
73318471 785 // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
0f712a2e 786 // 1e-15 corresponds to nsigma ~ 7.7
787 if (TMath::Exp(-d * d / 2) < 1e-15)
73318471 788 return 1000;
789
0f712a2e 790 Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
791 return nSigma;
73318471 792}
793
794void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
795{
796 // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
797
798 tree->SetBranchStatus("fTracks.fFlags", 1);
799 tree->SetBranchStatus("fTracks.fITSncls", 1);
800 tree->SetBranchStatus("fTracks.fTPCncls", 1);
801 tree->SetBranchStatus("fTracks.fITSchi2", 1);
802 tree->SetBranchStatus("fTracks.fTPCchi2", 1);
803 tree->SetBranchStatus("fTracks.fC*", 1);
804 tree->SetBranchStatus("fTracks.fD", 1);
805 tree->SetBranchStatus("fTracks.fZ", 1);
806 tree->SetBranchStatus("fTracks.fCdd", 1);
807 tree->SetBranchStatus("fTracks.fCdz", 1);
808 tree->SetBranchStatus("fTracks.fCzz", 1);
809 tree->SetBranchStatus("fTracks.fP*", 1);
810 tree->SetBranchStatus("fTracks.fR*", 1);
811 tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
812}
813
814//____________________________________________________________________
d95684c0 815Bool_t AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack)
816{
73318471 817 //
818 // figure out if the tracks survives all the track cuts defined
819 //
820 // the different quality parameter and kinematic values are first
821 // retrieved from the track. then it is found out what cuts the
822 // track did not survive and finally the cuts are imposed.
823
824 // this function needs the following branches:
825 // fTracks.fFlags
826 // fTracks.fITSncls
827 // fTracks.fTPCncls
828 // fTracks.fITSchi2
829 // fTracks.fTPCchi2
830 // fTracks.fC //GetExternalCovariance
831 // fTracks.fD //GetImpactParameters
832 // fTracks.fZ //GetImpactParameters
833 // fTracks.fCdd //GetImpactParameters
834 // fTracks.fCdz //GetImpactParameters
835 // fTracks.fCzz //GetImpactParameters
836 // fTracks.fP //GetPxPyPz
837 // fTracks.fR //GetMass
838 // fTracks.fP //GetMass
839 // fTracks.fKinkIndexes
840
841 UInt_t status = esdTrack->GetStatus();
842
73318471 843 // getting quality parameters from the ESD track
524916f0 844 Int_t nClustersITS = esdTrack->GetITSclusters(0);
a86cf7f4 845 Int_t nClustersTPC = -1;
846 if(fCutRequireTPCStandAlone) {
847 nClustersTPC = esdTrack->GetTPCNclsIter1();
848 }
849 else {
850 nClustersTPC = esdTrack->GetTPCclusters(0);
851 }
524916f0 852
3128582b 853 Int_t nClustersTPCShared = esdTrack->GetTPCnclsS();
854 Float_t fracClustersTPCShared = -1.;
855
73318471 856 Float_t chi2PerClusterITS = -1;
857 Float_t chi2PerClusterTPC = -1;
858 if (nClustersITS!=0)
859 chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
a86cf7f4 860 if (nClustersTPC!=0) {
861 if(fCutRequireTPCStandAlone) {
862 chi2PerClusterTPC = esdTrack->GetTPCchi2Iter1()/Float_t(nClustersTPC);
863 } else {
864 chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
865 }
3128582b 866 fracClustersTPCShared = Float_t(nClustersTPCShared)/Float_t(nClustersTPC);
a86cf7f4 867 }
868
73318471 869 Double_t extCov[15];
870 esdTrack->GetExternalCovariance(extCov);
871
872 // getting the track to vertex parameters
873 Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
524916f0 874
875 Float_t b[2];
876 Float_t bCov[3];
877 esdTrack->GetImpactParameters(b,bCov);
878 if (bCov[0]<=0 || bCov[2]<=0) {
879 AliDebug(1, "Estimated b resolution lower or equal zero!");
880 bCov[0]=0; bCov[2]=0;
881 }
74687314 882
f4e7aa32 883
884 // set pt-dependent DCA cuts, if requested
885 SetPtDepDCACuts(esdTrack->Pt());
886
887
e4617f4e 888 Float_t dcaToVertexXY = b[0];
74687314 889 Float_t dcaToVertexZ = b[1];
890
86f0e195 891 Float_t dcaToVertex = -1;
892
893 if (fCutDCAToVertex2D)
894 {
133a5e00 895 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
86f0e195 896 }
897 else
898 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
133a5e00 899
73318471 900 // getting the kinematic variables of the track
901 // (assuming the mass is known)
902 Double_t p[3];
903 esdTrack->GetPxPyPz(p);
36853ddd 904
73318471 905 Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
906 Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
907 Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
908
73318471 909 //y-eta related calculations
910 Float_t eta = -100.;
911 Float_t y = -100.;
912 if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
913 eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
914 if((energy != TMath::Abs(p[2]))&&(momentum != 0))
915 y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
025fb458 916
4853f638 917 if (extCov[14] < 0)
918 {
919 Printf("AliESDtrackCuts::AcceptTrack: WARNING: GetSigma1Pt2() returns negative value for external covariance matrix element fC[14]: %f. Corrupted track information, track will not be accepted!", extCov[14]);
920 return kFALSE;
921 }
025fb458 922 Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt;
73318471 923
924 //########################################################################
925 // cut the track?
926
927 Bool_t cuts[kNCuts];
928 for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
929
930 // track quality cuts
931 if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
932 cuts[0]=kTRUE;
a86cf7f4 933 if (fCutRequireTPCStandAlone && (status&AliESDtrack::kTPCin)==0)
73318471 934 cuts[1]=kTRUE;
a86cf7f4 935 if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
73318471 936 cuts[2]=kTRUE;
a86cf7f4 937 if (nClustersTPC<fCutMinNClusterTPC)
73318471 938 cuts[3]=kTRUE;
a86cf7f4 939 if (nClustersITS<fCutMinNClusterITS)
940 cuts[4]=kTRUE;
73318471 941 if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
a86cf7f4 942 cuts[5]=kTRUE;
73318471 943 if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
a86cf7f4 944 cuts[6]=kTRUE;
73318471 945 if (extCov[0] > fCutMaxC11)
73318471 946 cuts[7]=kTRUE;
a86cf7f4 947 if (extCov[2] > fCutMaxC22)
73318471 948 cuts[8]=kTRUE;
a86cf7f4 949 if (extCov[5] > fCutMaxC33)
73318471 950 cuts[9]=kTRUE;
a86cf7f4 951 if (extCov[9] > fCutMaxC44)
73318471 952 cuts[10]=kTRUE;
a86cf7f4 953 if (extCov[14] > fCutMaxC55)
954 cuts[11]=kTRUE;
73318471 955 if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
a86cf7f4 956 cuts[12] = kTRUE;
73318471 957 // if n sigma could not be calculated
958 if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
73318471 959 cuts[13]=kTRUE;
a86cf7f4 960 if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
961 cuts[14]=kTRUE;
73318471 962 // track kinematics cut
963 if((momentum < fPMin) || (momentum > fPMax))
a86cf7f4 964 cuts[15]=kTRUE;
73318471 965 if((pt < fPtMin) || (pt > fPtMax))
73318471 966 cuts[16] = kTRUE;
a86cf7f4 967 if((p[0] < fPxMin) || (p[0] > fPxMax))
73318471 968 cuts[17] = kTRUE;
a86cf7f4 969 if((p[1] < fPyMin) || (p[1] > fPyMax))
73318471 970 cuts[18] = kTRUE;
a86cf7f4 971 if((p[2] < fPzMin) || (p[2] > fPzMax))
73318471 972 cuts[19] = kTRUE;
a86cf7f4 973 if((eta < fEtaMin) || (eta > fEtaMax))
73318471 974 cuts[20] = kTRUE;
a86cf7f4 975 if((y < fRapMin) || (y > fRapMax))
524916f0 976 cuts[21] = kTRUE;
a86cf7f4 977 if (fCutDCAToVertex2D && dcaToVertex > 1)
e4617f4e 978 cuts[22] = kTRUE;
a86cf7f4 979 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
74687314 980 cuts[23] = kTRUE;
a86cf7f4 981 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
133a5e00 982 cuts[24] = kTRUE;
a86cf7f4 983 if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1)
133a5e00 984 cuts[25] = kTRUE;
a86cf7f4 985 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY)
133a5e00 986 cuts[26] = kTRUE;
a86cf7f4 987 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ)
988 cuts[27] = kTRUE;
94c06b89 989
990 for (Int_t i = 0; i < 3; i++)
a86cf7f4 991 cuts[28+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1));
d95684c0 992
0274b76f 993 if(fCutRequireITSStandAlone || fCutRequireITSpureSA){
994 if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)){
995 // TPC tracks
996 cuts[31] = kTRUE;
997 }else{
998 // ITS standalone tracks
999 if(fCutRequireITSStandAlone && !fCutRequireITSpureSA){
1000 if(status & AliESDtrack::kITSpureSA) cuts[31] = kTRUE;
1001 }else if(fCutRequireITSpureSA){
1002 if(!(status & AliESDtrack::kITSpureSA)) cuts[31] = kTRUE;
1003 }
1004 }
1005 }
f4e7aa32 1006
025fb458 1007 if (relUncertainty1Pt > fCutMaxRel1PtUncertainty)
3128582b 1008 cuts[32] = kTRUE;
1009
1010 if (!fCutAcceptSharedTPCClusters && nClustersTPCShared!=0)
1011 cuts[33] = kTRUE;
1012
1013 if (fracClustersTPCShared > fCutMaxFractionSharedTPCClusters)
1014 cuts[34] = kTRUE;
1015
0274b76f 1016 if(fCutRequireITSPid){
1017 UChar_t clumap=esdTrack->GetITSClusterMap();
1018 Int_t nPointsForPid=0;
1019 for(Int_t i=2; i<6; i++){
1020 if(clumap&(1<<i)) ++nPointsForPid;
1021 }
1022 if(nPointsForPid<3) cuts[35] = kTRUE;
1023 }
1024
73318471 1025 Bool_t cut=kFALSE;
1026 for (Int_t i=0; i<kNCuts; i++)
133a5e00 1027 if (cuts[i]) {cut = kTRUE;}
524916f0 1028
1029
73318471 1030 //########################################################################
1031 // filling histograms
1032 if (fHistogramsOn) {
1033 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
73318471 1034 if (cut)
1035 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
1036
1037 for (Int_t i=0; i<kNCuts; i++) {
1038 if (cuts[i])
524916f0 1039 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
1040
73318471 1041 for (Int_t j=i; j<kNCuts; j++) {
524916f0 1042 if (cuts[i] && cuts[j]) {
1043 Float_t xC = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
1044 Float_t yC = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
1045 fhCutCorrelation->Fill(xC, yC);
1046 }
73318471 1047 }
1048 }
73318471 1049 }
1050
524916f0 1051 // now we loop over the filling of the histograms twice: once "before" the cut, once "after"
1052 // the code is not in a function due to too many local variables that would need to be passed
73318471 1053
524916f0 1054 for (Int_t id = 0; id < 2; id++)
1055 {
1056 // id = 0 --> before cut
1057 // id = 1 --> after cut
73318471 1058
524916f0 1059 if (fHistogramsOn)
73318471 1060 {
524916f0 1061 fhNClustersITS[id]->Fill(nClustersITS);
1062 fhNClustersTPC[id]->Fill(nClustersTPC);
1063 fhChi2PerClusterITS[id]->Fill(chi2PerClusterITS);
1064 fhChi2PerClusterTPC[id]->Fill(chi2PerClusterTPC);
1065
1066 fhC11[id]->Fill(extCov[0]);
1067 fhC22[id]->Fill(extCov[2]);
1068 fhC33[id]->Fill(extCov[5]);
1069 fhC44[id]->Fill(extCov[9]);
1070 fhC55[id]->Fill(extCov[14]);
1071
025fb458 1072 fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt);
1073
524916f0 1074 fhPt[id]->Fill(pt);
1075 fhEta[id]->Fill(eta);
1076
1077 Float_t bRes[2];
1078 bRes[0] = TMath::Sqrt(bCov[0]);
1079 bRes[1] = TMath::Sqrt(bCov[2]);
1080
1081 fhDZ[id]->Fill(b[1]);
1082 fhDXY[id]->Fill(b[0]);
1083 fhDXYDZ[id]->Fill(dcaToVertex);
1084 fhDXYvsDZ[id]->Fill(b[1],b[0]);
1085
1086 if (bRes[0]!=0 && bRes[1]!=0) {
1087 fhDZNormalized[id]->Fill(b[1]/bRes[1]);
1088 fhDXYNormalized[id]->Fill(b[0]/bRes[0]);
1089 fhDXYvsDZNormalized[id]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
1090 fhNSigmaToVertex[id]->Fill(nSigmaToVertex);
1091 }
73318471 1092 }
524916f0 1093
1094 // cut the track
1095 if (cut)
1096 return kFALSE;
73318471 1097 }
1098
1099 return kTRUE;
1100}
1101
94c06b89 1102//____________________________________________________________________
1103Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2)
1104{
1105 // checks if the cluster requirement is fullfilled (in this case: return kTRUE)
1106
1107 switch (req)
1108 {
1109 case kOff: return kTRUE;
1110 case kNone: return !clusterL1 && !clusterL2;
1111 case kAny: return clusterL1 || clusterL2;
1112 case kFirst: return clusterL1;
1113 case kOnlyFirst: return clusterL1 && !clusterL2;
1114 case kSecond: return clusterL2;
1115 case kOnlySecond: return clusterL2 && !clusterL1;
1116 case kBoth: return clusterL1 && clusterL2;
1117 }
1118
1119 return kFALSE;
1120}
1121
73318471 1122//____________________________________________________________________
524916f0 1123AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack)
73318471 1124{
b7b857f0 1125
1126 // Utility function to
1127 // create a TPC only track from the given esd track
1128 //
1129 // IMPORTANT: The track has to be deleted by the user
73318471 1130 //
524916f0 1131 // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be
1132 // there are only missing propagations here that are needed for old data
1133 // this function will therefore become obsolete
73318471 1134 //
524916f0 1135 // adapted from code provided by CKB
73318471 1136
524916f0 1137 if (!esd->GetPrimaryVertexTPC())
1138 return 0; // No TPC vertex no TPC tracks
73318471 1139
91c88f16 1140 if(!esd->GetPrimaryVertexTPC()->GetStatus())
1141 return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case
91c88f16 1142
524916f0 1143 AliESDtrack* track = esd->GetTrack(iTrack);
1144 if (!track)
1145 return 0;
36853ddd 1146
524916f0 1147 AliESDtrack *tpcTrack = new AliESDtrack();
73318471 1148
524916f0 1149 // only true if we have a tpc track
1150 if (!track->FillTPCOnlyTrack(*tpcTrack))
1151 {
1152 delete tpcTrack;
1153 return 0;
73318471 1154 }
1155
524916f0 1156 // propagate to Vertex
1157 // not needed for normal reconstructed ESDs...
1158 // Double_t pTPC[2],covTPC[3];
1159 // tpcTrack->PropagateToDCA(esd->GetPrimaryVertexTPC(), esd->GetMagneticField(), 10000, pTPC, covTPC);
1160
1161 return tpcTrack;
73318471 1162}
1163
1164//____________________________________________________________________
36853ddd 1165TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd,Bool_t bTPC)
73318471 1166{
1167 //
1168 // returns an array of all tracks that pass the cuts
36853ddd 1169 // or an array of TPC only tracks (propagated to the TPC vertex during reco)
1170 // tracks that pass the cut
73318471 1171
1172 TObjArray* acceptedTracks = new TObjArray();
1173
1174 // loop over esd tracks
1175 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
36853ddd 1176 if(bTPC){
1177 if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks
91c88f16 1178 if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default
36853ddd 1179
524916f0 1180 AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack);
1181 if (!tpcTrack)
1182 continue;
1183
1184 if (AcceptTrack(tpcTrack)) {
1185 acceptedTracks->Add(tpcTrack);
36853ddd 1186 }
524916f0 1187 else
1188 delete tpcTrack;
1189 }
1190 else
1191 {
1192 AliESDtrack* track = esd->GetTrack(iTrack);
1193 if(AcceptTrack(track))
1194 acceptedTracks->Add(track);
36853ddd 1195 }
36853ddd 1196 }
1197 if(bTPC)acceptedTracks->SetOwner(kTRUE);
73318471 1198 return acceptedTracks;
1199}
1200
1201//____________________________________________________________________
1202Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd)
1203{
1204 //
1205 // returns an the number of tracks that pass the cuts
1206 //
1207
1208 Int_t count = 0;
1209
1210 // loop over esd tracks
1211 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1212 AliESDtrack* track = esd->GetTrack(iTrack);
73318471 1213 if (AcceptTrack(track))
1214 count++;
1215 }
1216
1217 return count;
1218}
1219
1220//____________________________________________________________________
1221 void AliESDtrackCuts::DefineHistograms(Int_t color) {
1222 //
1223 // diagnostics histograms are defined
1224 //
1225
1226 fHistogramsOn=kTRUE;
1227
1228 Bool_t oldStatus = TH1::AddDirectoryStatus();
1229 TH1::AddDirectory(kFALSE);
1230
1231 //###################################################################################
1232 // defining histograms
1233
1234 fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
1235
1236 fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
1237 fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
1238
1239 fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
1240
1241 for (Int_t i=0; i<kNCuts; i++) {
1242 fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
1243 fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1244 fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
0f712a2e 1245 }
73318471 1246
1247 fhCutStatistics ->SetLineColor(color);
1248 fhCutCorrelation ->SetLineColor(color);
1249 fhCutStatistics ->SetLineWidth(2);
1250 fhCutCorrelation ->SetLineWidth(2);
1251
73318471 1252 for (Int_t i=0; i<2; i++) {
524916f0 1253 fhNClustersITS[i] = new TH1F("nClustersITS" ,"",8,-0.5,7.5);
1254 fhNClustersTPC[i] = new TH1F("nClustersTPC" ,"",165,-0.5,164.5);
1255 fhChi2PerClusterITS[i] = new TH1F("chi2PerClusterITS","",500,0,10);
1256 fhChi2PerClusterTPC[i] = new TH1F("chi2PerClusterTPC","",500,0,10);
1257
1258 fhC11[i] = new TH1F("covMatrixDiagonal11","",2000,0,20);
1259 fhC22[i] = new TH1F("covMatrixDiagonal22","",2000,0,20);
0f712a2e 1260 fhC33[i] = new TH1F("covMatrixDiagonal33","",1000,0,0.1);
1261 fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1);
524916f0 1262 fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5);
1263
025fb458 1264 fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5);
1265
524916f0 1266 fhDXY[i] = new TH1F("dXY" ,"",500,-10,10);
1267 fhDZ[i] = new TH1F("dZ" ,"",500,-10,10);
1268 fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10);
1269 fhDXYvsDZ[i] = new TH2F("dXYvsDZ","",200,-10,10,200,-10,10);
1270
1271 fhDXYNormalized[i] = new TH1F("dXYNormalized" ,"",500,-10,10);
1272 fhDZNormalized[i] = new TH1F("dZNormalized" ,"",500,-10,10);
1273 fhDXYvsDZNormalized[i] = new TH2F("dXYvsDZNormalized","",200,-10,10,200,-10,10);
1274
1275 fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10);
1276
86f0e195 1277 fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0);
524916f0 1278 fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0);
73318471 1279
1280 fhNClustersITS[i]->SetTitle("n ITS clusters");
1281 fhNClustersTPC[i]->SetTitle("n TPC clusters");
1282 fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
1283 fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
1284
1285 fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
1286 fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
1287 fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
1288 fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
1289 fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
1290
025fb458 1291 fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}");
1292
86f0e195 1293 fhDXY[i]->SetXTitle("transverse impact parameter (cm)");
1294 fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1295 fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)");
1296 fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1297 fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)");
73318471 1298
86f0e195 1299 fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)");
1300 fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1301 fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1302 fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)");
73318471 1303 fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
1304
1305 fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2);
1306 fhNClustersTPC[i]->SetLineColor(color); fhNClustersTPC[i]->SetLineWidth(2);
1307 fhChi2PerClusterITS[i]->SetLineColor(color); fhChi2PerClusterITS[i]->SetLineWidth(2);
1308 fhChi2PerClusterTPC[i]->SetLineColor(color); fhChi2PerClusterTPC[i]->SetLineWidth(2);
1309
1310 fhC11[i]->SetLineColor(color); fhC11[i]->SetLineWidth(2);
1311 fhC22[i]->SetLineColor(color); fhC22[i]->SetLineWidth(2);
1312 fhC33[i]->SetLineColor(color); fhC33[i]->SetLineWidth(2);
1313 fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2);
1314 fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2);
1315
025fb458 1316 fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2);
1317
73318471 1318 fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2);
524916f0 1319 fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2);
1320 fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2);
73318471 1321
1322 fhDXYNormalized[i]->SetLineColor(color); fhDXYNormalized[i]->SetLineWidth(2);
1323 fhDZNormalized[i]->SetLineColor(color); fhDZNormalized[i]->SetLineWidth(2);
1324 fhNSigmaToVertex[i]->SetLineColor(color); fhNSigmaToVertex[i]->SetLineWidth(2);
1325 }
1326
1327 // The number of sigmas to the vertex is per definition gaussian
1328 ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
1329 ffDTheoretical->SetParameter(0,1);
524916f0 1330
73318471 1331 TH1::AddDirectory(oldStatus);
1332}
1333
1334//____________________________________________________________________
1335Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
1336{
1337 //
1338 // loads the histograms from a file
1339 // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
1340 //
1341
1342 if (!dir)
1343 dir = GetName();
1344
1345 if (!gDirectory->cd(dir))
1346 return kFALSE;
1347
1348 ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
1349
1350 fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
1351 fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
1352
73318471 1353 for (Int_t i=0; i<2; i++) {
1354 if (i==0)
1355 {
1356 gDirectory->cd("before_cuts");
73318471 1357 }
1358 else
73318471 1359 gDirectory->cd("after_cuts");
73318471 1360
524916f0 1361 fhNClustersITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersITS" ));
1362 fhNClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersTPC" ));
1363 fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterITS"));
1364 fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterTPC"));
73318471 1365
524916f0 1366 fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal11"));
1367 fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal22"));
1368 fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal33"));
1369 fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal44"));
1370 fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal55"));
73318471 1371
025fb458 1372 fhRel1PtUncertainty[i] = dynamic_cast<TH1F*> (gDirectory->Get("rel1PtUncertainty"));
1373
524916f0 1374 fhDXY[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXY" ));
1375 fhDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZ" ));
1376 fhDXYDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYDZ"));
1377 fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZ"));
73318471 1378
524916f0 1379 fhDXYNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYNormalized" ));
1380 fhDZNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZNormalized" ));
1381 fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZNormalized"));
1382 fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSigmaToVertex"));
73318471 1383
524916f0 1384 fhPt[i] = dynamic_cast<TH1F*> (gDirectory->Get("pt"));
1385 fhEta[i] = dynamic_cast<TH1F*> (gDirectory->Get("eta"));
73318471 1386
1387 gDirectory->cd("../");
1388 }
1389
1390 gDirectory->cd("..");
1391
1392 return kTRUE;
1393}
1394
1395//____________________________________________________________________
1396void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1397 //
1398 // saves the histograms in a directory (dir)
1399 //
1400
1401 if (!fHistogramsOn) {
1402 AliDebug(0, "Histograms not on - cannot save histograms!!!");
1403 return;
1404 }
1405
1406 if (!dir)
1407 dir = GetName();
1408
1409 gDirectory->mkdir(dir);
1410 gDirectory->cd(dir);
1411
1412 gDirectory->mkdir("before_cuts");
1413 gDirectory->mkdir("after_cuts");
1414
1415 // a factor of 2 is needed since n sigma is positive
1416 ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1417 ffDTheoretical->Write("nSigmaToVertexTheory");
1418
1419 fhCutStatistics->Write();
1420 fhCutCorrelation->Write();
1421
1422 for (Int_t i=0; i<2; i++) {
1423 if (i==0)
1424 gDirectory->cd("before_cuts");
1425 else
1426 gDirectory->cd("after_cuts");
1427
1428 fhNClustersITS[i] ->Write();
1429 fhNClustersTPC[i] ->Write();
1430 fhChi2PerClusterITS[i] ->Write();
1431 fhChi2PerClusterTPC[i] ->Write();
1432
1433 fhC11[i] ->Write();
1434 fhC22[i] ->Write();
1435 fhC33[i] ->Write();
1436 fhC44[i] ->Write();
1437 fhC55[i] ->Write();
1438
025fb458 1439 fhRel1PtUncertainty[i] ->Write();
1440
73318471 1441 fhDXY[i] ->Write();
1442 fhDZ[i] ->Write();
524916f0 1443 fhDXYDZ[i] ->Write();
73318471 1444 fhDXYvsDZ[i] ->Write();
1445
1446 fhDXYNormalized[i] ->Write();
1447 fhDZNormalized[i] ->Write();
1448 fhDXYvsDZNormalized[i] ->Write();
1449 fhNSigmaToVertex[i] ->Write();
1450
1451 fhPt[i] ->Write();
1452 fhEta[i] ->Write();
1453
1454 gDirectory->cd("../");
1455 }
1456
1457 gDirectory->cd("../");
1458}
1459
1460//____________________________________________________________________
1461void AliESDtrackCuts::DrawHistograms()
1462{
1463 // draws some histograms
1464
1465 TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1466 canvas1->Divide(2, 2);
1467
1468 canvas1->cd(1);
1469 fhNClustersTPC[0]->SetStats(kFALSE);
1470 fhNClustersTPC[0]->Draw();
1471
1472 canvas1->cd(2);
1473 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1474 fhChi2PerClusterTPC[0]->Draw();
1475
1476 canvas1->cd(3);
1477 fhNSigmaToVertex[0]->SetStats(kFALSE);
1478 fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1479 fhNSigmaToVertex[0]->Draw();
1480
1481 canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1482
1483 TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1484 canvas2->Divide(3, 2);
1485
1486 canvas2->cd(1);
1487 fhC11[0]->SetStats(kFALSE);
1488 gPad->SetLogy();
1489 fhC11[0]->Draw();
1490
1491 canvas2->cd(2);
1492 fhC22[0]->SetStats(kFALSE);
1493 gPad->SetLogy();
1494 fhC22[0]->Draw();
1495
1496 canvas2->cd(3);
1497 fhC33[0]->SetStats(kFALSE);
1498 gPad->SetLogy();
1499 fhC33[0]->Draw();
1500
1501 canvas2->cd(4);
1502 fhC44[0]->SetStats(kFALSE);
1503 gPad->SetLogy();
1504 fhC44[0]->Draw();
1505
1506 canvas2->cd(5);
1507 fhC55[0]->SetStats(kFALSE);
1508 gPad->SetLogy();
1509 fhC55[0]->Draw();
1510
025fb458 1511 canvas2->cd(6);
1512 fhRel1PtUncertainty[0]->SetStats(kFALSE);
1513 gPad->SetLogy();
1514 fhRel1PtUncertainty[0]->Draw();
1515
73318471 1516 canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1517
1518 TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1519 canvas3->Divide(3, 2);
1520
1521 canvas3->cd(1);
1522 fhDXY[0]->SetStats(kFALSE);
1523 gPad->SetLogy();
1524 fhDXY[0]->Draw();
1525
1526 canvas3->cd(2);
1527 fhDZ[0]->SetStats(kFALSE);
1528 gPad->SetLogy();
1529 fhDZ[0]->Draw();
1530
1531 canvas3->cd(3);
1532 fhDXYvsDZ[0]->SetStats(kFALSE);
1533 gPad->SetLogz();
1534 gPad->SetRightMargin(0.15);
1535 fhDXYvsDZ[0]->Draw("COLZ");
1536
1537 canvas3->cd(4);
1538 fhDXYNormalized[0]->SetStats(kFALSE);
1539 gPad->SetLogy();
1540 fhDXYNormalized[0]->Draw();
1541
1542 canvas3->cd(5);
1543 fhDZNormalized[0]->SetStats(kFALSE);
1544 gPad->SetLogy();
1545 fhDZNormalized[0]->Draw();
1546
1547 canvas3->cd(6);
1548 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1549 gPad->SetLogz();
1550 gPad->SetRightMargin(0.15);
1551 fhDXYvsDZNormalized[0]->Draw("COLZ");
1552
1553 canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1554
1555 TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1556 canvas4->Divide(2, 1);
1557
1558 canvas4->cd(1);
1559 fhCutStatistics->SetStats(kFALSE);
1560 fhCutStatistics->LabelsOption("v");
1561 gPad->SetBottomMargin(0.3);
1562 fhCutStatistics->Draw();
1563
1564 canvas4->cd(2);
1565 fhCutCorrelation->SetStats(kFALSE);
1566 fhCutCorrelation->LabelsOption("v");
1567 gPad->SetBottomMargin(0.3);
1568 gPad->SetLeftMargin(0.3);
1569 fhCutCorrelation->Draw("COLZ");
1570
1571 canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1572
1573 /*canvas->cd(1);
1574 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1575 fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1576
1577 canvas->cd(2);
1578 fhNClustersTPC[0]->SetStats(kFALSE);
1579 fhNClustersTPC[0]->DrawCopy();
1580
1581 canvas->cd(3);
1582 fhChi2PerClusterITS[0]->SetStats(kFALSE);
1583 fhChi2PerClusterITS[0]->DrawCopy();
1584 fhChi2PerClusterITS[1]->SetLineColor(2);
1585 fhChi2PerClusterITS[1]->DrawCopy("SAME");
1586
1587 canvas->cd(4);
1588 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1589 fhChi2PerClusterTPC[0]->DrawCopy();
1590 fhChi2PerClusterTPC[1]->SetLineColor(2);
1591 fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1592}
f4e7aa32 1593//--------------------------------------------------------------------------
1594void AliESDtrackCuts::SetPtDepDCACuts(Double_t pt) {
1595 //
1596 // set the pt-dependent DCA cuts
1597 //
1598
f328399b 1599 if(f1CutMaxDCAToVertexXYPtDep) {
1600 fCutMaxDCAToVertexXY=f1CutMaxDCAToVertexXYPtDep->Eval(pt);
f4e7aa32 1601 }
1602
f328399b 1603 if(f1CutMaxDCAToVertexZPtDep) {
1604 fCutMaxDCAToVertexZ=f1CutMaxDCAToVertexZPtDep->Eval(pt);
f4e7aa32 1605 }
1606
f328399b 1607 if(f1CutMinDCAToVertexXYPtDep) {
1608 fCutMinDCAToVertexXY=f1CutMinDCAToVertexXYPtDep->Eval(pt);
f4e7aa32 1609 }
1610
f328399b 1611 if(f1CutMinDCAToVertexZPtDep) {
1612 fCutMinDCAToVertexZ=f1CutMinDCAToVertexZPtDep->Eval(pt);
f4e7aa32 1613 }
1614
1615
1616 return;
1617}
f328399b 1618
1619
1620
f4e7aa32 1621//--------------------------------------------------------------------------
1622Bool_t AliESDtrackCuts::CheckPtDepDCA(TString dist,Bool_t print) const {
1623 //
1624 // Check the correctness of the string syntax
1625 //
1626 Bool_t retval=kTRUE;
1627
1628 if(!dist.Contains("pt")) {
1629 if(print) printf("AliESDtrackCuts::CheckPtDepDCA(): string must contain \"pt\"\n");
1630 retval= kFALSE;
1631 }
1632 return retval;
1633}
73318471 1634
f328399b 1635 void AliESDtrackCuts::SetMaxDCAToVertexXYPtDep(const char *dist){
1636 if(!CheckPtDepDCA(dist,kTRUE)) return;
1637 if(f1CutMaxDCAToVertexXYPtDep)delete f1CutMaxDCAToVertexXYPtDep;
1638 fCutMaxDCAToVertexXYPtDep = dist;
1639 TString tmp(dist);
1640 tmp.ReplaceAll("pt","x");
1641 f1CutMaxDCAToVertexXYPtDep = new TFormula("f1CutMaxDCAToVertexXYPtDep",tmp.Data());
1642
1643}
1644
1645 void AliESDtrackCuts::SetMaxDCAToVertexZPtDep(const char *dist){
1646 if(!CheckPtDepDCA(dist,kTRUE)) return;
1647 if(f1CutMaxDCAToVertexZPtDep)delete f1CutMaxDCAToVertexZPtDep;
1648 fCutMaxDCAToVertexZPtDep = dist;
1649 TString tmp(dist);
1650 tmp.ReplaceAll("pt","x");
1651 f1CutMaxDCAToVertexZPtDep = new TFormula("f1CutMaxDCAToVertexZPtDep",tmp.Data());
1652
1653
1654}
1655
1656
1657 void AliESDtrackCuts::SetMinDCAToVertexXYPtDep(const char *dist){
1658 if(!CheckPtDepDCA(dist,kTRUE)) return;
1659 if(f1CutMinDCAToVertexXYPtDep)delete f1CutMinDCAToVertexXYPtDep;
1660 fCutMinDCAToVertexXYPtDep = dist;
1661 TString tmp(dist);
1662 tmp.ReplaceAll("pt","x");
1663 f1CutMinDCAToVertexXYPtDep = new TFormula("f1CutMinDCAToVertexXYPtDep",tmp.Data());
1664
1665}
1666
1667
1668 void AliESDtrackCuts::SetMinDCAToVertexZPtDep(const char *dist){
1669 if(!CheckPtDepDCA(dist,kTRUE)) return;
1670 if(f1CutMinDCAToVertexZPtDep)delete f1CutMinDCAToVertexZPtDep;
1671 fCutMinDCAToVertexZPtDep = dist;
1672 TString tmp(dist);
1673 tmp.ReplaceAll("pt","x");
1674 f1CutMinDCAToVertexZPtDep = new TFormula("f1CutMinDCAToVertexZPtDep",tmp.Data());
1675}