CORRFW/AliCFTrackKineCuts.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 AliCFTrackKineCuts is designed to select both generated
  17 // and reconstructed tracks of a given range in momentum space,
  18 // electric charge and azimuthal emission angle phi
  19 // and to provide corresponding QA histograms.
  20 // This class inherits from the Analysis' Framework abstract base class
  21 // AliAnalysisCuts and is a part of the Correction Framework.
  22 // This class acts on single, generated and reconstructed tracks, it is
  23 // applicable on ESD and AOD data.
  24 // It mainly consists of a IsSelected function that returns a boolean.
  25 // This function checks whether the considered track passes a set of cuts:
  26 // - total momentum
  27 // - pt
  28 // - px
  29 // - py
  30 // - pz
  31 // - eta
  32 // - rapidity
  33 // - phi
  34 // - charge
  35 // - is charged
  36 //
  37 // The cut values for these cuts are set with the corresponding set functions.
  38 // All cut classes provided by the correction framework are supposed to be
  39 // added in the Analysis Framwork's class AliAnalysisFilter and applied by
  40 // the filter via a loop.
  41 //
  42 // author: I. Kraus (Ingrid.Kraus@cern.ch)
  43 // idea taken form
  44 // AliESDtrackCuts writte by Jan Fiete Grosse-Oetringhaus and
  45 // AliRsnDaughterCut class written by A. Pulvirenti.
  46
  47 #include <TCanvas.h>
  48 #include <TDirectory.h>
  49 #include <TH2.h>
  50 #include <TBits.h>
  51
  52 #include <AliVParticle.h>
  53 #include <AliLog.h>
  54 #include "AliCFTrackKineCuts.h"
  55
  56 ClassImp(AliCFTrackKineCuts)
  57
  58 //__________________________________________________________________________________
  59 AliCFTrackKineCuts::AliCFTrackKineCuts() :
  60   AliCFCutBase(),
  61   fMomentumMin(0),
  62   fMomentumMax(0),
  63   fPtMin(0),
  64   fPtMax(0),
  65   fPxMin(0),
  66   fPxMax(0),
  67   fPyMin(0),
  68   fPyMax(0),
  69   fPzMin(0),
  70   fPzMax(0),
  71   fEtaMin(0),
  72   fEtaMax(0),
  73   fRapidityMin(0),
  74   fRapidityMax(0),
  75   fPhiMin(0),
  76   fPhiMax(0),
  77   fCharge(0),
  78   fRequireIsCharged(0),
  79   fhCutStatistics(0),
  80   fhCutCorrelation(0),
  81   fBitmap(0x0),
  82   fhNBinsMomentum(0),
  83   fhNBinsPt(0),
  84   fhNBinsPx(0),
  85   fhNBinsPy(0),
  86   fhNBinsPz(0),
  87   fhNBinsEta(0),
  88   fhNBinsRapidity(0),
  89   fhNBinsPhi(0),
  90   fhNBinsCharge(0),
  91   fhBinLimMomentum(0x0),
  92   fhBinLimPt(0x0),
  93   fhBinLimPx(0x0),
  94   fhBinLimPy(0x0),
  95   fhBinLimPz(0x0),
  96   fhBinLimEta(0x0),
  97   fhBinLimRapidity(0x0),
  98   fhBinLimPhi(0x0),
  99   fhBinLimCharge(0x0)
 100 {
 101   //
 102   // Default constructor
 103   //
 104   Initialise();
 105 }
 106 //__________________________________________________________________________________
 107 AliCFTrackKineCuts::AliCFTrackKineCuts(Char_t* name, Char_t* title) :
 108   AliCFCutBase(name,title),
 109   fMomentumMin(0),
 110   fMomentumMax(0),
 111   fPtMin(0),
 112   fPtMax(0),
 113   fPxMin(0),
 114   fPxMax(0),
 115   fPyMin(0),
 116   fPyMax(0),
 117   fPzMin(0),
 118   fPzMax(0),
 119   fEtaMin(0),
 120   fEtaMax(0),
 121   fRapidityMin(0),
 122   fRapidityMax(0),
 123   fPhiMin(0),
 124   fPhiMax(0),
 125   fCharge(0),
 126   fRequireIsCharged(0),
 127   fhCutStatistics(0),
 128   fhCutCorrelation(0),
 129   fBitmap(0x0),
 130   fhNBinsMomentum(0),
 131   fhNBinsPt(0),
 132   fhNBinsPx(0),
 133   fhNBinsPy(0),
 134   fhNBinsPz(0),
 135   fhNBinsEta(0),
 136   fhNBinsRapidity(0),
 137   fhNBinsPhi(0),
 138   fhNBinsCharge(0),
 139   fhBinLimMomentum(0x0),
 140   fhBinLimPt(0x0),
 141   fhBinLimPx(0x0),
 142   fhBinLimPy(0x0),
 143   fhBinLimPz(0x0),
 144   fhBinLimEta(0x0),
 145   fhBinLimRapidity(0x0),
 146   fhBinLimPhi(0x0),
 147   fhBinLimCharge(0x0)
 148 {
 149   //
 150   // Constructor
 151   //
 152   Initialise();
 153 }
 154 //__________________________________________________________________________________
 155 AliCFTrackKineCuts::AliCFTrackKineCuts(const AliCFTrackKineCuts& c) :
 156   AliCFCutBase(c),
 157   fMomentumMin(c.fMomentumMin),
 158   fMomentumMax(c.fMomentumMax),
 159   fPtMin(c.fPtMin),
 160   fPtMax(c.fPtMax),
 161   fPxMin(c.fPxMin),
 162   fPxMax(c.fPxMax),
 163   fPyMin(c.fPyMin),
 164   fPyMax(c.fPyMax),
 165   fPzMin(c.fPzMin),
 166   fPzMax(c.fPzMax),
 167   fEtaMin(c.fEtaMin),
 168   fEtaMax(c.fEtaMax),
 169   fRapidityMin(c.fRapidityMin),
 170   fRapidityMax(c.fRapidityMax),
 171   fPhiMin(c.fPhiMin),
 172   fPhiMax(c.fPhiMax),
 173   fCharge(c.fCharge),
 174   fRequireIsCharged(c.fRequireIsCharged),
 175   fhCutStatistics(c.fhCutStatistics),
 176   fhCutCorrelation(c.fhCutCorrelation),
 177   fBitmap(c.fBitmap),
 178   fhNBinsMomentum(c.fhNBinsMomentum),
 179   fhNBinsPt(c.fhNBinsPt),
 180   fhNBinsPx(c.fhNBinsPx),
 181   fhNBinsPy(c.fhNBinsPy),
 182   fhNBinsPz(c.fhNBinsPz),
 183   fhNBinsEta(c.fhNBinsEta),
 184   fhNBinsRapidity(c.fhNBinsRapidity),
 185   fhNBinsPhi(c.fhNBinsPhi),
 186   fhNBinsCharge(c.fhNBinsCharge),
 187   fhBinLimMomentum(c.fhBinLimMomentum),
 188   fhBinLimPt(c.fhBinLimPt),
 189   fhBinLimPx(c.fhBinLimPx),
 190   fhBinLimPy(c.fhBinLimPy),
 191   fhBinLimPz(c.fhBinLimPz),
 192   fhBinLimEta(c.fhBinLimEta),
 193   fhBinLimRapidity(c.fhBinLimRapidity),
 194   fhBinLimPhi(c.fhBinLimPhi),
 195   fhBinLimCharge(c.fhBinLimCharge)
 196 {
 197   //
 198   // copy constructor
 199   //
 200   ((AliCFTrackKineCuts &) c).Copy(*this);
 201 }
 202 //__________________________________________________________________________________
 203 AliCFTrackKineCuts& AliCFTrackKineCuts::operator=(const AliCFTrackKineCuts& c)
 204 {
 205   //
 206   // Assignment operator
 207   //
 208   if (this != &c) {
 209     AliCFCutBase::operator=(c) ;
 210     fMomentumMin = c.fMomentumMin ;
 211     fMomentumMax = c.fMomentumMax ;
 212     fPtMin = c.fPtMin ;
 213     fPtMax = c.fPtMax ;
 214     fPxMin = c.fPxMin ;
 215     fPxMax = c.fPxMax ;
 216     fPyMin = c.fPyMin ;
 217     fPyMax = c.fPyMax ;
 218     fPzMin = c.fPzMin ;
 219     fPzMax = c.fPzMax ;
 220     fEtaMin = c.fEtaMin ;
 221     fEtaMax = c.fEtaMax ;
 222     fRapidityMin = c.fRapidityMin ;
 223     fRapidityMax = c.fRapidityMax ;
 224     fPhiMin = c.fPhiMin ;
 225     fPhiMax = c.fPhiMax ;
 226     fCharge = c.fCharge ;
 227     fRequireIsCharged = c.fRequireIsCharged ;
 228     fhCutStatistics = c.fhCutStatistics ;
 229     fhCutCorrelation = c.fhCutCorrelation ;
 230     fBitmap = c.fBitmap;
 231     fhNBinsMomentum = c.fhNBinsMomentum;
 232     fhNBinsPt = c.fhNBinsPt;
 233     fhNBinsPx = c.fhNBinsPx;
 234     fhNBinsPy = c.fhNBinsPy;
 235     fhNBinsPz = c.fhNBinsPz;
 236     fhNBinsEta = c.fhNBinsEta;
 237     fhNBinsRapidity = c.fhNBinsRapidity;
 238     fhNBinsPhi = c.fhNBinsPhi;
 239     fhNBinsCharge = c.fhNBinsCharge;
 240     fhBinLimMomentum = c.fhBinLimMomentum;
 241     fhBinLimPt = c.fhBinLimPt;
 242     fhBinLimPx = c.fhBinLimPx;
 243     fhBinLimPy = c.fhBinLimPy;
 244     fhBinLimPz = c.fhBinLimPz;
 245     fhBinLimEta = c.fhBinLimEta;
 246     fhBinLimRapidity = c.fhBinLimRapidity;
 247     fhBinLimPhi = c.fhBinLimPhi;
 248     fhBinLimCharge = c.fhBinLimCharge;
 249
 250     for (Int_t i=0; i<c.kNHist; i++){
 251       for (Int_t j=0; j<c.kNStepQA; j++){
 252         if(c.fhQA[i][j]) fhQA[i][j] = (TH1F*)c.fhQA[i][j]->Clone();
 253       }
 254     }
 255     ((AliCFTrackKineCuts &) c).Copy(*this);
 256   }
 257   return *this ;
 258 }
 259 //__________________________________________________________________________________
 260 AliCFTrackKineCuts::~AliCFTrackKineCuts()
 261 {
 262   //
 263   // destructor
 264   //
 265   if (fhCutStatistics)                  delete fhCutStatistics;
 266   if (fhCutCorrelation)                 delete fhCutCorrelation;
 267
 268   for (Int_t i=0; i<kNHist; i++){
 269     for (Int_t j=0; j<kNStepQA; j++){
 270       if(fhQA[i][j]) delete fhQA[i][j];
 271     }
 272   }
 273   if(fBitmap) delete fBitmap;
 274   if(fhBinLimMomentum) delete fhBinLimMomentum;
 275   if(fhBinLimPt) delete fhBinLimPt;
 276   if(fhBinLimPx) delete fhBinLimPx;
 277   if(fhBinLimPy) delete fhBinLimPy;
 278   if(fhBinLimPz) delete fhBinLimPz;
 279   if(fhBinLimEta) delete fhBinLimEta;
 280   if(fhBinLimRapidity) delete fhBinLimRapidity;
 281   if(fhBinLimPhi) delete fhBinLimPhi;
 282   if(fhBinLimCharge) delete fhBinLimCharge;
 283 }
 284 //__________________________________________________________________________________
 285 void AliCFTrackKineCuts::Initialise()
 286 {
 287   //
 288   // sets everything to zero
 289   //
 290   fMomentumMin = 0;
 291   fMomentumMax = 0;
 292   fPtMin = 0;
 293   fPtMax = 0;
 294   fPxMin = 0;
 295   fPxMax = 0;
 296   fPyMin = 0;
 297   fPyMax = 0;
 298   fPzMin = 0;
 299   fPzMax = 0;
 300   fEtaMin = 0;
 301   fEtaMax = 0;
 302   fRapidityMin = 0;
 303   fRapidityMax = 0;
 304   fPhiMin = 0;
 305   fPhiMax = 0;
 306   fCharge = 0;
 307   fRequireIsCharged = 0;
 308
 309   SetMomentumRange();
 310   SetPtRange();
 311   SetPxRange();
 312   SetPyRange();
 313   SetPzRange();
 314   SetEtaRange();
 315   SetRapidityRange();
 316   SetPhiRange();
 317   SetChargeRec();
 318   SetChargeMC();
 319   SetRequireIsCharged();
 320
 321   for (Int_t i=0; i<kNHist; i++){
 322     for (Int_t j=0; j<kNStepQA; j++)  {
 323       fhQA[i][j] = 0x0;
 324     }
 325   }
 326
 327   fhCutStatistics = 0;
 328   fhCutCorrelation = 0;
 329   fBitmap=new TBits(0);
 330
 331   //set default bining for QA histograms
 332   SetHistogramBins(kCutP,200,0.,20.);
 333   SetHistogramBins(kCutPt,200,0.,20.);
 334   SetHistogramBins(kCutPx,400,-20.,20.);
 335   SetHistogramBins(kCutPy,400,-20.,20.);
 336   SetHistogramBins(kCutPz,400,-20.,20.);
 337   SetHistogramBins(kCutRapidity,200,-10.,10.);
 338   SetHistogramBins(kCutEta,200,-10.,10.);
 339   SetHistogramBins(kCutPhi,38,-0.6,7.);
 340   SetHistogramBins(kCutCharge,21,-10.5,10.5);
 341 }
 342 //__________________________________________________________________________________
 343 void AliCFTrackKineCuts::Copy(TObject &c) const
 344 {
 345   //
 346   // Copy function
 347   //
 348   AliCFTrackKineCuts& target = (AliCFTrackKineCuts &) c;
 349
 350   target.Initialise();
 351
 352   if (fhCutStatistics)  target.fhCutStatistics = (TH1F*) fhCutStatistics->Clone();
 353   if (fhCutCorrelation) target.fhCutCorrelation = (TH2F*) fhCutCorrelation->Clone();
 354
 355   for (Int_t i=0; i<kNHist; i++){
 356     for (Int_t j=0; j<kNStepQA; j++){
 357       if(fhQA[i][j]) target.fhQA[i][j] = (TH1F*)fhQA[i][j]->Clone();
 358     }
 359   }
 360   TNamed::Copy(c);
 361 }
 362 //__________________________________________________________________________________
 363 void AliCFTrackKineCuts::SelectionBitMap(TObject* obj) {
 364   //
 365   // test if the track passes the single cuts
 366   // and store the information in a bitmap
 367   //
 368
 369   // bitmap stores the decision of each single cut
 370   for(Int_t i=0; i<kNCuts; i++)fBitmap->SetBitNumber(i,kFALSE);
 371
 372   // check TObject and cast into VParticle
 373   if (!obj) return  ;
 374   if (!obj->InheritsFrom("AliVParticle")) AliError("object must derived from AliVParticle !");
 375   AliVParticle* particle = dynamic_cast<AliVParticle *>(obj);
 376   if ( !particle ) return;
 377
 378   Int_t iCutBit = 0;
 379   if((particle->P() >= fMomentumMin) && (particle->P() <= fMomentumMax))
 380         fBitmap->SetBitNumber(iCutBit,kTRUE);
 381   iCutBit++;
 382   if ((particle->Pt() >= fPtMin) && (particle->Pt() <= fPtMax))
 383         fBitmap->SetBitNumber(iCutBit,kTRUE);
 384   iCutBit++;
 385   if ((particle->Px() >= fPxMin) && (particle->Px() <= fPxMax))
 386         fBitmap->SetBitNumber(iCutBit,kTRUE);
 387   iCutBit++;
 388   if ((particle->Py() >= fPyMin) && (particle->Py() <= fPyMax))
 389         fBitmap->SetBitNumber(iCutBit,kTRUE);
 390   iCutBit++;
 391   if ((particle->Pz() >= fPzMin) && (particle->Pz() <= fPzMax))
 392         fBitmap->SetBitNumber(iCutBit,kTRUE);
 393   iCutBit++;
 394   if ((particle->Eta() >= fEtaMin) && (particle->Eta() <= fEtaMax))
 395         fBitmap->SetBitNumber(iCutBit,kTRUE);
 396   iCutBit++;
 397   if ((particle->Y() >= fRapidityMin) && (particle->Y() <= fRapidityMax))
 398         fBitmap->SetBitNumber(iCutBit,kTRUE);
 399   iCutBit++;
 400   if ((particle->Phi() >= fPhiMin) && (particle->Phi() <= fPhiMax))
 401         fBitmap->SetBitNumber(iCutBit,kTRUE);
 402   iCutBit++;
 403   if (fCharge >= 10 || (particle->Charge() == fCharge))
 404         fBitmap->SetBitNumber(iCutBit,kTRUE);
 405   iCutBit++;
 406   if (fRequireIsCharged && particle->Charge()!=0)
 407         fBitmap->SetBitNumber(iCutBit,kTRUE);
 408   if (!fRequireIsCharged)
 409         fBitmap->SetBitNumber(iCutBit,kTRUE);
 410
 411   return;
 412 }
 413 //__________________________________________________________________________________
 414 Bool_t AliCFTrackKineCuts::IsSelected(TObject* obj) {
 415   //
 416   // loops over decisions of single cuts and returns if the track is accepted
 417   //
 418   SelectionBitMap(obj);
 419
 420   if (fIsQAOn) FillHistograms(obj,0);
 421   Bool_t isSelected = kTRUE;
 422
 423   for (UInt_t icut=0; icut<fBitmap->GetNbits();icut++) {
 424     if(!fBitmap->TestBitNumber(icut)) {
 425         isSelected = kFALSE;
 426         break;
 427     }
 428   }
 429   if (!isSelected) return kFALSE ;
 430   if (fIsQAOn) FillHistograms(obj,1);
 431   return kTRUE;
 432 }
 433 //__________________________________________________________________________________
 434 void AliCFTrackKineCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t *bins)
 435 {
 436   //
 437   // variable bin size
 438   //
 439   if(!fIsQAOn) return;
 440
 441   switch(index){
 442   case kCutP:
 443     fhNBinsMomentum=nbins+1;
 444     fhBinLimMomentum=new Double_t[nbins+1];
 445     for(Int_t i=0;i<nbins+1;i++)fhBinLimMomentum[i]=bins[i];
 446     break;
 447
 448   case kCutPt:
 449     fhNBinsPt=nbins+1;
 450     fhBinLimPt=new Double_t[nbins+1];
 451     for(Int_t i=0;i<nbins+1;i++)fhBinLimPt[i]=bins[i];
 452     break;
 453
 454   case kCutPx:
 455     fhNBinsPx=nbins+1;
 456     fhBinLimPx=new Double_t[nbins+1];
 457     for(Int_t i=0;i<nbins+1;i++)fhBinLimPx[i]=bins[i];
 458     break;
 459
 460   case kCutPy:
 461     fhNBinsPy=nbins+1;
 462     fhBinLimPy=new Double_t[nbins+1];
 463     for(Int_t i=0;i<nbins+1;i++)fhBinLimPy[i]=bins[i];
 464     break;
 465
 466   case kCutPz:
 467     fhNBinsPz=nbins+1;
 468     fhBinLimPz=new Double_t[nbins+1];
 469     for(Int_t i=0;i<nbins+1;i++)fhBinLimPz[i]=bins[i];
 470     break;
 471
 472   case kCutRapidity:
 473     fhNBinsRapidity=nbins+1;
 474     fhBinLimRapidity=new Double_t[nbins+1];
 475     for(Int_t i=0;i<nbins+1;i++)fhBinLimRapidity[i]=bins[i];
 476     break;
 477
 478   case kCutEta:
 479     fhNBinsEta=nbins+1;
 480     fhBinLimEta=new Double_t[nbins+1];
 481     for(Int_t i=0;i<nbins+1;i++)fhBinLimEta[i]=bins[i];
 482     break;
 483
 484   case kCutPhi:
 485     fhNBinsPhi=nbins+1;
 486     fhBinLimPhi=new Double_t[nbins+1];
 487     for(Int_t i=0;i<nbins+1;i++)fhBinLimPhi[i]=bins[i];
 488     break;
 489
 490   case kCutCharge:
 491     fhNBinsCharge=nbins+1;
 492     fhBinLimCharge=new Double_t[nbins+1];
 493     for(Int_t i=0;i<nbins+1;i++)fhBinLimCharge[i]=bins[i];
 494     break;
 495   }
 496 }
 497 //__________________________________________________________________________________
 498 void AliCFTrackKineCuts::SetHistogramBins(Int_t index, Int_t nbins, Double_t xmin, Double_t xmax)
 499 {
 500   //
 501   // fixed bin size
 502   //
 503   switch(index){
 504   case kCutP:
 505     fhNBinsMomentum=nbins+1;
 506     fhBinLimMomentum=new Double_t[nbins+1];
 507     for(Int_t i=0;i<nbins+1;i++)fhBinLimMomentum[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 508     break;
 509
 510   case kCutPt:
 511     fhNBinsPt=nbins+1;
 512     fhBinLimPt=new Double_t[nbins+1];
 513     for(Int_t i=0;i<nbins+1;i++)fhBinLimPt[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 514     break;
 515
 516   case kCutPx:
 517     fhNBinsPx=nbins+1;
 518     fhBinLimPx=new Double_t[nbins+1];
 519     for(Int_t i=0;i<nbins+1;i++)fhBinLimPx[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 520     break;
 521
 522   case kCutPy:
 523     fhNBinsPy=nbins+1;
 524     fhBinLimPy=new Double_t[nbins+1];
 525     for(Int_t i=0;i<nbins+1;i++)fhBinLimPy[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 526     break;
 527
 528   case kCutPz:
 529     fhNBinsPz=nbins+1;
 530     fhBinLimPz=new Double_t[nbins+1];
 531     for(Int_t i=0;i<nbins+1;i++)fhBinLimPz[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 532     break;
 533
 534   case kCutRapidity:
 535     fhNBinsRapidity=nbins+1;
 536     fhBinLimRapidity=new Double_t[nbins+1];
 537     for(Int_t i=0;i<nbins+1;i++)fhBinLimRapidity[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 538     break;
 539
 540   case kCutEta:
 541     fhNBinsEta=nbins+1;
 542     fhBinLimEta=new Double_t[nbins+1];
 543     for(Int_t i=0;i<nbins+1;i++)fhBinLimEta[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 544     break;
 545
 546   case kCutPhi:
 547     fhNBinsPhi=nbins+1;
 548     fhBinLimPhi=new Double_t[nbins+1];
 549     for(Int_t i=0;i<nbins+1;i++)fhBinLimPhi[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 550     break;
 551
 552   case kCutCharge:
 553     fhNBinsCharge=nbins+1;
 554     fhBinLimCharge=new Double_t[nbins+1];
 555     for(Int_t i=0;i<nbins+1;i++)fhBinLimCharge[i]=xmin+i*(xmax-xmin)/Double_t(nbins);
 556     break;
 557   }
 558 }
 559 //__________________________________________________________________________________
 560  void AliCFTrackKineCuts::DefineHistograms() {
 561   //
 562   // histograms for cut variables, cut statistics and cut correlations
 563   //
 564   Int_t color = 2;
 565
 566   // book cut statistics and cut correlation histograms
 567   fhCutStatistics = new TH1F(Form("%s_cut_statistics",GetName()), Form("%s cut statistics",GetName()), kNCuts,0.5,kNCuts+0.5);
 568   fhCutStatistics->SetLineWidth(2);
 569   fhCutStatistics->GetXaxis()->SetBinLabel(1,"p");
 570   fhCutStatistics->GetXaxis()->SetBinLabel(2,"pt");
 571   fhCutStatistics->GetXaxis()->SetBinLabel(3,"px");
 572   fhCutStatistics->GetXaxis()->SetBinLabel(4,"py");
 573   fhCutStatistics->GetXaxis()->SetBinLabel(5,"pz");
 574   fhCutStatistics->GetXaxis()->SetBinLabel(6,"eta");
 575   fhCutStatistics->GetXaxis()->SetBinLabel(7,"y");
 576   fhCutStatistics->GetXaxis()->SetBinLabel(8,"phi");
 577   fhCutStatistics->GetXaxis()->SetBinLabel(9,"charge");
 578   fhCutStatistics->GetXaxis()->SetBinLabel(10,"is charged");
 579
 580   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);
 581   fhCutCorrelation->SetLineWidth(2);
 582   fhCutCorrelation->GetXaxis()->SetBinLabel(1,"p");
 583   fhCutCorrelation->GetXaxis()->SetBinLabel(2,"pt");
 584   fhCutCorrelation->GetXaxis()->SetBinLabel(3,"px");
 585   fhCutCorrelation->GetXaxis()->SetBinLabel(4,"py");
 586   fhCutCorrelation->GetXaxis()->SetBinLabel(5,"pz");
 587   fhCutCorrelation->GetXaxis()->SetBinLabel(6,"eta");
 588   fhCutCorrelation->GetXaxis()->SetBinLabel(7,"y");
 589   fhCutCorrelation->GetXaxis()->SetBinLabel(8,"phi");
 590   fhCutCorrelation->GetXaxis()->SetBinLabel(9,"charge");
 591   fhCutCorrelation->GetXaxis()->SetBinLabel(10,"is charged");
 592
 593   fhCutCorrelation->GetYaxis()->SetBinLabel(1,"p");
 594   fhCutCorrelation->GetYaxis()->SetBinLabel(2,"pt");
 595   fhCutCorrelation->GetYaxis()->SetBinLabel(3,"px");
 596   fhCutCorrelation->GetYaxis()->SetBinLabel(4,"py");
 597   fhCutCorrelation->GetYaxis()->SetBinLabel(5,"pz");
 598   fhCutCorrelation->GetYaxis()->SetBinLabel(6,"eta");
 599   fhCutCorrelation->GetYaxis()->SetBinLabel(7,"y");
 600   fhCutCorrelation->GetYaxis()->SetBinLabel(8,"phi");
 601   fhCutCorrelation->GetYaxis()->SetBinLabel(9,"charge");
 602   fhCutCorrelation->GetYaxis()->SetBinLabel(10,"is charged");
 603
 604
 605   // book QA histograms
 606   Char_t str[256];
 607   for (Int_t i=0; i<kNStepQA; i++) {
 608     if (i==0) sprintf(str," ");
 609     else sprintf(str,"_cut");
 610
 611     fhQA[kCutP][i]      = new  TH1F(Form("%s_momentum%s",GetName(),str),        "",fhNBinsMomentum-1,fhBinLimMomentum);
 612     fhQA[kCutPt][i]     = new  TH1F(Form("%s_transverse_momentum%s",GetName(),str),"",fhNBinsPt-1,fhBinLimPt);
 613     fhQA[kCutPx][i]     = new  TH1F(Form("%s_px%s",GetName(),str),              "",fhNBinsPx-1,fhBinLimPx);
 614     fhQA[kCutPy][i]     = new  TH1F(Form("%s_py%s",GetName(),str),              "",fhNBinsPy-1,fhBinLimPy);
 615     fhQA[kCutPz][i]     = new  TH1F(Form("%s_pz%s",GetName(),str),              "",fhNBinsPz-1,fhBinLimPz);
 616     fhQA[kCutRapidity][i]=new  TH1F(Form("%s_rapidity%s",GetName(),str),        "",fhNBinsRapidity-1,fhBinLimRapidity);
 617     fhQA[kCutEta][i]    = new  TH1F(Form("%s_eta%s",GetName(),str),             "",fhNBinsEta-1,fhBinLimEta);
 618     fhQA[kCutPhi][i]    = new  TH1F(Form("%s_phi%s",GetName(),str),             "",fhNBinsPhi-1,fhBinLimPhi);
 619     fhQA[kCutCharge][i] = new  TH1F(Form("%s_charge%s",GetName(),str),          "",fhNBinsCharge-1,fhBinLimCharge);
 620
 621     fhQA[kCutP][i]      ->SetXTitle("momentum p (GeV/c)");
 622     fhQA[kCutPt][i]     ->SetXTitle("p_{T} (GeV/c)");
 623     fhQA[kCutPx][i]     ->SetXTitle("p_{x} (GeV/c)");
 624     fhQA[kCutPy][i]     ->SetXTitle("p_{y} (GeV/c)");
 625     fhQA[kCutPz][i]     ->SetXTitle("p_{z} (GeV/c)");
 626     fhQA[kCutRapidity][i]->SetXTitle("rapidity y");
 627     fhQA[kCutEta][i]    ->SetXTitle("pseudo rapidity #eta");
 628     fhQA[kCutPhi][i]    ->SetXTitle("azimuth #phi (rad)");
 629     fhQA[kCutCharge][i] ->SetXTitle("charge");
 630   }
 631   for(Int_t i=0; i<kNHist; i++) fhQA[i][1]->SetLineColor(color);
 632 }
 633 //__________________________________________________________________________________
 634 void AliCFTrackKineCuts::FillHistograms(TObject* obj, Bool_t b)
 635 {
 636   //
 637   // fill the QA histograms
 638   //
 639
 640   // cast TObject into VParticle
 641   if (!obj) return;
 642   AliVParticle* particle = dynamic_cast<AliVParticle *>(obj);
 643   if ( !particle ) return;
 644
 645   // b = 0: fill histograms before cuts
 646   // b = 1: fill histograms after cuts
 647   fhQA[kCutP][b]->Fill(particle->P());
 648   fhQA[kCutPt][b]->Fill(particle->Pt());
 649   fhQA[kCutPx][b]->Fill(particle->Px());
 650   fhQA[kCutPy][b]->Fill(particle->Py());
 651   fhQA[kCutPz][b]->Fill(particle->Pz());
 652   fhQA[kCutRapidity][b]->Fill(particle->Y());
 653   fhQA[kCutEta][b]->Fill(particle->Eta());
 654   fhQA[kCutPhi][b]->Fill(particle->Phi());
 655   fhQA[kCutCharge][b]->Fill((float)particle->Charge());
 656
 657   // fill cut statistics and cut correlation histograms with information from the bitmap
 658   if (b) return;
 659
 660   // Number of single cuts in this class
 661   UInt_t ncuts = fBitmap->GetNbits();
 662   for(UInt_t bit=0; bit<ncuts;bit++) {
 663     if (!fBitmap->TestBitNumber(bit)) {
 664       fhCutStatistics->Fill(bit+1);
 665       for (UInt_t bit2=bit; bit2<ncuts;bit2++) {
 666         if (!fBitmap->TestBitNumber(bit2))
 667           fhCutCorrelation->Fill(bit+1,bit2+1);
 668       }
 669     }
 670   }
 671 }
 672 //__________________________________________________________________________________
 673 void AliCFTrackKineCuts::SaveHistograms(const Char_t* dir) {
 674   //
 675   // saves the histograms in a directory (dir)
 676   //
 677   if(!fIsQAOn) return;
 678
 679   if (!dir)
 680     dir = GetName();
 681
 682   gDirectory->mkdir(dir);
 683   gDirectory->cd(dir);
 684
 685   gDirectory->mkdir("before_cuts");
 686   gDirectory->mkdir("after_cuts");
 687
 688   fhCutStatistics->Write();
 689   fhCutCorrelation->Write();
 690
 691   for (Int_t j=0; j<kNStepQA; j++) {
 692     if (j==0)
 693       gDirectory->cd("before_cuts");
 694     else
 695       gDirectory->cd("after_cuts");
 696
 697     for(Int_t i=0; i<kNHist; i++) fhQA[i][j]->Write();
 698
 699     gDirectory->cd("../");
 700   }
 701   gDirectory->cd("../");
 702 }
 703 //__________________________________________________________________________________
 704 void AliCFTrackKineCuts::DrawHistograms(Bool_t drawLogScale)
 705 {
 706   //
 707   // draws some histograms
 708   //
 709   if(!fIsQAOn) return;
 710
 711   // pad margins
 712   Float_t right = 0.03;
 713   Float_t left = 0.175;
 714   Float_t top = 0.03;
 715   Float_t bottom = 0.175;
 716
 717   TCanvas* canvas1 = new TCanvas("Track_QA_Kinematics_1", "Track QA Kinematics 1", 800, 500);
 718   canvas1->Divide(2, 1);
 719
 720   canvas1->cd(1);
 721   fhCutStatistics->SetStats(kFALSE);
 722   fhCutStatistics->LabelsOption("v");
 723   gPad->SetLeftMargin(left);
 724   gPad->SetBottomMargin(0.25);
 725   gPad->SetRightMargin(right);
 726   gPad->SetTopMargin(0.1);
 727   fhCutStatistics->Draw();
 728
 729   canvas1->cd(2);
 730   fhCutCorrelation->SetStats(kFALSE);
 731   fhCutCorrelation->LabelsOption("v");
 732   gPad->SetLeftMargin(0.30);
 733   gPad->SetRightMargin(bottom);
 734   gPad->SetTopMargin(0.1);
 735   gPad->SetBottomMargin(0.25);
 736   fhCutCorrelation->Draw("COLZ");
 737
 738   canvas1->SaveAs(Form("%s.eps", canvas1->GetName()));
 739   canvas1->SaveAs(Form("%s.ps", canvas1->GetName()));
 740
 741   // -----
 742
 743   TCanvas* canvas2 = new TCanvas("Track_QA_Kinematics_2", "Track QA Kinematics 2", 1600, 800);
 744   canvas2->Divide(4, 2);
 745
 746   canvas2->cd(1);
 747   fhQA[kCutP][0]->SetStats(kFALSE);
 748   if(drawLogScale) gPad->SetLogy();
 749   gPad->SetRightMargin(right);
 750   gPad->SetLeftMargin(left);
 751   gPad->SetTopMargin(top);
 752   gPad->SetBottomMargin(bottom);
 753   fhQA[kCutP][0]->Draw();
 754   fhQA[kCutP][1]->Draw("same");
 755
 756   canvas2->cd(2);
 757   fhQA[kCutPt][0]->SetStats(kFALSE);
 758   if(drawLogScale) gPad->SetLogy();
 759   gPad->SetRightMargin(right);
 760   gPad->SetLeftMargin(left);
 761   gPad->SetTopMargin(top);
 762   gPad->SetBottomMargin(bottom);
 763   fhQA[kCutPt][0]->Draw();
 764   fhQA[kCutPt][1]->Draw("same");
 765
 766   canvas2->cd(3);
 767   fhQA[kCutRapidity][0]->SetStats(kFALSE);
 768   if(drawLogScale) gPad->SetLogy();
 769   gPad->SetRightMargin(right);
 770   gPad->SetLeftMargin(left);
 771   gPad->SetTopMargin(top);
 772   gPad->SetBottomMargin(bottom);
 773   fhQA[kCutRapidity][0]->Draw();
 774   fhQA[kCutRapidity][1]->Draw("same");
 775
 776   canvas2->cd(4);
 777   fhQA[kCutEta][0]->SetStats(kFALSE);
 778   if(drawLogScale) gPad->SetLogy();
 779   gPad->SetRightMargin(right);
 780   gPad->SetLeftMargin(left);
 781   gPad->SetTopMargin(top);
 782   gPad->SetBottomMargin(bottom);
 783   fhQA[kCutEta][0]->Draw();
 784   fhQA[kCutEta][1]->Draw("same");
 785
 786   canvas2->cd(5);
 787   fhQA[kCutPx][0]->SetStats(kFALSE);
 788   if(drawLogScale) gPad->SetLogy();
 789   gPad->SetRightMargin(right);
 790   gPad->SetLeftMargin(left);
 791   gPad->SetTopMargin(top);
 792   gPad->SetBottomMargin(bottom);
 793   fhQA[kCutPx][0]->Draw();
 794   fhQA[kCutPx][1]->Draw("same");
 795
 796   canvas2->cd(6);
 797   fhQA[kCutPy][0]->SetStats(kFALSE);
 798   if(drawLogScale) gPad->SetLogy();
 799   gPad->SetRightMargin(right);
 800   gPad->SetLeftMargin(left);
 801   gPad->SetTopMargin(top);
 802   gPad->SetBottomMargin(bottom);
 803   fhQA[kCutPy][0]->Draw();
 804   fhQA[kCutPy][1]->Draw("same");
 805
 806   canvas2->cd(7);
 807   fhQA[kCutPz][0]->SetStats(kFALSE);
 808   if(drawLogScale) gPad->SetLogy();
 809   gPad->SetRightMargin(right);
 810   gPad->SetLeftMargin(left);
 811   gPad->SetTopMargin(top);
 812   gPad->SetBottomMargin(bottom);
 813   fhQA[kCutPz][0]->Draw();
 814   fhQA[kCutPz][1]->Draw("same");
 815
 816   canvas2->SaveAs(Form("%s.eps", canvas2->GetName()));
 817   canvas2->SaveAs(Form("%s.ps", canvas2->GetName()));
 818
 819   // -----
 820
 821   TCanvas* canvas3 = new TCanvas("Track_QA_Kinematics_3", "Track QA Kinematics 3", 800, 400);
 822   canvas3->Divide(2, 1);
 823
 824   canvas3->cd(1);
 825   gPad->SetRightMargin(right);
 826   gPad->SetLeftMargin(left);
 827   gPad->SetTopMargin(top);
 828   gPad->SetBottomMargin(bottom);
 829   fhQA[kCutPhi][0]->SetStats(kFALSE);
 830   fhQA[kCutPhi][0]->Draw();
 831   fhQA[kCutPhi][1]->Draw("same");
 832
 833   canvas3->cd(2);
 834   gPad->SetRightMargin(right);
 835   gPad->SetLeftMargin(left);
 836   gPad->SetTopMargin(top);
 837   gPad->SetBottomMargin(bottom);
 838   fhQA[kCutCharge][0]->SetStats(kFALSE);
 839   fhQA[kCutCharge][0]->Draw();
 840   fhQA[kCutCharge][1]->Draw("same");
 841
 842   canvas3->SaveAs(Form("%s.eps", canvas3->GetName()));
 843   canvas3->SaveAs(Form("%s.ps", canvas3->GetName()));
 844 }
 845 //__________________________________________________________________________________
 846 void AliCFTrackKineCuts::AddQAHistograms(TList *qaList) {
 847   //
 848   // saves the histograms in a TList
 849   //
 850   DefineHistograms();
 851
 852   qaList->Add(fhCutStatistics);
 853   qaList->Add(fhCutCorrelation);
 854
 855   for (Int_t j=0; j<kNStepQA; j++) {
 856     for(Int_t i=0; i<kNHist; i++)
 857         qaList->Add(fhQA[i][j]);
 858   }
 859 }