PWG0/esdTrackCuts/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$ */
  17
  18 #include "AliESDtrackCuts.h"
  19
  20 #include <AliESDtrack.h>
  21 #include <AliESD.h>
  22 #include <AliESDEvent.h>
  23 #include <AliLog.h>
  24
  25 #include <TTree.h>
  26 #include <TCanvas.h>
  27 #include <TDirectory.h>
  28
  29 //____________________________________________________________________
  30 ClassImp(AliESDtrackCuts)
  31
  32 // Cut names
  33 const Char_t* AliESDtrackCuts::fgkCutNames[kNCuts] = {
  34  "require TPC refit",
  35  "require ITS refit",
  36  "n clusters TPC",
  37  "n clusters ITS",
  38  "#Chi^{2}/clusters TPC",
  39  "#Chi^{2}/clusters ITS",
  40  "cov 11",
  41  "cov 22",
  42  "cov 33",
  43  "cov 44",
  44  "cov 55",
  45  "trk-to-vtx",
  46  "trk-to-vtx failed",
  47  "kink daughters",
  48  "p",
  49  "p_{T}",
  50  "p_{x}",
  51  "p_{y}",
  52  "p_{z}",
  53  "y",
  54  "eta"
  55 };
  56
  57 //____________________________________________________________________
  58 AliESDtrackCuts::AliESDtrackCuts(const Char_t* name, const Char_t* title) : AliAnalysisCuts(name,title),
  59   fCutMinNClusterTPC(0),
  60   fCutMinNClusterITS(0),
  61   fCutMaxChi2PerClusterTPC(0),
  62   fCutMaxChi2PerClusterITS(0),
  63   fCutMaxC11(0),
  64   fCutMaxC22(0),
  65   fCutMaxC33(0),
  66   fCutMaxC44(0),
  67   fCutMaxC55(0),
  68   fCutAcceptKinkDaughters(0),
  69   fCutRequireTPCRefit(0),
  70   fCutRequireITSRefit(0),
  71   fCutNsigmaToVertex(0),
  72   fCutSigmaToVertexRequired(0),
  73   fPMin(0),
  74   fPMax(0),
  75   fPtMin(0),
  76   fPtMax(0),
  77   fPxMin(0),
  78   fPxMax(0),
  79   fPyMin(0),
  80   fPyMax(0),
  81   fPzMin(0),
  82   fPzMax(0),
  83   fEtaMin(0),
  84   fEtaMax(0),
  85   fRapMin(0),
  86   fRapMax(0),
  87   fHistogramsOn(0),
  88   fhCutStatistics(0),
  89   fhCutCorrelation(0)
  90 {
  91   //
  92   // constructor
  93   //
  94
  95   Init();
  96
  97   //##############################################################################
  98   // setting default cuts
  99   SetMinNClustersTPC();
 100   SetMinNClustersITS();
 101   SetMaxChi2PerClusterTPC();
 102   SetMaxChi2PerClusterITS();
 103   SetMaxCovDiagonalElements();
 104   SetRequireTPCRefit();
 105   SetRequireITSRefit();
 106   SetAcceptKingDaughters();
 107   SetMinNsigmaToVertex();
 108   SetRequireSigmaToVertex();
 109   SetPRange();
 110   SetPtRange();
 111   SetPxRange();
 112   SetPyRange();
 113   SetPzRange();
 114   SetEtaRange();
 115   SetRapRange();
 116
 117   SetHistogramsOn();
 118 }
 119
 120 //_____________________________________________________________________________
 121 AliESDtrackCuts::AliESDtrackCuts(const AliESDtrackCuts &c) : AliAnalysisCuts(c),
 122   fCutMinNClusterTPC(0),
 123   fCutMinNClusterITS(0),
 124   fCutMaxChi2PerClusterTPC(0),
 125   fCutMaxChi2PerClusterITS(0),
 126   fCutMaxC11(0),
 127   fCutMaxC22(0),
 128   fCutMaxC33(0),
 129   fCutMaxC44(0),
 130   fCutMaxC55(0),
 131   fCutAcceptKinkDaughters(0),
 132   fCutRequireTPCRefit(0),
 133   fCutRequireITSRefit(0),
 134   fCutNsigmaToVertex(0),
 135   fCutSigmaToVertexRequired(0),
 136   fPMin(0),
 137   fPMax(0),
 138   fPtMin(0),
 139   fPtMax(0),
 140   fPxMin(0),
 141   fPxMax(0),
 142   fPyMin(0),
 143   fPyMax(0),
 144   fPzMin(0),
 145   fPzMax(0),
 146   fEtaMin(0),
 147   fEtaMax(0),
 148   fRapMin(0),
 149   fRapMax(0),
 150   fHistogramsOn(0),
 151   ffDTheoretical(0),
 152   fhCutStatistics(0),
 153   fhCutCorrelation(0)
 154 {
 155   //
 156   // copy constructor
 157   //
 158
 159   ((AliESDtrackCuts &) c).Copy(*this);
 160 }
 161
 162 AliESDtrackCuts::~AliESDtrackCuts()
 163 {
 164   //
 165   // destructor
 166   //
 167
 168   for (Int_t i=0; i<2; i++) {
 169
 170     if (fhNClustersITS[i])
 171       delete fhNClustersITS[i];
 172     if (fhNClustersTPC[i])
 173       delete fhNClustersTPC[i];
 174     if (fhChi2PerClusterITS[i])
 175       delete fhChi2PerClusterITS[i];
 176     if (fhChi2PerClusterTPC[i])
 177       delete fhChi2PerClusterTPC[i];
 178     if (fhC11[i])
 179       delete fhC11[i];
 180     if (fhC22[i])
 181       delete fhC22[i];
 182     if (fhC33[i])
 183       delete fhC33[i];
 184     if (fhC44[i])
 185       delete fhC44[i];
 186     if (fhC55[i])
 187     delete fhC55[i];
 188
 189     if (fhDXY[i])
 190       delete fhDXY[i];
 191     if (fhDZ[i])
 192       delete fhDZ[i];
 193     if (fhDXYvsDZ[i])
 194       delete fhDXYvsDZ[i];
 195
 196     if (fhDXYNormalized[i])
 197       delete fhDXYNormalized[i];
 198     if (fhDZNormalized[i])
 199       delete fhDZNormalized[i];
 200     if (fhDXYvsDZNormalized[i])
 201       delete fhDXYvsDZNormalized[i];
 202     if (fhNSigmaToVertex[i])
 203       delete fhNSigmaToVertex[i];
 204   }
 205
 206   if (ffDTheoretical)
 207     delete ffDTheoretical;
 208
 209   if (fhCutStatistics)
 210     delete fhCutStatistics;
 211   if (fhCutCorrelation)
 212     delete fhCutCorrelation;
 213 }
 214
 215 void AliESDtrackCuts::Init()
 216 {
 217   //
 218   // sets everything to zero
 219   //
 220
 221   fCutMinNClusterTPC = 0;
 222   fCutMinNClusterITS = 0;
 223
 224   fCutMaxChi2PerClusterTPC = 0;
 225   fCutMaxChi2PerClusterITS = 0;
 226
 227   fCutMaxC11 = 0;
 228   fCutMaxC22 = 0;
 229   fCutMaxC33 = 0;
 230   fCutMaxC44 = 0;
 231   fCutMaxC55 = 0;
 232
 233   fCutAcceptKinkDaughters = 0;
 234   fCutRequireTPCRefit = 0;
 235   fCutRequireITSRefit = 0;
 236
 237   fCutNsigmaToVertex = 0;
 238   fCutSigmaToVertexRequired = 0;
 239
 240   fPMin = 0;
 241   fPMax = 0;
 242   fPtMin = 0;
 243   fPtMax = 0;
 244   fPxMin = 0;
 245   fPxMax = 0;
 246   fPyMin = 0;
 247   fPyMax = 0;
 248   fPzMin = 0;
 249   fPzMax = 0;
 250   fEtaMin = 0;
 251   fEtaMax = 0;
 252   fRapMin = 0;
 253   fRapMax = 0;
 254
 255   fHistogramsOn = kFALSE;
 256
 257   for (Int_t i=0; i<2; ++i)
 258   {
 259     fhNClustersITS[i] = 0;
 260     fhNClustersTPC[i] = 0;
 261
 262     fhChi2PerClusterITS[i] = 0;
 263     fhChi2PerClusterTPC[i] = 0;
 264
 265     fhC11[i] = 0;
 266     fhC22[i] = 0;
 267     fhC33[i] = 0;
 268     fhC44[i] = 0;
 269     fhC55[i] = 0;
 270
 271     fhDXY[i] = 0;
 272     fhDZ[i] = 0;
 273     fhDXYvsDZ[i] = 0;
 274
 275     fhDXYNormalized[i] = 0;
 276     fhDZNormalized[i] = 0;
 277     fhDXYvsDZNormalized[i] = 0;
 278     fhNSigmaToVertex[i] = 0;
 279   }
 280   ffDTheoretical = 0;
 281
 282   fhCutStatistics = 0;
 283   fhCutCorrelation = 0;
 284 }
 285
 286 //_____________________________________________________________________________
 287 AliESDtrackCuts &AliESDtrackCuts::operator=(const AliESDtrackCuts &c)
 288 {
 289   //
 290   // Assignment operator
 291   //
 292
 293   if (this != &c) ((AliESDtrackCuts &) c).Copy(*this);
 294   return *this;
 295 }
 296
 297 //_____________________________________________________________________________
 298 void AliESDtrackCuts::Copy(TObject &c) const
 299 {
 300   //
 301   // Copy function
 302   //
 303
 304   AliESDtrackCuts& target = (AliESDtrackCuts &) c;
 305
 306   target.Init();
 307
 308   target.fCutMinNClusterTPC = fCutMinNClusterTPC;
 309   target.fCutMinNClusterITS = fCutMinNClusterITS;
 310
 311   target.fCutMaxChi2PerClusterTPC = fCutMaxChi2PerClusterTPC;
 312   target.fCutMaxChi2PerClusterITS = fCutMaxChi2PerClusterITS;
 313
 314   target.fCutMaxC11 = fCutMaxC11;
 315   target.fCutMaxC22 = fCutMaxC22;
 316   target.fCutMaxC33 = fCutMaxC33;
 317   target.fCutMaxC44 = fCutMaxC44;
 318   target.fCutMaxC55 = fCutMaxC55;
 319
 320   target.fCutAcceptKinkDaughters = fCutAcceptKinkDaughters;
 321   target.fCutRequireTPCRefit = fCutRequireTPCRefit;
 322   target.fCutRequireITSRefit = fCutRequireITSRefit;
 323
 324   target.fCutNsigmaToVertex = fCutNsigmaToVertex;
 325   target.fCutSigmaToVertexRequired = fCutSigmaToVertexRequired;
 326
 327   target.fPMin = fPMin;
 328   target.fPMax = fPMax;
 329   target.fPtMin = fPtMin;
 330   target.fPtMax = fPtMax;
 331   target.fPxMin = fPxMin;
 332   target.fPxMax = fPxMax;
 333   target.fPyMin = fPyMin;
 334   target.fPyMax = fPyMax;
 335   target.fPzMin = fPzMin;
 336   target.fPzMax = fPzMax;
 337   target.fEtaMin = fEtaMin;
 338   target.fEtaMax = fEtaMax;
 339   target.fRapMin = fRapMin;
 340   target.fRapMax = fRapMax;
 341
 342   target.fHistogramsOn = fHistogramsOn;
 343
 344   for (Int_t i=0; i<2; ++i)
 345   {
 346     if (fhNClustersITS[i]) target.fhNClustersITS[i] = (TH1F*) fhNClustersITS[i]->Clone();
 347     if (fhNClustersTPC[i]) target.fhNClustersTPC[i] = (TH1F*) fhNClustersTPC[i]->Clone();
 348
 349     if (fhChi2PerClusterITS[i]) target.fhChi2PerClusterITS[i] = (TH1F*) fhChi2PerClusterITS[i]->Clone();
 350     if (fhChi2PerClusterTPC[i]) target.fhChi2PerClusterTPC[i] = (TH1F*) fhChi2PerClusterTPC[i]->Clone();
 351
 352     if (fhC11[i]) target.fhC11[i] = (TH1F*) fhC11[i]->Clone();
 353     if (fhC22[i]) target.fhC22[i] = (TH1F*) fhC22[i]->Clone();
 354     if (fhC33[i]) target.fhC33[i] = (TH1F*) fhC33[i]->Clone();
 355     if (fhC44[i]) target.fhC44[i] = (TH1F*) fhC44[i]->Clone();
 356     if (fhC55[i]) target.fhC55[i] = (TH1F*) fhC55[i]->Clone();
 357
 358     if (fhDXY[i]) target.fhDXY[i] = (TH1F*) fhDXY[i]->Clone();
 359     if (fhDZ[i]) target.fhDZ[i] = (TH1F*) fhDZ[i]->Clone();
 360     if (fhDXYvsDZ[i]) target.fhDXYvsDZ[i] = (TH2F*) fhDXYvsDZ[i]->Clone();
 361
 362     if (fhDXYNormalized[i]) target.fhDXYNormalized[i] = (TH1F*) fhDXYNormalized[i]->Clone();
 363     if (fhDZNormalized[i]) target.fhDZNormalized[i] = (TH1F*) fhDZNormalized[i]->Clone();
 364     if (fhDXYvsDZNormalized[i]) target.fhDXYvsDZNormalized[i] = (TH2F*) fhDXYvsDZNormalized[i]->Clone();
 365     if (fhNSigmaToVertex[i]) target.fhNSigmaToVertex[i] = (TH1F*) fhNSigmaToVertex[i]->Clone();
 366   }
 367   if (ffDTheoretical) target.ffDTheoretical = (TF1*) ffDTheoretical->Clone();
 368
 369   if (fhCutStatistics) target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
 370   if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
 371
 372   TNamed::Copy(c);
 373 }
 374
 375 //_____________________________________________________________________________
 376 Long64_t AliESDtrackCuts::Merge(TCollection* list) {
 377   // Merge a list of AliESDtrackCuts objects with this (needed for PROOF)
 378   // Returns the number of merged objects (including this)
 379
 380   if (!list)
 381     return 0;
 382
 383   if (list->IsEmpty())
 384     return 1;
 385
 386   if (!fHistogramsOn)
 387     return 0;
 388
 389   TIterator* iter = list->MakeIterator();
 390   TObject* obj;
 391
 392
 393   // collection of measured and generated histograms
 394   Int_t count = 0;
 395   while ((obj = iter->Next())) {
 396
 397     AliESDtrackCuts* entry = dynamic_cast<AliESDtrackCuts*>(obj);
 398     if (entry == 0)
 399       continue;
 400
 401     if (!entry->fHistogramsOn)
 402       continue;
 403
 404     for (Int_t i=0; i<2; i++) {
 405
 406       fhNClustersITS[i]      ->Add(entry->fhNClustersITS[i]     );
 407       fhNClustersTPC[i]      ->Add(entry->fhNClustersTPC[i]     );
 408
 409       fhChi2PerClusterITS[i] ->Add(entry->fhChi2PerClusterITS[i]);
 410       fhChi2PerClusterTPC[i] ->Add(entry->fhChi2PerClusterTPC[i]);
 411
 412       fhC11[i]               ->Add(entry->fhC11[i]              );
 413       fhC22[i]               ->Add(entry->fhC22[i]              );
 414       fhC33[i]               ->Add(entry->fhC33[i]              );
 415       fhC44[i]               ->Add(entry->fhC44[i]              );
 416       fhC55[i]               ->Add(entry->fhC55[i]              );
 417
 418       fhDXY[i]               ->Add(entry->fhDXY[i]              );
 419       fhDZ[i]                ->Add(entry->fhDZ[i]               );
 420       fhDXYvsDZ[i]           ->Add(entry->fhDXYvsDZ[i]          );
 421
 422       fhDXYNormalized[i]     ->Add(entry->fhDXYNormalized[i]    );
 423       fhDZNormalized[i]      ->Add(entry->fhDZNormalized[i]     );
 424       fhDXYvsDZNormalized[i] ->Add(entry->fhDXYvsDZNormalized[i]);
 425       fhNSigmaToVertex[i]    ->Add(entry->fhNSigmaToVertex[i]);
 426
 427     }
 428
 429     fhCutStatistics  ->Add(entry->fhCutStatistics);
 430     fhCutCorrelation ->Add(entry->fhCutCorrelation);
 431
 432     count++;
 433   }
 434
 435   return count+1;
 436 }
 437
 438
 439 //____________________________________________________________________
 440 Float_t AliESDtrackCuts::GetSigmaToVertex(AliESDtrack* esdTrack)
 441 {
 442   // Calculates the number of sigma to the vertex.
 443
 444   Float_t b[2];
 445   Float_t bRes[2];
 446   Float_t bCov[3];
 447   esdTrack->GetImpactParameters(b,bCov);
 448   if (bCov[0]<=0 || bCov[2]<=0) {
 449     AliDebug(1, "Estimated b resolution lower or equal zero!");
 450     bCov[0]=0; bCov[2]=0;
 451   }
 452   bRes[0] = TMath::Sqrt(bCov[0]);
 453   bRes[1] = TMath::Sqrt(bCov[2]);
 454
 455   // -----------------------------------
 456   // How to get to a n-sigma cut?
 457   //
 458   // The accumulated statistics from 0 to d is
 459   //
 460   // ->  Erf(d/Sqrt(2)) for a 1-dim gauss (d = n_sigma)
 461   // ->  1 - Exp(-d**2) for a 2-dim gauss (d*d = dx*dx + dy*dy != n_sigma)
 462   //
 463   // It means that for a 2-dim gauss: n_sigma(d) = Sqrt(2)*ErfInv(1 - Exp((-x**2)/2)
 464   // Can this be expressed in a different way?
 465
 466   if (bRes[0] == 0 || bRes[1] ==0)
 467     return -1;
 468
 469   Float_t d = TMath::Sqrt(TMath::Power(b[0]/bRes[0],2) + TMath::Power(b[1]/bRes[1],2));
 470
 471   // stupid rounding problem screws up everything:
 472   // if d is too big, TMath::Exp(...) gets 0, and TMath::ErfInverse(1) that should be infinite, gets 0 :(
 473   if (TMath::Exp(-d * d / 2) < 1e-10)
 474     return 1000;
 475
 476   d = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
 477   return d;
 478 }
 479
 480 void AliESDtrackCuts::EnableNeededBranches(TTree* tree)
 481 {
 482   // enables the branches needed by AcceptTrack, for a list see comment of AcceptTrack
 483
 484   tree->SetBranchStatus("fTracks.fFlags", 1);
 485   tree->SetBranchStatus("fTracks.fITSncls", 1);
 486   tree->SetBranchStatus("fTracks.fTPCncls", 1);
 487   tree->SetBranchStatus("fTracks.fITSchi2", 1);
 488   tree->SetBranchStatus("fTracks.fTPCchi2", 1);
 489   tree->SetBranchStatus("fTracks.fC*", 1);
 490   tree->SetBranchStatus("fTracks.fD", 1);
 491   tree->SetBranchStatus("fTracks.fZ", 1);
 492   tree->SetBranchStatus("fTracks.fCdd", 1);
 493   tree->SetBranchStatus("fTracks.fCdz", 1);
 494   tree->SetBranchStatus("fTracks.fCzz", 1);
 495   tree->SetBranchStatus("fTracks.fP*", 1);
 496   tree->SetBranchStatus("fTracks.fR*", 1);
 497   tree->SetBranchStatus("fTracks.fKinkIndexes*", 1);
 498 }
 499
 500 //____________________________________________________________________
 501 Bool_t
 502 AliESDtrackCuts::AcceptTrack(AliESDtrack* esdTrack) {
 503   //
 504   // figure out if the tracks survives all the track cuts defined
 505   //
 506   // the different quality parameter and kinematic values are first
 507   // retrieved from the track. then it is found out what cuts the
 508   // track did not survive and finally the cuts are imposed.
 509
 510   // this function needs the following branches:
 511   // fTracks.fFlags
 512   // fTracks.fITSncls
 513   // fTracks.fTPCncls
 514   // fTracks.fITSchi2
 515   // fTracks.fTPCchi2
 516   // fTracks.fC   //GetExternalCovariance
 517   // fTracks.fD   //GetImpactParameters
 518   // fTracks.fZ   //GetImpactParameters
 519   // fTracks.fCdd //GetImpactParameters
 520   // fTracks.fCdz //GetImpactParameters
 521   // fTracks.fCzz //GetImpactParameters
 522   // fTracks.fP   //GetPxPyPz
 523   // fTracks.fR   //GetMass
 524   // fTracks.fP   //GetMass
 525   // fTracks.fKinkIndexes
 526
 527   UInt_t status = esdTrack->GetStatus();
 528
 529   // dummy array
 530   Int_t  fIdxInt[200];
 531
 532   // getting quality parameters from the ESD track
 533   Int_t nClustersITS = esdTrack->GetITSclusters(fIdxInt);
 534   Int_t nClustersTPC = esdTrack->GetTPCclusters(fIdxInt);
 535
 536
 537
 538   Float_t chi2PerClusterITS = -1;
 539   Float_t chi2PerClusterTPC = -1;
 540   if (nClustersITS!=0)
 541     chi2PerClusterITS = esdTrack->GetITSchi2()/Float_t(nClustersITS);
 542   if (nClustersTPC!=0)
 543     chi2PerClusterTPC = esdTrack->GetTPCchi2()/Float_t(nClustersTPC);
 544
 545   Double_t extCov[15];
 546   esdTrack->GetExternalCovariance(extCov);
 547
 548   // getting the track to vertex parameters
 549   Float_t nSigmaToVertex = GetSigmaToVertex(esdTrack);
 550
 551   // getting the kinematic variables of the track
 552   // (assuming the mass is known)
 553   Double_t p[3];
 554   esdTrack->GetPxPyPz(p);
 555   Float_t momentum = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2) + TMath::Power(p[2],2));
 556   Float_t pt       = TMath::Sqrt(TMath::Power(p[0],2) + TMath::Power(p[1],2));
 557   Float_t energy   = TMath::Sqrt(TMath::Power(esdTrack->GetMass(),2) + TMath::Power(momentum,2));
 558
 559
 560   //y-eta related calculations
 561   Float_t eta = -100.;
 562   Float_t y   = -100.;
 563   if((momentum != TMath::Abs(p[2]))&&(momentum != 0))
 564     eta = 0.5*TMath::Log((momentum + p[2])/(momentum - p[2]));
 565   if((energy != TMath::Abs(p[2]))&&(momentum != 0))
 566     y = 0.5*TMath::Log((energy + p[2])/(energy - p[2]));
 567
 568
 569   //########################################################################
 570   // cut the track?
 571
 572   Bool_t cuts[kNCuts];
 573   for (Int_t i=0; i<kNCuts; i++) cuts[i]=kFALSE;
 574
 575   // track quality cuts
 576   if (fCutRequireTPCRefit && (status&AliESDtrack::kTPCrefit)==0)
 577     cuts[0]=kTRUE;
 578   if (fCutRequireITSRefit && (status&AliESDtrack::kITSrefit)==0)
 579     cuts[1]=kTRUE;
 580   if (nClustersTPC<fCutMinNClusterTPC)
 581     cuts[2]=kTRUE;
 582   if (nClustersITS<fCutMinNClusterITS)
 583     cuts[3]=kTRUE;
 584   if (chi2PerClusterTPC>fCutMaxChi2PerClusterTPC)
 585     cuts[4]=kTRUE;
 586   if (chi2PerClusterITS>fCutMaxChi2PerClusterITS)
 587     cuts[5]=kTRUE;
 588   if (extCov[0]  > fCutMaxC11)
 589     cuts[6]=kTRUE;
 590   if (extCov[2]  > fCutMaxC22)
 591     cuts[7]=kTRUE;
 592   if (extCov[5]  > fCutMaxC33)
 593     cuts[8]=kTRUE;
 594   if (extCov[9]  > fCutMaxC44)
 595     cuts[9]=kTRUE;
 596   if (extCov[14]  > fCutMaxC55)
 597     cuts[10]=kTRUE;
 598   if (nSigmaToVertex > fCutNsigmaToVertex && fCutSigmaToVertexRequired)
 599     cuts[11] = kTRUE;
 600   // if n sigma could not be calculated
 601   if (nSigmaToVertex<0 && fCutSigmaToVertexRequired)
 602     cuts[12]=kTRUE;
 603   if (!fCutAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)
 604     cuts[13]=kTRUE;
 605   // track kinematics cut
 606   if((momentum < fPMin) || (momentum > fPMax))
 607     cuts[14]=kTRUE;
 608   if((pt < fPtMin) || (pt > fPtMax))
 609     cuts[15] = kTRUE;
 610   if((p[0] < fPxMin) || (p[0] > fPxMax))
 611     cuts[16] = kTRUE;
 612   if((p[1] < fPyMin) || (p[1] > fPyMax))
 613     cuts[17] = kTRUE;
 614   if((p[2] < fPzMin) || (p[2] > fPzMax))
 615     cuts[18] = kTRUE;
 616   if((eta < fEtaMin) || (eta > fEtaMax))
 617     cuts[19] = kTRUE;
 618   if((y < fRapMin) || (y > fRapMax))
 619     cuts[20] = kTRUE;
 620
 621   Bool_t cut=kFALSE;
 622   for (Int_t i=0; i<kNCuts; i++)
 623     if (cuts[i]) cut = kTRUE;
 624
 625   //########################################################################
 626   // filling histograms
 627   if (fHistogramsOn) {
 628     fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n tracks")));
 629
 630     if (cut)
 631       fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin("n cut tracks")));
 632
 633     for (Int_t i=0; i<kNCuts; i++) {
 634       if (cuts[i])
 635         fhCutStatistics->Fill(fhCutStatistics->GetBinCenter(fhCutStatistics->GetXaxis()->FindBin(fgkCutNames[i])));
 636
 637       for (Int_t j=i; j<kNCuts; j++) {
 638         if (cuts[i] && cuts[j]) {
 639           Float_t x = fhCutCorrelation->GetXaxis()->GetBinCenter(fhCutCorrelation->GetXaxis()->FindBin(fgkCutNames[i]));
 640           Float_t y = fhCutCorrelation->GetYaxis()->GetBinCenter(fhCutCorrelation->GetYaxis()->FindBin(fgkCutNames[j]));
 641           fhCutCorrelation->Fill(x,y);
 642         }
 643       }
 644     }
 645
 646
 647     fhNClustersITS[0]->Fill(nClustersITS);
 648     fhNClustersTPC[0]->Fill(nClustersTPC);
 649     fhChi2PerClusterITS[0]->Fill(chi2PerClusterITS);
 650     fhChi2PerClusterTPC[0]->Fill(chi2PerClusterTPC);
 651
 652     fhC11[0]->Fill(extCov[0]);
 653     fhC22[0]->Fill(extCov[2]);
 654     fhC33[0]->Fill(extCov[5]);
 655     fhC44[0]->Fill(extCov[9]);
 656     fhC55[0]->Fill(extCov[14]);
 657
 658     Float_t b[2];
 659     Float_t bRes[2];
 660     Float_t bCov[3];
 661     esdTrack->GetImpactParameters(b,bCov);
 662     if (bCov[0]<=0 || bCov[2]<=0) {
 663       AliDebug(1, "Estimated b resolution lower or equal zero!");
 664       bCov[0]=0; bCov[2]=0;
 665     }
 666     bRes[0] = TMath::Sqrt(bCov[0]);
 667     bRes[1] = TMath::Sqrt(bCov[2]);
 668
 669     fhDZ[0]->Fill(b[1]);
 670     fhDXY[0]->Fill(b[0]);
 671     fhDXYvsDZ[0]->Fill(b[1],b[0]);
 672
 673     if (bRes[0]!=0 && bRes[1]!=0) {
 674       fhDZNormalized[0]->Fill(b[1]/bRes[1]);
 675       fhDXYNormalized[0]->Fill(b[0]/bRes[0]);
 676       fhDXYvsDZNormalized[0]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
 677       fhNSigmaToVertex[0]->Fill(nSigmaToVertex);
 678     }
 679   }
 680
 681   //########################################################################
 682   // cut the track!
 683   if (cut) return kFALSE;
 684
 685   //########################################################################
 686   // filling histograms after cut
 687   if (fHistogramsOn) {
 688     fhNClustersITS[1]->Fill(nClustersITS);
 689     fhNClustersTPC[1]->Fill(nClustersTPC);
 690     fhChi2PerClusterITS[1]->Fill(chi2PerClusterITS);
 691     fhChi2PerClusterTPC[1]->Fill(chi2PerClusterTPC);
 692
 693     fhC11[1]->Fill(extCov[0]);
 694     fhC22[1]->Fill(extCov[2]);
 695     fhC33[1]->Fill(extCov[5]);
 696     fhC44[1]->Fill(extCov[9]);
 697     fhC55[1]->Fill(extCov[14]);
 698
 699     Float_t b[2];
 700     Float_t bRes[2];
 701     Float_t bCov[3];
 702     esdTrack->GetImpactParameters(b,bCov);
 703     if (bCov[0]<=0 || bCov[2]<=0) {
 704       AliDebug(1, "Estimated b resolution lower or equal zero!");
 705       bCov[0]=0; bCov[2]=0;
 706     }
 707     bRes[0] = TMath::Sqrt(bCov[0]);
 708     bRes[1] = TMath::Sqrt(bCov[2]);
 709
 710     fhDZ[1]->Fill(b[1]);
 711     fhDXY[1]->Fill(b[0]);
 712     fhDXYvsDZ[1]->Fill(b[1],b[0]);
 713
 714     if (bRes[0]!=0 && bRes[1]!=0)
 715     {
 716       fhDZNormalized[1]->Fill(b[1]/bRes[1]);
 717       fhDXYNormalized[1]->Fill(b[0]/bRes[0]);
 718       fhDXYvsDZNormalized[1]->Fill(b[1]/bRes[1], b[0]/bRes[0]);
 719       fhNSigmaToVertex[1]->Fill(nSigmaToVertex);
 720     }
 721   }
 722
 723   return kTRUE;
 724 }
 725
 726 //____________________________________________________________________
 727 TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESD* esd)
 728 {
 729   //
 730   // returns an array of all tracks that pass the cuts
 731   //
 732
 733   TObjArray* acceptedTracks = new TObjArray();
 734
 735   // loop over esd tracks
 736   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
 737     AliESDtrack* track = esd->GetTrack(iTrack);
 738
 739     if (AcceptTrack(track))
 740       acceptedTracks->Add(track);
 741   }
 742
 743   return acceptedTracks;
 744 }
 745
 746 //____________________________________________________________________
 747 Int_t AliESDtrackCuts::CountAcceptedTracks(AliESD* esd)
 748 {
 749   //
 750   // returns an the number of tracks that pass the cuts
 751   //
 752
 753   Int_t count = 0;
 754
 755   // loop over esd tracks
 756   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
 757     AliESDtrack* track = esd->GetTrack(iTrack);
 758
 759     if (AcceptTrack(track))
 760       count++;
 761   }
 762
 763   return count;
 764 }
 765
 766 //____________________________________________________________________
 767 TObjArray* AliESDtrackCuts::GetAcceptedTracks(AliESDEvent* esd)
 768 {
 769   //
 770   // returns an array of all tracks that pass the cuts
 771   //
 772
 773   TObjArray* acceptedTracks = new TObjArray();
 774
 775   // loop over esd tracks
 776   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
 777     AliESDtrack* track = esd->GetTrack(iTrack);
 778
 779     if (AcceptTrack(track))
 780       acceptedTracks->Add(track);
 781   }
 782
 783   return acceptedTracks;
 784 }
 785
 786 //____________________________________________________________________
 787 Int_t AliESDtrackCuts::CountAcceptedTracks(AliESDEvent* esd)
 788 {
 789   //
 790   // returns an the number of tracks that pass the cuts
 791   //
 792
 793   Int_t count = 0;
 794
 795   // loop over esd tracks
 796   for (Int_t iTrack = 0; iTrack < esd->GetNumberOfTracks(); iTrack++) {
 797     AliESDtrack* track = esd->GetTrack(iTrack);
 798
 799     if (AcceptTrack(track))
 800       count++;
 801   }
 802
 803   return count;
 804 }
 805
 806 //____________________________________________________________________
 807  void AliESDtrackCuts::DefineHistograms(Int_t color) {
 808    //
 809    // diagnostics histograms are defined
 810    //
 811
 812    fHistogramsOn=kTRUE;
 813
 814    Bool_t oldStatus = TH1::AddDirectoryStatus();
 815    TH1::AddDirectory(kFALSE);
 816
 817    //###################################################################################
 818    // defining histograms
 819
 820    fhCutStatistics = new TH1F("cut_statistics","cut statistics",kNCuts+4,-0.5,kNCuts+3.5);
 821
 822    fhCutStatistics->GetXaxis()->SetBinLabel(1,"n tracks");
 823    fhCutStatistics->GetXaxis()->SetBinLabel(2,"n cut tracks");
 824
 825    fhCutCorrelation = new TH2F("cut_correlation","cut correlation",kNCuts,-0.5,kNCuts-0.5,kNCuts,-0.5,kNCuts-0.5);;
 826
 827    for (Int_t i=0; i<kNCuts; i++) {
 828      fhCutStatistics->GetXaxis()->SetBinLabel(i+4,fgkCutNames[i]);
 829      fhCutCorrelation->GetXaxis()->SetBinLabel(i+1,fgkCutNames[i]);
 830      fhCutCorrelation->GetYaxis()->SetBinLabel(i+1,fgkCutNames[i]);
 831    }
 832
 833   fhCutStatistics  ->SetLineColor(color);
 834   fhCutCorrelation ->SetLineColor(color);
 835   fhCutStatistics  ->SetLineWidth(2);
 836   fhCutCorrelation ->SetLineWidth(2);
 837
 838   Char_t str[256];
 839   for (Int_t i=0; i<2; i++) {
 840     if (i==0) sprintf(str," ");
 841     else sprintf(str,"_cut");
 842
 843     fhNClustersITS[i]        = new TH1F(Form("nClustersITS%s",str)     ,"",8,-0.5,7.5);
 844     fhNClustersTPC[i]        = new TH1F(Form("nClustersTPC%s",str)     ,"",165,-0.5,164.5);
 845     fhChi2PerClusterITS[i]   = new TH1F(Form("chi2PerClusterITS%s",str),"",500,0,10);
 846     fhChi2PerClusterTPC[i]   = new TH1F(Form("chi2PerClusterTPC%s",str),"",500,0,10);
 847
 848     fhC11[i]                 = new  TH1F(Form("covMatrixDiagonal11%s",str),"",2000,0,20);
 849     fhC22[i]                 = new  TH1F(Form("covMatrixDiagonal22%s",str),"",2000,0,20);
 850     fhC33[i]                 = new  TH1F(Form("covMatrixDiagonal33%s",str),"",1000,0,1);
 851     fhC44[i]                 = new  TH1F(Form("covMatrixDiagonal44%s",str),"",1000,0,5);
 852     fhC55[i]                 = new  TH1F(Form("covMatrixDiagonal55%s",str),"",1000,0,5);
 853
 854     fhDXY[i]                 = new  TH1F(Form("dXY%s",str)    ,"",500,-10,10);
 855     fhDZ[i]                  = new  TH1F(Form("dZ%s",str)     ,"",500,-10,10);
 856     fhDXYvsDZ[i]             = new  TH2F(Form("dXYvsDZ%s",str),"",200,-10,10,200,-10,10);
 857
 858     fhDXYNormalized[i]       = new  TH1F(Form("dXYNormalized%s",str)    ,"",500,-10,10);
 859     fhDZNormalized[i]        = new  TH1F(Form("dZNormalized%s",str)     ,"",500,-10,10);
 860     fhDXYvsDZNormalized[i]   = new  TH2F(Form("dXYvsDZNormalized%s",str),"",200,-10,10,200,-10,10);
 861
 862     fhNSigmaToVertex[i]         = new  TH1F(Form("nSigmaToVertex%s",str),"",500,0,50);
 863
 864     fhNClustersITS[i]->SetTitle("n ITS clusters");
 865     fhNClustersTPC[i]->SetTitle("n TPC clusters");
 866     fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
 867     fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
 868
 869     fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
 870     fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
 871     fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
 872     fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
 873     fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
 874
 875     fhDXY[i]->SetTitle("transverse impact parameter");
 876     fhDZ[i]->SetTitle("longitudinal impact parameter");
 877     fhDXYvsDZ[i]->SetTitle("longitudinal impact parameter");
 878     fhDXYvsDZ[i]->SetYTitle("transverse impact parameter");
 879
 880     fhDXYNormalized[i]->SetTitle("normalized trans impact par");
 881     fhDZNormalized[i]->SetTitle("normalized long impact par");
 882     fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par");
 883     fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par");
 884     fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");
 885
 886     fhNClustersITS[i]->SetLineColor(color);   fhNClustersITS[i]->SetLineWidth(2);
 887     fhNClustersTPC[i]->SetLineColor(color);   fhNClustersTPC[i]->SetLineWidth(2);
 888     fhChi2PerClusterITS[i]->SetLineColor(color);   fhChi2PerClusterITS[i]->SetLineWidth(2);
 889     fhChi2PerClusterTPC[i]->SetLineColor(color);   fhChi2PerClusterTPC[i]->SetLineWidth(2);
 890
 891     fhC11[i]->SetLineColor(color);   fhC11[i]->SetLineWidth(2);
 892     fhC22[i]->SetLineColor(color);   fhC22[i]->SetLineWidth(2);
 893     fhC33[i]->SetLineColor(color);   fhC33[i]->SetLineWidth(2);
 894     fhC44[i]->SetLineColor(color);   fhC44[i]->SetLineWidth(2);
 895     fhC55[i]->SetLineColor(color);   fhC55[i]->SetLineWidth(2);
 896
 897     fhDXY[i]->SetLineColor(color);   fhDXY[i]->SetLineWidth(2);
 898     fhDZ[i]->SetLineColor(color);   fhDZ[i]->SetLineWidth(2);
 899
 900     fhDXYNormalized[i]->SetLineColor(color);   fhDXYNormalized[i]->SetLineWidth(2);
 901     fhDZNormalized[i]->SetLineColor(color);    fhDZNormalized[i]->SetLineWidth(2);
 902     fhNSigmaToVertex[i]->SetLineColor(color);  fhNSigmaToVertex[i]->SetLineWidth(2);
 903   }
 904
 905   // The number of sigmas to the vertex is per definition gaussian
 906   ffDTheoretical = new TF1("nSigmaToVertexTheoretical","([0]/2.506628274)*exp(-(x**2)/2)",0,50);
 907   ffDTheoretical->SetParameter(0,1);
 908
 909   TH1::AddDirectory(oldStatus);
 910 }
 911
 912 //____________________________________________________________________
 913 Bool_t AliESDtrackCuts::LoadHistograms(const Char_t* dir)
 914 {
 915   //
 916   // loads the histograms from a file
 917   // if dir is empty a directory with the name of this object is taken (like in SaveHistogram)
 918   //
 919
 920   if (!dir)
 921     dir = GetName();
 922
 923   if (!gDirectory->cd(dir))
 924     return kFALSE;
 925
 926   ffDTheoretical = dynamic_cast<TF1*> (gDirectory->Get("nSigmaToVertexTheory"));
 927
 928   fhCutStatistics = dynamic_cast<TH1F*> (gDirectory->Get("cut_statistics"));
 929   fhCutCorrelation = dynamic_cast<TH2F*> (gDirectory->Get("cut_correlation"));
 930
 931   Char_t str[5];
 932   for (Int_t i=0; i<2; i++) {
 933     if (i==0)
 934     {
 935       gDirectory->cd("before_cuts");
 936       str[0] = 0;
 937     }
 938     else
 939     {
 940       gDirectory->cd("after_cuts");
 941       sprintf(str,"_cut");
 942     }
 943
 944     fhNClustersITS[i]      = dynamic_cast<TH1F*> (gDirectory->Get(Form("nClustersITS%s",str)     ));
 945     fhNClustersTPC[i]      = dynamic_cast<TH1F*> (gDirectory->Get(Form("nClustersTPC%s",str)     ));
 946     fhChi2PerClusterITS[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("chi2PerClusterITS%s",str)));
 947     fhChi2PerClusterTPC[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("chi2PerClusterTPC%s",str)));
 948
 949     fhC11[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal11%s",str)));
 950     fhC22[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal22%s",str)));
 951     fhC33[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal33%s",str)));
 952     fhC44[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal44%s",str)));
 953     fhC55[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("covMatrixDiagonal55%s",str)));
 954
 955     fhDXY[i] =     dynamic_cast<TH1F*> (gDirectory->Get(Form("dXY%s",str)    ));
 956     fhDZ[i] =      dynamic_cast<TH1F*> (gDirectory->Get(Form("dZ%s",str)     ));
 957     fhDXYvsDZ[i] = dynamic_cast<TH2F*> (gDirectory->Get(Form("dXYvsDZ%s",str)));
 958
 959     fhDXYNormalized[i] =     dynamic_cast<TH1F*> (gDirectory->Get(Form("dXYNormalized%s",str)    ));
 960     fhDZNormalized[i] =      dynamic_cast<TH1F*> (gDirectory->Get(Form("dZNormalized%s",str)     ));
 961     fhDXYvsDZNormalized[i] = dynamic_cast<TH2F*> (gDirectory->Get(Form("dXYvsDZNormalized%s",str)));
 962
 963     fhNSigmaToVertex[i] = dynamic_cast<TH1F*> (gDirectory->Get(Form("nSigmaToVertex%s",str)));
 964
 965     // TODO only temporary
 966     /*fhNClustersITS[i]->SetTitle("n ITS clusters");
 967     fhNClustersTPC[i]->SetTitle("n TPC clusters");
 968     fhChi2PerClusterITS[i]->SetTitle("#Chi^{2} per ITS cluster");
 969     fhChi2PerClusterTPC[i]->SetTitle("#Chi^{2} per TPC cluster");
 970
 971     fhC11[i]->SetTitle("cov 11 : #sigma_{y}^{2} [cm^{2}]");
 972     fhC22[i]->SetTitle("cov 22 : #sigma_{z}^{2} [cm^{2}]");
 973     fhC33[i]->SetTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
 974     fhC44[i]->SetTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
 975     fhC55[i]->SetTitle("cov 55 : #sigma_{1/p_{T}}^{2} [(c/GeV)^2]");
 976
 977     fhDXY[i]->SetTitle("transverse impact parameter");
 978     fhDZ[i]->SetTitle("longitudinal impact parameter");
 979     fhDXYvsDZ[i]->SetTitle("longitudinal impact parameter");
 980     fhDXYvsDZ[i]->SetYTitle("transverse impact parameter");
 981
 982     fhDXYNormalized[i]->SetTitle("normalized trans impact par");
 983     fhDZNormalized[i]->SetTitle("normalized long impact par");
 984     fhDXYvsDZNormalized[i]->SetTitle("normalized long impact par");
 985     fhDXYvsDZNormalized[i]->SetYTitle("normalized trans impact par");
 986     fhNSigmaToVertex[i]->SetTitle("n #sigma to vertex");*/
 987
 988     gDirectory->cd("../");
 989   }
 990
 991   gDirectory->cd("..");
 992
 993   return kTRUE;
 994 }
 995
 996 //____________________________________________________________________
 997 void AliESDtrackCuts::SaveHistograms(const Char_t* dir) {
 998   //
 999   // saves the histograms in a directory (dir)
1000   //
1001
1002   if (!fHistogramsOn) {
1003     AliDebug(0, "Histograms not on - cannot save histograms!!!");
1004     return;
1005   }
1006
1007   if (!dir)
1008     dir = GetName();
1009
1010   gDirectory->mkdir(dir);
1011   gDirectory->cd(dir);
1012
1013   gDirectory->mkdir("before_cuts");
1014   gDirectory->mkdir("after_cuts");
1015
1016   // a factor of 2 is needed since n sigma is positive
1017   ffDTheoretical->SetParameter(0,2*fhNSigmaToVertex[0]->Integral("width"));
1018   ffDTheoretical->Write("nSigmaToVertexTheory");
1019
1020   fhCutStatistics->Write();
1021   fhCutCorrelation->Write();
1022
1023   for (Int_t i=0; i<2; i++) {
1024     if (i==0)
1025       gDirectory->cd("before_cuts");
1026     else
1027       gDirectory->cd("after_cuts");
1028
1029     fhNClustersITS[i]        ->Write();
1030     fhNClustersTPC[i]        ->Write();
1031     fhChi2PerClusterITS[i]   ->Write();
1032     fhChi2PerClusterTPC[i]   ->Write();
1033
1034     fhC11[i]                 ->Write();
1035     fhC22[i]                 ->Write();
1036     fhC33[i]                 ->Write();
1037     fhC44[i]                 ->Write();
1038     fhC55[i]                 ->Write();
1039
1040     fhDXY[i]                 ->Write();
1041     fhDZ[i]                  ->Write();
1042     fhDXYvsDZ[i]             ->Write();
1043
1044     fhDXYNormalized[i]       ->Write();
1045     fhDZNormalized[i]        ->Write();
1046     fhDXYvsDZNormalized[i]   ->Write();
1047     fhNSigmaToVertex[i]      ->Write();
1048
1049     gDirectory->cd("../");
1050   }
1051
1052   gDirectory->cd("../");
1053 }
1054
1055 //____________________________________________________________________
1056 void AliESDtrackCuts::DrawHistograms()
1057 {
1058   // draws some histograms
1059
1060   TCanvas* canvas1 = new TCanvas(Form("%s_1", GetName()), "Track Quality Results1", 800, 800);
1061   canvas1->Divide(2, 2);
1062
1063   canvas1->cd(1);
1064   fhNClustersTPC[0]->SetStats(kFALSE);
1065   fhNClustersTPC[0]->Draw();
1066
1067   canvas1->cd(2);
1068   fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1069   fhChi2PerClusterTPC[0]->Draw();
1070
1071   canvas1->cd(3);
1072   fhNSigmaToVertex[0]->SetStats(kFALSE);
1073   fhNSigmaToVertex[0]->GetXaxis()->SetRangeUser(0, 10);
1074   fhNSigmaToVertex[0]->Draw();
1075
1076   canvas1->SaveAs(Form("%s_%s.gif", GetName(), canvas1->GetName()));
1077
1078   TCanvas* canvas2 = new TCanvas(Form("%s_2", GetName()), "Track Quality Results2", 1200, 800);
1079   canvas2->Divide(3, 2);
1080
1081   canvas2->cd(1);
1082   fhC11[0]->SetStats(kFALSE);
1083   gPad->SetLogy();
1084   fhC11[0]->Draw();
1085
1086   canvas2->cd(2);
1087   fhC22[0]->SetStats(kFALSE);
1088   gPad->SetLogy();
1089   fhC22[0]->Draw();
1090
1091   canvas2->cd(3);
1092   fhC33[0]->SetStats(kFALSE);
1093   gPad->SetLogy();
1094   fhC33[0]->Draw();
1095
1096   canvas2->cd(4);
1097   fhC44[0]->SetStats(kFALSE);
1098   gPad->SetLogy();
1099   fhC44[0]->Draw();
1100
1101   canvas2->cd(5);
1102   fhC55[0]->SetStats(kFALSE);
1103   gPad->SetLogy();
1104   fhC55[0]->Draw();
1105
1106   canvas2->SaveAs(Form("%s_%s.gif", GetName(), canvas2->GetName()));
1107
1108   TCanvas* canvas3 = new TCanvas(Form("%s_3", GetName()), "Track Quality Results3", 1200, 800);
1109   canvas3->Divide(3, 2);
1110
1111   canvas3->cd(1);
1112   fhDXY[0]->SetStats(kFALSE);
1113   gPad->SetLogy();
1114   fhDXY[0]->Draw();
1115
1116   canvas3->cd(2);
1117   fhDZ[0]->SetStats(kFALSE);
1118   gPad->SetLogy();
1119   fhDZ[0]->Draw();
1120
1121   canvas3->cd(3);
1122   fhDXYvsDZ[0]->SetStats(kFALSE);
1123   gPad->SetLogz();
1124   gPad->SetRightMargin(0.15);
1125   fhDXYvsDZ[0]->Draw("COLZ");
1126
1127   canvas3->cd(4);
1128   fhDXYNormalized[0]->SetStats(kFALSE);
1129   gPad->SetLogy();
1130   fhDXYNormalized[0]->Draw();
1131
1132   canvas3->cd(5);
1133   fhDZNormalized[0]->SetStats(kFALSE);
1134   gPad->SetLogy();
1135   fhDZNormalized[0]->Draw();
1136
1137   canvas3->cd(6);
1138   fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1139   gPad->SetLogz();
1140   gPad->SetRightMargin(0.15);
1141   fhDXYvsDZNormalized[0]->Draw("COLZ");
1142
1143   canvas3->SaveAs(Form("%s_%s.gif", GetName(), canvas3->GetName()));
1144
1145   TCanvas* canvas4 = new TCanvas(Form("%s_4", GetName()), "Track Quality Results4", 800, 500);
1146   canvas4->Divide(2, 1);
1147
1148   canvas4->cd(1);
1149   fhCutStatistics->SetStats(kFALSE);
1150   fhCutStatistics->LabelsOption("v");
1151   gPad->SetBottomMargin(0.3);
1152   fhCutStatistics->Draw();
1153
1154   canvas4->cd(2);
1155   fhCutCorrelation->SetStats(kFALSE);
1156   fhCutCorrelation->LabelsOption("v");
1157   gPad->SetBottomMargin(0.3);
1158   gPad->SetLeftMargin(0.3);
1159   fhCutCorrelation->Draw("COLZ");
1160
1161   canvas4->SaveAs(Form("%s_%s.gif", GetName(), canvas4->GetName()));
1162
1163   /*canvas->cd(1);
1164   fhDXYvsDZNormalized[0]->SetStats(kFALSE);
1165   fhDXYvsDZNormalized[0]->DrawCopy("COLZ");
1166
1167   canvas->cd(2);
1168   fhNClustersTPC[0]->SetStats(kFALSE);
1169   fhNClustersTPC[0]->DrawCopy();
1170
1171   canvas->cd(3);
1172   fhChi2PerClusterITS[0]->SetStats(kFALSE);
1173   fhChi2PerClusterITS[0]->DrawCopy();
1174   fhChi2PerClusterITS[1]->SetLineColor(2);
1175   fhChi2PerClusterITS[1]->DrawCopy("SAME");
1176
1177   canvas->cd(4);
1178   fhChi2PerClusterTPC[0]->SetStats(kFALSE);
1179   fhChi2PerClusterTPC[0]->DrawCopy();
1180   fhChi2PerClusterTPC[1]->SetLineColor(2);
1181   fhChi2PerClusterTPC[1]->DrawCopy("SAME");*/
1182 }
1183