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