ANALYSIS/AliESDtrackCuts.cxx

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