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