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