CORRFW/AliCFTrackQualityCuts.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 // The class AliCFTrackQualityCuts is designed to select reconstructed tracks
  17 // of high quality and to provide corresponding QA histograms.
  18 // This class inherits from the Analysis' Framework abstract base class
  19 // AliAnalysisCuts and is a part of the Correction Framework.
  20 // This class acts on single, reconstructed tracks, it is applicable on
  21 // ESD and AOD data.
  22 // It mainly consists of a IsSelected function that returns a boolean.
  23 // This function checks whether the considered track passes a set of cuts:
  24 // - number of clusters in the ITS
  25 // - number of clusters in the TPC
  26 // - number of clusters in the TRD
  27 // - ratio of found / finable number of clusters in the TPC
  28 // - number of tracklets in the TRD
  29 // - number TRD tracklets used for pid
  30 // - chi2 / cluster in the ITS
  31 // - chi2 / cluster in the TPC
  32 // - chi2 / tracklet in the TRD
  33 // - number of clusters in the TPC used for dEdx calculation
  34 // - successful TPC refit
  35 // - successful ITS refit
  36 // - covariance matrix diagonal elements
  37 //
  38 // The cut values for these cuts are set with the corresponding set functions.
  39 // All cut classes provided by the correction framework are supposed to be
  40 // added in the Analysis Framwork's class AliAnalysisFilter and applied by
  41 // the filter via a loop.
  42 //
  43 // author: I. Kraus (Ingrid.Kraus@cern.ch)
  44 // idea taken form
  45 // AliESDtrackCuts writte by Jan Fiete Grosse-Oetringhaus and
  46 // AliRsnDaughterCut class written by A. Pulvirenti.
  47
  48
  49 #include <TCanvas.h>
  50 #include <TDirectory.h>
  51 #include <TH2.h>
  52 #include <TBits.h>
  53
  54 #include <AliESDtrack.h>
  55 #include <AliESDtrackCuts.h>
  56 #include <AliLog.h>
  57 #include "AliCFTrackQualityCuts.h"
  58 #include "AliAODTrack.h"
  59
  60 ClassImp(AliCFTrackQualityCuts)
  61
  62 //__________________________________________________________________________________
  63 AliCFTrackQualityCuts::AliCFTrackQualityCuts() :
  64   AliCFCutBase(),
  65   fMinNClusterTPC(0),
  66   fMinNClusterITS(0),
  67   fMinNClusterTRD(0),
  68   fMinFoundClusterTPC(0),
  69   fMinNTrackletTRD(0),
  70   fMinNTrackletTRDpid(0),
  71   fMaxChi2PerClusterTPC(0),
  72   fMaxChi2PerClusterITS(0),
  73   fMaxChi2PerTrackletTRD(0),
  74   fMinNdEdxClusterTPC(0),
  75   fCovariance11Max(0),
  76   fCovariance22Max(0),
  77   fCovariance33Max(0),
  78   fCovariance44Max(0),
  79   fCovariance55Max(0),
  80   fStatus(0),
  81   fhCutStatistics(0),
  82   fhCutCorrelation(0),
  83   fBitmap(0x0),
  84   fTrackCuts(0x0),
  85   fhNBinsClusterTPC(0),
  86   fhNBinsClusterITS(0),
  87   fhNBinsClusterTRD(0),
  88   fhNBinsFoundClusterTPC(0),
  89   fhNBinsTrackletTRD(0),
  90   fhNBinsTrackletTRDpid(0),
  91   fhNBinsChi2TPC(0),
  92   fhNBinsChi2ITS(0),
  93   fhNBinsChi2TRD(0),
  94   fhNBinsdEdxClusterTPC(0),
  95   fhNBinsCovariance11(0),
  96   fhNBinsCovariance22(0),
  97   fhNBinsCovariance33(0),
  98   fhNBinsCovariance44(0),
  99   fhNBinsCovariance55(0),
 100   fhBinLimClusterTPC(0x0),
 101   fhBinLimClusterITS(0x0),
 102   fhBinLimClusterTRD(0x0),
 103   fhBinLimFoundClusterTPC(0x0),
 104   fhBinLimTrackletTRD(0x0),
 105   fhBinLimTrackletTRDpid(0x0),
 106   fhBinLimChi2TPC(0x0),
 107   fhBinLimChi2ITS(0x0),
 108   fhBinLimChi2TRD(0x0),
 109   fhBinLimdEdxClusterTPC(0x0),
 110   fhBinLimCovariance11(0x0),
 111   fhBinLimCovariance22(0x0),
 112   fhBinLimCovariance33(0x0),
 113   fhBinLimCovariance44(0x0),
 114   fhBinLimCovariance55(0x0)
 115 {
 116   //
 117   // Default constructor
 118   //
 119   Initialise();
 120 }
 121 //__________________________________________________________________________________
 122 AliCFTrackQualityCuts::AliCFTrackQualityCuts(Char_t* name, Char_t* title) :
 123   AliCFCutBase(name,title),
 124   fMinNClusterTPC(0),
 125   fMinNClusterITS(0),
 126   fMinNClusterTRD(0),
 127   fMinFoundClusterTPC(0),
 128   fMinNTrackletTRD(0),
 129   fMinNTrackletTRDpid(0),
 130   fMaxChi2PerClusterTPC(0),
 131   fMaxChi2PerClusterITS(0),
 132   fMaxChi2PerTrackletTRD(0),
 133   fMinNdEdxClusterTPC(0),
 134   fCovariance11Max(0),
 135   fCovariance22Max(0),
 136   fCovariance33Max(0),
 137   fCovariance44Max(0),
 138   fCovariance55Max(0),
 139   fStatus(0),
 140   fhCutStatistics(0),
 141   fhCutCorrelation(0),
 142   fBitmap(0x0),
 143   fTrackCuts(0x0),
 144   fhNBinsClusterTPC(0),
 145   fhNBinsClusterITS(0),
 146   fhNBinsClusterTRD(0),
 147   fhNBinsFoundClusterTPC(0),
 148   fhNBinsTrackletTRD(0),
 149   fhNBinsTrackletTRDpid(0),
 150   fhNBinsChi2TPC(0),
 151   fhNBinsChi2ITS(0),
 152   fhNBinsChi2TRD(0),
 153   fhNBinsdEdxClusterTPC(0),
 154   fhNBinsCovariance11(0),
 155   fhNBinsCovariance22(0),
 156   fhNBinsCovariance33(0),
 157   fhNBinsCovariance44(0),
 158   fhNBinsCovariance55(0),
 159   fhBinLimClusterTPC(0x0),
 160   fhBinLimClusterITS(0x0),
 161   fhBinLimClusterTRD(0x0),
 162   fhBinLimFoundClusterTPC(0x0),
 163   fhBinLimTrackletTRD(0x0),
 164   fhBinLimTrackletTRDpid(0x0),
 165   fhBinLimChi2TPC(0x0),
 166   fhBinLimChi2ITS(0x0),
 167   fhBinLimChi2TRD(0x0),
 168   fhBinLimdEdxClusterTPC(0x0),
 169   fhBinLimCovariance11(0x0),
 170   fhBinLimCovariance22(0x0),
 171   fhBinLimCovariance33(0x0),
 172   fhBinLimCovariance44(0x0),
 173   fhBinLimCovariance55(0x0)
 174 {
 175   //
 176   // Constructor
 177   //
 178   Initialise();
 179 }
 180 //__________________________________________________________________________________
 181 AliCFTrackQualityCuts::AliCFTrackQualityCuts(const AliCFTrackQualityCuts& c) :
 182   AliCFCutBase(c),
 183   fMinNClusterTPC(c.fMinNClusterTPC),
 184   fMinNClusterITS(c.fMinNClusterITS),
 185   fMinNClusterTRD(c.fMinNClusterTRD),
 186   fMinFoundClusterTPC(c.fMinFoundClusterTPC),
 187   fMinNTrackletTRD(c.fMinNTrackletTRD),
 188   fMinNTrackletTRDpid(c.fMinNTrackletTRDpid),
 189   fMaxChi2PerClusterTPC(c.fMaxChi2PerClusterTPC),
 190   fMaxChi2PerClusterITS(c.fMaxChi2PerClusterITS),
 191   fMaxChi2PerTrackletTRD(c.fMaxChi2PerTrackletTRD),
 192   fMinNdEdxClusterTPC(c.fMinNdEdxClusterTPC),
 193   fCovariance11Max(c.fCovariance11Max),
 194   fCovariance22Max(c.fCovariance22Max),
 195   fCovariance33Max(c.fCovariance33Max),
 196   fCovariance44Max(c.fCovariance44Max),
 197   fCovariance55Max(c.fCovariance55Max),
 198   fStatus(c.fStatus),
 199   fhCutStatistics(c.fhCutStatistics),
 200   fhCutCorrelation(c.fhCutCorrelation),
 201   fBitmap(c.fBitmap),
 202   fTrackCuts(c.fTrackCuts),
 203   fhNBinsClusterTPC(c.fhNBinsClusterTPC),
 204   fhNBinsClusterITS(c.fhNBinsClusterITS),
 205   fhNBinsClusterTRD(c.fhNBinsClusterTRD),
 206   fhNBinsFoundClusterTPC(c.fhNBinsFoundClusterTPC),
 207   fhNBinsTrackletTRD(c.fhNBinsTrackletTRD),
 208   fhNBinsTrackletTRDpid(c.fhNBinsTrackletTRDpid),
 209   fhNBinsChi2TPC(c.fhNBinsChi2TPC),
 210   fhNBinsChi2ITS(c.fhNBinsChi2ITS),
 211   fhNBinsChi2TRD(c.fhNBinsChi2TRD),
 212   fhNBinsdEdxClusterTPC(c.fhNBinsdEdxClusterTPC),
 213   fhNBinsCovariance11(c.fhNBinsCovariance11),
 214   fhNBinsCovariance22(c.fhNBinsCovariance22),
 215   fhNBinsCovariance33(c.fhNBinsCovariance33),
 216   fhNBinsCovariance44(c.fhNBinsCovariance44),
 217   fhNBinsCovariance55(c.fhNBinsCovariance55),
 218   fhBinLimClusterTPC(c.fhBinLimClusterTPC),
 219   fhBinLimClusterITS(c.fhBinLimClusterITS),
 220   fhBinLimClusterTRD(c.fhBinLimClusterTRD),
 221   fhBinLimFoundClusterTPC(c.fhBinLimFoundClusterTPC),
 222   fhBinLimTrackletTRD(c.fhBinLimTrackletTRD),
 223   fhBinLimTrackletTRDpid(c.fhBinLimTrackletTRDpid),
 224   fhBinLimChi2TPC(c.fhBinLimChi2TPC),
 225   fhBinLimChi2ITS(c.fhBinLimChi2ITS),
 226   fhBinLimChi2TRD(c.fhBinLimChi2TRD),
 227   fhBinLimdEdxClusterTPC(c.fhBinLimdEdxClusterTPC),
 228   fhBinLimCovariance11(c.fhBinLimCovariance11),
 229   fhBinLimCovariance22(c.fhBinLimCovariance22),
 230   fhBinLimCovariance33(c.fhBinLimCovariance33),
 231   fhBinLimCovariance44(c.fhBinLimCovariance44),
 232   fhBinLimCovariance55(c.fhBinLimCovariance55)
 233 {
 234   //
 235   // copy constructor
 236   //
 237   ((AliCFTrackQualityCuts &) c).Copy(*this);
 238 }
 239 //__________________________________________________________________________________
 240 AliCFTrackQualityCuts& AliCFTrackQualityCuts::operator=(const AliCFTrackQualityCuts& c)
 241 {
 242   //
 243   // Assignment operator
 244   //
 245   if (this != &c) {
 246     AliCFCutBase::operator=(c) ;
 247     fMinNClusterTPC = c.fMinNClusterTPC ;
 248     fMinNClusterITS = c.fMinNClusterITS ;
 249     fMinNClusterTRD = c.fMinNClusterTRD ;
 250     fMinFoundClusterTPC = c.fMinFoundClusterTPC ;
 251     fMinNTrackletTRD = c.fMinNTrackletTRD ;
 252     fMinNTrackletTRDpid = c.fMinNTrackletTRDpid ;
 253     fMaxChi2PerClusterTPC = c.fMaxChi2PerClusterTPC ;
 254     fMaxChi2PerClusterITS = c.fMaxChi2PerClusterITS ;
 255     fMaxChi2PerTrackletTRD = c.fMaxChi2PerTrackletTRD ;
 256     fMinNdEdxClusterTPC = c.fMinNdEdxClusterTPC;
 257     fCovariance11Max = c.fCovariance11Max ;
 258     fCovariance22Max = c.fCovariance22Max ;
 259     fCovariance33Max = c.fCovariance33Max ;
 260     fCovariance44Max = c.fCovariance44Max ;
 261     fCovariance55Max = c.fCovariance55Max ;
 262     fStatus = c.fStatus ;
 263     fhCutStatistics = c.fhCutStatistics ;
 264     fhCutCorrelation = c.fhCutCorrelation ;
 265     fBitmap =  c.fBitmap ;
 266     fTrackCuts = c.fTrackCuts ;
 267     fhNBinsClusterTPC = c.fhNBinsClusterTPC ;
 268     fhNBinsClusterITS = c.fhNBinsClusterITS ;
 269     fhNBinsClusterTRD = c.fhNBinsClusterTRD ;
 270     fhNBinsFoundClusterTPC = c.fhNBinsFoundClusterTPC ;
 271     fhNBinsTrackletTRD = c.fhNBinsTrackletTRD ;
 272     fhNBinsTrackletTRDpid = c.fhNBinsTrackletTRDpid ;
 273     fhNBinsChi2TPC = c.fhNBinsChi2TPC ;
 274     fhNBinsChi2ITS = c.fhNBinsChi2ITS ;
 275     fhNBinsChi2TRD = c.fhNBinsChi2TRD ;
 276     fhNBinsdEdxClusterTPC = c.fhNBinsdEdxClusterTPC ;
 277     fhNBinsCovariance11 = c.fhNBinsCovariance11 ;
 278     fhNBinsCovariance22 = c.fhNBinsCovariance22 ;
 279     fhNBinsCovariance33 = c.fhNBinsCovariance33 ;
 280     fhNBinsCovariance44 = c.fhNBinsCovariance44 ;
 281     fhNBinsCovariance55 = c.fhNBinsCovariance55 ;
 282     fhBinLimClusterTPC = c.fhBinLimClusterTPC ;
 283     fhBinLimClusterITS = c.fhBinLimClusterITS ;
 284     fhBinLimClusterTRD = c.fhBinLimClusterTRD ;
 285     fhBinLimFoundClusterTPC = c.fhBinLimFoundClusterTPC ;
 286     fhBinLimTrackletTRD = c.fhBinLimTrackletTRD ;
 287     fhBinLimTrackletTRDpid = c.fhBinLimTrackletTRDpid ;
 288     fhBinLimChi2TPC = c.fhBinLimChi2TPC ;
 289     fhBinLimChi2ITS = c.fhBinLimChi2ITS ;
 290     fhBinLimChi2TRD = c.fhBinLimChi2TRD ;
 291     fhBinLimdEdxClusterTPC = c.fhBinLimdEdxClusterTPC ;
 292     fhBinLimCovariance11 = c.fhBinLimCovariance11 ;
 293     fhBinLimCovariance22 = c.fhBinLimCovariance22 ;
 294     fhBinLimCovariance33 = c.fhBinLimCovariance33 ;
 295     fhBinLimCovariance44 = c.fhBinLimCovariance44 ;
 296     fhBinLimCovariance55 = c.fhBinLimCovariance55 ;
 297
 298     for (Int_t i=0; i<c.kNHist; i++){
 299       for (Int_t j=0; j<c.kNStepQA; j++){
 300         if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
 301       }
 302     }
 303     ((AliCFTrackQualityCuts &) c).Copy(*this);
 304   }
 305   return *this;
 306 }
 307 //__________________________________________________________________________________
 308 AliCFTrackQualityCuts::~AliCFTrackQualityCuts()
 309 {
 310   //
 311   // destructor
 312   //
 313   if (fhCutStatistics)  delete fhCutStatistics;
 314   if (fhCutCorrelation) delete fhCutCorrelation;
 315
 316   for (Int_t i=0; i<kNHist; i++){
 317     for (Int_t j=0; j<kNStepQA; j++){
 318       if(fhQA[i][j]) delete fhQA[i][j];
 319     }
 320   }
 321   if(fBitmap) delete fBitmap;
 322   if(fTrackCuts) delete fTrackCuts;
 323   if(fhBinLimClusterTPC) delete fhBinLimClusterTPC;
 324   if(fhBinLimClusterITS) delete fhBinLimClusterITS;
 325   if(fhBinLimClusterTRD) delete fhBinLimClusterTRD;
 326   if(fhBinLimFoundClusterTPC) delete fhBinLimFoundClusterTPC;
 327   if(fhBinLimTrackletTRD) delete fhBinLimTrackletTRD;
 328   if(fhBinLimTrackletTRDpid) delete fhBinLimTrackletTRDpid;
 329   if(fhBinLimChi2TPC) delete fhBinLimChi2TPC;
 330   if(fhBinLimChi2ITS) delete fhBinLimChi2ITS;
 331   if(fhBinLimChi2TRD) delete fhBinLimChi2TRD;
 332   if(fhBinLimdEdxClusterTPC) delete fhBinLimdEdxClusterTPC;
 333   if(fhBinLimCovariance11) delete fhBinLimCovariance11;
 334   if(fhBinLimCovariance22) delete fhBinLimCovariance22;
 335   if(fhBinLimCovariance33) delete fhBinLimCovariance33;
 336   if(fhBinLimCovariance44) delete fhBinLimCovariance44;
 337   if(fhBinLimCovariance55) delete fhBinLimCovariance55;
 338 }
 339 //__________________________________________________________________________________
 340 void AliCFTrackQualityCuts::Initialise()
 341 {
 342   //
 343   // sets everything to zero
 344   //
 345   fMinNClusterTPC = 0;
 346   fMinNClusterITS = 0;
 347   fMinNClusterTRD = 0;
 348   fMinFoundClusterTPC = 0;
 349   fMinNTrackletTRD = 0;
 350   fMinNTrackletTRDpid = 0;
 351   fMaxChi2PerClusterTPC = 0;
 352   fMaxChi2PerClusterITS = 0;
 353   fMaxChi2PerTrackletTRD = 0;
 354   fMinNdEdxClusterTPC = 0;
 355   fCovariance11Max = 0;
 356   fCovariance22Max = 0;
 357   fCovariance33Max = 0;
 358   fCovariance44Max = 0;
 359   fCovariance55Max = 0;
 360   fStatus = 0;
 361
 362   SetMinNClusterTPC();
 363   SetMinNClusterITS();
 364   SetMinNClusterTRD();
 365   SetMinFoundClusterTPC();
 366   SetMinNTrackletTRD();
 367   SetMinNTrackletTRDpid();
 368   SetMaxChi2PerClusterTPC();
 369   SetMaxChi2PerClusterITS();
 370   SetMaxChi2PerTrackletTRD();
 371   SetMinNdEdxClusterTPC();
 372   SetMaxCovDiagonalElements();
 373   SetStatus();
 374
 375   for (Int_t i=0; i<kNHist; i++){
 376     for (Int_t j=0; j<kNStepQA; j++)
 377       fhQA[i][j] = 0x0;
 378   }
 379   fhCutStatistics = 0;
 380   fhCutCorrelation = 0;
 381   fBitmap=new TBits(0);
 382   fTrackCuts=new AliESDtrackCuts("aliESDtrackCuts","aliESDtrackCuts");
 383
 384   //set default bining for QA histograms
 385   SetHistogramBins(kCutClusterTPC,165,-0.5,164.5);
 386   SetHistogramBins(kCutClusterITS,8,-0.5,7.5);
 387   SetHistogramBins(kCutClusterTRD,120,-0.5,119.5);
 388   SetHistogramBins(kCutMinFoundClusterTPC,110,-0.05,1.05);
 389   SetHistogramBins(kCutTrackletTRD,7,-0.5,6.5);
 390   SetHistogramBins(kCutTrackletTRDpid,7,-0.5,6.5);
 391   SetHistogramBins(kCutChi2TPC,500,0.,10.);
 392   SetHistogramBins(kCutChi2ITS,500,0.,10.);
 393   SetHistogramBins(kCutChi2TRD,500,0.,10.);
 394   SetHistogramBins(kCutdEdxClusterTPC,165,-0.5,164.5);
 395   SetHistogramBins(kCutCovElement11,200,0.,20.);
 396   SetHistogramBins(kCutCovElement22,200,0.,20.);
 397   SetHistogramBins(kCutCovElement33,100,0.,1.);
 398   SetHistogramBins(kCutCovElement44,100,0.,5.);
 399   SetHistogramBins(kCutCovElement55,100,0.,5.);
 400 }
 401 //__________________________________________________________________________________
 402 void AliCFTrackQualityCuts::Copy(TObject &c) const
 403 {
 404   //
 405   // Copy function
 406   //
 407   AliCFTrackQualityCuts& target = (AliCFTrackQualityCuts &) c;
 408
 409   target.Initialise();
 410
 411   if (fhCutStatistics)  target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
 412   if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
 413
 414   for (Int_t i=0; i<kNHist; i++){
 415     for (Int_t j=0; j<kNStepQA; j++){
 416       if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
 417     }
 418   }
 419   TNamed::Copy(c);
 420 }
 421 //__________________________________________________________________________________
 422 void AliCFTrackQualityCuts::SelectionBitMap(TObject* obj)
 423 {
 424   //
 425   // test if the track passes the single cuts
 426   // and store the information in a bitmap
 427   //
 428
 429   // bitmap stores the decision of each single cut
 430   for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
 431
 432   if (!obj) return;
 433   if (!obj->InheritsFrom("AliVParticle")) {
 434     AliError("object must derived from AliVParticle !");
 435     return;
 436   }
 437
 438   Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
 439   Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
 440
 441   AliESDtrack * esdTrack = 0x0 ;
 442   AliAODTrack * aodTrack = 0x0 ;
 443   if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
 444   if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
 445
 446   fTrackCuts->SetMinNClustersTPC(fMinNClusterTPC);
 447   fTrackCuts->SetMinNClustersITS(fMinNClusterITS);
 448   fTrackCuts->SetMaxChi2PerClusterTPC(fMaxChi2PerClusterTPC);
 449   fTrackCuts->SetMaxChi2PerClusterITS(fMaxChi2PerClusterITS);
 450   fTrackCuts->SetMaxCovDiagonalElements(fCovariance11Max,fCovariance22Max,fCovariance33Max,fCovariance44Max,fCovariance55Max);
 451
 452 // // // remove following 5 lines when AliESDtrackCuts is updated
 453    Int_t    nClustersTPC = 0;
 454    Int_t    nClustersITS = 0 ;
 455    Float_t  chi2PerClusterTPC =  0 ;
 456    Float_t  chi2PerClusterITS = 0 ;
 457    Double_t extCov[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 458
 459   // get cut quantities
 460   Int_t   nClustersTRD = 0;
 461   Int_t   nTrackletsTRD = 0;
 462   Float_t chi2PerTrackletTRD = 0;
 463   Float_t fractionFoundClustersTPC = 0;
 464
 465   if (isESDTrack) {
 466     nClustersTRD = esdTrack->GetTRDncls();
 467     nTrackletsTRD = esdTrack->GetTRDntracklets();
 468     if (nTrackletsTRD != 0) chi2PerTrackletTRD = esdTrack->GetTRDchi2() / Float_t(nTrackletsTRD);
 469 // // // include following line when AliESDtrackCuts is updated
 470 //     if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = fTrackCuts->GetCutVariable(2) / float(esdTrack->GetTPCNclsF());
 471
 472 // // // remove following 6 lines when AliESDtrackCuts is updated
 473      nClustersTPC = esdTrack->GetTPCclusters(0x0);
 474      nClustersITS = esdTrack->GetITSclusters(0x0);
 475      if (nClustersTPC != 0) chi2PerClusterTPC = esdTrack->GetTPCchi2() / Float_t(nClustersTPC);
 476      if (nClustersITS != 0) chi2PerClusterITS = esdTrack->GetITSchi2() / Float_t(nClustersITS);
 477      esdTrack->GetExternalCovariance(extCov);
 478      if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = float(nClustersTPC) / float(esdTrack->GetTPCNclsF());
 479   }
 480
 481   // fill the bitmap
 482   Int_t iCutBit = 0;
 483
 484 // // // include following lines when AliESDtrackCuts is updated
 485 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(2)); iCutBit++; // nClustersTPC
 486 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(3)); iCutBit++; // nClustersITS
 487 // // // remove following 6 lines when AliESDtrackCuts is updated
 488    if (nClustersTPC >= fMinNClusterTPC)
 489      fBitmap->SetBitNumber(iCutBit,kTRUE);
 490    iCutBit++;
 491    if (nClustersITS >= fMinNClusterITS)
 492      fBitmap->SetBitNumber(iCutBit,kTRUE);
 493    iCutBit++;
 494
 495   if (nClustersTRD >= fMinNClusterTRD)
 496     fBitmap->SetBitNumber(iCutBit,kTRUE);
 497   iCutBit++;
 498 // // //   if ((fMinFoundClusterTPC <= 0) || (fTrackCuts->GetCutVariable(2) > 0 && (fractionFoundClustersTPC >= fMinFoundClusterTPC)))
 499   if ((fMinFoundClusterTPC <= 0) || (nClustersTPC > 0 && (fractionFoundClustersTPC >= fMinFoundClusterTPC)))
 500     fBitmap->SetBitNumber(iCutBit,kTRUE);
 501   iCutBit++;
 502   if (nTrackletsTRD >= fMinNTrackletTRD)
 503     fBitmap->SetBitNumber(iCutBit,kTRUE);
 504   iCutBit++;
 505   if (esdTrack->GetTRDntrackletsPID() >= fMinNTrackletTRDpid)
 506     fBitmap->SetBitNumber(iCutBit,kTRUE);
 507   iCutBit++;
 508
 509 // // // include following lines when AliESDtrackCuts is updated
 510 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(4)); iCutBit++; // chi2PerClusterTPC
 511 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(5)); iCutBit++; // chi2PerClusterITS
 512 // // // remove following 6 lines when AliESDtrackCuts is updated
 513    if (chi2PerClusterTPC <= fMaxChi2PerClusterTPC)
 514      fBitmap->SetBitNumber(iCutBit,kTRUE);
 515    iCutBit++;
 516    if (chi2PerClusterITS <= fMaxChi2PerClusterITS)
 517      fBitmap->SetBitNumber(iCutBit,kTRUE);
 518    iCutBit++;
 519
 520   if (chi2PerTrackletTRD <= fMaxChi2PerTrackletTRD)
 521     fBitmap->SetBitNumber(iCutBit,kTRUE);
 522   iCutBit++;
 523   if (esdTrack->GetTPCsignalN() >= fMinNdEdxClusterTPC)
 524     fBitmap->SetBitNumber(iCutBit,kTRUE);
 525   iCutBit++;
 526
 527 // // // include following lines when AliESDtrackCuts is updated
 528 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(6)); iCutBit++; // extCov[0]
 529 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(7)); iCutBit++; // extCov[2]
 530 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(8)); iCutBit++; // extCov[5]
 531 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(9)); iCutBit++; // extCov[9]
 532 //   fBitmap->SetBitNumber(iCutBit,fTrackCuts->GetCutDecision(10)); iCutBit++; // extCov[14]
 533 // // // remove following lines when AliESDtrackCuts is updated
 534    if (extCov[0]  <= fCovariance11Max)
 535      fBitmap->SetBitNumber(iCutBit,kTRUE);
 536    iCutBit++;
 537    if (extCov[2]  <= fCovariance22Max)
 538      fBitmap->SetBitNumber(iCutBit,kTRUE);
 539    iCutBit++;
 540    if (extCov[5]  <= fCovariance33Max)
 541      fBitmap->SetBitNumber(iCutBit,kTRUE);
 542    iCutBit++;
 543    if (extCov[9]  <= fCovariance44Max)
 544      fBitmap->SetBitNumber(iCutBit,kTRUE);
 545    iCutBit++;
 546    if (extCov[14] <= fCovariance55Max)
 547      fBitmap->SetBitNumber(iCutBit,kTRUE);
 548    iCutBit++;
 549
 550
 551   if (isESDTrack) {
 552     if ( (esdTrack->GetStatus() & fStatus) == fStatus ) fBitmap->SetBitNumber(iCutBit,kTRUE);
 553   }
 554   else {
 555     if ( (aodTrack->GetStatus() & fStatus) == fStatus ) fBitmap->SetBitNumber(iCutBit,kTRUE);
 556   }
 557
 558   return;
 559 }
 560 //__________________________________________________________________________________
 561 Bool_t AliCFTrackQualityCuts::IsSelected(TObject* obj) {
 562   //
 563   // loops over decisions of single cuts and returns if the track is accepted
 564   //
 565   SelectionBitMap(obj);
 566
 567   if (fIsQAOn) FillHistograms(obj,0);
 568   Bool_t isSelected = kTRUE;
 569
 570   for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
 571     if(!fBitmap->TestBitNumber(icut)) {
 572         isSelected = kFALSE;
 573         break;
 574     }
 575   }
 576   if (!isSelected) return kFALSE ;
 577   if (fIsQAOn) FillHistograms(obj,1);
 578   return kTRUE;
 579 }
 580 //__________________________________________________________________________________
 581 void AliCFTrackQualityCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
 582 {
 583   //
 584   // variable bin size
 585   //
 586   if(!fIsQAOn) return;
 587
 588   if (index<0 || index>=kNHist) {
 589     Error("SetHistogramBins","could not determine histogram from index %d",index);
 590     return;
 591   }
 592
 593   switch(index){
 594   case kCutClusterTPC:
 595     fhNBinsClusterTPC=nbins+1;
 596     fhBinLimClusterTPC=new Double_t[nbins+1];
 597     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTPC[i]=bins[i];
 598     break;
 599
 600   case kCutClusterITS:
 601     fhNBinsClusterITS=nbins+1;
 602     fhBinLimClusterITS=new Double_t[nbins+1];
 603     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterITS[i]=bins[i];
 604     break;
 605
 606   case kCutClusterTRD:
 607     fhNBinsClusterTRD=nbins+1;
 608     fhBinLimClusterTRD=new Double_t[nbins+1];
 609     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTRD[i]=bins[i];
 610     break;
 611
 612   case kCutMinFoundClusterTPC:
 613     fhNBinsFoundClusterTPC=nbins+1;
 614     fhBinLimFoundClusterTPC=new Double_t[nbins+1];
 615     for(Int_t i=0;i<nbins+1;i++)fhBinLimFoundClusterTPC[i]=bins[i];
 616     break;
 617
 618   case kCutTrackletTRD:
 619     fhNBinsTrackletTRD=nbins+1;
 620     fhBinLimTrackletTRD=new Double_t[nbins+1];
 621     for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRD[i]=bins[i];
 622     break;
 623
 624   case kCutTrackletTRDpid:
 625     fhNBinsTrackletTRDpid=nbins+1;
 626     fhBinLimTrackletTRDpid=new Double_t[nbins+1];
 627     for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRDpid[i]=bins[i];
 628     break;
 629
 630   case kCutChi2TPC:
 631     fhNBinsChi2TPC=nbins+1;
 632     fhBinLimChi2TPC=new Double_t[nbins+1];
 633     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TPC[i]=bins[i];
 634     break;
 635
 636   case kCutChi2ITS:
 637     fhNBinsChi2ITS=nbins+1;
 638     fhBinLimChi2ITS=new Double_t[nbins+1];
 639     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2ITS[i]=bins[i];
 640     break;
 641
 642   case kCutChi2TRD:
 643     fhNBinsChi2TRD=nbins+1;
 644     fhBinLimChi2TRD=new Double_t[nbins+1];
 645     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TRD[i]=bins[i];
 646     break;
 647
 648   case kCutdEdxClusterTPC:
 649     fhNBinsdEdxClusterTPC=nbins+1;
 650     fhBinLimdEdxClusterTPC=new Double_t[nbins+1];
 651     for(Int_t i=0;i<nbins+1;i++)fhBinLimdEdxClusterTPC[i]=bins[i];
 652     break;
 653
 654   case kCutCovElement11:
 655     fhNBinsCovariance11=nbins+1;
 656     fhBinLimCovariance11=new Double_t[nbins+1];
 657     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance11[i]=bins[i];
 658     break;
 659
 660   case kCutCovElement22:
 661     fhNBinsCovariance22=nbins+1;
 662     fhBinLimCovariance22=new Double_t[nbins+1];
 663     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance22[i]=bins[i];
 664     break;
 665
 666   case kCutCovElement33:
 667     fhNBinsCovariance33=nbins+1;
 668     fhBinLimCovariance33=new Double_t[nbins+1];
 669     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance33[i]=bins[i];
 670     break;
 671
 672   case kCutCovElement44:
 673     fhNBinsCovariance44=nbins+1;
 674     fhBinLimCovariance44=new Double_t[nbins+1];
 675     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance44[i]=bins[i];
 676     break;
 677
 678   case kCutCovElement55:
 679     fhNBinsCovariance55=nbins+1;
 680     fhBinLimCovariance55=new Double_t[nbins+1];
 681     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance55[i]=bins[i];
 682     break;
 683  }
 684 }
 685 //__________________________________________________________________________________
 686 void AliCFTrackQualityCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t xmin, Double_t xmax)
 687 {
 688   //
 689   // fixed bin size
 690   //
 691   if (index<0 || index>=kNHist) {
 692     Error("SetHistogramBins","could not determine histogram from index %d",index);
 693     return;
 694   }
 695
 696   switch(index){
 697   case kCutClusterTPC:
 698     fhNBinsClusterTPC=nbins+1;
 699     fhBinLimClusterTPC=new Double_t[nbins+1];
 700     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 701     break;
 702
 703   case kCutClusterITS:
 704     fhNBinsClusterITS=nbins+1;
 705     fhBinLimClusterITS=new Double_t[nbins+1];
 706     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterITS[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 707     break;
 708
 709   case kCutClusterTRD:
 710     fhNBinsClusterTRD=nbins+1;
 711     fhBinLimClusterTRD=new Double_t[nbins+1];
 712     for(Int_t i=0;i<nbins+1;i++)fhBinLimClusterTRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 713     break;
 714
 715   case kCutMinFoundClusterTPC:
 716     fhNBinsFoundClusterTPC=nbins+1;
 717     fhBinLimFoundClusterTPC=new Double_t[nbins+1];
 718     for(Int_t i=0;i<nbins+1;i++)fhBinLimFoundClusterTPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 719     break;
 720
 721   case kCutTrackletTRD:
 722     fhNBinsTrackletTRD=nbins+1;
 723     fhBinLimTrackletTRD=new Double_t[nbins+1];
 724     for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 725     break;
 726
 727   case kCutTrackletTRDpid:
 728     fhNBinsTrackletTRDpid=nbins+1;
 729     fhBinLimTrackletTRDpid=new Double_t[nbins+1];
 730     for(Int_t i=0;i<nbins+1;i++)fhBinLimTrackletTRDpid[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 731     break;
 732
 733   case kCutChi2TPC:
 734     fhNBinsChi2TPC=nbins+1;
 735     fhBinLimChi2TPC=new Double_t[nbins+1];
 736     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 737     break;
 738
 739   case kCutChi2ITS:
 740     fhNBinsChi2ITS=nbins+1;
 741     fhBinLimChi2ITS=new Double_t[nbins+1];
 742     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2ITS[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 743     break;
 744
 745   case kCutChi2TRD:
 746     fhNBinsChi2TRD=nbins+1;
 747     fhBinLimChi2TRD=new Double_t[nbins+1];
 748     for(Int_t i=0;i<nbins+1;i++)fhBinLimChi2TRD[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 749     break;
 750
 751   case kCutdEdxClusterTPC:
 752     fhNBinsdEdxClusterTPC=nbins+1;
 753     fhBinLimdEdxClusterTPC=new Double_t[nbins+1];
 754     for(Int_t i=0;i<nbins+1;i++)fhBinLimdEdxClusterTPC[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 755     break;
 756
 757   case kCutCovElement11:
 758     fhNBinsCovariance11=nbins+1;
 759     fhBinLimCovariance11=new Double_t[nbins+1];
 760     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance11[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 761     break;
 762
 763   case kCutCovElement22:
 764     fhNBinsCovariance22=nbins+1;
 765     fhBinLimCovariance22=new Double_t[nbins+1];
 766     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance22[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 767     break;
 768
 769   case kCutCovElement33:
 770     fhNBinsCovariance33=nbins+1;
 771     fhBinLimCovariance33=new Double_t[nbins+1];
 772     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance33[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 773     break;
 774
 775   case kCutCovElement44:
 776     fhNBinsCovariance44=nbins+1;
 777     fhBinLimCovariance44=new Double_t[nbins+1];
 778     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance44[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 779     break;
 780
 781   case kCutCovElement55:
 782     fhNBinsCovariance55=nbins+1;
 783     fhBinLimCovariance55=new Double_t[nbins+1];
 784     for(Int_t i=0;i<nbins+1;i++)fhBinLimCovariance55[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 785     break;
 786  }
 787 }
 788 //__________________________________________________________________________________
 789  void AliCFTrackQualityCuts::DefineHistograms() {
 790   //
 791   // histograms for cut variables, cut statistics and cut correlations
 792   //
 793   Int_t color = 2;
 794
 795   // book cut statistics and cut correlation histograms
 796   fhCutStatistics = new TH1F(Form("%s_cut_statistics",GetName()), Form("%s cut statistics",GetName()), kNCuts,0.5,kNCuts+0.5);
 797   fhCutStatistics->SetLineWidth(2);
 798   fhCutStatistics->GetXaxis()->SetBinLabel(1, "nClustersTPC");
 799   fhCutStatistics->GetXaxis()->SetBinLabel(2, "nClustersITS");
 800   fhCutStatistics->GetXaxis()->SetBinLabel(3, "nClustersTRD");
 801   fhCutStatistics->GetXaxis()->SetBinLabel(4, "fractionClustersTPC");
 802   fhCutStatistics->GetXaxis()->SetBinLabel(5, "ntrackletsTRD");
 803   fhCutStatistics->GetXaxis()->SetBinLabel(6, "ntrackletsTRDpid");
 804   fhCutStatistics->GetXaxis()->SetBinLabel(7, "chi2PerClusterTPC");
 805   fhCutStatistics->GetXaxis()->SetBinLabel(8, "chi2PerClusterITS");
 806   fhCutStatistics->GetXaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
 807   fhCutStatistics->GetXaxis()->SetBinLabel(10, "ndEdxClusterTPC");
 808   fhCutStatistics->GetXaxis()->SetBinLabel(11, "covElement11");
 809   fhCutStatistics->GetXaxis()->SetBinLabel(12, "covElement22");
 810   fhCutStatistics->GetXaxis()->SetBinLabel(13, "covElement33");
 811   fhCutStatistics->GetXaxis()->SetBinLabel(14, "covElement44");
 812   fhCutStatistics->GetXaxis()->SetBinLabel(15, "covElement55");
 813   fhCutStatistics->GetXaxis()->SetBinLabel(16, "status");
 814
 815   fhCutCorrelation = new TH2F(Form("%s_cut_correlation",GetName()), Form("%s cut  correlation",GetName()), kNCuts,0.5,kNCuts+0.5,kNCuts,0.5,kNCuts+0.5);
 816   fhCutCorrelation->SetLineWidth(2);
 817   fhCutCorrelation->GetXaxis()->SetBinLabel(1, "nClustersTPC");
 818   fhCutCorrelation->GetXaxis()->SetBinLabel(2, "nClustersITS");
 819   fhCutCorrelation->GetXaxis()->SetBinLabel(3, "nClustersTRD");
 820   fhCutCorrelation->GetXaxis()->SetBinLabel(4, "fractionClustersTPC");
 821   fhCutCorrelation->GetXaxis()->SetBinLabel(5, "ntrackletsTRD");
 822   fhCutCorrelation->GetXaxis()->SetBinLabel(6, "ntrackletsTRDpid");
 823   fhCutCorrelation->GetXaxis()->SetBinLabel(7, "chi2PerClusterTPC");
 824   fhCutCorrelation->GetXaxis()->SetBinLabel(8, "chi2PerClusterITS");
 825   fhCutCorrelation->GetXaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
 826   fhCutCorrelation->GetXaxis()->SetBinLabel(10, "ndEdxClustersTPC");
 827   fhCutCorrelation->GetXaxis()->SetBinLabel(11, "covElement11");
 828   fhCutCorrelation->GetXaxis()->SetBinLabel(12, "covElement22");
 829   fhCutCorrelation->GetXaxis()->SetBinLabel(13, "covElement33");
 830   fhCutCorrelation->GetXaxis()->SetBinLabel(14, "covElement44");
 831   fhCutCorrelation->GetXaxis()->SetBinLabel(15, "covElement55");
 832   fhCutCorrelation->GetXaxis()->SetBinLabel(16, "status");
 833
 834   fhCutCorrelation->GetYaxis()->SetBinLabel(1, "nClustersTPC");
 835   fhCutCorrelation->GetYaxis()->SetBinLabel(2, "nClustersITS");
 836   fhCutCorrelation->GetYaxis()->SetBinLabel(3, "nClustersTRD");
 837   fhCutCorrelation->GetYaxis()->SetBinLabel(4, "fractionClustersTPC");
 838   fhCutCorrelation->GetYaxis()->SetBinLabel(5, "ntrackletsTRD");
 839   fhCutCorrelation->GetYaxis()->SetBinLabel(6, "ntrackletsTRDpid");
 840   fhCutCorrelation->GetYaxis()->SetBinLabel(7, "chi2PerClusterTPC");
 841   fhCutCorrelation->GetYaxis()->SetBinLabel(8, "chi2PerClusterITS");
 842   fhCutCorrelation->GetYaxis()->SetBinLabel(9, "chi2PerTrackletTRD");
 843   fhCutCorrelation->GetYaxis()->SetBinLabel(10, "ndEdxClustersTPC");
 844   fhCutCorrelation->GetYaxis()->SetBinLabel(11, "covElement11");
 845   fhCutCorrelation->GetYaxis()->SetBinLabel(12, "covElement22");
 846   fhCutCorrelation->GetYaxis()->SetBinLabel(13, "covElement33");
 847   fhCutCorrelation->GetYaxis()->SetBinLabel(14, "covElement44");
 848   fhCutCorrelation->GetYaxis()->SetBinLabel(15, "covElement55");
 849   fhCutCorrelation->GetYaxis()->SetBinLabel(16, "status");
 850
 851
 852   // book QA histograms
 853   Char_t str[256];
 854   for (Int_t i=0; i<kNStepQA; i++) {
 855     if (i==0) sprintf(str," ");
 856     else sprintf(str,"_cut");
 857
 858     fhQA[kCutClusterTPC][i]     = new TH1F(Form("%s_nClustersTPC%s",GetName(),str)     ,"",fhNBinsClusterTPC-1,fhBinLimClusterTPC);
 859     fhQA[kCutClusterITS][i]     = new TH1F(Form("%s_nClustersITS%s",GetName(),str)     ,"",fhNBinsClusterITS-1,fhBinLimClusterITS);
 860     fhQA[kCutClusterTRD][i]     = new TH1F(Form("%s_nClustersTRD%s",GetName(),str)     ,"",fhNBinsClusterTRD-1,fhBinLimClusterTRD);
 861     fhQA[kCutMinFoundClusterTPC][i]     = new TH1F(Form("%s_fractionClustersTPC%s",GetName(),str)     ,"",fhNBinsFoundClusterTPC-1,fhBinLimFoundClusterTPC);
 862     fhQA[kCutTrackletTRD][i]    = new TH1F(Form("%s_ntrackletsTRD%s",GetName(),str)     ,"",fhNBinsTrackletTRD-1,fhBinLimTrackletTRD);
 863     fhQA[kCutTrackletTRDpid][i] = new TH1F(Form("%s_ntrackletsTRDpid%s",GetName(),str)     ,"",fhNBinsTrackletTRDpid-1,fhBinLimTrackletTRDpid);
 864     fhQA[kCutChi2TPC][i]        = new TH1F(Form("%s_chi2PerClusterTPC%s",GetName(),str),"",fhNBinsChi2TPC-1,fhBinLimChi2TPC);
 865     fhQA[kCutChi2ITS][i]        = new TH1F(Form("%s_chi2PerClusterITS%s",GetName(),str),"",fhNBinsChi2ITS-1,fhBinLimChi2ITS);
 866     fhQA[kCutChi2TRD][i]        = new TH1F(Form("%s_chi2PerTrackletTRD%s",GetName(),str),"",fhNBinsChi2TRD-1,fhBinLimChi2TRD);
 867     fhQA[kCutdEdxClusterTPC][i] = new TH1F(Form("%s_ndEdxClustersTPC%s",GetName(),str)     ,"",fhNBinsdEdxClusterTPC-1,fhBinLimdEdxClusterTPC);
 868     fhQA[kCutCovElement11][i]   = new TH1F(Form("%s_covMatrixDiagonal11%s",GetName(),str),"",fhNBinsCovariance11-1,fhBinLimCovariance11);
 869     fhQA[kCutCovElement22][i]   = new TH1F(Form("%s_covMatrixDiagonal22%s",GetName(),str),"",fhNBinsCovariance22-1,fhBinLimCovariance22);
 870     fhQA[kCutCovElement33][i]   = new TH1F(Form("%s_covMatrixDiagonal33%s",GetName(),str),"",fhNBinsCovariance33-1,fhBinLimCovariance33);
 871     fhQA[kCutCovElement44][i]   = new TH1F(Form("%s_covMatrixDiagonal44%s",GetName(),str),"",fhNBinsCovariance44-1,fhBinLimCovariance44);
 872     fhQA[kCutCovElement55][i]   = new TH1F(Form("%s_covMatrixDiagonal55%s",GetName(),str),"",fhNBinsCovariance55-1,fhBinLimCovariance55);
 873
 874     fhQA[kCutClusterTPC][i]     ->SetXTitle("n TPC clusters");
 875     fhQA[kCutClusterITS][i]     ->SetXTitle("n ITS clusters");
 876     fhQA[kCutClusterTRD][i]     ->SetXTitle("n TRD clusters");
 877     fhQA[kCutMinFoundClusterTPC][i]->SetXTitle("fraction TPC clusters");
 878     fhQA[kCutTrackletTRD][i] ->SetXTitle("n tracklets TRD");
 879     fhQA[kCutTrackletTRDpid][i]->SetXTitle("n tracklets TRD pid");
 880     fhQA[kCutChi2TPC][i]        ->SetXTitle("#chi^{2} per TPC cluster");
 881     fhQA[kCutChi2ITS][i]        ->SetXTitle("#chi^{2} per ITS cluster");
 882     fhQA[kCutChi2TRD][i]        ->SetXTitle("#chi^{2} per TRD tracklet");
 883     fhQA[kCutdEdxClusterTPC][i] ->SetXTitle("n dEdx TPC clusters");
 884     fhQA[kCutCovElement11][i]   ->SetXTitle("cov 11 : #sigma_{y}^{2} (cm^{2})");
 885     fhQA[kCutCovElement22][i]   ->SetXTitle("cov 22 : #sigma_{z}^{2} (cm^{2})");
 886     fhQA[kCutCovElement33][i]   ->SetXTitle("cov 33 : #sigma_{sin(#phi)}^{2}");
 887     fhQA[kCutCovElement44][i]   ->SetXTitle("cov 44 : #sigma_{tan(#theta_{dip})}^{2}");
 888     fhQA[kCutCovElement55][i]   ->SetXTitle("cov 55 : #sigma_{1/p_{T}}^{2} ((c/GeV)^{2})");
 889   }
 890
 891   for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
 892 }
 893 //__________________________________________________________________________________
 894 void AliCFTrackQualityCuts::FillHistograms(TObject* obj, Bool_t b)
 895 {
 896   //
 897   // fill the QA histograms
 898   //
 899
 900   if (!obj) return;
 901   if (!obj->InheritsFrom("AliVParticle")) {
 902     AliError("object must derived from AliVParticle !");
 903     return;
 904   }
 905
 906   Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
 907   Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
 908
 909   AliESDtrack * esdTrack = 0x0 ;
 910   AliAODTrack * aodTrack = 0x0 ;
 911   if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
 912   if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
 913
 914   // b = 0: fill histograms before cuts
 915   // b = 1: fill histograms after cuts
 916
 917 // // // remove following 5 lines when AliESDtrackCuts is updated
 918    Int_t    nClustersTPC = 0;
 919    Int_t    nClustersITS = 0 ;
 920    Float_t  chi2PerClusterTPC =  0 ;
 921    Float_t  chi2PerClusterITS = 0 ;
 922    Double_t extCov[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
 923
 924   Int_t   nClustersTRD = 0 ;
 925   Int_t   nTrackletsTRD = 0 ;
 926   Float_t chi2PerTrackletTRD = 0 ;
 927   Float_t fractionFoundClustersTPC = 0;
 928
 929   if (isESDTrack) {
 930     nClustersTRD = esdTrack->GetTRDncls();
 931     nTrackletsTRD = esdTrack->GetTRDntracklets();
 932     if (nTrackletsTRD != 0) chi2PerTrackletTRD = esdTrack->GetTRDchi2() / Float_t(nTrackletsTRD);
 933
 934 // // // include following line when AliESDtrackCuts is updated
 935 //     if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = fTrackCuts->GetCutVariable(2) / float(esdTrack->GetTPCNclsF());
 936
 937 // // // remove following 6 lines when AliESDtrackCuts is updated
 938      nClustersTPC = esdTrack->GetTPCclusters(0x0);
 939      nClustersITS = esdTrack->GetITSclusters(0x0);
 940      if (nClustersTPC != 0) chi2PerClusterTPC = esdTrack->GetTPCchi2() / Float_t(nClustersTPC);
 941      if (nClustersITS != 0) chi2PerClusterITS = esdTrack->GetITSchi2() / Float_t(nClustersITS);
 942      esdTrack->GetExternalCovariance(extCov);
 943      if (esdTrack->GetTPCNclsF() != 0) fractionFoundClustersTPC = float(nClustersTPC) / float(esdTrack->GetTPCNclsF());
 944   }
 945
 946 // // // include following lines when AliESDtrackCuts is updated
 947 //   fhQA[kCutClusterTPC][b]->Fill(fTrackCuts->GetCutVariable(2));
 948 //   fhQA[kCutClusterITS][b]->Fill(fTrackCuts->GetCutVariable(3));
 949 //   fhQA[kCutChi2TPC][b]->Fill(fTrackCuts->GetCutVariable(4));
 950 //   fhQA[kCutChi2ITS][b]->Fill(fTrackCuts->GetCutVariable(5));
 951 // // // remove following 4 lines when AliESDtrackCuts is updated
 952    fhQA[kCutClusterTPC][b]->Fill((float)nClustersTPC);
 953    fhQA[kCutChi2TPC][b]->Fill(chi2PerClusterTPC);
 954    fhQA[kCutClusterITS][b]->Fill((float)nClustersITS);
 955    fhQA[kCutChi2ITS][b]->Fill(chi2PerClusterITS);
 956
 957
 958   fhQA[kCutClusterTRD][b]->Fill((float)nClustersTRD);
 959   fhQA[kCutChi2TRD][b]->Fill(chi2PerTrackletTRD);
 960 //   if (b==0 || (b==1 && fTrackCuts->GetCutVariable(2)>0)) fhQA[kCutMinFoundClusterTPC][b]->Fill((float)fractionFoundClustersTPC);
 961   if (b==0 || (b==1 && nClustersTPC>0)) fhQA[kCutMinFoundClusterTPC][b]->Fill((float)fractionFoundClustersTPC);
 962   fhQA[kCutTrackletTRD][b]->Fill((float)nTrackletsTRD);
 963   fhQA[kCutTrackletTRDpid][b]->Fill((float)esdTrack->GetTRDntrackletsPID());
 964   fhQA[kCutdEdxClusterTPC][b]->Fill((float)esdTrack->GetTPCsignalN());
 965
 966 // // // include following lines when AliESDtrackCuts is updated
 967 //   fhQA[kCutCovElement11][b]->Fill(fTrackCuts->GetCutVariable(6));
 968 //   fhQA[kCutCovElement22][b]->Fill(fTrackCuts->GetCutVariable(7));
 969 //   fhQA[kCutCovElement33][b]->Fill(fTrackCuts->GetCutVariable(8));
 970 //   fhQA[kCutCovElement44][b]->Fill(fTrackCuts->GetCutVariable(9));
 971 //   fhQA[kCutCovElement55][b]->Fill(fTrackCuts->GetCutVariable(10));
 972 // // // remove following 5 lines when AliESDtrackCuts is updated
 973    fhQA[kCutCovElement11][b]->Fill(extCov[0]);
 974    fhQA[kCutCovElement22][b]->Fill(extCov[2]);
 975    fhQA[kCutCovElement33][b]->Fill(extCov[5]);
 976    fhQA[kCutCovElement44][b]->Fill(extCov[9]);
 977    fhQA[kCutCovElement55][b]->Fill(extCov[14]);
 978
 979
 980   // fill cut statistics and cut correlation histograms with information from the bitmap
 981   if (b) return;
 982
 983   // Get the bitmap of the single cuts
 984   if ( !obj ) return;
 985   SelectionBitMap(obj);
 986
 987   // Number of single cuts in this class
 988   UInt_t ncuts = fBitmap->GetNbits();
 989   for(UInt_t bit=0; bit<ncuts;bit++) {
 990     if (!fBitmap->TestBitNumber(bit)) {
 991         fhCutStatistics->Fill(bit+1);
 992         for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
 993           if (!fBitmap->TestBitNumber(bit2))
 994             fhCutCorrelation->Fill(bit+1,bit2+1);
 995         }
 996     }
 997   }
 998 }
 999 //__________________________________________________________________________________
1000 void AliCFTrackQualityCuts::SaveHistograms(const Char_t* dir) {
1001   //
1002   // saves the histograms in a directory (dir)
1003   //
1004   if(!fIsQAOn) return;
1005
1006   if (!dir)
1007     dir = GetName();
1008
1009   gDirectory->mkdir(dir);
1010   gDirectory->cd(dir);
1011
1012   gDirectory->mkdir("before_cuts");
1013   gDirectory->mkdir("after_cuts");
1014
1015   fhCutStatistics->Write();
1016   fhCutCorrelation->Write();
1017
1018   for (Int_t j=0; j<kNStepQA; j++) {
1019     if (j==0)
1020       gDirectory->cd("before_cuts");
1021     else
1022       gDirectory->cd("after_cuts");
1023
1024     for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
1025
1026     gDirectory->cd("../");
1027   }
1028   gDirectory->cd("../");
1029 }
1030 //__________________________________________________________________________________
1031 void AliCFTrackQualityCuts::DrawHistograms(Bool_t drawLogScale)
1032 {
1033   //
1034   // draws some histograms
1035   //
1036   if(!fIsQAOn) return;
1037
1038   // pad margins
1039   Float_t right = 0.03;
1040   Float_t left = 0.175;
1041   Float_t top = 0.03;
1042   Float_t bottom = 0.175;
1043
1044   TCanvas* canvas1 = new TCanvas("Track_QA_Quality_1", "Track QA Quality 1", 800, 500);
1045   canvas1->Divide(2, 1);
1046
1047   canvas1->cd(1);
1048   fhCutStatistics->SetStats(kFALSE);
1049   fhCutStatistics->LabelsOption("v");
1050   gPad->SetLeftMargin(left);
1051   gPad->SetBottomMargin(0.25);
1052   gPad->SetRightMargin(right);
1053   gPad->SetTopMargin(0.1);
1054   fhCutStatistics->Draw();
1055
1056   canvas1->cd(2);
1057   fhCutCorrelation->SetStats(kFALSE);
1058   fhCutCorrelation->LabelsOption("v");
1059   gPad->SetLeftMargin(0.30);
1060   gPad->SetRightMargin(bottom);
1061   gPad->SetTopMargin(0.1);
1062   gPad->SetBottomMargin(0.25);
1063   fhCutCorrelation->Draw("COLZ");
1064
1065   canvas1->SaveAs(Form("%s.eps", canvas1->GetName()));
1066   canvas1->SaveAs(Form("%s.ps", canvas1->GetName()));
1067
1068   // -----
1069
1070   TCanvas* canvas2 = new TCanvas("Track_QA_Quality_2", "Track QA Quality 2", 1200, 800);
1071   canvas2->Divide(2, 2);
1072
1073   canvas2->cd(1);
1074   gPad->SetRightMargin(right);
1075   gPad->SetLeftMargin(left);
1076   gPad->SetTopMargin(top);
1077   gPad->SetBottomMargin(bottom);
1078   fhQA[kCutClusterTPC][0]->SetStats(kFALSE);
1079   fhQA[kCutClusterTPC][0]->Draw();
1080   fhQA[kCutClusterTPC][1]->Draw("same");
1081
1082   canvas2->cd(2);
1083   gPad->SetRightMargin(right);
1084   gPad->SetLeftMargin(left);
1085   gPad->SetTopMargin(top);
1086   gPad->SetBottomMargin(bottom);
1087   fhQA[kCutChi2TPC][0]->SetStats(kFALSE);
1088   fhQA[kCutChi2TPC][0]->Draw();
1089   fhQA[kCutChi2TPC][1]->Draw("same");
1090
1091   canvas2->cd(3);
1092   gPad->SetRightMargin(right);
1093   gPad->SetLeftMargin(left);
1094   gPad->SetTopMargin(top);
1095   gPad->SetBottomMargin(bottom);
1096   fhQA[kCutClusterITS][0]->SetStats(kFALSE);
1097   fhQA[kCutClusterITS][0]->Draw();
1098   fhQA[kCutClusterITS][1]->Draw("same");
1099
1100   canvas2->cd(4);
1101   gPad->SetRightMargin(right);
1102   gPad->SetLeftMargin(left);
1103   gPad->SetTopMargin(top);
1104   gPad->SetBottomMargin(bottom);
1105   fhQA[kCutChi2ITS][0]->SetStats(kFALSE);
1106   fhQA[kCutChi2ITS][0]->Draw();
1107   fhQA[kCutChi2ITS][1]->Draw("same");
1108
1109   canvas2->SaveAs(Form("%s.eps", canvas2->GetName()));
1110   canvas2->SaveAs(Form("%s.ps", canvas2->GetName()));
1111
1112   // -----
1113
1114   TCanvas* canvas3 = new TCanvas("Track_QA_Quality_3", "Track QA Quality 3", 1200, 800);
1115   canvas3->Divide(3, 2);
1116
1117   canvas3->cd(1);
1118   if(drawLogScale) gPad->SetLogy();
1119   gPad->SetRightMargin(right);
1120   gPad->SetLeftMargin(left);
1121   gPad->SetTopMargin(top);
1122   gPad->SetBottomMargin(bottom);
1123   fhQA[kCutCovElement11][0]->SetStats(kFALSE);
1124   fhQA[kCutCovElement11][0]->Draw();
1125   fhQA[kCutCovElement11][1]->Draw("same");
1126
1127   canvas3->cd(2);
1128   if(drawLogScale) gPad->SetLogy();
1129   gPad->SetRightMargin(right);
1130   gPad->SetLeftMargin(left);
1131   gPad->SetTopMargin(top);
1132   gPad->SetBottomMargin(bottom);
1133   fhQA[kCutCovElement22][0]->SetStats(kFALSE);
1134   fhQA[kCutCovElement22][0]->Draw();
1135   fhQA[kCutCovElement22][1]->Draw("same");
1136
1137   canvas3->cd(3);
1138   if(drawLogScale) gPad->SetLogy();
1139   gPad->SetRightMargin(right);
1140   gPad->SetLeftMargin(left);
1141   gPad->SetTopMargin(top);
1142   gPad->SetBottomMargin(bottom);
1143   fhQA[kCutCovElement33][0]->SetStats(kFALSE);
1144   fhQA[kCutCovElement33][0]->Draw();
1145   fhQA[kCutCovElement33][1]->Draw("same");
1146
1147   canvas3->cd(4);
1148   if(drawLogScale) gPad->SetLogy();
1149   gPad->SetRightMargin(right);
1150   gPad->SetLeftMargin(left);
1151   gPad->SetTopMargin(top);
1152   gPad->SetBottomMargin(bottom);
1153   fhQA[kCutCovElement44][0]->SetStats(kFALSE);
1154   fhQA[kCutCovElement44][0]->Draw();
1155   fhQA[kCutCovElement44][1]->Draw("same");
1156
1157   canvas3->cd(5);
1158   if(drawLogScale) gPad->SetLogy();
1159   gPad->SetRightMargin(right);
1160   gPad->SetLeftMargin(left);
1161   gPad->SetTopMargin(top);
1162   gPad->SetBottomMargin(bottom);
1163   fhQA[kCutCovElement55][0]->SetStats(kFALSE);
1164   fhQA[kCutCovElement55][0]->Draw();
1165   fhQA[kCutCovElement55][1]->Draw("same");
1166
1167   canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
1168   canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
1169 }
1170 //__________________________________________________________________________________
1171 void AliCFTrackQualityCuts::AddQAHistograms(TList *qaList) {
1172   //
1173   // saves the histograms in a TList
1174   //
1175   DefineHistograms();
1176
1177   qaList->Add(fhCutStatistics);
1178   qaList->Add(fhCutCorrelation);
1179
1180   for (Int_t j=0; j<kNStepQA; j++) {
1181     for(Int_t i=0; i<kNHist; i++)
1182         qaList->Add(fhQA[i][j]);
1183   }
1184 }