]> 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
script to run energy fits from a file
[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
ccfc2389 657 esdTrackCuts->SetMinNClustersTPC(70);
658 esdTrackCuts->SetMaxChi2PerClusterTPC(4);
659 esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
660 esdTrackCuts->SetRequireTPCRefit(kTRUE);
661 // ITS
662 esdTrackCuts->SetRequireITSRefit(kTRUE);
663 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
664 AliESDtrackCuts::kAny);
665 if(selPrimaries) {
666 // 7*(0.0026+0.0050/pt^1.01)
667 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
668 }
669 esdTrackCuts->SetMaxDCAToVertexZ(2);
670 esdTrackCuts->SetDCAToVertex2D(kFALSE);
671 esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
ccfc2389 672
673 return esdTrackCuts;
674}
675
0274b76f 676//____________________________________________________________________
677AliESDtrackCuts* AliESDtrackCuts::GetStandardITSPureSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
678{
679 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
680
681 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
682 esdTrackCuts->SetRequireITSPureStandAlone(kTRUE);
683 esdTrackCuts->SetRequireITSRefit(kTRUE);
684 esdTrackCuts->SetMinNClustersITS(4);
685 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
686 AliESDtrackCuts::kAny);
687 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
688
689 if(selPrimaries) {
690 // 7*(0.0085+0.0026/pt^1.55)
691 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
692 }
693 if(useForPid){
694 esdTrackCuts->SetRequireITSPid(kTRUE);
695 }
696 return esdTrackCuts;
697}
ccfc2389 698
0274b76f 699//____________________________________________________________________
700AliESDtrackCuts* AliESDtrackCuts::GetStandardITSSATrackCuts2009(Bool_t selPrimaries, Bool_t useForPid)
701{
702 // creates an AliESDtrackCuts object and fills it with standard values for ITS pure SA tracks
703
704 AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
705 esdTrackCuts->SetRequireITSStandAlone(kTRUE);
706 esdTrackCuts->SetRequireITSPureStandAlone(kFALSE);
707 esdTrackCuts->SetRequireITSRefit(kTRUE);
708 esdTrackCuts->SetMinNClustersITS(4);
709 esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
710 AliESDtrackCuts::kAny);
711 esdTrackCuts->SetMaxChi2PerClusterITS(1.);
712
713 if(selPrimaries) {
714 // 7*(0.0085+0.0026/pt^1.55)
715 esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0595+0.0182/pt^1.55");
716 }
717 if(useForPid){
718 esdTrackCuts->SetRequireITSPid(kTRUE);
719 }
720 return esdTrackCuts;
721}
722
f4e7aa32 723
1bf80d20 724//____________________________________________________________________
725Int_t AliESDtrackCuts::GetReferenceMultiplicity(AliESDEvent* esd, Bool_t tpcOnly)
726{
727 // Gets reference multiplicity following the standard cuts and a defined fiducial volume
728 // tpcOnly = kTRUE -> consider TPC-only tracks
729 // = kFALSE -> consider global tracks
730
731 if (!tpcOnly)
732 {
733 Printf("AliESDtrackCuts::GetReferenceMultiplicity: Not implemented for global tracks!");
734 return -1;
735 }
736
8fb3df98 737 static AliESDtrackCuts* esdTrackCuts = 0;
738 if (!esdTrackCuts)
739 {
740 esdTrackCuts = GetStandardTPCOnlyTrackCuts();
741 esdTrackCuts->SetEtaRange(-0.8, 0.8);
742 esdTrackCuts->SetPtRange(0.15);
743 }
1bf80d20 744
745 Int_t nTracks = esdTrackCuts->CountAcceptedTracks(esd);
746
1bf80d20 747 return nTracks;
748}
73318471 749
750//____________________________________________________________________
751Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
752{
753 // Calculates the number of sigma to the vertex.
754
755 Float_t b[2];
756 Float_t bRes[2];
757 Float_t bCov[3];
758 esdTrack->GetImpactParameters(b,bCov);
36853ddd 759
73318471 760 if (bCov[0]<=0 || bCov[2]<=0) {
57fddfbc 761 AliDebugClass(1, "Estimated b resolution lower or equal zero!");
73318471 762 bCov[0]=0; bCov[2]=0;
763 }
764 bRes[0] = TMath::Sqrt(bCov[0]);
765 bRes[1] = TMath::Sqrt(bCov[2]);
766
767 // -----------------------------------
768 // How to get to a n-sigma cut?
769 //
770 // The accumulated statistics from 0 to d is
771 //
772 // -> Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
773 // -> 1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
774 //
cae2c21a 775 // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-d**2)/2)
73318471 776 // Can this be expressed in a different way?
777
778 if (bRes[0] == 0 || bRes[1] ==0)
779 return -1;
780
781 Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
782
0f712a2e 783 // work around precision problem
73318471 784 // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
0f712a2e 785 // 1e-15 corresponds to nsigma ~ 7.7
786 if (TMath::Exp(-d * d / 2) < 1e-15)
73318471 787 return 1000;
788
0f712a2e 789 Float_t nSigma = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
790 return nSigma;
73318471 791}
792
793void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
794{
795 // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
796
797 tree->SetBranchStatus("fTracks.fFlags", 1);
798 tree->SetBranchStatus("fTracks.fITSncls", 1);
799 tree->SetBranchStatus("fTracks.fTPCncls", 1);
800 tree->SetBranchStatus("fTracks.fITSchi2", 1);
801 tree->SetBranchStatus("fTracks.fTPCchi2", 1);
802 tree->SetBranchStatus("fTracks.fC*", 1);
803 tree->SetBranchStatus("fTracks.fD", 1);
804 tree->SetBranchStatus("fTracks.fZ", 1);
805 tree->SetBranchStatus("fTracks.fCdd", 1);
806 tree->SetBranchStatus("fTracks.fCdz", 1);
807 tree->SetBranchStatus("fTracks.fCzz", 1);
808 tree->SetBranchStatus("fTracks.fP*", 1);
809 tree->SetBranchStatus("fTracks.fR*", 1);
810 tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
811}
812
813//____________________________________________________________________
d95684c0 814Bool_t AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack)
815{
73318471 816 //
817 // figure out if the tracks survives all the track cuts defined
818 //
819 // the different quality parameter and kinematic values are first
820 // retrieved from the track. then it is found out what cuts the
821 // track did not survive and finally the cuts are imposed.
822
823 // this function needs the following branches:
824 // fTracks.fFlags
825 // fTracks.fITSncls
826 // fTracks.fTPCncls
827 // fTracks.fITSchi2
828 // fTracks.fTPCchi2
829 // fTracks.fC //GetExternalCovariance
830 // fTracks.fD //GetImpactParameters
831 // fTracks.fZ //GetImpactParameters
832 // fTracks.fCdd //GetImpactParameters
833 // fTracks.fCdz //GetImpactParameters
834 // fTracks.fCzz //GetImpactParameters
835 // fTracks.fP //GetPxPyPz
836 // fTracks.fR //GetMass
837 // fTracks.fP //GetMass
838 // fTracks.fKinkIndexes
839
840 UInt_t status = esdTrack->GetStatus();
841
73318471 842 // getting quality parameters from the ESD track
524916f0 843 Int_t nClustersITS = esdTrack->GetITSclusters(0);
a86cf7f4 844 Int_t nClustersTPC = -1;
845 if(fCutRequireTPCStandAlone) {
846 nClustersTPC = esdTrack->GetTPCNclsIter1();
847 }
848 else {
849 nClustersTPC = esdTrack->GetTPCclusters(0);
850 }
524916f0 851
3128582b 852 Int_t nClustersTPCShared = esdTrack->GetTPCnclsS();
853 Float_t fracClustersTPCShared = -1.;
854
73318471 855 Float_t chi2PerClusterITS = -1;
856 Float_t chi2PerClusterTPC = -1;
857 if (nClustersITS!=0)
858 chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
a86cf7f4 859 if (nClustersTPC!=0) {
860 if(fCutRequireTPCStandAlone) {
861 chi2PerClusterTPC = esdTrack->GetTPCchi2Iter1()/Float_t(nClustersTPC);
862 } else {
863 chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
864 }
3128582b 865 fracClustersTPCShared = Float_t(nClustersTPCShared)/Float_t(nClustersTPC);
a86cf7f4 866 }
867
73318471 868 Double_t extCov[15];
869 esdTrack->GetExternalCovariance(extCov);
870
871 // getting the track to vertex parameters
872 Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
524916f0 873
874 Float_t b[2];
875 Float_t bCov[3];
876 esdTrack->GetImpactParameters(b,bCov);
877 if (bCov[0]<=0 || bCov[2]<=0) {
878 AliDebug(1, "Estimated b resolution lower or equal zero!");
879 bCov[0]=0; bCov[2]=0;
880 }
74687314 881
f4e7aa32 882
883 // set pt-dependent DCA cuts, if requested
884 SetPtDepDCACuts(esdTrack->Pt());
885
886
e4617f4e 887 Float_t dcaToVertexXY = b[0];
74687314 888 Float_t dcaToVertexZ = b[1];
889
86f0e195 890 Float_t dcaToVertex = -1;
891
892 if (fCutDCAToVertex2D)
893 {
133a5e00 894 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY/fCutMaxDCAToVertexXY/fCutMaxDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMaxDCAToVertexZ/fCutMaxDCAToVertexZ);
86f0e195 895 }
896 else
897 dcaToVertex = TMath::Sqrt(dcaToVertexXY*dcaToVertexXY + dcaToVertexZ*dcaToVertexZ);
133a5e00 898
73318471 899 // getting the kinematic variables of the track
900 // (assuming the mass is known)
901 Double_t p[3];
902 esdTrack->GetPxPyPz(p);
36853ddd 903
73318471 904 Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
905 Float_t pt = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
906 Float_t energy = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
907
73318471 908 //y-eta related calculations
909 Float_t eta = -100.;
910 Float_t y = -100.;
911 if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
912 eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
913 if((energy != TMath::Abs(p[2]))&&(momentum != 0))
914 y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
025fb458 915
4853f638 916 if (extCov[14] < 0)
917 {
918 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]);
919 return kFALSE;
920 }
025fb458 921 Float_t relUncertainty1Pt = TMath::Sqrt(extCov[14])*pt;
73318471 922
923 //########################################################################
924 // cut the track?
925
926 Bool_t cuts[kNCuts];
927 for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
928
929 // track quality cuts
930 if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
931 cuts[0]=kTRUE;
a86cf7f4 932 if (fCutRequireTPCStandAlone && (status&AliESDtrack::kTPCin)==0)
73318471 933 cuts[1]=kTRUE;
a86cf7f4 934 if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
73318471 935 cuts[2]=kTRUE;
a86cf7f4 936 if (nClustersTPC<fCutMinNClusterTPC)
73318471 937 cuts[3]=kTRUE;
a86cf7f4 938 if (nClustersITS<fCutMinNClusterITS)
939 cuts[4]=kTRUE;
73318471 940 if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
a86cf7f4 941 cuts[5]=kTRUE;
73318471 942 if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
a86cf7f4 943 cuts[6]=kTRUE;
73318471 944 if (extCov[0] > fCutMaxC11)
73318471 945 cuts[7]=kTRUE;
a86cf7f4 946 if (extCov[2] > fCutMaxC22)
73318471 947 cuts[8]=kTRUE;
a86cf7f4 948 if (extCov[5] > fCutMaxC33)
73318471 949 cuts[9]=kTRUE;
a86cf7f4 950 if (extCov[9] > fCutMaxC44)
73318471 951 cuts[10]=kTRUE;
a86cf7f4 952 if (extCov[14] > fCutMaxC55)
953 cuts[11]=kTRUE;
73318471 954 if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
a86cf7f4 955 cuts[12] = kTRUE;
73318471 956 // if n sigma could not be calculated
957 if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
73318471 958 cuts[13]=kTRUE;
a86cf7f4 959 if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
960 cuts[14]=kTRUE;
73318471 961 // track kinematics cut
962 if((momentum < fPMin) || (momentum > fPMax))
a86cf7f4 963 cuts[15]=kTRUE;
73318471 964 if((pt < fPtMin) || (pt > fPtMax))
73318471 965 cuts[16] = kTRUE;
a86cf7f4 966 if((p[0] < fPxMin) || (p[0] > fPxMax))
73318471 967 cuts[17] = kTRUE;
a86cf7f4 968 if((p[1] < fPyMin) || (p[1] > fPyMax))
73318471 969 cuts[18] = kTRUE;
a86cf7f4 970 if((p[2] < fPzMin) || (p[2] > fPzMax))
73318471 971 cuts[19] = kTRUE;
a86cf7f4 972 if((eta < fEtaMin) || (eta > fEtaMax))
73318471 973 cuts[20] = kTRUE;
a86cf7f4 974 if((y < fRapMin) || (y > fRapMax))
524916f0 975 cuts[21] = kTRUE;
a86cf7f4 976 if (fCutDCAToVertex2D && dcaToVertex > 1)
e4617f4e 977 cuts[22] = kTRUE;
a86cf7f4 978 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) > fCutMaxDCAToVertexXY)
74687314 979 cuts[23] = kTRUE;
a86cf7f4 980 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) > fCutMaxDCAToVertexZ)
133a5e00 981 cuts[24] = kTRUE;
a86cf7f4 982 if (fCutDCAToVertex2D && fCutMinDCAToVertexXY > 0 && fCutMinDCAToVertexZ > 0 && dcaToVertexXY*dcaToVertexXY/fCutMinDCAToVertexXY/fCutMinDCAToVertexXY + dcaToVertexZ*dcaToVertexZ/fCutMinDCAToVertexZ/fCutMinDCAToVertexZ < 1)
133a5e00 983 cuts[25] = kTRUE;
a86cf7f4 984 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexXY) < fCutMinDCAToVertexXY)
133a5e00 985 cuts[26] = kTRUE;
a86cf7f4 986 if (!fCutDCAToVertex2D && TMath::Abs(dcaToVertexZ) < fCutMinDCAToVertexZ)
987 cuts[27] = kTRUE;
94c06b89 988
989 for (Int_t i = 0; i < 3; i++)
a86cf7f4 990 cuts[28+i] = !CheckITSClusterRequirement(fCutClusterRequirementITS[i], esdTrack->HasPointOnITSLayer(i*2), esdTrack->HasPointOnITSLayer(i*2+1));
d95684c0 991
0274b76f 992 if(fCutRequireITSStandAlone || fCutRequireITSpureSA){
993 if ((status & AliESDtrack::kITSin) == 0 || (status & AliESDtrack::kTPCin)){
994 // TPC tracks
995 cuts[31] = kTRUE;
996 }else{
997 // ITS standalone tracks
998 if(fCutRequireITSStandAlone && !fCutRequireITSpureSA){
999 if(status & AliESDtrack::kITSpureSA) cuts[31] = kTRUE;
1000 }else if(fCutRequireITSpureSA){
1001 if(!(status & AliESDtrack::kITSpureSA)) cuts[31] = kTRUE;
1002 }
1003 }
1004 }
f4e7aa32 1005
025fb458 1006 if (relUncertainty1Pt > fCutMaxRel1PtUncertainty)
3128582b 1007 cuts[32] = kTRUE;
1008
1009 if (!fCutAcceptSharedTPCClusters && nClustersTPCShared!=0)
1010 cuts[33] = kTRUE;
1011
1012 if (fracClustersTPCShared > fCutMaxFractionSharedTPCClusters)
1013 cuts[34] = kTRUE;
1014
0274b76f 1015 if(fCutRequireITSPid){
1016 UChar_t clumap=esdTrack->GetITSClusterMap();
1017 Int_t nPointsForPid=0;
1018 for(Int_t i=2; i<6; i++){
1019 if(clumap&(1<<i)) ++nPointsForPid;
1020 }
1021 if(nPointsForPid<3) cuts[35] = kTRUE;
1022 }
1023
73318471 1024 Bool_t cut=kFALSE;
1025 for (Int_t i=0; i<kNCuts; i++)
133a5e00 1026 if (cuts[i]) {cut = kTRUE;}
524916f0 1027
1028
73318471 1029 //########################################################################
1030 // filling histograms
1031 if (fHistogramsOn) {
1032 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
73318471 1033 if (cut)
1034 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
1035
1036 for (Int_t i=0; i<kNCuts; i++) {
1037 if (cuts[i])
524916f0 1038 fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
1039
73318471 1040 for (Int_t j=i; j<kNCuts; j++) {
524916f0 1041 if (cuts[i] && cuts[j]) {
1042 Float_t xC = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
1043 Float_t yC = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
1044 fhCutCorrelation->Fill(xC, yC);
1045 }
73318471 1046 }
1047 }
73318471 1048 }
1049
524916f0 1050 // now we loop over the filling of the histograms twice: once "before" the cut, once "after"
1051 // the code is not in a function due to too many local variables that would need to be passed
73318471 1052
524916f0 1053 for (Int_t id = 0; id < 2; id++)
1054 {
1055 // id = 0 --> before cut
1056 // id = 1 --> after cut
73318471 1057
524916f0 1058 if (fHistogramsOn)
73318471 1059 {
524916f0 1060 fhNClustersITS[id]->Fill(nClustersITS);
1061 fhNClustersTPC[id]->Fill(nClustersTPC);
1062 fhChi2PerClusterITS[id]->Fill(chi2PerClusterITS);
1063 fhChi2PerClusterTPC[id]->Fill(chi2PerClusterTPC);
1064
1065 fhC11[id]->Fill(extCov[0]);
1066 fhC22[id]->Fill(extCov[2]);
1067 fhC33[id]->Fill(extCov[5]);
1068 fhC44[id]->Fill(extCov[9]);
1069 fhC55[id]->Fill(extCov[14]);
1070
025fb458 1071 fhRel1PtUncertainty[id]->Fill(relUncertainty1Pt);
1072
524916f0 1073 fhPt[id]->Fill(pt);
1074 fhEta[id]->Fill(eta);
1075
1076 Float_t bRes[2];
1077 bRes[0] = TMath::Sqrt(bCov[0]);
1078 bRes[1] = TMath::Sqrt(bCov[2]);
1079
1080 fhDZ[id]->Fill(b[1]);
1081 fhDXY[id]->Fill(b[0]);
1082 fhDXYDZ[id]->Fill(dcaToVertex);
1083 fhDXYvsDZ[id]->Fill(b[1],b[0]);
1084
1085 if (bRes[0]!=0 && bRes[1]!=0) {
1086 fhDZNormalized[id]->Fill(b[1]/bRes[1]);
1087 fhDXYNormalized[id]->Fill(b[0]/bRes[0]);
1088 fhDXYvsDZNormalized[id]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
1089 fhNSigmaToVertex[id]->Fill(nSigmaToVertex);
1090 }
73318471 1091 }
524916f0 1092
1093 // cut the track
1094 if (cut)
1095 return kFALSE;
73318471 1096 }
1097
1098 return kTRUE;
1099}
1100
94c06b89 1101//____________________________________________________________________
1102Bool_t AliESDtrackCuts::CheckITSClusterRequirement(ITSClusterRequirement req, Bool_t clusterL1, Bool_t clusterL2)
1103{
1104 // checks if the cluster requirement is fullfilled (in this case: return kTRUE)
1105
1106 switch (req)
1107 {
1108 case kOff: return kTRUE;
1109 case kNone: return !clusterL1 && !clusterL2;
1110 case kAny: return clusterL1 || clusterL2;
1111 case kFirst: return clusterL1;
1112 case kOnlyFirst: return clusterL1 && !clusterL2;
1113 case kSecond: return clusterL2;
1114 case kOnlySecond: return clusterL2 && !clusterL1;
1115 case kBoth: return clusterL1 && clusterL2;
1116 }
1117
1118 return kFALSE;
1119}
1120
73318471 1121//____________________________________________________________________
524916f0 1122AliESDtrack* AliESDtrackCuts::GetTPCOnlyTrack(AliESDEvent* esd, Int_t iTrack)
73318471 1123{
b7b857f0 1124
1125 // Utility function to
1126 // create a TPC only track from the given esd track
1127 //
1128 // IMPORTANT: The track has to be deleted by the user
73318471 1129 //
524916f0 1130 // NB. most of the functionality to get a TPC only track from an ESD track is in AliESDtrack, where it should be
1131 // there are only missing propagations here that are needed for old data
1132 // this function will therefore become obsolete
73318471 1133 //
524916f0 1134 // adapted from code provided by CKB
73318471 1135
524916f0 1136 if (!esd->GetPrimaryVertexTPC())
1137 return 0; // No TPC vertex no TPC tracks
73318471 1138
91c88f16 1139 if(!esd->GetPrimaryVertexTPC()->GetStatus())
1140 return 0; // TPC Vertex is created by default in AliESDEvent, do not use in this case
91c88f16 1141
524916f0 1142 AliESDtrack* track = esd->GetTrack(iTrack);
1143 if (!track)
1144 return 0;
36853ddd 1145
524916f0 1146 AliESDtrack *tpcTrack = new AliESDtrack();
73318471 1147
524916f0 1148 // only true if we have a tpc track
1149 if (!track->FillTPCOnlyTrack(*tpcTrack))
1150 {
1151 delete tpcTrack;
1152 return 0;
73318471 1153 }
1154
524916f0 1155 // propagate to Vertex
1156 // not needed for normal reconstructed ESDs...
1157 // Double_t pTPC[2],covTPC[3];
1158 // tpcTrack->PropagateToDCA(esd->GetPrimaryVertexTPC(), esd->GetMagneticField(), 10000, pTPC, covTPC);
1159
1160 return tpcTrack;
73318471 1161}
1162
1163//____________________________________________________________________
36853ddd 1164TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd,Bool_t bTPC)
73318471 1165{
1166 //
1167 // returns an array of all tracks that pass the cuts
36853ddd 1168 // or an array of TPC only tracks (propagated to the TPC vertex during reco)
1169 // tracks that pass the cut
73318471 1170
1171 TObjArray* acceptedTracks = new TObjArray();
1172
1173 // loop over esd tracks
1174 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
36853ddd 1175 if(bTPC){
1176 if(!esd->GetPrimaryVertexTPC())return acceptedTracks; // No TPC vertex no TPC tracks
91c88f16 1177 if(!esd->GetPrimaryVertexTPC()->GetStatus())return acceptedTracks; // No proper TPC vertex, only the default
36853ddd 1178
524916f0 1179 AliESDtrack *tpcTrack = GetTPCOnlyTrack(esd, iTrack);
1180 if (!tpcTrack)
1181 continue;
1182
1183 if (AcceptTrack(tpcTrack)) {
1184 acceptedTracks->Add(tpcTrack);
36853ddd 1185 }
524916f0 1186 else
1187 delete tpcTrack;
1188 }
1189 else
1190 {
1191 AliESDtrack* track = esd->GetTrack(iTrack);
1192 if(AcceptTrack(track))
1193 acceptedTracks->Add(track);
36853ddd 1194 }
36853ddd 1195 }
1196 if(bTPC)acceptedTracks->SetOwner(kTRUE);
73318471 1197 return acceptedTracks;
1198}
1199
1200//____________________________________________________________________
1201Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd)
1202{
1203 //
1204 // returns an the number of tracks that pass the cuts
1205 //
1206
1207 Int_t count = 0;
1208
1209 // loop over esd tracks
1210 for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
1211 AliESDtrack* track = esd->GetTrack(iTrack);
73318471 1212 if (AcceptTrack(track))
1213 count++;
1214 }
1215
1216 return count;
1217}
1218
1219//____________________________________________________________________
1220 void AliESDtrackCuts::DefineHistograms(Int_t color) {
1221 //
1222 // diagnostics histograms are defined
1223 //
1224
1225 fHistogramsOn=kTRUE;
1226
1227 Bool_t oldStatus = TH1::AddDirectoryStatus();
1228 TH1::AddDirectory(kFALSE);
1229
1230 //###################################################################################
1231 // defining histograms
1232
1233 fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
1234
1235 fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
1236 fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
1237
1238 fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
1239
1240 for (Int_t i=0; i<kNCuts; i++) {
1241 fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
1242 fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
1243 fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
0f712a2e 1244 }
73318471 1245
1246 fhCutStatistics ->SetLineColor(color);
1247 fhCutCorrelation ->SetLineColor(color);
1248 fhCutStatistics ->SetLineWidth(2);
1249 fhCutCorrelation ->SetLineWidth(2);
1250
73318471 1251 for (Int_t i=0; i<2; i++) {
524916f0 1252 fhNClustersITS[i] = new TH1F("nClustersITS" ,"",8,-0.5,7.5);
1253 fhNClustersTPC[i] = new TH1F("nClustersTPC" ,"",165,-0.5,164.5);
1254 fhChi2PerClusterITS[i] = new TH1F("chi2PerClusterITS","",500,0,10);
1255 fhChi2PerClusterTPC[i] = new TH1F("chi2PerClusterTPC","",500,0,10);
1256
1257 fhC11[i] = new TH1F("covMatrixDiagonal11","",2000,0,20);
1258 fhC22[i] = new TH1F("covMatrixDiagonal22","",2000,0,20);
0f712a2e 1259 fhC33[i] = new TH1F("covMatrixDiagonal33","",1000,0,0.1);
1260 fhC44[i] = new TH1F("covMatrixDiagonal44","",1000,0,0.1);
524916f0 1261 fhC55[i] = new TH1F("covMatrixDiagonal55","",1000,0,5);
1262
025fb458 1263 fhRel1PtUncertainty[i] = new TH1F("rel1PtUncertainty","",1000,0,5);
1264
524916f0 1265 fhDXY[i] = new TH1F("dXY" ,"",500,-10,10);
1266 fhDZ[i] = new TH1F("dZ" ,"",500,-10,10);
1267 fhDXYDZ[i] = new TH1F("dXYDZ" ,"",500,0,10);
1268 fhDXYvsDZ[i] = new TH2F("dXYvsDZ","",200,-10,10,200,-10,10);
1269
1270 fhDXYNormalized[i] = new TH1F("dXYNormalized" ,"",500,-10,10);
1271 fhDZNormalized[i] = new TH1F("dZNormalized" ,"",500,-10,10);
1272 fhDXYvsDZNormalized[i] = new TH2F("dXYvsDZNormalized","",200,-10,10,200,-10,10);
1273
1274 fhNSigmaToVertex[i] = new TH1F("nSigmaToVertex","",500,0,10);
1275
86f0e195 1276 fhPt[i] = new TH1F("pt" ,"p_{T} distribution;p_{T} (GeV/c)", 800, 0.0, 10.0);
524916f0 1277 fhEta[i] = new TH1F("eta" ,"#eta distribution;#eta",40,-2.0,2.0);
73318471 1278
1279 fhNClustersITS[i]->SetTitle("n ITS clusters");
1280 fhNClustersTPC[i]->SetTitle("n TPC clusters");
1281 fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
1282 fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
1283
1284 fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
1285 fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
1286 fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
1287 fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
1288 fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
1289
025fb458 1290 fhRel1PtUncertainty[i]->SetTitle("rel. uncertainty of 1/p_{T}");
1291
86f0e195 1292 fhDXY[i]->SetXTitle("transverse impact parameter (cm)");
1293 fhDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1294 fhDXYDZ[i]->SetTitle("absolute impact parameter;sqrt(dXY**2 + dZ**2) (cm)");
1295 fhDXYvsDZ[i]->SetXTitle("longitudinal impact parameter (cm)");
1296 fhDXYvsDZ[i]->SetYTitle("transverse impact parameter (cm)");
73318471 1297
86f0e195 1298 fhDXYNormalized[i]->SetTitle("normalized trans impact par (n#sigma)");
1299 fhDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1300 fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par (n#sigma)");
1301 fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par (n#sigma)");
73318471 1302 fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
1303
1304 fhNClustersITS[i]->SetLineColor(color); fhNClustersITS[i]->SetLineWidth(2);
1305 fhNClustersTPC[i]->SetLineColor(color); fhNClustersTPC[i]->SetLineWidth(2);
1306 fhChi2PerClusterITS[i]->SetLineColor(color); fhChi2PerClusterITS[i]->SetLineWidth(2);
1307 fhChi2PerClusterTPC[i]->SetLineColor(color); fhChi2PerClusterTPC[i]->SetLineWidth(2);
1308
1309 fhC11[i]->SetLineColor(color); fhC11[i]->SetLineWidth(2);
1310 fhC22[i]->SetLineColor(color); fhC22[i]->SetLineWidth(2);
1311 fhC33[i]->SetLineColor(color); fhC33[i]->SetLineWidth(2);
1312 fhC44[i]->SetLineColor(color); fhC44[i]->SetLineWidth(2);
1313 fhC55[i]->SetLineColor(color); fhC55[i]->SetLineWidth(2);
1314
025fb458 1315 fhRel1PtUncertainty[i]->SetLineColor(color); fhRel1PtUncertainty[i]->SetLineWidth(2);
1316
73318471 1317 fhDXY[i]->SetLineColor(color); fhDXY[i]->SetLineWidth(2);
524916f0 1318 fhDZ[i]->SetLineColor(color); fhDZ[i]->SetLineWidth(2);
1319 fhDXYDZ[i]->SetLineColor(color); fhDXYDZ[i]->SetLineWidth(2);
73318471 1320
1321 fhDXYNormalized[i]->SetLineColor(color); fhDXYNormalized[i]->SetLineWidth(2);
1322 fhDZNormalized[i]->SetLineColor(color); fhDZNormalized[i]->SetLineWidth(2);
1323 fhNSigmaToVertex[i]->SetLineColor(color); fhNSigmaToVertex[i]->SetLineWidth(2);
1324 }
1325
1326 // The number of sigmas to the vertex is per definition gaussian
1327 ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
1328 ffDTheoretical->SetParameter(0,1);
524916f0 1329
73318471 1330 TH1::AddDirectory(oldStatus);
1331}
1332
1333//____________________________________________________________________
1334Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
1335{
1336 //
1337 // loads the histograms from a file
1338 // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
1339 //
1340
1341 if (!dir)
1342 dir = GetName();
1343
1344 if (!gDirectory->cd(dir))
1345 return kFALSE;
1346
1347 ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
1348
1349 fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
1350 fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
1351
73318471 1352 for (Int_t i=0; i<2; i++) {
1353 if (i==0)
1354 {
1355 gDirectory->cd("before_cuts");
73318471 1356 }
1357 else
73318471 1358 gDirectory->cd("after_cuts");
73318471 1359
524916f0 1360 fhNClustersITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersITS" ));
1361 fhNClustersTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("nClustersTPC" ));
1362 fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterITS"));
1363 fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get("chi2PerClusterTPC"));
73318471 1364
524916f0 1365 fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal11"));
1366 fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal22"));
1367 fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal33"));
1368 fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal44"));
1369 fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get("covMatrixDiagonal55"));
73318471 1370
025fb458 1371 fhRel1PtUncertainty[i] = dynamic_cast<TH1F*> (gDirectory->Get("rel1PtUncertainty"));
1372
524916f0 1373 fhDXY[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXY" ));
1374 fhDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZ" ));
1375 fhDXYDZ[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYDZ"));
1376 fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZ"));
73318471 1377
524916f0 1378 fhDXYNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dXYNormalized" ));
1379 fhDZNormalized[i] = dynamic_cast<TH1F*> (gDirectory->Get("dZNormalized" ));
1380 fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get("dXYvsDZNormalized"));
1381 fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get("nSigmaToVertex"));
73318471 1382
524916f0 1383 fhPt[i] = dynamic_cast<TH1F*> (gDirectory->Get("pt"));
1384 fhEta[i] = dynamic_cast<TH1F*> (gDirectory->Get("eta"));
73318471 1385
1386 gDirectory->cd("../");
1387 }
1388
1389 gDirectory->cd("..");
1390
1391 return kTRUE;
1392}
1393
1394//____________________________________________________________________
1395void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
1396 //
1397 // saves the histograms in a directory (dir)
1398 //
1399
1400 if (!fHistogramsOn) {
1401 AliDebug(0, "Histograms not on - cannot save histograms!!!");
1402 return;
1403 }
1404
1405 if (!dir)
1406 dir = GetName();
1407
1408 gDirectory->mkdir(dir);
1409 gDirectory->cd(dir);
1410
1411 gDirectory->mkdir("before_cuts");
1412 gDirectory->mkdir("after_cuts");
1413
1414 // a factor of 2 is needed since n sigma is positive
1415 ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1416 ffDTheoretical->Write("nSigmaToVertexTheory");
1417
1418 fhCutStatistics->Write();
1419 fhCutCorrelation->Write();
1420
1421 for (Int_t i=0; i<2; i++) {
1422 if (i==0)
1423 gDirectory->cd("before_cuts");
1424 else
1425 gDirectory->cd("after_cuts");
1426
1427 fhNClustersITS[i] ->Write();
1428 fhNClustersTPC[i] ->Write();
1429 fhChi2PerClusterITS[i] ->Write();
1430 fhChi2PerClusterTPC[i] ->Write();
1431
1432 fhC11[i] ->Write();
1433 fhC22[i] ->Write();
1434 fhC33[i] ->Write();
1435 fhC44[i] ->Write();
1436 fhC55[i] ->Write();
1437
025fb458 1438 fhRel1PtUncertainty[i] ->Write();
1439
73318471 1440 fhDXY[i] ->Write();
1441 fhDZ[i] ->Write();
524916f0 1442 fhDXYDZ[i] ->Write();
73318471 1443 fhDXYvsDZ[i] ->Write();
1444
1445 fhDXYNormalized[i] ->Write();
1446 fhDZNormalized[i] ->Write();
1447 fhDXYvsDZNormalized[i] ->Write();
1448 fhNSigmaToVertex[i] ->Write();
1449
1450 fhPt[i] ->Write();
1451 fhEta[i] ->Write();
1452
1453 gDirectory->cd("../");
1454 }
1455
1456 gDirectory->cd("../");
1457}
1458
1459//____________________________________________________________________
1460void AliESDtrackCuts::DrawHistograms()
1461{
1462 // draws some histograms
1463
1464 TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1465 canvas1->Divide(2, 2);
1466
1467 canvas1->cd(1);
1468 fhNClustersTPC[0]->SetStats(kFALSE);
1469 fhNClustersTPC[0]->Draw();
1470
1471 canvas1->cd(2);
1472 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1473 fhChi2PerClusterTPC[0]->Draw();
1474
1475 canvas1->cd(3);
1476 fhNSigmaToVertex[0]->SetStats(kFALSE);
1477 fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1478 fhNSigmaToVertex[0]->Draw();
1479
1480 canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1481
1482 TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1483 canvas2->Divide(3, 2);
1484
1485 canvas2->cd(1);
1486 fhC11[0]->SetStats(kFALSE);
1487 gPad->SetLogy();
1488 fhC11[0]->Draw();
1489
1490 canvas2->cd(2);
1491 fhC22[0]->SetStats(kFALSE);
1492 gPad->SetLogy();
1493 fhC22[0]->Draw();
1494
1495 canvas2->cd(3);
1496 fhC33[0]->SetStats(kFALSE);
1497 gPad->SetLogy();
1498 fhC33[0]->Draw();
1499
1500 canvas2->cd(4);
1501 fhC44[0]->SetStats(kFALSE);
1502 gPad->SetLogy();
1503 fhC44[0]->Draw();
1504
1505 canvas2->cd(5);
1506 fhC55[0]->SetStats(kFALSE);
1507 gPad->SetLogy();
1508 fhC55[0]->Draw();
1509
025fb458 1510 canvas2->cd(6);
1511 fhRel1PtUncertainty[0]->SetStats(kFALSE);
1512 gPad->SetLogy();
1513 fhRel1PtUncertainty[0]->Draw();
1514
73318471 1515 canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1516
1517 TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1518 canvas3->Divide(3, 2);
1519
1520 canvas3->cd(1);
1521 fhDXY[0]->SetStats(kFALSE);
1522 gPad->SetLogy();
1523 fhDXY[0]->Draw();
1524
1525 canvas3->cd(2);
1526 fhDZ[0]->SetStats(kFALSE);
1527 gPad->SetLogy();
1528 fhDZ[0]->Draw();
1529
1530 canvas3->cd(3);
1531 fhDXYvsDZ[0]->SetStats(kFALSE);
1532 gPad->SetLogz();
1533 gPad->SetRightMargin(0.15);
1534 fhDXYvsDZ[0]->Draw("COLZ");
1535
1536 canvas3->cd(4);
1537 fhDXYNormalized[0]->SetStats(kFALSE);
1538 gPad->SetLogy();
1539 fhDXYNormalized[0]->Draw();
1540
1541 canvas3->cd(5);
1542 fhDZNormalized[0]->SetStats(kFALSE);
1543 gPad->SetLogy();
1544 fhDZNormalized[0]->Draw();
1545
1546 canvas3->cd(6);
1547 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1548 gPad->SetLogz();
1549 gPad->SetRightMargin(0.15);
1550 fhDXYvsDZNormalized[0]->Draw("COLZ");
1551
1552 canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1553
1554 TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1555 canvas4->Divide(2, 1);
1556
1557 canvas4->cd(1);
1558 fhCutStatistics->SetStats(kFALSE);
1559 fhCutStatistics->LabelsOption("v");
1560 gPad->SetBottomMargin(0.3);
1561 fhCutStatistics->Draw();
1562
1563 canvas4->cd(2);
1564 fhCutCorrelation->SetStats(kFALSE);
1565 fhCutCorrelation->LabelsOption("v");
1566 gPad->SetBottomMargin(0.3);
1567 gPad->SetLeftMargin(0.3);
1568 fhCutCorrelation->Draw("COLZ");
1569
1570 canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1571
1572 /*canvas->cd(1);
1573 fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1574 fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1575
1576 canvas->cd(2);
1577 fhNClustersTPC[0]->SetStats(kFALSE);
1578 fhNClustersTPC[0]->DrawCopy();
1579
1580 canvas->cd(3);
1581 fhChi2PerClusterITS[0]->SetStats(kFALSE);
1582 fhChi2PerClusterITS[0]->DrawCopy();
1583 fhChi2PerClusterITS[1]->SetLineColor(2);
1584 fhChi2PerClusterITS[1]->DrawCopy("SAME");
1585
1586 canvas->cd(4);
1587 fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1588 fhChi2PerClusterTPC[0]->DrawCopy();
1589 fhChi2PerClusterTPC[1]->SetLineColor(2);
1590 fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1591}
f4e7aa32 1592//--------------------------------------------------------------------------
1593void AliESDtrackCuts::SetPtDepDCACuts(Double_t pt) {
1594 //
1595 // set the pt-dependent DCA cuts
1596 //
1597
f328399b 1598 if(f1CutMaxDCAToVertexXYPtDep) {
1599 fCutMaxDCAToVertexXY=f1CutMaxDCAToVertexXYPtDep->Eval(pt);
f4e7aa32 1600 }
1601
f328399b 1602 if(f1CutMaxDCAToVertexZPtDep) {
1603 fCutMaxDCAToVertexZ=f1CutMaxDCAToVertexZPtDep->Eval(pt);
f4e7aa32 1604 }
1605
f328399b 1606 if(f1CutMinDCAToVertexXYPtDep) {
1607 fCutMinDCAToVertexXY=f1CutMinDCAToVertexXYPtDep->Eval(pt);
f4e7aa32 1608 }
1609
f328399b 1610 if(f1CutMinDCAToVertexZPtDep) {
1611 fCutMinDCAToVertexZ=f1CutMinDCAToVertexZPtDep->Eval(pt);
f4e7aa32 1612 }
1613
1614
1615 return;
1616}
f328399b 1617
1618
1619
f4e7aa32 1620//--------------------------------------------------------------------------
1621Bool_t AliESDtrackCuts::CheckPtDepDCA(TString dist,Bool_t print) const {
1622 //
1623 // Check the correctness of the string syntax
1624 //
1625 Bool_t retval=kTRUE;
1626
1627 if(!dist.Contains("pt")) {
1628 if(print) printf("AliESDtrackCuts::CheckPtDepDCA(): string must contain \"pt\"\n");
1629 retval= kFALSE;
1630 }
1631 return retval;
1632}
73318471 1633
f328399b 1634 void AliESDtrackCuts::SetMaxDCAToVertexXYPtDep(const char *dist){
34aef0ad 1635
1636 if(f1CutMaxDCAToVertexXYPtDep){
1637 delete f1CutMaxDCAToVertexXYPtDep;
1638 // resetiing both
1639 f1CutMaxDCAToVertexXYPtDep = 0;
1640 fCutMaxDCAToVertexXYPtDep = "";
1641 }
1642 if(!CheckPtDepDCA(dist,kTRUE)){
1643 return;
1644 }
f328399b 1645 fCutMaxDCAToVertexXYPtDep = dist;
1646 TString tmp(dist);
1647 tmp.ReplaceAll("pt","x");
1648 f1CutMaxDCAToVertexXYPtDep = new TFormula("f1CutMaxDCAToVertexXYPtDep",tmp.Data());
1649
1650}
1651
1652 void AliESDtrackCuts::SetMaxDCAToVertexZPtDep(const char *dist){
34aef0ad 1653
1654
1655 if(f1CutMaxDCAToVertexZPtDep){
1656 delete f1CutMaxDCAToVertexZPtDep;
1657 // resetiing both
1658 f1CutMaxDCAToVertexZPtDep = 0;
1659 fCutMaxDCAToVertexZPtDep = "";
1660 }
1661 if(!CheckPtDepDCA(dist,kTRUE))return;
1662
f328399b 1663 fCutMaxDCAToVertexZPtDep = dist;
1664 TString tmp(dist);
1665 tmp.ReplaceAll("pt","x");
1666 f1CutMaxDCAToVertexZPtDep = new TFormula("f1CutMaxDCAToVertexZPtDep",tmp.Data());
1667
1668
1669}
1670
1671
1672 void AliESDtrackCuts::SetMinDCAToVertexXYPtDep(const char *dist){
34aef0ad 1673
1674
1675 if(f1CutMinDCAToVertexXYPtDep){
1676 delete f1CutMinDCAToVertexXYPtDep;
1677 // resetiing both
1678 f1CutMinDCAToVertexXYPtDep = 0;
1679 fCutMinDCAToVertexXYPtDep = "";
1680 }
1681 if(!CheckPtDepDCA(dist,kTRUE))return;
1682
f328399b 1683 fCutMinDCAToVertexXYPtDep = dist;
1684 TString tmp(dist);
1685 tmp.ReplaceAll("pt","x");
1686 f1CutMinDCAToVertexXYPtDep = new TFormula("f1CutMinDCAToVertexXYPtDep",tmp.Data());
1687
1688}
1689
1690
1691 void AliESDtrackCuts::SetMinDCAToVertexZPtDep(const char *dist){
34aef0ad 1692
1693
1694
1695 if(f1CutMinDCAToVertexZPtDep){
1696 delete f1CutMinDCAToVertexZPtDep;
1697 // resetiing both
1698 f1CutMinDCAToVertexZPtDep = 0;
1699 fCutMinDCAToVertexZPtDep = "";
1700 }
1701 if(!CheckPtDepDCA(dist,kTRUE))return;
f328399b 1702 fCutMinDCAToVertexZPtDep = dist;
1703 TString tmp(dist);
1704 tmp.ReplaceAll("pt","x");
1705 f1CutMinDCAToVertexZPtDep = new TFormula("f1CutMinDCAToVertexZPtDep",tmp.Data());
1706}