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