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