CORRFW/AliCFTrackIsPrimaryCuts.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 AliCFTrackIsPrimaryCut is designed to select reconstructed tracks
  17 // with a small impact parameter and tracks which are (not) daughters of kink
  18 // decays and to provide corresponding QA histograms.
  19 // This class inherits from the Analysis' Framework abstract base class
  20 // AliAnalysisCuts and is a part of the Correction Framework.
  21 // This class acts on single, reconstructed tracks, it is applicable on
  22 // ESD and AOD data.
  23 // It mainly consists of a IsSelected function that returns a boolean.
  24 // This function checks whether the considered track passes a set of cuts:
  25 // - min. and max. distance to main vertex in transverse plane (xy)
  26 // - min. and max. longitudinal distance to main vertex (z)
  27 // - min. and max. distance to main vertex as ellpise in xy - z plane
  28 // - all above cuts on absolute values or in units of sigma (resolution)
  29 // - min. and max. distance to main vertex in units of sigma (resolution)
  30 // - max. transverse (xy) and longitudinal (z) impact parameter resolution
  31 // - require that the dca calculation doesn't fail
  32 // - accept or not accept daughter tracks of kink decays
  33 //
  34 // By default, the distance to 'vertex calculated from tracks' is used.
  35 // Optionally the SPD (tracklet based) or TPC (TPC only tracks based) vertex
  36 // can be used.
  37 // Note: the distance to the TPC-vertex is already stored in the ESD,
  38 // the distance to the SPD-vertex has to be re-calculated by propagating each
  39 // track while executing this cut.
  40 //
  41 // The cut values for these cuts are set with the corresponding set functions.
  42 // All cut classes provided by the correction framework are supposed to be
  43 // added in the Analysis Framwork's class AliAnalysisFilter and applied by
  44 // the filter via a loop.
  45 //
  46 // author: I. Kraus (Ingrid.Kraus@cern.ch)
  47 // idea taken form
  48 // AliESDtrackCuts writte by Jan Fiete Grosse-Oetringhaus and
  49 // AliRsnDaughterCut class written by A. Pulvirenti.
  50
  51 #include <TCanvas.h>
  52 #include <TDirectory.h>
  53 #include <TH2.h>
  54 #include <TBits.h>
  55
  56 #include <AliESDtrack.h>
  57 #include <AliESDEvent.h>
  58 #include <AliLog.h>
  59 #include "AliCFTrackIsPrimaryCuts.h"
  60
  61 ClassImp(AliCFTrackIsPrimaryCuts)
  62
  63 //__________________________________________________________________________________
  64 AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts() :
  65   AliCFCutBase(),
  66   fESD(0x0),
  67   fUseSPDvertex(0),
  68   fUseTPCvertex(0),
  69   fMinDCAToVertexXY(0),
  70   fMinDCAToVertexZ(0),
  71   fMaxDCAToVertexXY(0),
  72   fMaxDCAToVertexZ(0),
  73   fDCAToVertex2D(0),
  74   fAbsDCAToVertex(0),
  75   fNSigmaToVertexMin(0),
  76   fNSigmaToVertexMax(0),
  77   fSigmaDCAxy(0),
  78   fSigmaDCAz(0),
  79   fRequireSigmaToVertex(0),
  80   fAODType(AliAODTrack::kUndef),
  81   fAcceptKinkDaughters(0),
  82   fhCutStatistics(0),
  83   fhCutCorrelation(0),
  84   fBitmap(0x0),
  85   fhNBinsNSigma(0),
  86   fhNBinsRequireSigma(0),
  87   fhNBinsAcceptKink(0),
  88   fhNBinsDcaXY(0),
  89   fhNBinsDcaZ(0),
  90   fhNBinsDcaXYnorm(0),
  91   fhNBinsDcaZnorm(0),
  92   fhNBinsSigmaDcaXY(0),
  93   fhNBinsSigmaDcaZ(0),
  94   fhBinLimNSigma(0x0),
  95   fhBinLimRequireSigma(0x0),
  96   fhBinLimAcceptKink(0x0),
  97   fhBinLimDcaXY(0x0),
  98   fhBinLimDcaZ(0x0),
  99   fhBinLimDcaXYnorm(0x0),
 100   fhBinLimDcaZnorm(0x0),
 101   fhBinLimSigmaDcaXY(0x0),
 102   fhBinLimSigmaDcaZ(0x0)
 103 {
 104   //
 105   // Default constructor
 106   //
 107   Initialise();
 108 }
 109 //__________________________________________________________________________________
 110 AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(Char_t* name, Char_t* title) :
 111   AliCFCutBase(name,title),
 112   fESD(0x0),
 113   fUseSPDvertex(0),
 114   fUseTPCvertex(0),
 115   fMinDCAToVertexXY(0),
 116   fMinDCAToVertexZ(0),
 117   fMaxDCAToVertexXY(0),
 118   fMaxDCAToVertexZ(0),
 119   fDCAToVertex2D(0),
 120   fAbsDCAToVertex(0),
 121   fNSigmaToVertexMin(0),
 122   fNSigmaToVertexMax(0),
 123   fSigmaDCAxy(0),
 124   fSigmaDCAz(0),
 125   fRequireSigmaToVertex(0),
 126   fAODType(AliAODTrack::kUndef),
 127   fAcceptKinkDaughters(0),
 128   fhCutStatistics(0),
 129   fhCutCorrelation(0),
 130   fBitmap(0x0),
 131   fhNBinsNSigma(0),
 132   fhNBinsRequireSigma(0),
 133   fhNBinsAcceptKink(0),
 134   fhNBinsDcaXY(0),
 135   fhNBinsDcaZ(0),
 136   fhNBinsDcaXYnorm(0),
 137   fhNBinsDcaZnorm(0),
 138   fhNBinsSigmaDcaXY(0),
 139   fhNBinsSigmaDcaZ(0),
 140   fhBinLimNSigma(0x0),
 141   fhBinLimRequireSigma(0x0),
 142   fhBinLimAcceptKink(0x0),
 143   fhBinLimDcaXY(0x0),
 144   fhBinLimDcaZ(0x0),
 145   fhBinLimDcaXYnorm(0x0),
 146   fhBinLimDcaZnorm(0x0),
 147   fhBinLimSigmaDcaXY(0x0),
 148   fhBinLimSigmaDcaZ(0x0)
 149 {
 150   //
 151   // Constructor
 152   //
 153   Initialise();
 154 }
 155 //__________________________________________________________________________________
 156 AliCFTrackIsPrimaryCuts::AliCFTrackIsPrimaryCuts(const AliCFTrackIsPrimaryCuts& c) :
 157   AliCFCutBase(c),
 158   fESD(c.fESD),
 159   fUseSPDvertex(c.fUseSPDvertex),
 160   fUseTPCvertex(c.fUseTPCvertex),
 161   fMinDCAToVertexXY(c.fMinDCAToVertexXY),
 162   fMinDCAToVertexZ(c.fMinDCAToVertexZ),
 163   fMaxDCAToVertexXY(c.fMaxDCAToVertexXY),
 164   fMaxDCAToVertexZ(c.fMaxDCAToVertexZ),
 165   fDCAToVertex2D(c.fDCAToVertex2D),
 166   fAbsDCAToVertex(c.fAbsDCAToVertex),
 167   fNSigmaToVertexMin(c.fNSigmaToVertexMin),
 168   fNSigmaToVertexMax(c.fNSigmaToVertexMax),
 169   fSigmaDCAxy(c.fSigmaDCAxy),
 170   fSigmaDCAz(c.fSigmaDCAz),
 171   fRequireSigmaToVertex(c.fRequireSigmaToVertex),
 172   fAODType(c.fAODType),
 173   fAcceptKinkDaughters(c.fAcceptKinkDaughters),
 174   fhCutStatistics(c.fhCutStatistics),
 175   fhCutCorrelation(c.fhCutCorrelation),
 176   fBitmap(c.fBitmap),
 177   fhNBinsNSigma(c.fhNBinsNSigma),
 178   fhNBinsRequireSigma(c.fhNBinsRequireSigma),
 179   fhNBinsAcceptKink(c.fhNBinsAcceptKink),
 180   fhNBinsDcaXY(c.fhNBinsDcaXY),
 181   fhNBinsDcaZ(c.fhNBinsDcaZ),
 182   fhNBinsDcaXYnorm(c.fhNBinsDcaXYnorm),
 183   fhNBinsDcaZnorm(c.fhNBinsDcaZnorm),
 184   fhNBinsSigmaDcaXY(c.fhNBinsSigmaDcaXY),
 185   fhNBinsSigmaDcaZ(c.fhNBinsSigmaDcaZ),
 186   fhBinLimNSigma(c.fhBinLimNSigma),
 187   fhBinLimRequireSigma(c.fhBinLimRequireSigma),
 188   fhBinLimAcceptKink(c.fhBinLimAcceptKink),
 189   fhBinLimDcaXY(c.fhBinLimDcaXY),
 190   fhBinLimDcaZ(c.fhBinLimDcaZ),
 191   fhBinLimDcaXYnorm(c.fhBinLimDcaXYnorm),
 192   fhBinLimDcaZnorm(c.fhBinLimDcaZnorm),
 193   fhBinLimSigmaDcaXY(c.fhBinLimSigmaDcaXY),
 194   fhBinLimSigmaDcaZ(c.fhBinLimSigmaDcaZ)
 195 {
 196   //
 197   // copy constructor
 198   //
 199   ((AliCFTrackIsPrimaryCuts &) c).Copy(*this);
 200 }
 201 //__________________________________________________________________________________
 202 AliCFTrackIsPrimaryCuts& AliCFTrackIsPrimaryCuts::operator=(const AliCFTrackIsPrimaryCuts& c)
 203 {
 204   //
 205   // Assignment operator
 206   //
 207   if (this != &c) {
 208     AliCFCutBase::operator=(c) ;
 209     fESD = c.fESD;
 210     fUseSPDvertex = c.fUseSPDvertex;
 211     fUseTPCvertex = c.fUseTPCvertex;
 212     fMinDCAToVertexXY = c.fMinDCAToVertexXY;
 213     fMinDCAToVertexZ = c.fMinDCAToVertexZ;
 214     fMaxDCAToVertexXY = c.fMaxDCAToVertexXY;
 215     fMaxDCAToVertexZ = c.fMaxDCAToVertexZ;
 216     fDCAToVertex2D = c.fDCAToVertex2D;
 217     fAbsDCAToVertex = c.fAbsDCAToVertex;
 218     fNSigmaToVertexMin = c.fNSigmaToVertexMin ;
 219     fNSigmaToVertexMax = c.fNSigmaToVertexMax ;
 220     fSigmaDCAxy = c.fSigmaDCAxy ;
 221     fSigmaDCAz = c.fSigmaDCAz ;
 222     fRequireSigmaToVertex = c.fRequireSigmaToVertex ;
 223     fAODType = c.fAODType ;
 224     fAcceptKinkDaughters = c.fAcceptKinkDaughters ;
 225     fhCutStatistics = c.fhCutStatistics ;
 226     fhCutCorrelation = c.fhCutCorrelation ;
 227     fBitmap =  c.fBitmap;
 228     fhNBinsNSigma = c.fhNBinsNSigma;
 229     fhNBinsRequireSigma = c.fhNBinsRequireSigma;
 230     fhNBinsAcceptKink = c.fhNBinsAcceptKink;
 231     fhNBinsDcaXY = c.fhNBinsDcaXY;
 232     fhNBinsDcaZ = c.fhNBinsDcaZ;
 233     fhNBinsDcaXYnorm = c.fhNBinsDcaXYnorm;
 234     fhNBinsDcaZnorm = c.fhNBinsDcaZnorm;
 235     fhNBinsSigmaDcaXY = c.fhNBinsSigmaDcaXY;
 236     fhNBinsSigmaDcaZ = c.fhNBinsSigmaDcaZ;
 237     fhBinLimNSigma = c.fhBinLimNSigma;
 238     fhBinLimRequireSigma = c.fhBinLimRequireSigma;
 239     fhBinLimAcceptKink = c.fhBinLimAcceptKink;
 240     fhBinLimDcaXY = c.fhBinLimDcaXY;
 241     fhBinLimDcaZ = c.fhBinLimDcaZ;
 242     fhBinLimDcaXYnorm = c.fhBinLimDcaXYnorm;
 243     fhBinLimDcaZnorm = c.fhBinLimDcaZnorm;
 244     fhBinLimSigmaDcaXY = c.fhBinLimSigmaDcaXY;
 245     fhBinLimSigmaDcaZ = c.fhBinLimSigmaDcaZ;
 246
 247     for (Int_t j=0; j<6; j++) fDCA[j] = c.fDCA[j];
 248     for (Int_t j=0; j<c.kNStepQA; j++){
 249       if(c.fhDcaXYvsDcaZ[j]) fhDcaXYvsDcaZ[j] = (TH2F*)c.fhDcaXYvsDcaZ[j]->Clone();
 250       for (Int_t i=0; i<c.kNHist; i++){
 251         if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
 252       }
 253     }
 254     ((AliCFTrackIsPrimaryCuts &) c).Copy(*this);
 255  }
 256   return *this;
 257 }
 258 //__________________________________________________________________________________
 259 AliCFTrackIsPrimaryCuts::~AliCFTrackIsPrimaryCuts()
 260 {
 261   //
 262   // destructor
 263   //
 264   if (fhCutStatistics)                  delete fhCutStatistics;
 265   if (fhCutCorrelation)                 delete fhCutCorrelation;
 266
 267   for (Int_t j=0; j<kNStepQA; j++){
 268     if(fhDcaXYvsDcaZ[j])        delete fhDcaXYvsDcaZ[j];
 269     for (Int_t i=0; i<kNHist; i++)
 270       if(fhQA[i][j])            delete fhQA[i][j];
 271   }
 272   if(fESD)                      delete fESD;
 273   if(fBitmap)                   delete fBitmap;
 274   if(fhBinLimNSigma)            delete fhBinLimNSigma;
 275   if(fhBinLimRequireSigma)      delete fhBinLimRequireSigma;
 276   if(fhBinLimAcceptKink)        delete fhBinLimAcceptKink;
 277   if(fhBinLimDcaXY)             delete fhBinLimDcaXY;
 278   if(fhBinLimDcaZ)              delete fhBinLimDcaZ;
 279   if(fhBinLimDcaXYnorm)         delete fhBinLimDcaXYnorm;
 280   if(fhBinLimDcaZnorm)          delete fhBinLimDcaZnorm;
 281   if(fhBinLimSigmaDcaXY)        delete fhBinLimSigmaDcaXY;
 282   if(fhBinLimSigmaDcaZ)         delete fhBinLimSigmaDcaZ;
 283 }
 284 //__________________________________________________________________________________
 285 void AliCFTrackIsPrimaryCuts::Initialise()
 286 {
 287   //
 288   // sets everything to zero
 289   //
 290   fUseSPDvertex = 0;
 291   fUseTPCvertex = 0;
 292   fMinDCAToVertexXY = 0;
 293   fMinDCAToVertexZ = 0;
 294   fMaxDCAToVertexXY = 0;
 295   fMaxDCAToVertexZ = 0;
 296   fDCAToVertex2D = 0;
 297   fAbsDCAToVertex = 0;
 298   fNSigmaToVertexMin = 0;
 299   fNSigmaToVertexMax = 0;
 300   fSigmaDCAxy = 0;
 301   fSigmaDCAz = 0;
 302   fRequireSigmaToVertex = 0;
 303   fAcceptKinkDaughters = 0;
 304   fAODType = AliAODTrack::kUndef;
 305
 306   SetMinDCAToVertexXY();
 307   SetMinDCAToVertexZ();
 308   SetMaxDCAToVertexXY();
 309   SetMaxDCAToVertexZ();
 310   SetDCAToVertex2D();
 311   SetAbsDCAToVertex();
 312   SetMinNSigmaToVertex();
 313   SetMaxNSigmaToVertex();
 314   SetMaxSigmaDCAxy();
 315   SetMaxSigmaDCAz();
 316   SetRequireSigmaToVertex();
 317   SetAcceptKinkDaughters();
 318   SetAODType();
 319
 320   for (Int_t j=0; j<6; j++) fDCA[j] = 0.;
 321   for (Int_t j=0; j<kNStepQA; j++)  {
 322     fhDcaXYvsDcaZ[j] = 0x0;
 323     for (Int_t i=0; i<kNHist; i++)
 324       fhQA[i][j] = 0x0;
 325   }
 326   fhCutStatistics = 0;
 327   fhCutCorrelation = 0;
 328   fBitmap=new TBits(0);
 329
 330   //set default bining for QA histograms
 331   SetHistogramBins(kCutNSigmaToVertex,100,0.,10.);
 332   SetHistogramBins(kCutRequireSigmaToVertex,5,-0.75,1.75);
 333   SetHistogramBins(kCutAcceptKinkDaughters,5,-0.75,1.75);
 334   SetHistogramBins(kDcaXY,500,-10.,10.);
 335   SetHistogramBins(kDcaZ,500,-10.,10.);
 336   SetHistogramBins(kDcaXYnorm,500,-10.,10.);
 337   SetHistogramBins(kDcaZnorm,500,-10.,10.);
 338   SetHistogramBins(kSigmaDcaXY,500,-0.1,0.9);
 339   SetHistogramBins(kSigmaDcaZ,500,-0.1,0.9);
 340 }
 341 //__________________________________________________________________________________
 342 void AliCFTrackIsPrimaryCuts::Copy(TObject &c) const
 343 {
 344   //
 345   // Copy function
 346   //
 347   AliCFTrackIsPrimaryCuts& target = (AliCFTrackIsPrimaryCuts &) c;
 348
 349   target.Initialise();
 350
 351   if (fhCutStatistics)  target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
 352   if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
 353
 354   for (Int_t j=0; j<6; j++) target.fDCA[j] = fDCA[j];
 355   for (Int_t j=0; j<kNStepQA; j++){
 356     if(fhDcaXYvsDcaZ[j]) target.fhDcaXYvsDcaZ[j] = (TH2F*)fhDcaXYvsDcaZ[j]->Clone();
 357     for (Int_t i=0; i<kNHist; i++)
 358       if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
 359   }
 360   TNamed::Copy(c);
 361 }
 362 //__________________________________________________________________________________
 363 void AliCFTrackIsPrimaryCuts::SetEvtInfo(TObject* esd) {
 364   //
 365   // Sets pointer to esd event information (AliESDEvent)
 366   //
 367   if (!esd) {
 368     AliError("Pointer to AliESDEvent !");
 369     return;
 370   }
 371   TString className(esd->ClassName());
 372   if (className.CompareTo("AliESDEvent") != 0) {
 373     AliError("argument must point to an AliESDEvent !");
 374     return ;
 375   }
 376   fESD = (AliESDEvent*) esd;
 377 }
 378 //__________________________________________________________________________________
 379 void AliCFTrackIsPrimaryCuts::UseSPDvertex(Bool_t b) {
 380   fUseSPDvertex = b;
 381   if(fUseTPCvertex && fUseSPDvertex) {
 382         fUseSPDvertex = kFALSE;
 383         AliError("SPD and TPC vertex chosen. TPC vertex is preferred.");
 384   }
 385 }
 386 //__________________________________________________________________________________
 387 void AliCFTrackIsPrimaryCuts::UseTPCvertex(Bool_t b) {
 388   fUseTPCvertex = b;
 389   if(fUseTPCvertex) fUseSPDvertex = kFALSE;
 390 }
 391 //__________________________________________________________________________________
 392 void AliCFTrackIsPrimaryCuts::GetDCA(AliESDtrack* esdTrack)
 393 {
 394   if (!esdTrack) return;
 395
 396   Float_t b[2] = {0.,0.};
 397   Float_t bCov[3] = {0.,0.,0.};
 398   if(!fUseSPDvertex && !fUseTPCvertex)  esdTrack->GetImpactParameters(b,bCov);
 399   if( fUseTPCvertex)                    esdTrack->GetImpactParametersTPC(b,bCov);
 400
 401   if( fUseSPDvertex) {
 402         if (!fESD) return;
 403         const AliESDVertex *vtx = fESD->GetVertex();
 404         const Double_t Bz = fESD->GetMagneticField();
 405         AliExternalTrackParam *cParam = 0;
 406         Bool_t success = esdTrack->RelateToVertex(vtx, Bz, kVeryBig, cParam);
 407         if (success) esdTrack->GetImpactParameters(b,bCov);
 408   }
 409
 410   if (bCov[0]<=0 || bCov[2]<=0) {
 411       bCov[0]=0; bCov[2]=0;
 412   }
 413   fDCA[0] = b[0]; // impact parameter xy
 414   fDCA[1] = b[1]; // impact parameter z
 415   fDCA[2] = TMath::Sqrt(bCov[0]); // resolution xy
 416   fDCA[3] = TMath::Sqrt(bCov[2]); // resolution z
 417
 418   if (!fAbsDCAToVertex) {
 419         if (fDCA[2] > 0) fDCA[0] = fDCA[0]/fDCA[2]; // normalised impact parameter xy
 420         if (fDCA[3] > 0) fDCA[1] = fDCA[1]/fDCA[3]; // normalised impact parameter z
 421   }
 422
 423   // get n_sigma
 424   if(!fUseSPDvertex && !fUseTPCvertex)
 425         fDCA[5] = AliESDtrackCuts::GetSigmaToVertex(esdTrack);
 426
 427   if(fUseTPCvertex) {
 428         fDCA[5] = -1;
 429         if (fDCA[2]==0 || fDCA[3]==0)
 430           return;
 431         fDCA[5] = 1000.;
 432         Float_t d = TMath::Sqrt(TMath::Power(b[0]/fDCA[2],2) + TMath::Power(b[1]/fDCA[3],2));
 433         if (TMath::Exp(-d * d / 2) < 1e-15)
 434           return;
 435         fDCA[5] = TMath::ErfInverse(1 - TMath::Exp(-d * d / 2)) * TMath::Sqrt(2);
 436   }
 437   return;
 438 }
 439 //__________________________________________________________________________________
 440 void AliCFTrackIsPrimaryCuts::SelectionBitMap(TObject* obj)
 441 {
 442   //
 443   // test if the track passes the single cuts
 444   // and store the information in a bitmap
 445   //
 446
 447   // bitmap stores the decision of each single cut
 448   for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
 449
 450   // check TObject and cast into ESDtrack
 451   if (!obj) return;
 452   if (!obj->InheritsFrom("AliVParticle")) {
 453     AliError("object must derived from AliVParticle !");
 454     return;
 455   }
 456
 457   Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
 458   Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
 459
 460   AliESDtrack * esdTrack = 0x0 ;
 461   AliAODTrack * aodTrack = 0x0 ;
 462   if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
 463   if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
 464
 465   // get the track to vertex parameter for ESD track
 466   if (isESDTrack) GetDCA(esdTrack);
 467
 468   Float_t bxy = 0, bz = 0;
 469   if (isESDTrack) {
 470         bxy = TMath::Abs(fDCA[0]);
 471         bz  = TMath::Abs(fDCA[1]);
 472  }
 473   Float_t b2Dmin = 0, b2Dmax = 0;
 474   if (isESDTrack) {
 475     if (fMinDCAToVertexXY>0 && fMinDCAToVertexZ>0)
 476         b2Dmin = fDCA[0]*fDCA[0]/fMinDCAToVertexXY/fMinDCAToVertexXY + fDCA[1]*fDCA[1]/fMinDCAToVertexZ/fMinDCAToVertexZ;
 477     if (fMaxDCAToVertexXY>0 && fMaxDCAToVertexZ>0)
 478         b2Dmax = fDCA[0]*fDCA[0]/fMaxDCAToVertexXY/fMaxDCAToVertexXY + fDCA[1]*fDCA[1]/fMaxDCAToVertexZ/fMaxDCAToVertexZ;
 479   }
 480
 481   // fill the bitmap
 482   Int_t iCutBit = 0;
 483
 484   if (isESDTrack) {
 485     if (fDCAToVertex2D || (!fDCAToVertex2D && bxy >= fMinDCAToVertexXY && bxy <= fMaxDCAToVertexXY)) {
 486       fBitmap->SetBitNumber(iCutBit,kTRUE);
 487     }
 488   }
 489   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 490
 491   iCutBit++;
 492
 493   if (isESDTrack) {
 494     if (fDCAToVertex2D || (!fDCAToVertex2D && bz  >= fMinDCAToVertexZ && bz  <= fMaxDCAToVertexZ)) {
 495       fBitmap->SetBitNumber(iCutBit,kTRUE);
 496     }
 497   }
 498   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 499
 500   iCutBit++;
 501
 502   if (isESDTrack) {
 503     if (!fDCAToVertex2D || (fDCAToVertex2D && b2Dmin > 1  && b2Dmax < 1)) {
 504       fBitmap->SetBitNumber(iCutBit,kTRUE);
 505     }
 506   }
 507   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 508
 509   iCutBit++;
 510
 511   if (isESDTrack) {
 512     if (fDCA[5] >= fNSigmaToVertexMin && fDCA[5] <= fNSigmaToVertexMax) {
 513       fBitmap->SetBitNumber(iCutBit,kTRUE);
 514     }
 515   }
 516   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 517
 518   iCutBit++;
 519
 520   if (isESDTrack) {
 521     if (fDCA[2] < fSigmaDCAxy) {
 522       fBitmap->SetBitNumber(iCutBit,kTRUE);
 523     }
 524   }
 525   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 526
 527   iCutBit++;
 528
 529   if (isESDTrack) {
 530     if (fDCA[3] < fSigmaDCAz) {
 531       fBitmap->SetBitNumber(iCutBit,kTRUE);
 532     }
 533   }
 534   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 535
 536   iCutBit++;
 537
 538   if (isESDTrack) {
 539     if (!fRequireSigmaToVertex || (fDCA[5]>=0 && fRequireSigmaToVertex)) {
 540       fBitmap->SetBitNumber(iCutBit,kTRUE);
 541     }
 542   }
 543   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 544
 545   iCutBit++;
 546
 547   if (esdTrack) {
 548     if (fAcceptKinkDaughters || (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)<=0)) {
 549       fBitmap->SetBitNumber(iCutBit,kTRUE);
 550     }
 551   }
 552   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 553
 554   iCutBit++;
 555
 556   if (isAODTrack) {
 557     if (fAODType==AliAODTrack::kUndef || fAODType == aodTrack->GetType()) {
 558       fBitmap->SetBitNumber(iCutBit,kTRUE);
 559     }
 560   }
 561   else fBitmap->SetBitNumber(iCutBit,kTRUE);
 562
 563   return;
 564 }
 565 //__________________________________________________________________________________
 566 Bool_t AliCFTrackIsPrimaryCuts::IsSelected(TObject* obj) {
 567   //
 568   // loops over decisions of single cuts and returns if the track is accepted
 569   //
 570   SelectionBitMap(obj);
 571
 572   if (fIsQAOn) FillHistograms(obj,0);
 573   Bool_t isSelected = kTRUE;
 574
 575   for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
 576     if(!fBitmap->TestBitNumber(icut)) {
 577         isSelected = kFALSE;
 578         break;
 579     }
 580   }
 581   if (!isSelected) return kFALSE ;
 582   if (fIsQAOn) FillHistograms(obj,1);
 583   return kTRUE;
 584 }
 585 //__________________________________________________________________________________
 586 void AliCFTrackIsPrimaryCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
 587 {
 588   //
 589   // variable bin size
 590   //
 591   if(!fIsQAOn) return;
 592
 593   switch(index){
 594   case kCutNSigmaToVertex:
 595     fhNBinsNSigma=nbins+1;
 596     fhBinLimNSigma=new Double_t[nbins+1];
 597     for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=bins[i];
 598     break;
 599
 600   case kCutRequireSigmaToVertex:
 601     fhNBinsRequireSigma=nbins+1;
 602     fhBinLimRequireSigma=new Double_t[nbins+1];
 603     for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=bins[i];
 604     break;
 605
 606   case kCutAcceptKinkDaughters:
 607     fhNBinsAcceptKink=nbins+1;
 608     fhBinLimAcceptKink=new Double_t[nbins+1];
 609     for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=bins[i];
 610     break;
 611
 612   case kDcaXY:
 613     fhNBinsDcaXY=nbins+1;
 614     fhBinLimDcaXY=new Double_t[nbins+1];
 615     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=bins[i];
 616     break;
 617
 618   case kDcaZ:
 619     fhNBinsDcaZ=nbins+1;
 620     fhBinLimDcaZ=new Double_t[nbins+1];
 621     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=bins[i];
 622     break;
 623
 624   case kDcaXYnorm:
 625     fhNBinsDcaXYnorm=nbins+1;
 626     fhBinLimDcaXYnorm=new Double_t[nbins+1];
 627     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=bins[i];
 628     break;
 629
 630   case kDcaZnorm:
 631     fhNBinsDcaZnorm=nbins+1;
 632     fhBinLimDcaZnorm=new Double_t[nbins+1];
 633     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=bins[i];
 634     break;
 635
 636   case kSigmaDcaXY:
 637     fhNBinsSigmaDcaXY=nbins+1;
 638     fhBinLimSigmaDcaXY=new Double_t[nbins+1];
 639     for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaXY[i]=bins[i];
 640     break;
 641
 642   case kSigmaDcaZ:
 643     fhNBinsSigmaDcaZ=nbins+1;
 644     fhBinLimSigmaDcaZ=new Double_t[nbins+1];
 645     for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaZ[i]=bins[i];
 646     break;
 647   }
 648 }
 649 //__________________________________________________________________________________
 650 void AliCFTrackIsPrimaryCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t xmin, Double_t xmax)
 651 {
 652   //
 653   // fixed bin size
 654   //
 655   switch(index){
 656   case kCutNSigmaToVertex:
 657     fhNBinsNSigma=nbins+1;
 658     fhBinLimNSigma=new Double_t[nbins+1];
 659     for(Int_t i=0;i<nbins+1;i++)fhBinLimNSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 660     break;
 661
 662   case kCutRequireSigmaToVertex:
 663     fhNBinsRequireSigma=nbins+1;
 664     fhBinLimRequireSigma=new Double_t[nbins+1];
 665     for(Int_t i=0;i<nbins+1;i++)fhBinLimRequireSigma[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 666     break;
 667
 668   case kCutAcceptKinkDaughters:
 669     fhNBinsAcceptKink=nbins+1;
 670     fhBinLimAcceptKink=new Double_t[nbins+1];
 671     for(Int_t i=0;i<nbins+1;i++)fhBinLimAcceptKink[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 672     break;
 673
 674   case kDcaXY:
 675     fhNBinsDcaXY=nbins+1;
 676     fhBinLimDcaXY=new Double_t[nbins+1];
 677     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXY[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 678     break;
 679
 680   case kDcaZ:
 681     fhNBinsDcaZ=nbins+1;
 682     fhBinLimDcaZ=new Double_t[nbins+1];
 683     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZ[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 684     break;
 685
 686   case kDcaXYnorm:
 687     fhNBinsDcaXYnorm=nbins+1;
 688     fhBinLimDcaXYnorm=new Double_t[nbins+1];
 689     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaXYnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 690     break;
 691
 692   case kDcaZnorm:
 693     fhNBinsDcaZnorm=nbins+1;
 694     fhBinLimDcaZnorm=new Double_t[nbins+1];
 695     for(Int_t i=0;i<nbins+1;i++)fhBinLimDcaZnorm[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 696     break;
 697
 698   case kSigmaDcaXY:
 699     fhNBinsSigmaDcaXY=nbins+1;
 700     fhBinLimSigmaDcaXY=new Double_t[nbins+1];
 701     for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaXY[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 702     break;
 703
 704   case kSigmaDcaZ:
 705     fhNBinsSigmaDcaZ=nbins+1;
 706     fhBinLimSigmaDcaZ=new Double_t[nbins+1];
 707     for(Int_t i=0;i<nbins+1;i++)fhBinLimSigmaDcaZ[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 708     break;
 709   }
 710 }
 711 //__________________________________________________________________________________
 712  void AliCFTrackIsPrimaryCuts::DefineHistograms() {
 713   //
 714   // histograms for cut variables, cut statistics and cut correlations
 715   //
 716   Int_t color = 2;
 717
 718   // book cut statistics and cut correlation histograms
 719   fhCutStatistics = new TH1F(Form("%s_cut_statistics",GetName()), Form("%s cut statistics",GetName()), kNCuts,0.5,kNCuts+0.5);
 720   fhCutStatistics->SetLineWidth(2);
 721   fhCutStatistics->GetXaxis()->SetBinLabel(1,"dca xy");
 722   fhCutStatistics->GetXaxis()->SetBinLabel(2,"dca z");
 723   fhCutStatistics->GetXaxis()->SetBinLabel(3,"dca ellipse");
 724   fhCutStatistics->GetXaxis()->SetBinLabel(4,"n dca");
 725   fhCutStatistics->GetXaxis()->SetBinLabel(5,"sigma dca xy");
 726   fhCutStatistics->GetXaxis()->SetBinLabel(6,"sigma dca z");
 727   fhCutStatistics->GetXaxis()->SetBinLabel(7,"require dca");
 728   fhCutStatistics->GetXaxis()->SetBinLabel(8,"kink daughter");
 729   fhCutStatistics->GetXaxis()->SetBinLabel(9,"AOD type");
 730
 731   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);
 732   fhCutCorrelation->SetLineWidth(2);
 733   fhCutCorrelation->GetXaxis()->SetBinLabel(1,"dca xy");
 734   fhCutCorrelation->GetXaxis()->SetBinLabel(2,"dca z");
 735   fhCutCorrelation->GetXaxis()->SetBinLabel(3,"dca ellipse");
 736   fhCutCorrelation->GetXaxis()->SetBinLabel(4,"n dca");
 737   fhCutCorrelation->GetXaxis()->SetBinLabel(5,"sigma dca xy");
 738   fhCutCorrelation->GetXaxis()->SetBinLabel(6,"sigma dca z");
 739   fhCutCorrelation->GetXaxis()->SetBinLabel(7,"require dca");
 740   fhCutCorrelation->GetXaxis()->SetBinLabel(8,"kink daughter");
 741   fhCutCorrelation->GetXaxis()->SetBinLabel(9,"AOD type");
 742
 743   fhCutCorrelation->GetYaxis()->SetBinLabel(1,"dca xy");
 744   fhCutCorrelation->GetYaxis()->SetBinLabel(2,"dca z");
 745   fhCutCorrelation->GetYaxis()->SetBinLabel(3,"dca ellipse");
 746   fhCutCorrelation->GetYaxis()->SetBinLabel(4,"n dca");
 747   fhCutCorrelation->GetYaxis()->SetBinLabel(5,"sigma dca xy");
 748   fhCutCorrelation->GetYaxis()->SetBinLabel(6,"sigma dca z");
 749   fhCutCorrelation->GetYaxis()->SetBinLabel(7,"require dca");
 750   fhCutCorrelation->GetYaxis()->SetBinLabel(8,"kink daughter");
 751   fhCutCorrelation->GetYaxis()->SetBinLabel(9,"AOD type");
 752
 753   // book QA histograms
 754   Char_t str[256];
 755   for (Int_t i=0; i<kNStepQA; i++) {
 756     if (i==0) sprintf(str," ");
 757     else sprintf(str,"_cut");
 758
 759     fhDcaXYvsDcaZ[i]            = new  TH2F(Form("%s_dcaXYvsDcaZ%s",GetName(),str),"",200,-10,10,200,-10,10);
 760     fhQA[kCutNSigmaToVertex][i] = new TH1F(Form("%s_nSigmaToVertex%s",GetName(),str),"",fhNBinsNSigma-1,fhBinLimNSigma);
 761     fhQA[kCutRequireSigmaToVertex][i] = new TH1F(Form("%s_requireSigmaToVertex%s",GetName(),str),"",fhNBinsRequireSigma-1,fhBinLimRequireSigma);
 762     fhQA[kCutAcceptKinkDaughters][i] = new TH1F(Form("%s_acceptKinkDaughters%s",GetName(),str),"",fhNBinsAcceptKink-1,fhBinLimAcceptKink);
 763     fhQA[kDcaXY][i]             = new TH1F(Form("%s_dcaXY%s",GetName(),str),"",fhNBinsDcaXY-1,fhBinLimDcaXY);
 764     fhQA[kDcaZ][i]              = new TH1F(Form("%s_dcaZ%s",GetName(),str),"",fhNBinsDcaZ-1,fhBinLimDcaZ);
 765     fhQA[kDcaXYnorm][i]         = new TH1F(Form("%s_dcaXYnorm%s",GetName(),str),"",fhNBinsDcaXYnorm-1,fhBinLimDcaXYnorm);
 766     fhQA[kDcaZnorm][i]          = new TH1F(Form("%s_dcaZnorm%s",GetName(),str),"",fhNBinsDcaZnorm-1,fhBinLimDcaZnorm);
 767     fhQA[kSigmaDcaXY][i]        = new TH1F(Form("%s_sigmaDcaXY%s",GetName(),str),"",fhNBinsSigmaDcaXY-1,fhBinLimSigmaDcaXY);
 768     fhQA[kSigmaDcaZ][i]         = new TH1F(Form("%s_sigmaDcaZ%s",GetName(),str),"",fhNBinsSigmaDcaZ-1,fhBinLimSigmaDcaZ);
 769
 770     fhDcaXYvsDcaZ[i]->SetXTitle("impact par. d_{z}");
 771     fhDcaXYvsDcaZ[i]->SetYTitle("impact par. d_{xy}");
 772
 773     fhQA[kCutNSigmaToVertex][i]->SetXTitle("n #sigma to vertex");
 774     fhQA[kCutRequireSigmaToVertex][i]->SetXTitle("require #sigma to vertex");
 775     fhQA[kCutAcceptKinkDaughters][i]->SetXTitle("accept kink daughters");
 776     fhQA[kDcaXY][i]->SetXTitle("impact par. d_{xy}");
 777     fhQA[kDcaZ][i]->SetXTitle("impact par. d_{z}");
 778     fhQA[kDcaXYnorm][i]->SetXTitle("norm. impact par. d_{xy} / #sigma_{xy}");
 779     fhQA[kDcaZnorm][i]->SetXTitle("norm. impact par. d_{z} / #sigma_{z}");
 780     fhQA[kSigmaDcaXY][i]->SetXTitle("impact par. resolution #sigma_{xy}");
 781     fhQA[kSigmaDcaZ][i]->SetXTitle("impact par. resolution #sigma_{z}");
 782   }
 783   for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
 784 }
 785 //__________________________________________________________________________________
 786 void AliCFTrackIsPrimaryCuts::FillHistograms(TObject* obj, Bool_t f)
 787 {
 788   //
 789   // fill the QA histograms
 790   //
 791
 792   if (!obj) return;
 793
 794   Bool_t isESDTrack = strcmp(obj->ClassName(),"AliESDtrack") == 0 ? kTRUE : kFALSE ;
 795   Bool_t isAODTrack = strcmp(obj->ClassName(),"AliAODTrack") == 0 ? kTRUE : kFALSE ;
 796
 797   AliESDtrack * esdTrack = 0x0 ;
 798   AliAODTrack * aodTrack = 0x0 ;
 799   if (isESDTrack) esdTrack = dynamic_cast<AliESDtrack*>(obj);
 800   if (isAODTrack) aodTrack = dynamic_cast<AliAODTrack*>(obj);
 801
 802   // f = 0: fill histograms before cuts
 803   // f = 1: fill histograms after cuts
 804
 805   // get the track to vertex parameter for ESD track
 806   if (esdTrack) {
 807
 808     fhQA[kDcaZ][f]->Fill(fDCA[1]);
 809     fhQA[kDcaXY][f]->Fill(fDCA[0]);
 810     fhDcaXYvsDcaZ[f]->Fill(fDCA[1],fDCA[0]);
 811     fhQA[kSigmaDcaXY][f]->Fill(fDCA[2]);
 812     fhQA[kSigmaDcaZ][f]->Fill(fDCA[3]);
 813 // // // // // // //  delete histograms
 814       fhQA[kDcaZnorm][f]->Fill(fDCA[1]);
 815       fhQA[kDcaXYnorm][f]->Fill(fDCA[0]);
 816
 817     fhQA[kCutNSigmaToVertex][f]->Fill(fDCA[5]);
 818     if (fDCA[5]<0 && fRequireSigmaToVertex) fhQA[kCutRequireSigmaToVertex][f]->Fill(0.);
 819     if (!(fDCA[5]<0 && fRequireSigmaToVertex)) fhQA[kCutRequireSigmaToVertex][f]->Fill(1.);
 820
 821     if (!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
 822     if (!(!fAcceptKinkDaughters && esdTrack->GetKinkIndex(0)>0)) fhQA[kCutAcceptKinkDaughters][f]->Fill(0.);
 823   }
 824
 825   // fill cut statistics and cut correlation histograms with information from the bitmap
 826   if (f) return;
 827
 828   // Get the bitmap of the single cuts
 829   if ( !obj ) return;
 830   SelectionBitMap(obj);
 831
 832   // Number of single cuts in this class
 833   UInt_t ncuts = fBitmap->GetNbits();
 834   for(UInt_t bit=0; bit<ncuts;bit++) {
 835     if (!fBitmap->TestBitNumber(bit)) {
 836         fhCutStatistics->Fill(bit+1);
 837         for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
 838           if (!fBitmap->TestBitNumber(bit2))
 839             fhCutCorrelation->Fill(bit+1,bit2+1);
 840         }
 841     }
 842   }
 843 }
 844 //__________________________________________________________________________________
 845 void AliCFTrackIsPrimaryCuts::SaveHistograms(const Char_t* dir) {
 846   //
 847   // saves the histograms in a directory (dir)
 848   //
 849   if(!fIsQAOn) return;
 850
 851   if (!dir)
 852     dir = GetName();
 853
 854   gDirectory->mkdir(dir);
 855   gDirectory->cd(dir);
 856
 857   gDirectory->mkdir("before_cuts");
 858   gDirectory->mkdir("after_cuts");
 859
 860   fhCutStatistics->Write();
 861   fhCutCorrelation->Write();
 862
 863   for (Int_t j=0; j<kNStepQA; j++) {
 864     if (j==0)
 865       gDirectory->cd("before_cuts");
 866     else
 867       gDirectory->cd("after_cuts");
 868
 869     fhDcaXYvsDcaZ[j]    ->Write();
 870
 871     for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
 872
 873     gDirectory->cd("../");
 874   }
 875   gDirectory->cd("../");
 876 }
 877 //__________________________________________________________________________________
 878 void AliCFTrackIsPrimaryCuts::DrawHistograms()
 879 {
 880   //
 881   // draws some histograms
 882   //
 883   if(!fIsQAOn) return;
 884
 885   // pad margins
 886   Float_t right = 0.03;
 887   Float_t left = 0.175;
 888   Float_t top = 0.03;
 889   Float_t bottom = 0.175;
 890
 891   TCanvas* canvas1 = new TCanvas("Track_QA_Primary_1", "Track QA Primary 1", 800, 500);
 892   canvas1->Divide(2, 1);
 893
 894   canvas1->cd(1);
 895   fhCutStatistics->SetStats(kFALSE);
 896   fhCutStatistics->LabelsOption("v");
 897   gPad->SetLeftMargin(left);
 898   gPad->SetBottomMargin(0.25);
 899   gPad->SetRightMargin(right);
 900   gPad->SetTopMargin(0.1);
 901   fhCutStatistics->Draw();
 902
 903   canvas1->cd(2);
 904   fhCutCorrelation->SetStats(kFALSE);
 905   fhCutCorrelation->LabelsOption("v");
 906   gPad->SetLeftMargin(0.30);
 907   gPad->SetRightMargin(bottom);
 908   gPad->SetTopMargin(0.1);
 909   gPad->SetBottomMargin(0.25);
 910   fhCutCorrelation->Draw("COLZ");
 911
 912   canvas1->SaveAs(Form("%s.eps", canvas1->GetName()));
 913   canvas1->SaveAs(Form("%s.ps", canvas1->GetName()));
 914
 915   // -----
 916
 917   TCanvas* canvas2 = new TCanvas("Track_QA_Primary_2", "Track QA Primary 2", 800, 800);
 918   canvas2->Divide(2, 2);
 919
 920   canvas2->cd(1);
 921   gPad->SetRightMargin(right);
 922   gPad->SetLeftMargin(left);
 923   gPad->SetTopMargin(top);
 924   gPad->SetBottomMargin(bottom);
 925   fhQA[kDcaXY][0]->SetStats(kFALSE);
 926   fhQA[kDcaXY][0]->Draw();
 927   fhQA[kDcaXY][1]->Draw("same");
 928
 929   canvas2->cd(2);
 930   gPad->SetRightMargin(right);
 931   gPad->SetLeftMargin(left);
 932   gPad->SetTopMargin(top);
 933   gPad->SetBottomMargin(bottom);
 934   fhQA[kDcaZ][0]->SetStats(kFALSE);
 935   fhQA[kDcaZ][0]->Draw();
 936   fhQA[kDcaZ][1]->Draw("same");
 937
 938   canvas2->cd(3);
 939 //   fhDXYvsDZ[0]->SetStats(kFALSE);
 940   gPad->SetLogz();
 941   gPad->SetLeftMargin(bottom);
 942   gPad->SetTopMargin(0.1);
 943   gPad->SetBottomMargin(bottom);
 944   gPad->SetRightMargin(0.2);
 945   fhDcaXYvsDcaZ[0]->Draw("COLZ");
 946
 947   canvas2->cd(4);
 948 //   fhDXYvsDZ[1]->SetStats(kFALSE);
 949   gPad->SetLogz();
 950   gPad->SetLeftMargin(bottom);
 951   gPad->SetTopMargin(0.1);
 952   gPad->SetBottomMargin(bottom);
 953   gPad->SetRightMargin(0.2);
 954   fhDcaXYvsDcaZ[1]->Draw("COLZ");
 955
 956   canvas2->SaveAs(Form("%s.eps", canvas2->GetName()));
 957   canvas2->SaveAs(Form("%s.ps", canvas2->GetName()));
 958
 959   // -----
 960
 961   TCanvas* canvas3 = new TCanvas("Track_QA_Primary_3", "Track QA Primary 3", 800, 400);
 962   canvas3->Divide(2, 1);
 963
 964   canvas3->cd(1);
 965   gPad->SetRightMargin(right);
 966   gPad->SetLeftMargin(left);
 967   gPad->SetTopMargin(top);
 968   gPad->SetBottomMargin(bottom);
 969   fhQA[kDcaXYnorm][0]->SetStats(kFALSE);
 970   fhQA[kDcaXYnorm][0]->Draw();
 971   fhQA[kDcaXYnorm][1]->Draw("same");
 972
 973   canvas3->cd(2);
 974   gPad->SetRightMargin(right);
 975   gPad->SetLeftMargin(left);
 976   gPad->SetTopMargin(top);
 977   gPad->SetBottomMargin(bottom);
 978   fhQA[kDcaZnorm][0]->SetStats(kFALSE);
 979   fhQA[kDcaZnorm][0]->Draw();
 980   fhQA[kDcaZnorm][1]->Draw("same");
 981
 982   canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
 983   canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
 984
 985   // -----
 986
 987   TCanvas* canvas4 = new TCanvas("Track_QA_Primary_4", "Track QA Primary 4", 1200, 800);
 988   canvas4->Divide(3, 2);
 989
 990   canvas4->cd(1);
 991   gPad->SetRightMargin(right);
 992   gPad->SetLeftMargin(left);
 993   gPad->SetTopMargin(top);
 994   gPad->SetBottomMargin(bottom);
 995   fhQA[kSigmaDcaXY][0]->SetStats(kFALSE);
 996   fhQA[kSigmaDcaXY][0]->Draw();
 997   fhQA[kSigmaDcaXY][1]->Draw("same");
 998
 999   canvas4->cd(2);
1000   gPad->SetRightMargin(right);
1001   gPad->SetLeftMargin(left);
1002   gPad->SetTopMargin(top);
1003   gPad->SetBottomMargin(bottom);
1004   fhQA[kSigmaDcaZ][0]->SetStats(kFALSE);
1005   fhQA[kSigmaDcaZ][0]->Draw();
1006   fhQA[kSigmaDcaZ][1]->Draw("same");
1007
1008   canvas4->cd(4);
1009   gPad->SetRightMargin(right);
1010   gPad->SetLeftMargin(left);
1011   gPad->SetTopMargin(top);
1012   gPad->SetBottomMargin(bottom);
1013   fhQA[kCutNSigmaToVertex][0]->SetStats(kFALSE);
1014   fhQA[kCutNSigmaToVertex][0]->Draw();
1015   fhQA[kCutNSigmaToVertex][1]->Draw("same");
1016
1017   canvas4->cd(5);
1018   gPad->SetRightMargin(right);
1019   gPad->SetLeftMargin(left);
1020   gPad->SetTopMargin(top);
1021   gPad->SetBottomMargin(bottom);
1022   fhQA[kCutRequireSigmaToVertex][0]->SetStats(kFALSE);
1023   fhQA[kCutRequireSigmaToVertex][0]->Draw();
1024   fhQA[kCutRequireSigmaToVertex][1]->Draw("same");
1025
1026   canvas4->cd(6);
1027   gPad->SetRightMargin(right);
1028   gPad->SetLeftMargin(left);
1029   gPad->SetTopMargin(top);
1030   gPad->SetBottomMargin(bottom);
1031   fhQA[kCutAcceptKinkDaughters][0]->SetStats(kFALSE);
1032   fhQA[kCutAcceptKinkDaughters][0]->Draw();
1033   fhQA[kCutAcceptKinkDaughters][1]->Draw("same");
1034
1035   canvas4->SaveAs(Form("%s.eps", canvas4->GetName()));
1036   canvas4->SaveAs(Form("%s.ps", canvas4->GetName()));
1037 }
1038 //__________________________________________________________________________________
1039 void AliCFTrackIsPrimaryCuts::AddQAHistograms(TList *qaList) {
1040   //
1041   // saves the histograms in a TList
1042   //
1043   DefineHistograms();
1044
1045   qaList->Add(fhCutStatistics);
1046   qaList->Add(fhCutCorrelation);
1047
1048   for (Int_t j=0; j<kNStepQA; j++) {
1049     qaList->Add(fhDcaXYvsDcaZ[j]);
1050     for(Int_t i=0; i<kNHist; i++)
1051         qaList->Add(fhQA[i][j]);
1052   }
1053 }