PWG4/JetTasks/AliAnalysisTaskPWG4PidDetEx.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 #include <TROOT.h>
  17 #include <TSystem.h>
  18 #include <TChain.h>
  19 #include <TTree.h>
  20 #include <TFile.h>
  21 #include <TList.h>
  22 #include <TStyle.h>
  23 #include <TCanvas.h>
  24 #include <TMath.h>
  25 #include <TH1.h>
  26 #include <TH2.h>
  27 #include <TF1.h>
  28 #include <TProfile.h>
  29 #include <TLegend.h>
  30 #include <TDatabasePDG.h>
  31 #include <TParticle.h>
  32
  33 #include "AliAnalysisManager.h"
  34 #include "AliAnalysisFilter.h"
  35 #include "AliESDInputHandler.h"
  36 #include "AliESDEvent.h"
  37 #include "AliESDVertex.h"
  38 #include "AliMCEventHandler.h"
  39 #include "AliMCEvent.h"
  40 #include "AliStack.h"
  41 #include "AliAODInputHandler.h"
  42 #include "AliAODEvent.h"
  43 #include "AliAODVertex.h"
  44 #include "AliAODMCParticle.h"
  45 #include "AliLog.h"
  46
  47 #include "AliAnalysisTaskPWG4PidDetEx.h"
  48
  49 // STL includes
  50 #include <iostream>
  51 using namespace std;
  52
  53 //
  54 // Analysis class example for PID using detector signals.
  55 // Works on ESD and AOD; has a flag for MC analysis
  56 //
  57 //    Alexandru.Dobrin@hep.lu.se
  58 //    Peter.Christiansen@hep.lu.se
  59 //
  60
  61 ClassImp(AliAnalysisTaskPWG4PidDetEx)
  62
  63 const Double_t AliAnalysisTaskPWG4PidDetEx::fgkCtau = 370;                //  distance for kaon decay
  64 const Double_t AliAnalysisTaskPWG4PidDetEx::fgkPionMass = TDatabasePDG::Instance()->GetParticle(211)->Mass();
  65 const Double_t AliAnalysisTaskPWG4PidDetEx::fgkKaonMass = TDatabasePDG::Instance()->GetParticle(321)->Mass();
  66 const Double_t AliAnalysisTaskPWG4PidDetEx::fgkProtonMass = TDatabasePDG::Instance()->GetParticle(2212)->Mass();
  67
  68 //_____________________________________________________________________________
  69 AliAnalysisTaskPWG4PidDetEx::AliAnalysisTaskPWG4PidDetEx():
  70   AliAnalysisTaskSE(),
  71   fESD(0),
  72   fAOD(0),
  73   fListOfHists(0),
  74   fEtaCut(0.9),
  75   fPtCut(0.5),
  76   fXbins(20),
  77   fXmin(0.),
  78   fTOFCutP(2.),
  79   fTrackFilter(0x0),
  80   fAnalysisMC(kTRUE),
  81   fAnalysisType("ESD"),
  82   fTriggerMode(kMB2),
  83   fEvents(0), fEffTot(0), fEffPID(0), fAccP(0), fAccPt(0), fKaonDecayCorr(0),
  84   fdNdPt(0), fMassAll(0),
  85   fdNdPtPion(0), fMassPion(0), fdEdxTPCPion(0), fbgTPCPion(0),
  86   fdNdPtKaon(0), fMassKaon(0), fdEdxTPCKaon(0), fbgTPCKaon(0),
  87   fdNdPtProton(0), fMassProton(0), fdEdxTPCProton(0), fbgTPCProton(0),
  88   fdNdPtMC(0), fdNdPtMCPion(0), fdNdPtMCKaon(0), fdNdPtMCProton(0)
  89 {
  90   // Default constructor (should not be used)
  91 }
  92
  93 //______________________________________________________________________________
  94 AliAnalysisTaskPWG4PidDetEx::AliAnalysisTaskPWG4PidDetEx(const char *name):
  95   AliAnalysisTaskSE(name),
  96   fESD(0),
  97   fAOD(0),
  98   fListOfHists(0),
  99   fEtaCut(0.9),
 100   fPtCut(0.5),
 101   fXbins(20),
 102   fXmin(0.),
 103   fTOFCutP(2.),
 104   fTrackFilter(0x0),
 105   fAnalysisMC(kTRUE),
 106   fAnalysisType("ESD"),
 107   fTriggerMode(kMB2),
 108   fEvents(0), fEffTot(0), fEffPID(0), fAccP(0), fAccPt(0), fKaonDecayCorr(0),
 109   fdNdPt(0), fMassAll(0),
 110   fdNdPtPion(0), fMassPion(0), fdEdxTPCPion(0), fbgTPCPion(0),
 111   fdNdPtKaon(0), fMassKaon(0), fdEdxTPCKaon(0), fbgTPCKaon(0),
 112   fdNdPtProton(0), fMassProton(0), fdEdxTPCProton(0), fbgTPCProton(0),
 113   fdNdPtMC(0), fdNdPtMCPion(0), fdNdPtMCKaon(0), fdNdPtMCProton(0)
 114 {
 115   // Normal constructor
 116   // Input slot #0 works with a TChain
 117   DefineInput(0, TChain::Class());
 118   // Output slot #0 writes into a TList
 119   DefineOutput(0, TList::Class());
 120
 121 }
 122
 123 //_____________________________________________________________________________
 124 AliAnalysisTaskPWG4PidDetEx::~AliAnalysisTaskPWG4PidDetEx()
 125 {
 126   // Destructor
 127   // histograms are in the output list and deleted when the output
 128   // list is deleted by the TSelector dtor
 129   if (fListOfHists) {
 130     delete fListOfHists;
 131     fListOfHists = 0;
 132   }
 133 }
 134
 135 //______________________________________________________________________________
 136 void AliAnalysisTaskPWG4PidDetEx::ConnectInputData(Option_t *)
 137 {
 138   // Connect AOD here
 139   // Called once
 140   if (fDebug > 1)  AliInfo("ConnectInputData() \n");
 141
 142   TTree* tree = dynamic_cast<TTree*> (GetInputData(0));
 143   if (!tree) {
 144     Printf("ERROR: Could not read chain from input slot 0");
 145   }
 146   else {
 147     if(fAnalysisType == "ESD") {
 148       AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 149       if (!esdH) {
 150         Printf("ERROR: Could not get ESDInputHandler");
 151       } else
 152         fESD = esdH->GetEvent();
 153     }
 154     else if(fAnalysisType == "AOD") {
 155       AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 156       if (!aodH) {
 157         Printf("ERROR: Could not get AODInputHandler");
 158       } else
 159         fAOD = aodH->GetEvent();
 160     }
 161   }
 162
 163 }
 164
 165 //______________________________________________________________________________
 166 void AliAnalysisTaskPWG4PidDetEx::CreateOutputObjects()
 167 {
 168   // Create histograms
 169   // Called once
 170   if (fDebug > 1) AliInfo("CreateOutPutData() \n");
 171
 172   OpenFile(0);
 173   fListOfHists = new TList();
 174
 175   fEvents = new TH1I("fEvents","Number of analyzed events; Events; Counts", 1, 0, 1);
 176   fListOfHists->Add(fEvents);
 177
 178   fEffTot = new TH1F ("fEffTot","Efficiency; p_{T} [GeV/c]; Counts", fXbins, fXmin, fTOFCutP);
 179   fEffTot->Sumw2();
 180   fListOfHists->Add(fEffTot);
 181
 182   fEffPID = new TH1F ("fEffPID","Efficiency; p_{T} [GeV/c]; Counts", fXbins, fXmin, fTOFCutP);
 183   fEffPID->Sumw2();
 184   fListOfHists->Add(fEffPID);
 185
 186   fAccP = new TH1F ("fAccP","Acceptance; p_{T} [GeV/c]; Counts", fXbins, fXmin, fTOFCutP);
 187   fAccP->Sumw2();
 188   fListOfHists->Add(fAccP);
 189
 190   fAccPt = new TH1F ("fAccPt","Acceptance; p_{T} [GeV/c]; Counts", fXbins, fXmin, fTOFCutP);
 191   fAccPt->Sumw2();
 192   fListOfHists->Add(fAccPt);
 193
 194   fKaonDecayCorr = new TProfile("fKaonDecayCorr","Kaon decay correction vs p_{T}; p_{T} [GeV/c]; Kaon decay correction", fXbins, fXmin, fTOFCutP);
 195   fListOfHists->Add(fKaonDecayCorr);
 196
 197   fdNdPt = new TH1F("fdNdPt","p_{T} distribution; p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", 100 , 0, 10);
 198   fdNdPt->Sumw2();
 199   fListOfHists->Add(fdNdPt);
 200
 201   fMassAll = new TH2F("fMassAll","Mass^{2} vs momentum (ToF); p [GeV/c]; M^{2} [GeV^{2}/c^{4}]", 100, -5, 5, 100, -0.2, 1.2);
 202   fListOfHists->Add(fMassAll);
 203
 204   //Pion
 205   fdNdPtPion = new TH1F("fdNdPtPion","p_{T} distribution (Pions); p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 206   fdNdPtPion->Sumw2();
 207   fListOfHists->Add(fdNdPtPion);
 208
 209   fMassPion = new TH2F("fMassPion","Mass squared for pions after cuts vs pmean; p [GeV/c]; Mass^{2} [GeV^{2}/c^{4}]", 100, -5, 5, 100, -0.2, 1.2);
 210   fListOfHists->Add(fMassPion);
 211
 212   fdEdxTPCPion = new TH2F("fdEdxTPCPion","Energy loss vs momentum; p [GeV/c]; dE/dx [a. u.]", 40, -2, 2, 100, 0, 200);
 213   fListOfHists->Add(fdEdxTPCPion);
 214
 215   fbgTPCPion = new TH2F("fbgTPCPion", "Energy loss vs #beta#gamma (Pions);#beta#gamma; dE/dx [a. u.]", 100, 0, 15, 100, 0, 200);
 216   fListOfHists->Add(fbgTPCPion);
 217
 218   //Kaon
 219   fdNdPtKaon = new TH1F("fdNdPtKaon","p_{T} distribution (Kaons);p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 220   fdNdPtKaon->Sumw2();
 221   fListOfHists->Add(fdNdPtKaon);
 222
 223   fMassKaon = new TH2F("fMassKaon","Mass squared for kaons after cuts vs pmean; p [GeV/c]; Mass^{2} [GeV^{2}/c^{4}]", 100, -5, 5, 100, -0.2, 1.2);
 224   fListOfHists->Add(fMassKaon);
 225
 226   fdEdxTPCKaon = new TH2F("fdEdxTPCKaon","Energy loss vs momentum; p [GeV/c]; dE/dx [a. u.]", 40, -2, 2, 100, 0, 200);
 227   fListOfHists->Add(fdEdxTPCKaon);
 228
 229   fbgTPCKaon = new TH2F("fbgTPCKaon", "Energy loss vs #beta#gamma (Kaons);#beta#gamma; dE/dx [a. u.]", 100, 0, 15, 100, 0, 200);
 230   fListOfHists->Add(fbgTPCKaon);
 231
 232   //Proton
 233   fdNdPtProton = new TH1F("fdNdPtProton","p_{T} distribution (Protons);p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 234   fdNdPtProton->Sumw2();
 235   fListOfHists->Add(fdNdPtProton);
 236
 237   fMassProton = new TH2F("fMassProton","Mass squared for protons after cuts vs pmean; p [GeV/c]; Mass^{2} [GeV^{2}/c^{4}]", 100, -5, 5, 100, -0.2, 1.2);
 238   fListOfHists->Add(fMassProton);
 239
 240   fdEdxTPCProton = new TH2F("fdEdxTPCProton","Energy loss vs momentum; p [GeV/c]; dE/dx [a. u.]", 40, -2, 2, 100, 0, 200);
 241   fListOfHists->Add(fdEdxTPCProton);
 242
 243   fbgTPCProton = new TH2F("fbgTPCProton", "Energy loss vs #beta#gamma (Protons);#beta#gamma; dE/dx [a. u.]", 100, 0, 15, 100, 0, 200);
 244   fListOfHists->Add(fbgTPCProton);
 245
 246
 247   //MC
 248   if(fAnalysisMC){
 249     fdNdPtMC = new TH1F("fdNdPtMC","p_{T} distribution;p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", 100, 0, 10);
 250     fdNdPtMC->SetLineColor(2);
 251     fdNdPtMC->Sumw2();
 252     fListOfHists->Add(fdNdPtMC);
 253
 254     fdNdPtMCPion = new TH1F("fdNdPtMCPion","p_{T} distribution;p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 255     fdNdPtMCPion->SetLineColor(2);
 256     fdNdPtMCPion->Sumw2();
 257     fListOfHists->Add(fdNdPtMCPion);
 258
 259     fdNdPtMCKaon = new TH1F("fdNdPtMCKaon","p_{T} distribution;p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 260     fdNdPtMCKaon->SetLineColor(2);
 261     fdNdPtMCKaon->Sumw2();
 262     fListOfHists->Add(fdNdPtMCKaon);
 263
 264     fdNdPtMCProton = new TH1F("fdNdPtMCProton","p_{T} distribution;p_{T} [GeV/c]; #frac{1}{2#pip_{T}} #frac{1}{N_{ev}} #frac{dN}{dp_{T}}", fXbins, fXmin, fTOFCutP);
 265     fdNdPtMCProton->SetLineColor(2);
 266     fdNdPtMCProton->Sumw2();
 267     fListOfHists->Add(fdNdPtMCProton);
 268   }
 269
 270 }
 271
 272 //______________________________________________________________________________
 273 void AliAnalysisTaskPWG4PidDetEx::Exec(Option_t *)
 274 {
 275   // Main loop
 276   // Called for each event
 277   if (fDebug > 1) AliInfo("Exec() \n" );
 278
 279   if(fAnalysisType == "ESD") {
 280     if (!fESD) {
 281       Printf("ERROR: fESD not available");
 282       return;
 283     }
 284     if(IsEventTriggered(fESD, fTriggerMode)) {
 285       Printf("PWG4 PID ESD analysis");
 286       AnalyzeESD(fESD);
 287     }//triggered event
 288   }//ESD analysis
 289
 290   else if(fAnalysisType == "AOD") {
 291     if (!fAOD) {
 292       Printf("ERROR: fAOD not available");
 293       return;
 294     }
 295     if(IsEventTriggered(fAOD, fTriggerMode)) {
 296       Printf("PWG4 PID AOD analysis");
 297       AnalyzeAOD(fAOD);
 298     }//triggered event
 299   }//AOD analysis
 300
 301   // Post output data.
 302   PostData(0, fListOfHists);
 303 }
 304
 305 //________________________________________________________________________
 306 void AliAnalysisTaskPWG4PidDetEx::AnalyzeESD(AliESDEvent* esd)
 307 {
 308   // Get vertex
 309   const AliESDVertex* primaryVertex = esd->GetPrimaryVertex();
 310   const Double_t vertexResZ = primaryVertex->GetZRes();
 311
 312   // Select only events with a reconstructed vertex
 313   if(vertexResZ<5.0) {
 314     const Int_t nESDTracks = esd->GetNumberOfTracks();
 315     for(Int_t i = 0; i < nESDTracks; i++) {
 316       AliESDtrack* trackESD = esd->GetTrack(i);
 317
 318       //Cuts
 319       UInt_t selectInfo = 0;
 320       if (fTrackFilter) {
 321         selectInfo = fTrackFilter->IsSelected(trackESD);
 322         if (!selectInfo) continue;
 323       }
 324
 325       if ((trackESD->Pt() < fPtCut) || (TMath::Abs(trackESD->Eta()) > fEtaCut ))
 326         continue;
 327
 328       //Corrections
 329       fEffTot->Fill(trackESD->Pt());
 330       if (trackESD->GetTOFsignal() !=0)
 331         fEffPID->Fill(trackESD->Pt());
 332
 333       if (trackESD->P() < fTOFCutP) fAccP->Fill(trackESD->Pt());
 334       if (trackESD->Pt() < fTOFCutP) fAccPt->Fill(trackESD->Pt());
 335
 336       //Analysis
 337       fdNdPt->Fill(trackESD->Pt(), 1.0/trackESD->Pt());
 338
 339       //TOF
 340       if ((trackESD->GetIntegratedLength() == 0) || (trackESD->GetTOFsignal() == 0))
 341         continue;
 342
 343       fMassAll->Fill(trackESD->Charge()*trackESD->P(), MassSquared(trackESD));
 344
 345       if ((MassSquared(trackESD) < 0.15) && (MassSquared(trackESD) > -0.15) && (trackESD->P() < fTOFCutP)){
 346         fdNdPtPion->Fill(trackESD->Pt(), 1.0/trackESD->Pt());
 347         fMassPion->Fill(trackESD->Charge()*trackESD->P(), MassSquared(trackESD));
 348         fdEdxTPCPion->Fill(trackESD->Charge()*trackESD->P(),trackESD->GetTPCsignal());
 349         fbgTPCPion->Fill(trackESD->P()/fgkPionMass,trackESD->GetTPCsignal());
 350       }
 351
 352       if ((MassSquared(trackESD) > 0.15) && (MassSquared(trackESD) < 0.45) && (trackESD->P() < fTOFCutP)){
 353         fdNdPtKaon->Fill(trackESD->Pt(), 1.0/trackESD->Pt());
 354         fMassKaon->Fill(trackESD->Charge()*trackESD->P(),  MassSquared(trackESD));
 355         fdEdxTPCKaon->Fill(trackESD->Charge()*trackESD->P(), trackESD->GetTPCsignal());
 356         fbgTPCKaon->Fill(trackESD->P()/fgkKaonMass, trackESD->GetTPCsignal());
 357         //Kaon decay correction
 358         fKaonDecayCorr->Fill(trackESD->Pt(), TMath::Exp(KaonDecay(trackESD)));
 359       }
 360
 361       if ((MassSquared(trackESD) > 0.75) && (MassSquared(trackESD) < 1.05) && (trackESD->P() < fTOFCutP)){
 362         fdNdPtProton->Fill(trackESD->Pt(), 1.0/trackESD->Pt());
 363         fMassProton->Fill(trackESD->Charge()*trackESD->P(), MassSquared(trackESD));
 364         fdEdxTPCProton->Fill(trackESD->Charge()*trackESD->P(),trackESD->GetTPCsignal());
 365         fbgTPCProton->Fill(trackESD->P()/fgkProtonMass,trackESD->GetTPCsignal());
 366       }
 367     }//ESD track loop
 368
 369     //MC
 370     if(fAnalysisMC){
 371       AliMCEventHandler* mcHandler = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
 372       if (!mcHandler) {
 373         Printf("ERROR: Could not retrieve MC event handler");
 374         return;
 375       }
 376
 377       AliMCEvent* mcEvent = mcHandler->MCEvent();
 378       if (!mcEvent) {
 379         Printf("ERROR: Could not retrieve MC event");
 380         return;
 381       }
 382
 383       AliStack* mcStack = mcEvent->Stack();
 384       if (!mcStack) {
 385         Printf("ERROR: Could not retrieve MC stack");
 386         return;
 387       }
 388
 389       const Int_t nTracksMC = mcStack->GetNtrack();
 390       for (Int_t iTracks = 0; iTracks < nTracksMC; iTracks++) {
 391         //Cuts
 392         if(!(mcStack->IsPhysicalPrimary(iTracks)))
 393           continue;
 394
 395         TParticle* mcTrack = mcStack->Particle(iTracks);
 396
 397         Double_t charge = mcTrack->GetPDG()->Charge();
 398         if (charge == 0)
 399           continue;
 400
 401         if ((mcTrack->Pt() < fPtCut) || (TMath::Abs(mcTrack->Eta()) > fEtaCut ))
 402           continue;
 403
 404         //Analysis
 405         fdNdPtMC->Fill(mcTrack->Pt(), 1.0/mcTrack->Pt());
 406
 407         if ((mcTrack->GetPdgCode() == 211) || (mcTrack->GetPdgCode() == -211))
 408           fdNdPtMCPion->Fill(mcTrack->Pt(),1.0/mcTrack->Pt());
 409
 410         if ((mcTrack->GetPdgCode() == 321) || (mcTrack->GetPdgCode() == -321))
 411           fdNdPtMCKaon->Fill(mcTrack->Pt(),1.0/mcTrack->Pt());
 412
 413         if ((mcTrack->GetPdgCode() == 2212) || (mcTrack->GetPdgCode() == -2212))
 414           fdNdPtMCProton->Fill(mcTrack->Pt(),1.0/mcTrack->Pt());
 415       }//MC track loop
 416     }//if MC
 417     fEvents->Fill(0);
 418   }//if vertex
 419
 420 }
 421
 422 //________________________________________________________________________
 423 void AliAnalysisTaskPWG4PidDetEx::AnalyzeAOD(AliAODEvent* aod)
 424 {
 425   // Get vertex
 426   AliAODVertex* primaryVertex = aod->GetPrimaryVertex();
 427   const Double_t vertexResZ = TMath::Sqrt(primaryVertex->RotatedCovMatrixZZ());
 428
 429   // Select only events with a reconstructed vertex
 430   if (vertexResZ < 5) {
 431     //AOD
 432     Int_t nGoodTracks = aod->GetNumberOfTracks();
 433
 434     for(Int_t iTracks = 0; iTracks < nGoodTracks; iTracks++) {
 435       AliAODTrack* trackAOD = aod->GetTrack(iTracks);
 436       //Cuts
 437       if (!(trackAOD->IsPrimaryCandidate()))
 438         continue;
 439
 440       if ((trackAOD->Pt() < fPtCut) || (TMath::Abs(trackAOD->Eta()) > fEtaCut ))
 441         continue;
 442
 443       //Corrections
 444       fEffTot->Fill(trackAOD->Pt());
 445       if (trackAOD->GetDetPid()->GetTOFsignal() !=0 )
 446         fEffPID->Fill(trackAOD->Pt());
 447
 448       if (trackAOD->P() < fTOFCutP) fAccP->Fill(trackAOD->Pt());
 449       if (trackAOD->Pt() < fTOFCutP) fAccPt->Fill(trackAOD->Pt());
 450
 451       //Analysis
 452       fdNdPt->Fill(trackAOD->Pt(), 1.0/trackAOD->Pt());
 453
 454       //TOF
 455       if ((IntegratedLength(trackAOD) == 0) || (trackAOD->GetDetPid()->GetTOFsignal() == 0))
 456         continue;
 457
 458       fMassAll->Fill(trackAOD->Charge()*trackAOD->P(), MassSquared(trackAOD));
 459
 460       if ((MassSquared(trackAOD) < 0.15) && (MassSquared(trackAOD) > -0.15) && (trackAOD->P() < fTOFCutP)){
 461         fdNdPtPion->Fill(trackAOD->Pt(), 1.0/trackAOD->Pt());
 462         fMassPion->Fill(trackAOD->Charge()*trackAOD->P(), MassSquared(trackAOD));
 463         fdEdxTPCPion->Fill(trackAOD->Charge()*trackAOD->P(),trackAOD->GetDetPid()->GetTPCsignal());
 464         fbgTPCPion->Fill(trackAOD->P()/fgkPionMass,trackAOD->GetDetPid()->GetTPCsignal());
 465       }
 466
 467       if ((MassSquared(trackAOD) > 0.15) && (MassSquared(trackAOD) < 0.45) && (trackAOD->P() < fTOFCutP)){
 468         fdNdPtKaon->Fill(trackAOD->Pt(), 1.0/trackAOD->Pt());
 469         fMassKaon->Fill(trackAOD->Charge()*trackAOD->P(), MassSquared(trackAOD));
 470         fdEdxTPCKaon->Fill(trackAOD->Charge()*trackAOD->P(),trackAOD->GetDetPid()->GetTPCsignal());
 471         fbgTPCKaon->Fill(trackAOD->P()/fgkKaonMass,trackAOD->GetDetPid()->GetTPCsignal());
 472         //Kaon decay correction
 473         fKaonDecayCorr->Fill(trackAOD->Pt(), TMath::Exp(KaonDecay(trackAOD)));
 474       }
 475
 476       if ((MassSquared(trackAOD) > 0.75) && (MassSquared(trackAOD) < 1.05) && (trackAOD->P() < fTOFCutP)){
 477         fdNdPtProton->Fill(trackAOD->Pt(), 1.0/trackAOD->Pt());
 478         fMassProton->Fill(trackAOD->Charge()*trackAOD->P(), MassSquared(trackAOD));
 479         fdEdxTPCProton->Fill(trackAOD->Charge()*trackAOD->P(),trackAOD->GetDetPid()->GetTPCsignal());
 480         fbgTPCProton->Fill(trackAOD->P()/fgkProtonMass,trackAOD->GetDetPid()->GetTPCsignal());
 481       }
 482     }//AOD track loop
 483
 484     //MC
 485     if(fAnalysisMC){
 486       TClonesArray* farray = (TClonesArray*)aod->FindListObject("mcparticles");
 487       Int_t ntrks = farray->GetEntries();
 488       for(Int_t i =0 ; i < ntrks; i++){
 489         AliAODMCParticle* trk = (AliAODMCParticle*)farray->At(i);
 490         //Cuts
 491         if (!(trk->IsPhysicalPrimary()))
 492           continue;
 493
 494         if (trk->Charge() == 0)
 495           continue;
 496
 497         if ((trk->Pt() < fPtCut) || (TMath::Abs(trk->Eta()) > fEtaCut ))
 498           continue;
 499
 500         //Analysis
 501         fdNdPtMC->Fill(trk->Pt(), 1.0/trk->Pt());
 502
 503         if ((trk->GetPdgCode() == 211) || (trk->GetPdgCode() == -211))
 504           fdNdPtMCPion->Fill(trk->Pt(),1.0/trk->Pt());
 505
 506         if ((trk->GetPdgCode() == 321) || (trk->GetPdgCode() == -321))
 507           fdNdPtMCKaon->Fill(trk->Pt(),1.0/trk->Pt());
 508
 509         if ((trk->GetPdgCode() == 2212) || (trk->GetPdgCode() == -2212))
 510           fdNdPtMCProton->Fill(trk->Pt(),1.0/trk->Pt());
 511       }//MC track loop
 512     }//if MC
 513     fEvents->Fill(0);
 514   }//if vertex resolution
 515
 516 }
 517
 518 //________________________________________________________________________
 519 Bool_t AliAnalysisTaskPWG4PidDetEx::IsEventTriggered(AliVEvent* ev, TriggerMode trigger)
 520 {
 521   //adapted from PWG2 (AliAnalysisTaskProton)
 522
 523   ULong64_t triggerMask = ev->GetTriggerMask();
 524
 525   // definitions from p-p.cfg
 526   ULong64_t spdFO = (1 << 14);
 527   ULong64_t v0left = (1 << 11);
 528   ULong64_t v0right = (1 << 12);
 529
 530   switch (trigger) {
 531   case kMB1:
 532     if (triggerMask & spdFO || ((triggerMask & v0left) || (triggerMask & v0right)))
 533       return kTRUE;
 534     break;
 535
 536   case kMB2:
 537     if (triggerMask & spdFO && ((triggerMask & v0left) || (triggerMask & v0right)))
 538       return kTRUE;
 539     break;
 540
 541   case kSPDFASTOR:
 542     if (triggerMask & spdFO)
 543       return kTRUE;
 544     break;
 545
 546   }//switch
 547
 548   return kFALSE;
 549 }
 550
 551 //_____________________________________________________________________________
 552 Double_t AliAnalysisTaskPWG4PidDetEx::IntegratedLength(AliVTrack* track) const
 553 {
 554   Double_t intTime [5];
 555   for (Int_t i = 0; i < 5; i++) intTime[i] = -100.;
 556   Double_t timeElectron = 0, intLength = 0;
 557
 558   AliAODTrack* trackAOD = (AliAODTrack*)track;
 559   trackAOD->GetDetPid()->GetIntegratedTimes(intTime);
 560   timeElectron = intTime[0];
 561   intLength = TMath::C()*timeElectron;
 562
 563   return intLength;
 564 }
 565
 566 //_____________________________________________________________________________
 567 Double_t AliAnalysisTaskPWG4PidDetEx::MassSquared(AliVTrack* track) const
 568 {
 569   Double_t beta = -10, mass = -10;
 570
 571   if(fAnalysisType == "ESD"){
 572     AliESDtrack* trackESD = (AliESDtrack*)track;
 573     beta = trackESD->GetIntegratedLength()/trackESD->GetTOFsignal()/TMath::C();
 574     mass = trackESD->P()*trackESD->P()*(1./(beta*beta) - 1.0);
 575   }
 576
 577   if(fAnalysisType == "AOD"){
 578     AliAODTrack* trackAOD = (AliAODTrack*)track;
 579     beta =IntegratedLength(trackAOD)/trackAOD->GetDetPid()->GetTOFsignal()/TMath::C();
 580     mass = trackAOD->P()*trackAOD->P()*(1./(beta*beta) - 1.0);
 581   }
 582
 583   return mass;
 584 }
 585
 586 //_____________________________________________________________________________
 587 Double_t AliAnalysisTaskPWG4PidDetEx::KaonDecay(AliVTrack* track) const
 588 {
 589   Double_t decay = -10;
 590
 591   if(fAnalysisType == "ESD"){
 592     AliESDtrack* trackESD = (AliESDtrack*)track;
 593     decay = trackESD->GetIntegratedLength()*fgkKaonMass/fgkCtau/trackESD->P();
 594   }
 595
 596   if (fAnalysisType == "AOD"){
 597     AliAODTrack* trackAOD = (AliAODTrack*)track;
 598     decay = IntegratedLength(trackAOD)*fgkKaonMass/fgkCtau/trackAOD->P();
 599   }
 600
 601   return decay;
 602 }
 603
 604 //_____________________________________________________________________________
 605 void AliAnalysisTaskPWG4PidDetEx::Terminate(Option_t *)
 606 {
 607   // Terminate loop
 608   if (fDebug > 1) Printf("Terminate()");
 609
 610   //
 611   // The followig code has now been moved to drawPid.C
 612   //
 613
 614 //   fListOfHists = dynamic_cast<TList*> (GetOutputData(0));
 615 //   if (!fListOfHists) {
 616 //     Printf("ERROR: fListOfHists not available");
 617 //     return;
 618 //   }
 619
 620 //   TH1I* hevents = dynamic_cast<TH1I*> (fListOfHists->FindObject("fEvents"));
 621 //   Int_t nEvents = (Int_t) hevents->GetBinContent(1);
 622
 623 //   const Float_t normalization = 2.0*fEtaCut*2.0*TMath::Pi();
 624
 625 //   //-----------------
 626 //   TCanvas* c1 = new TCanvas("c1", "c1");
 627 //   c1->cd();
 628
 629 //   TH2F* hMassAll =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fMassAll"));
 630 //   hMassAll->SetLineColor(1);
 631 //   hMassAll->SetMarkerColor(1);
 632 //   hMassAll->DrawCopy();
 633
 634 //   TH2F* hMassPion =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fMassPion"));
 635 //   hMassPion->SetLineColor(2);
 636 //   hMassPion->SetMarkerColor(2);
 637 //   hMassPion->SetMarkerStyle(7);
 638 //   hMassPion->DrawCopy("same");
 639
 640 //   TH2F* hMassKaon =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fMassKaon"));
 641 //   hMassKaon->SetLineColor(3);
 642 //   hMassKaon->SetMarkerColor(3);
 643 //   hMassKaon->SetMarkerStyle(7);
 644 //   hMassKaon->DrawCopy("same");
 645
 646 //   TH2F* hMassProton =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fMassProton"));
 647 //   hMassProton->SetLineColor(4);
 648 //   hMassProton->SetMarkerColor(4);
 649 //   hMassProton->SetMarkerStyle(7);
 650 //   hMassProton->DrawCopy("same");
 651
 652 //   TLegend* legend1 = new TLegend(0.8, 0.8, 1, 1);
 653 //   legend1->SetBorderSize(0);
 654 //   legend1->SetFillColor(0);
 655 //   legend1->AddEntry(hMassAll, "All","LP");
 656 //   legend1->AddEntry(hMassPion, "Pions","LP");
 657 //   legend1->AddEntry(hMassKaon, "Kaons","LP");
 658 //   legend1->AddEntry(hMassProton, "Protons","LP");
 659 //   legend1->Draw();
 660
 661 //   c1->Update();
 662
 663 //   //-----------------
 664 //   TCanvas* c2 = new TCanvas("c2", "c2");
 665 //   c2->cd();
 666
 667 //   TH2F* hdEdxTPCPion =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fdEdxTPCPion"));
 668 //   hdEdxTPCPion->SetTitle("dE/dx vs p (TPC)");
 669 //   hdEdxTPCPion->SetLineColor(2);
 670 //   hdEdxTPCPion->SetMarkerColor(2);
 671 //   hdEdxTPCPion->SetMarkerStyle(7);
 672 //   hdEdxTPCPion->DrawCopy();
 673
 674 //   TH2F* hdEdxTPCKaon =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fdEdxTPCKaon"));
 675 //   hdEdxTPCKaon->SetLineColor(3);
 676 //   hdEdxTPCKaon->SetMarkerColor(3);
 677 //   hdEdxTPCKaon->SetMarkerStyle(7);
 678 //   hdEdxTPCKaon->DrawCopy("same");
 679
 680 //   TH2F* hdEdxTPCProton =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fdEdxTPCProton"));
 681 //   hdEdxTPCProton->SetLineColor(4);
 682 //   hdEdxTPCProton->SetMarkerColor(4);
 683 //   hdEdxTPCProton->SetMarkerStyle(7);
 684 //   hdEdxTPCProton->DrawCopy("same");
 685
 686 //   TLegend* legend2 = new TLegend(0.66, 0.66, 0.88, 0.88);
 687 //   legend2->SetBorderSize(0);
 688 //   legend2->SetFillColor(0);
 689 //   legend2->AddEntry(hdEdxTPCPion, "Pions","LP");
 690 //   legend2->AddEntry(hdEdxTPCKaon, "Kaons","LP");
 691 //   legend2->AddEntry(hdEdxTPCProton, "Protons","LP");
 692 //   legend2->Draw();
 693
 694 //   c2->Update();
 695
 696 //   //-----------------
 697 //   TCanvas* c3 = new TCanvas("c3", "c3");
 698 //   c3->cd();
 699
 700 //   TH2F* hdEdxTPCbgPion =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fbgTPCPion"));
 701 //   hdEdxTPCbgPion->SetTitle("dE/dx vs #beta#gamma (TPC)");
 702 //   hdEdxTPCbgPion->SetLineColor(2);
 703 //   hdEdxTPCbgPion->SetMarkerColor(2);
 704 //   hdEdxTPCbgPion->SetMarkerStyle(7);
 705 //   hdEdxTPCbgPion->DrawCopy();
 706
 707 //   TH2F* hdEdxTPCbgKaon =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fbgTPCKaon"));
 708 //   hdEdxTPCbgKaon->SetLineColor(3);
 709 //   hdEdxTPCbgKaon->SetMarkerColor(3);
 710 //   hdEdxTPCbgKaon->SetMarkerStyle(7);
 711 //   hdEdxTPCbgKaon->DrawCopy("same");
 712
 713 //   TH2F* hdEdxTPCbgProton =  dynamic_cast<TH2F*> (fListOfHists->FindObject("fbgTPCProton"));
 714 //   hdEdxTPCbgProton->SetLineColor(4);
 715 //   hdEdxTPCbgProton->SetMarkerColor(4);
 716 //   hdEdxTPCbgProton->SetMarkerStyle(7);
 717 //   hdEdxTPCbgProton->DrawCopy("same");
 718
 719 //   TLegend* legend3 = new TLegend(0.66, 0.66, 0.88, 0.88);
 720 //   legend3->SetBorderSize(0);
 721 //   legend3->SetFillColor(0);
 722 //   legend3->AddEntry(hdEdxTPCbgPion, "Pions","LP");
 723 //   legend3->AddEntry(hdEdxTPCbgKaon, "Kaons","LP");
 724 //   legend3->AddEntry(hdEdxTPCbgProton, "Protons","LP");
 725 //   legend3->Draw();
 726
 727 //   c3->Update();
 728
 729 //   //-----------------
 730 //   TCanvas* c4 = new TCanvas("c4", "c4", 100, 100, 500, 900);
 731 //   c4->Divide(1,3);
 732
 733 //   c4->cd(1);
 734 //   TH1F* hAccepatncePt = dynamic_cast<TH1F*> (fListOfHists->FindObject("fAccPt"));
 735 //   TH1F* hAcceptanceP = dynamic_cast<TH1F*> (fListOfHists->FindObject("fAccP"));
 736 //   hAccepatncePt->Divide(hAcceptanceP);
 737 //   hAccepatncePt->SetTitle("Acceptance correction");
 738 //   hAccepatncePt->GetYaxis()->SetTitle("Acceptance correction");
 739 //   hAccepatncePt->DrawCopy();
 740
 741 //   c4->cd(2);
 742 //   TH1F* hEfficiencyPID = dynamic_cast<TH1F*> (fListOfHists->FindObject("fEffPID"));
 743 //   TH1F* hEfficiencyTot = dynamic_cast<TH1F*> (fListOfHists->FindObject("fEffTot"));
 744 //   hEfficiencyPID->Divide(hEfficiencyTot);
 745 //   hEfficiencyPID->SetTitle("Efficiency correction");
 746 //   hEfficiencyPID->GetYaxis()->SetTitle("Efficiency correction");
 747 //   hEfficiencyPID->DrawCopy();
 748
 749 //   c4->cd(3);
 750 //   TProfile* hKDecayCorr = dynamic_cast<TProfile*> (fListOfHists->FindObject("fKaonDecayCorr"));
 751 //   hKDecayCorr->SetTitle("Kaon decay correction");
 752 //   hKDecayCorr->GetYaxis()->SetTitle("Kaon decay correction");
 753 //   hKDecayCorr->GetXaxis()->SetTitle(" p_{T} [GeV/c]");
 754 //   hKDecayCorr->DrawCopy();
 755
 756 //   c4->Update();
 757
 758 //   //---------------------
 759 //   TCanvas* c5 = new TCanvas("c5", "c5", 100, 100, 600, 900);
 760 //   c5->Divide(1,2);
 761
 762 //   c5->cd(1);
 763 //   TH1F* hPtPionNoCorr = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtPion"));
 764 //   hPtPionNoCorr->Scale(1.0/nEvents/normalization/hPtPionNoCorr->GetBinWidth(1));
 765 //   hPtPionNoCorr->SetTitle("p_{T} distribution (no corrections)");
 766 //   hPtPionNoCorr->SetLineColor(2);
 767 //   hPtPionNoCorr->GetYaxis()->SetRangeUser(1E-3,1E1);
 768 //   hPtPionNoCorr->DrawCopy();
 769
 770 //   TH1F* hPtKaonNoCorr = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtKaon"));
 771 //   hPtKaonNoCorr->Scale(1.0/nEvents/normalization/hPtKaonNoCorr->GetBinWidth(1));
 772 //   hPtKaonNoCorr->SetLineColor(3);
 773 //   hPtKaonNoCorr->GetYaxis()->SetRangeUser(1E-3,1E1);
 774 //   hPtKaonNoCorr->DrawCopy("same");
 775
 776 //   TH1F* hPtProtonNoCorr = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtProton"));
 777 //   hPtProtonNoCorr->Scale(1.0/nEvents/normalization/hPtProtonNoCorr->GetBinWidth(1));
 778 //   hPtProtonNoCorr->SetLineColor(4);
 779 //   hPtProtonNoCorr->GetYaxis()->SetRangeUser(1E-3,1E1);
 780 //   hPtProtonNoCorr->DrawCopy("same");
 781
 782 //   TH1F* hPt = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPt"));
 783 //   hPt->Scale(1.0/nEvents/normalization/hPt->GetBinWidth(1));
 784 //   hPt->GetYaxis()->SetRangeUser(1E-3,1E1);
 785 //   hPt->DrawCopy("same");
 786
 787 //   TLegend* legend4 = new TLegend(0.63, 0.63, 0.88, 0.88);
 788 //   legend4->SetBorderSize(0);
 789 //   legend4->SetFillColor(0);
 790 //   legend4->AddEntry(hPt, "p_{T} dist (all)","L");
 791 //   legend4->AddEntry(hPtPionNoCorr, "p_{T} dist (Pions)","L");
 792 //   legend4->AddEntry(hPtKaonNoCorr, "p_{T} dist (Kaons)","L");
 793 //   legend4->AddEntry(hPtProtonNoCorr, "p_{T} dist (Protons)","L");
 794 //   legend4->Draw();
 795
 796 //   gPad->SetLogy();
 797
 798
 799 //   c5->cd(2);
 800 //   TH1F* hPtPionCorr = static_cast<TH1F*>(hPtPionNoCorr->Clone());
 801 //   hPtPionCorr->SetTitle("p_{T} distribution (with corrections)");
 802 //   hPtPionCorr->Multiply(hAccepatncePt);
 803 //   hPtPionCorr->Divide(hEfficiencyPID);
 804 //   hPtPionCorr->GetYaxis()->SetRangeUser(1E-2,1E1);
 805 //   hPtPionCorr->DrawCopy();
 806
 807 //   TH1F* hPtKaonCorr = static_cast<TH1F*>(hPtKaonNoCorr->Clone());
 808 //   hPtKaonCorr->Multiply(hAccepatncePt);
 809 //   hPtKaonCorr->Divide(hEfficiencyPID);
 810 //   hPtKaonCorr->Multiply(hKDecayCorr);
 811 //   hPtKaonCorr->GetYaxis()->SetRangeUser(1E-2,1E1);
 812 //   hPtKaonCorr->DrawCopy("same");
 813
 814 //   TH1F* hPtProtonCorr = static_cast<TH1F*>(hPtProtonNoCorr->Clone());
 815 //   hPtProtonCorr->Multiply(hAccepatncePt);
 816 //   hPtProtonCorr->Divide(hEfficiencyPID);
 817 //   hPtProtonCorr->GetYaxis()->SetRangeUser(1E-2,1E1);
 818 //   hPtProtonCorr->DrawCopy("same");
 819
 820 //   hPt->GetYaxis()->SetRangeUser(1E-2,1E1);
 821 //   hPt->DrawCopy("same");
 822
 823 //   TLegend* legend5 = new TLegend(0.63, 0.63, 0.88, 0.88);
 824 //   legend5->SetBorderSize(0);
 825 //   legend5->SetFillColor(0);
 826 //   legend5->AddEntry(hPt, "p_{T} dist (all)","L");
 827 //   legend5->AddEntry(hPtPionCorr, "p_{T} dist (Pions)","L");
 828 //   legend5->AddEntry(hPtKaonCorr, "p_{T} dist (Kaons)","L");
 829 //   legend5->AddEntry(hPtProtonCorr, "p_{T} dist (Protons)","L");
 830 //   legend5->Draw();
 831
 832 //   gPad->SetLogy();
 833
 834 //   c5->Update();
 835
 836 //   //-----------------
 837 //   if (fAnalysisMC){
 838 //     TCanvas* c6 = new TCanvas("c6", "c6", 100, 100, 1200, 800);
 839 //     c6->Divide(2,2);
 840
 841 //     c6->cd(1);
 842 //     TH1F* hPt_clone = static_cast<TH1F*>(hPt->Clone());
 843 //     hPt_clone->GetYaxis()->SetRangeUser(1E-5,1E1);
 844 //     hPt_clone->SetTitle("p_{T} distribution (all)");
 845 //     hPt_clone->SetLineColor(1);
 846 //     hPt_clone->DrawCopy();
 847
 848 //     TH1F* hPtMC = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtMC"));
 849 //     hPtMC->Scale(1.0/nEvents/normalization/hPtMC->GetBinWidth(1));
 850 //     hPtMC->GetYaxis()->SetRangeUser(1E-5,1E1);
 851 //     hPtMC->DrawCopy("same");
 852
 853 //     TLegend* legend6 = new TLegend(0.57, 0.57, 0.87, 0.87);
 854 //     legend6->SetBorderSize(0);
 855 //     legend6->SetFillColor(0);
 856 //     legend6->AddEntry(hPt_clone, "p_{T} dist (Rec)", "L");
 857 //     legend6->AddEntry(hPtMC, "p_{T} dist (MC)", "L");
 858 //     legend6->Draw();
 859
 860 //     gPad->SetLogy();
 861
 862 //     c6->cd(2);
 863 //     TH1F* hPtPion_clone = static_cast<TH1F*>(hPtPionCorr->Clone());
 864 //     hPtPion_clone->GetYaxis()->SetRangeUser(1E-2,1E1);
 865 //     hPtPion_clone->SetTitle("p_{T} distribution (Pions)");
 866 //     hPtPion_clone->SetLineColor(1);
 867 //     hPtPion_clone->DrawCopy();
 868
 869 //     TH1F* hPtMCPion = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtMCPion"));
 870 //     hPtMCPion->Scale(1.0/nEvents/normalization/hPtMCPion->GetBinWidth(1));
 871 //     hPtMCPion->GetYaxis()->SetRangeUser(1E-2,1E1);
 872 //     hPtMCPion->DrawCopy("same");
 873
 874 //     TLegend* legend7 = new TLegend(0.57, 0.57, 0.87, 0.87);
 875 //     legend7->SetBorderSize(0);
 876 //     legend7->SetFillColor(0);
 877 //     legend7->AddEntry(hPtPion_clone, "p_{T} dist (Rec)", "L");
 878 //     legend7->AddEntry(hPtMCPion, "p_{T} dist (MC)", "L");
 879 //     legend7->Draw();
 880
 881 //     gPad->SetLogy();
 882
 883 //     c6->cd(3);
 884 //     TH1F* hPtKaon_clone = static_cast<TH1F*>(hPtKaonCorr->Clone());
 885 //     hPtKaon_clone->GetYaxis()->SetRangeUser(1E-2,1E0);
 886 //     hPtKaon_clone->SetLineColor(1);
 887 //     hPtKaon_clone->DrawCopy();
 888
 889 //     TH1F* hPtMCKaon = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtMCKaon"));
 890 //     hPtMCKaon->Scale(1.0/nEvents/normalization/hPtMCKaon->GetBinWidth(1));
 891 //     hPtMCKaon->GetYaxis()->SetRangeUser(1E-2,1E0);
 892 //     hPtMCKaon->DrawCopy("same");
 893
 894 //     TLegend* legend8 = new TLegend(0.57, 0.57, 0.87, 0.87);
 895 //     legend8->SetBorderSize(0);
 896 //     legend8->SetFillColor(0);
 897 //     legend8->AddEntry(hPtKaon_clone, "p_{T} dist (Rec)", "L");
 898 //     legend8->AddEntry(hPtMCKaon, "p_{T} dist (MC)", "L");
 899 //     legend8->Draw();
 900
 901 //     gPad->SetLogy();
 902
 903 //     c6->cd(4);
 904 //     TH1F* hPtProton_clone = static_cast<TH1F*>(hPtProtonCorr->Clone());
 905 //     hPtProton_clone->GetYaxis()->SetRangeUser(1E-2,1E-1);
 906 //     hPtProton_clone->SetLineColor(1);
 907 //     hPtProton_clone->DrawCopy();
 908
 909 //     TH1F* hPtMCProton = dynamic_cast<TH1F*> (fListOfHists->FindObject("fdNdPtMCProton"));
 910 //     hPtMCProton->Scale(1.0/nEvents/normalization/hPtMCProton->GetBinWidth(1));
 911 //     hPtMCProton->GetYaxis()->SetRangeUser(1E-2,1E-1);
 912 //     hPtMCProton->DrawCopy("same");
 913
 914 //     TLegend* legend9 = new TLegend(0.2, 0.25, 0.5, 0.55);
 915 //     legend9->SetBorderSize(0);
 916 //     legend9->SetFillColor(0);
 917 //     legend9->AddEntry(hPtProton_clone, "p_{T} dist (Rec)", "L");
 918 //     legend9->AddEntry(hPtMCProton, "p_{T} dist (MC)", "L");
 919 //     legend9->Draw();
 920
 921 //     gPad->SetLogy();
 922
 923 //     c6->Update();
 924 //   }
 925
 926 }