PWGLF/STRANGENESS/LambdaK0PbPb/AliAnalysisTaskLukeAOD.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id: AliAnalysisTaskLukeAOD.cxx 46301 2011-01-06 14:25:27Z agheata $ */
  17
  18 /* AliAnalysisTaskLukeAOD.cxx
  19  *
  20  * Template task producing a P_t spectrum and pseudorapidity distribution.
  21  *
  22  * Instructions for adding histograms can be found below, starting with NEW HISTO
  23  *
  24  * Based on tutorial example from offline pages
  25  * Edited by Arvinder Palaha
  26  * Edited by Luke Hanratty for AODS
  27  */
  28 #include "AliAnalysisTaskLukeAOD.h"
  29
  30 #include "Riostream.h"
  31 #include "TChain.h"
  32 #include "TTree.h"
  33 #include "TH1F.h"
  34 #include "TH2F.h"
  35 #include "TCanvas.h"
  36 #include "TList.h"
  37 #include "TPDGCode.h"
  38
  39 #include "AliAnalysisTaskSE.h"
  40 #include "AliAnalysisManager.h"
  41 #include "AliStack.h"
  42 #include "AliESDtrackCuts.h"
  43 #include "AliESDEvent.h"
  44 #include "AliESDInputHandler.h"
  45 #include "AliAODEvent.h"
  46 #include "AliMCEvent.h"
  47 #include "AliMCVertex.h"
  48
  49 #include "AliAODEvent.h"
  50 #include "AliAODv0.h"
  51 #include "AliAODcascade.h"
  52
  53 #include "AliPID.h"
  54 #include "AliPIDResponse.h"
  55 #include "AliAODPid.h"
  56 #include "AliCentrality.h"
  57
  58 #include "AliAODMCHeader.h"
  59 #include "AliAODMCParticle.h"
  60
  61 #include "AliInputEventHandler.h"
  62
  63
  64
  65 ClassImp(AliAnalysisTaskLukeAOD)
  66
  67 //________________________________________________________________________
  68 AliAnalysisTaskLukeAOD::AliAnalysisTaskLukeAOD() // All data members should be initialised here
  69 :AliAnalysisTaskSE(),
  70 fOutput(0),
  71 fPIDResponse(0),
  72
  73 fHistPt(0),
  74 fHistEta(0),
  75 fHistLog(0),
  76 fHistNV0(0),
  77 fHistZVertex(0),
  78 fHistMCZVertex(0),
  79 fHistCentrality(0),
  80
  81 fHistBBK0Pos(0),
  82 fHistBBK0Neg(0),
  83 fHistBBLaPos(0),
  84 fHistBBLaNeg(0),
  85 fHistBBLbPos(0),
  86 fHistBBLbNeg(0),
  87
  88 fHistBB3SigProton(0),
  89 fHistMK0Pt(0),
  90 fHistMLaPt(0),
  91 fHistMLbPt(0),
  92 fHistMcPMK0Pt(0),
  93 fHistMcPMLaPt(0),
  94 fHistMcPMLbPt(0),
  95
  96 fHistMcFMLaPt(0),
  97
  98 fHistMK0PtCent0005(0),
  99 fHistMLaPtCent0005(0),
 100 fHistMLbPtCent0005(0),
 101 fHistMcPMK0PtCent0005(0),
 102 fHistMcPMLaPtCent0005(0),
 103 fHistMcPMLbPtCent0005(0),
 104 fHistZVertexCent0005(0),
 105 fHistMCZVertexCent0005(0),
 106
 107 fHistMK0PtCent0510(0),
 108 fHistMLaPtCent0510(0),
 109 fHistMLbPtCent0510(0),
 110 fHistMcPMK0PtCent0510(0),
 111 fHistMcPMLaPtCent0510(0),
 112 fHistMcPMLbPtCent0510(0),
 113 fHistZVertexCent0510(0),
 114 fHistMCZVertexCent0510(0),
 115
 116 fHistMK0PtCent1020(0),
 117 fHistMLaPtCent1020(0),
 118 fHistMLbPtCent1020(0),
 119 fHistMcPMK0PtCent1020(0),
 120 fHistMcPMLaPtCent1020(0),
 121 fHistMcPMLbPtCent1020(0),
 122 fHistZVertexCent1020(0),
 123 fHistMCZVertexCent1020(0),
 124
 125 fHistMK0PtCent2040(0),
 126 fHistMLaPtCent2040(0),
 127 fHistMLbPtCent2040(0),
 128 fHistMcPMK0PtCent2040(0),
 129 fHistMcPMLaPtCent2040(0),
 130 fHistMcPMLbPtCent2040(0),
 131 fHistZVertexCent2040(0),
 132 fHistMCZVertexCent2040(0),
 133
 134 fHistMK0PtCent4060(0),
 135 fHistMLaPtCent4060(0),
 136 fHistMLbPtCent4060(0),
 137 fHistMcPMK0PtCent4060(0),
 138 fHistMcPMLaPtCent4060(0),
 139 fHistMcPMLbPtCent4060(0),
 140 fHistZVertexCent4060(0),
 141 fHistMCZVertexCent4060(0),
 142
 143 fHistMK0PtCent6090(0),
 144 fHistMLaPtCent6090(0),
 145 fHistMLbPtCent6090(0),
 146 fHistMcPMK0PtCent6090(0),
 147 fHistMcPMLaPtCent6090(0),
 148 fHistMcPMLbPtCent6090(0),
 149 fHistZVertexCent6090(0),
 150 fHistMCZVertexCent6090(0),
 151
 152 fHistMK0PtCent0090(0),
 153 fHistMLaPtCent0090(0),
 154 fHistMLbPtCent0090(0),
 155 fHistMcPMK0PtCent0090(0),
 156 fHistMcPMLaPtCent0090(0),
 157 fHistMcPMLbPtCent0090(0),
 158 fHistZVertexCent0090(0),
 159 fHistMCZVertexCent0090(0),
 160
 161 fHistCosPaLaPt(0),
 162 fHistCosPaLbPt(0),
 163 fHistCosPaK0Pt(0),
 164 fHistMcCosPaAllLaPt(0),
 165 fHistMcCosPaAllLbPt(0),
 166 fHistMcCosPaAllK0Pt(0),
 167 fHistMcCosPaFoundLaPt(0),
 168 fHistMcCosPaFoundLbPt(0),
 169 fHistMcCosPaAFoundK0Pt(0),
 170
 171 fHistcTauLaPt(0),
 172 fHistcTauLbPt(0),
 173 fHistcTauK0Pt(0),
 174 fHistMccTauAllLaPt(0),
 175 fHistMccTauAllLbPt(0),
 176 fHistMccTauAllK0Pt(0),
 177 fHistMccTauFoundLaPt(0),
 178 fHistMccTauFoundLbPt(0),
 179 fHistMccTauAFoundK0Pt(0),
 180
 181 fHistDcaLaPt(0),
 182 fHistDcaLbPt(0),
 183 fHistDcaK0Pt(0),
 184 fHistMcDcaAllLaPt(0),
 185 fHistMcDcaAllLbPt(0),
 186 fHistMcDcaAllK0Pt(0),
 187 fHistMcDcaFoundLaPt(0),
 188 fHistMcDcaFoundLbPt(0),
 189 fHistMcDcaAFoundK0Pt(0),
 190
 191 fHistNSigmaLaPt(0),
 192 fHistNSigmaLbPt(0),
 193 fHistNSigmaK0Pt(0),
 194 fHistMcNSigmaAllLaPt(0),
 195 fHistMcNSigmaAllLbPt(0),
 196 fHistMcNSigmaAllK0Pt(0),
 197 fHistMcNSigmaFoundLaPt(0),
 198 fHistMcNSigmaFoundLbPt(0),
 199 fHistMcNSigmaAFoundK0Pt(0),
 200
 201 fHistEtaLaPt(0),
 202 fHistEtaLbPt(0),
 203 fHistEtaK0Pt(0),
 204 fHistMcEtaAllLaPt(0),
 205 fHistMcEtaAllLbPt(0),
 206 fHistMcEtaAllK0Pt(0),
 207 fHistMcEtaFoundLaPt(0),
 208 fHistMcEtaFoundLbPt(0),
 209 fHistMcEtaAFoundK0Pt(0),
 210
 211 fHistRapLaPt(0),
 212 fHistRapLbPt(0),
 213 fHistRapK0Pt(0),
 214 fHistMcRapAllLaPt(0),
 215 fHistMcRapAllLbPt(0),
 216 fHistMcRapAllK0Pt(0),
 217 fHistMcRapFoundLaPt(0),
 218 fHistMcRapFoundLbPt(0),
 219 fHistMcRapAFoundK0Pt(0)
 220
 221 // The last in the above list should not have a comma after it
 222 {
 223     // Dummy constructor ALWAYS needed for I/O.
 224 }
 225
 226 //________________________________________________________________________
 227 AliAnalysisTaskLukeAOD::AliAnalysisTaskLukeAOD(const char *name) // All data members should be initialised here
 228 :AliAnalysisTaskSE(name),
 229 fOutput(0),
 230 fPIDResponse(0),
 231
 232 fHistPt(0),
 233 fHistEta(0),
 234 fHistLog(0),
 235 fHistNV0(0),
 236 fHistZVertex(0),
 237 fHistMCZVertex(0),
 238 fHistCentrality(0),
 239
 240 fHistBBK0Pos(0),
 241 fHistBBK0Neg(0),
 242 fHistBBLaPos(0),
 243 fHistBBLaNeg(0),
 244 fHistBBLbPos(0),
 245 fHistBBLbNeg(0),
 246
 247 fHistBB3SigProton(0),
 248 fHistMK0Pt(0),
 249 fHistMLaPt(0),
 250 fHistMLbPt(0),
 251 fHistMcPMK0Pt(0),
 252 fHistMcPMLaPt(0),
 253 fHistMcPMLbPt(0),
 254
 255 fHistMcFMLaPt(0),
 256
 257 fHistMK0PtCent0005(0),
 258 fHistMLaPtCent0005(0),
 259 fHistMLbPtCent0005(0),
 260 fHistMcPMK0PtCent0005(0),
 261 fHistMcPMLaPtCent0005(0),
 262 fHistMcPMLbPtCent0005(0),
 263 fHistZVertexCent0005(0),
 264 fHistMCZVertexCent0005(0),
 265
 266 fHistMK0PtCent0510(0),
 267 fHistMLaPtCent0510(0),
 268 fHistMLbPtCent0510(0),
 269 fHistMcPMK0PtCent0510(0),
 270 fHistMcPMLaPtCent0510(0),
 271 fHistMcPMLbPtCent0510(0),
 272 fHistZVertexCent0510(0),
 273 fHistMCZVertexCent0510(0),
 274
 275 fHistMK0PtCent1020(0),
 276 fHistMLaPtCent1020(0),
 277 fHistMLbPtCent1020(0),
 278 fHistMcPMK0PtCent1020(0),
 279 fHistMcPMLaPtCent1020(0),
 280 fHistMcPMLbPtCent1020(0),
 281 fHistZVertexCent1020(0),
 282 fHistMCZVertexCent1020(0),
 283
 284 fHistMK0PtCent2040(0),
 285 fHistMLaPtCent2040(0),
 286 fHistMLbPtCent2040(0),
 287 fHistMcPMK0PtCent2040(0),
 288 fHistMcPMLaPtCent2040(0),
 289 fHistMcPMLbPtCent2040(0),
 290 fHistZVertexCent2040(0),
 291 fHistMCZVertexCent2040(0),
 292
 293 fHistMK0PtCent4060(0),
 294 fHistMLaPtCent4060(0),
 295 fHistMLbPtCent4060(0),
 296 fHistMcPMK0PtCent4060(0),
 297 fHistMcPMLaPtCent4060(0),
 298 fHistMcPMLbPtCent4060(0),
 299 fHistZVertexCent4060(0),
 300 fHistMCZVertexCent4060(0),
 301
 302 fHistMK0PtCent6090(0),
 303 fHistMLaPtCent6090(0),
 304 fHistMLbPtCent6090(0),
 305 fHistMcPMK0PtCent6090(0),
 306 fHistMcPMLaPtCent6090(0),
 307 fHistMcPMLbPtCent6090(0),
 308 fHistZVertexCent6090(0),
 309 fHistMCZVertexCent6090(0),
 310
 311 fHistMK0PtCent0090(0),
 312 fHistMLaPtCent0090(0),
 313 fHistMLbPtCent0090(0),
 314 fHistMcPMK0PtCent0090(0),
 315 fHistMcPMLaPtCent0090(0),
 316 fHistMcPMLbPtCent0090(0),
 317 fHistZVertexCent0090(0),
 318 fHistMCZVertexCent0090(0),
 319
 320 fHistCosPaLaPt(0),
 321 fHistCosPaLbPt(0),
 322 fHistCosPaK0Pt(0),
 323 fHistMcCosPaAllLaPt(0),
 324 fHistMcCosPaAllLbPt(0),
 325 fHistMcCosPaAllK0Pt(0),
 326 fHistMcCosPaFoundLaPt(0),
 327 fHistMcCosPaFoundLbPt(0),
 328 fHistMcCosPaAFoundK0Pt(0),
 329
 330 fHistcTauLaPt(0),
 331 fHistcTauLbPt(0),
 332 fHistcTauK0Pt(0),
 333 fHistMccTauAllLaPt(0),
 334 fHistMccTauAllLbPt(0),
 335 fHistMccTauAllK0Pt(0),
 336 fHistMccTauFoundLaPt(0),
 337 fHistMccTauFoundLbPt(0),
 338 fHistMccTauAFoundK0Pt(0),
 339
 340 fHistDcaLaPt(0),
 341 fHistDcaLbPt(0),
 342 fHistDcaK0Pt(0),
 343 fHistMcDcaAllLaPt(0),
 344 fHistMcDcaAllLbPt(0),
 345 fHistMcDcaAllK0Pt(0),
 346 fHistMcDcaFoundLaPt(0),
 347 fHistMcDcaFoundLbPt(0),
 348 fHistMcDcaAFoundK0Pt(0),
 349
 350 fHistNSigmaLaPt(0),
 351 fHistNSigmaLbPt(0),
 352 fHistNSigmaK0Pt(0),
 353 fHistMcNSigmaAllLaPt(0),
 354 fHistMcNSigmaAllLbPt(0),
 355 fHistMcNSigmaAllK0Pt(0),
 356 fHistMcNSigmaFoundLaPt(0),
 357 fHistMcNSigmaFoundLbPt(0),
 358 fHistMcNSigmaAFoundK0Pt(0),
 359
 360 fHistEtaLaPt(0),
 361 fHistEtaLbPt(0),
 362 fHistEtaK0Pt(0),
 363 fHistMcEtaAllLaPt(0),
 364 fHistMcEtaAllLbPt(0),
 365 fHistMcEtaAllK0Pt(0),
 366 fHistMcEtaFoundLaPt(0),
 367 fHistMcEtaFoundLbPt(0),
 368 fHistMcEtaAFoundK0Pt(0),
 369
 370 fHistRapLaPt(0),
 371 fHistRapLbPt(0),
 372 fHistRapK0Pt(0),
 373 fHistMcRapAllLaPt(0),
 374 fHistMcRapAllLbPt(0),
 375 fHistMcRapAllK0Pt(0),
 376 fHistMcRapFoundLaPt(0),
 377 fHistMcRapFoundLbPt(0),
 378 fHistMcRapAFoundK0Pt(0)
 379
 380 // The last in the above list should not have a comma after it
 381 {
 382     // Constructor
 383     // Define input and output slots here (never in the dummy constructor)
 384     // Input slot #0 works with a TChain - it is connected to the default input container
 385     // Output slot #1 writes into a TH1 container
 386     DefineOutput(1, TList::Class());                                            // for output list
 387 }
 388
 389 //________________________________________________________________________
 390 AliAnalysisTaskLukeAOD::~AliAnalysisTaskLukeAOD()
 391 {
 392     // Destructor. Clean-up the output list, but not the histograms that are put inside
 393     // (the list is owner and will clean-up these histograms). Protect in PROOF case.
 394     if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
 395         delete fOutput;
 396     }
 397 }
 398
 399 //________________________________________________________________________
 400 void AliAnalysisTaskLukeAOD::UserCreateOutputObjects()
 401 {
 402     // Create histograms
 403     // Called once (on the worker node)
 404
 405     fOutput = new TList();
 406     fOutput->SetOwner();  // IMPORTANT!
 407
 408         AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 409         AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 410         fPIDResponse = inputHandler->GetPIDResponse();
 411         maskIsSelected = inputHandler->IsEventSelected();
 412
 413         // Create histograms
 414     Int_t ptbins = 15;
 415     Float_t ptlow = 0.1, ptup = 3.1;
 416     fHistPt = new TH1F("fHistPt", "P_{T} distribution for reconstructed", ptbins, ptlow, ptup);
 417     fHistPt->GetXaxis()->SetTitle("P_{T} (GeV/c)");
 418     fHistPt->GetYaxis()->SetTitle("dN/dP_{T} (c/GeV)");
 419     fHistPt->SetMarkerStyle(kFullCircle);
 420
 421     Int_t etabins = 40;
 422     Float_t etalow = -2.0, etaup = 2.0;
 423     fHistEta = new TH1F("fHistEta","#eta distribution for reconstructed",etabins, etalow, etaup);
 424     fHistEta->GetXaxis()->SetTitle("#eta");
 425     fHistEta->GetYaxis()->SetTitle("counts");
 426
 427         fHistLog = new TH1F("fHistLog","Log Variables",100, -0.5, 99.5);
 428         fHistNV0 = new TH1F("fHistNV0","Number of V0s per event",100, 0, 5000);
 429         fHistZVertex = new TH1F("fHistZVertex","Z coordinate of primary vertex",60, -15, 15);
 430         fHistMCZVertex = new TH1F("fHistMCZVertex","Z coordinate of primary vertex in MC truth",60, -15, 15);
 431         fHistCentrality = new   TH1F("fHistCentrality", "Centrality of Events; Centrality Percentile (%); N",110,-5,105);
 432
 433         fHistBBK0Pos = new      TH2F("fHistBBK0Pos","PID of the positive daughter of K0 candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 434         fHistBBK0Neg = new      TH2F("fHistBBK0Neg","PID of the negative daughter of K0 candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 435         fHistBBLaPos = new      TH2F("fHistBBLaPos","PID of the positive daughter of La candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 436         fHistBBLaNeg = new      TH2F("fHistBBLaNeg","PID of the negative daughter of La candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 437         fHistBBLbPos = new      TH2F("fHistBBLbPos","PID of the positive daughter of Lb candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 438         fHistBBLbNeg = new      TH2F("fHistBBLbNeg","PID of the negative daughter of Lb candidates; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 439
 440         fHistBB3SigProton = new TH2F("fHistBB3SigProton","-dE/dX against Momentum for Protons @3sigma from TPC; P (GeV); -dE/dx (keV/cm ?)",1000,0,10,1000,0,200);
 441         fHistMK0Pt = new        TH2F("fHistMK0Pt","K0 Mass versus Pt; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 442         fHistMLaPt = new        TH2F("fHistMLaPt","Lambda Mass versus Pt; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 443         fHistMLbPt = new        TH2F("fHistMLbPt","AntiLambda Mass versus Pt; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 444         fHistMcPMK0Pt = new     TH2F("fHistMcPMK0Pt","Monte Carlo primary K0 Mass versus Pt; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 445         fHistMcPMLaPt = new     TH2F("fHistMcPMLaPt","Monte Carlo primary (& sigma0) Lambda Mass versus Pt; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 446         fHistMcPMLbPt = new     TH2F("fHistMcPMLbPt","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 447
 448         fHistMcFMLaPt = new     TH2F("fHistMcFMLaPt","Monte Carlo Reconstructed Lambda Mass versus Pt for feeddown lambda; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 449
 450         fHistMK0PtCent0005 = new        TH2F("fHistMK0PtCent0005","K0 Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 451         fHistMLaPtCent0005 = new        TH2F("fHistMLaPtCent0005","Lambda Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 452         fHistMLbPtCent0005 = new        TH2F("fHistMLbPtCent0005","AntiLambda Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 453         fHistMcPMK0PtCent0005 = new     TH2F("fHistMcPMK0PtCent0005","Monte Carlo primary K0 Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 454         fHistMcPMLaPtCent0005 = new     TH2F("fHistMcPMLaPtCent0005","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 455         fHistMcPMLbPtCent0005 = new     TH2F("fHistMcPMLbPtCent0005","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 0-5%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 456         fHistZVertexCent0005 = new TH1F("fHistZVertexCent0005","Z coordinate of primary vertex for Centrality 0-5%",60, -15, 15);
 457         fHistMCZVertexCent0005 = new TH1F("fHistMCZVertexCent0005","Z coordinate of primary vertex in MC truth for Centrality 0-5%",60, -15, 15);
 458
 459         fHistMK0PtCent0510 = new        TH2F("fHistMK0PtCent0510","K0 Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 460         fHistMLaPtCent0510 = new        TH2F("fHistMLaPtCent0510","Lambda Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 461         fHistMLbPtCent0510 = new        TH2F("fHistMLbPtCent0510","AntiLambda Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 462         fHistMcPMK0PtCent0510 = new     TH2F("fHistMcPMK0PtCent0510","Monte Carlo primary K0 Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 463         fHistMcPMLaPtCent0510 = new     TH2F("fHistMcPMLaPtCent0510","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 464         fHistMcPMLbPtCent0510 = new     TH2F("fHistMcPMLbPtCent0510","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 5-10%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 465         fHistZVertexCent0510 = new TH1F("fHistZVertexCent0510","Z coordinate of primary vertex for Centrality 5-10%",60, -15, 15);
 466         fHistMCZVertexCent0510 = new TH1F("fHistMCZVertexCent0510","Z coordinate of primary vertex in MC truth for Centrality 5-10%",60, -15, 15);
 467
 468         fHistMK0PtCent1020 = new        TH2F("fHistMK0PtCent1020","K0 Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 469         fHistMLaPtCent1020 = new        TH2F("fHistMLaPtCent1020","Lambda Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 470         fHistMLbPtCent1020 = new        TH2F("fHistMLbPtCent1020","AntiLambda Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 471         fHistMcPMK0PtCent1020 = new     TH2F("fHistMcPMK0PtCent1020","Monte Carlo primary K0 Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 472         fHistMcPMLaPtCent1020 = new     TH2F("fHistMcPMLaPtCent1020","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 473         fHistMcPMLbPtCent1020 = new     TH2F("fHistMcPMLbPtCent1020","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 10-20%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 474         fHistZVertexCent1020 = new TH1F("fHistZVertexCent1020","Z coordinate of primary vertex for Centrality 10-20%",60, -15, 15);
 475         fHistMCZVertexCent1020 = new TH1F("fHistMCZVertexCent1020","Z coordinate of primary vertex in MC truth for Centrality 10-20%",60, -15, 15);
 476
 477         fHistMK0PtCent2040 = new        TH2F("fHistMK0PtCent2040","K0 Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 478         fHistMLaPtCent2040 = new        TH2F("fHistMLaPtCent2040","Lambda Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 479         fHistMLbPtCent2040 = new        TH2F("fHistMLbPtCent2040","AntiLambda Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 480         fHistMcPMK0PtCent2040 = new     TH2F("fHistMcPMK0PtCent2040","Monte Carlo primary K0 Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 481         fHistMcPMLaPtCent2040 = new     TH2F("fHistMcPMLaPtCent2040","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 482         fHistMcPMLbPtCent2040 = new     TH2F("fHistMcPMLbPtCent2040","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 20-40%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 483         fHistZVertexCent2040 = new TH1F("fHistZVertexCent2040","Z coordinate of primary vertex for Centrality 20-40%",60, -15, 15);
 484         fHistMCZVertexCent2040 = new TH1F("fHistMCZVertexCent2040","Z coordinate of primary vertex in MC truth for Centrality 20-40%",60, -15, 15);
 485
 486         fHistMK0PtCent4060 = new        TH2F("fHistMK0PtCent4060","K0 Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 487         fHistMLaPtCent4060 = new        TH2F("fHistMLaPtCent4060","Lambda Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 488         fHistMLbPtCent4060 = new        TH2F("fHistMLbPtCent4060","AntiLambda Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 489         fHistMcPMK0PtCent4060 = new     TH2F("fHistMcPMK0PtCent4060","Monte Carlo primary K0 Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 490         fHistMcPMLaPtCent4060 = new     TH2F("fHistMcPMLaPtCent4060","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 491         fHistMcPMLbPtCent4060 = new     TH2F("fHistMcPMLbPtCent4060","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 40-60%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 492         fHistZVertexCent4060 = new TH1F("fHistZVertexCent4060","Z coordinate of primary vertex for Centrality 40-60%",60, -15, 15);
 493         fHistMCZVertexCent4060 = new TH1F("fHistMCZVertexCent4060","Z coordinate of primary vertex in MC truth for Centrality 40-60%",60, -15, 15);
 494
 495         fHistMK0PtCent6090 = new        TH2F("fHistMK0PtCent6090","K0 Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 496         fHistMLaPtCent6090 = new        TH2F("fHistMLaPtCent6090","Lambda Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 497         fHistMLbPtCent6090 = new        TH2F("fHistMLbPtCent6090","AntiLambda Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 498         fHistMcPMK0PtCent6090 = new     TH2F("fHistMcPMK0PtCent6090","Monte Carlo primary K0 Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 499         fHistMcPMLaPtCent6090 = new     TH2F("fHistMcPMLaPtCent6090","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 500         fHistMcPMLbPtCent6090 = new     TH2F("fHistMcPMLbPtCent6090","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 60-90%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 501         fHistZVertexCent6090 = new TH1F("fHistZVertexCent6090","Z coordinate of primary vertex for Centrality 60-90%",60, -15, 15);
 502         fHistMCZVertexCent6090 = new TH1F("fHistMCZVertexCent6090","Z coordinate of primary vertex in MC truth for Centrality 60-90%",60, -15, 15);
 503
 504         fHistMK0PtCent0090 = new        TH2F("fHistMK0PtCent0090","K0 Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 505         fHistMLaPtCent0090 = new        TH2F("fHistMLaPtCent0090","Lambda Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 506         fHistMLbPtCent0090 = new        TH2F("fHistMLbPtCent0090","AntiLambda Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 507         fHistMcPMK0PtCent0090 = new     TH2F("fHistMcPMK0PtCent0090","Monte Carlo primary K0 Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); K0 Mass (GeV/c^2)",200,0,10,140,0.414,0.582);
 508         fHistMcPMLaPtCent0090 = new     TH2F("fHistMcPMLaPtCent0090","Monte Carlo primary (& sigma0) Lambda Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); M(p#pi^{-}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 509         fHistMcPMLbPtCent0090 = new     TH2F("fHistMcPMLbPtCent0090","Monte Carlo primary (& sigma0) AntiLambda Mass versus Pt for Centrality 0-90%; P_{perp} (GeV/c); M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,10,96,1.08,1.2);
 510         fHistZVertexCent0090 = new TH1F("fHistZVertexCent0090","Z coordinate of primary vertex for Centrality 0-90%",60, -15, 15);
 511         fHistMCZVertexCent0090 = new TH1F("fHistMCZVertexCent0090","Z coordinate of primary vertex in MC truth for Centrality 0-90%",60, -15, 15);
 512
 513
 514         fHistCosPaLaPt           = new  TH2F("fHistCosPaLaPt"," Reconstructed Mass vs CosPa for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 515         fHistCosPaLbPt           = new  TH2F("fHistCosPaLbPt"," Reconstructed Mass vs CosPa for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 516         fHistCosPaK0Pt           = new  TH2F("fHistCosPaK0Pt"," Reconstructed Mass vs CosPa for K0Short Candidates; K0 Mass (GeV/c^2)",200,0.99,1.001,140,0.414,0.582);
 517         fHistMcCosPaAllLaPt      = new  TH2F("fHistMcCosPaAllLaPt","    Reconstructed Mass vs CosPa for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 518         fHistMcCosPaAllLbPt      = new  TH2F("fHistMcCosPaAllLbPt","    Reconstructed Mass vs CosPa for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 519         fHistMcCosPaAllK0Pt      = new  TH2F("fHistMcCosPaAllK0Pt","    Reconstructed Mass vs CosPa for all MC primary K0Short; K0 Mass (GeV/c^2)",200,0.99,1.001,140,0.414,0.582);
 520         fHistMcCosPaFoundLaPt    = new  TH2F("fHistMcCosPaFoundLaPt","  Reconstructed Mass vs CosPa for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 521         fHistMcCosPaFoundLbPt    = new  TH2F("fHistMcCosPaFoundLbPt","  Reconstructed Mass vs CosPa for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0.99,1.001,96,1.08,1.2);
 522         fHistMcCosPaAFoundK0Pt = new    TH2F("fHistMcCosPaAFoundK0Pt"," Reconstructed Mass vs CosPa for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",200,0.99,1.001,140,0.414,0.582);
 523
 524         fHistcTauLaPt            = new  TH2F("fHistcTauLaPt","  Reconstructed Mass vs cTau for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 525         fHistcTauLbPt            = new  TH2F("fHistcTauLbPt","  Reconstructed Mass vs cTau for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 526         fHistcTauK0Pt            = new  TH2F("fHistcTauK0Pt","  Reconstructed Mass vs cTau for K0Short Candidates; K0 Mass (GeV/c^2)",200,0,50,140,0.414,0.582);
 527         fHistMccTauAllLaPt       = new  TH2F("fHistMccTauAllLaPt","     Reconstructed Mass vs cTau for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 528         fHistMccTauAllLbPt       = new  TH2F("fHistMccTauAllLbPt","     Reconstructed Mass vs cTau for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 529         fHistMccTauAllK0Pt       = new  TH2F("fHistMccTauAllK0Pt","     Reconstructed Mass vs cTau for all MC primary K0Short; K0 Mass (GeV/c^2)",200,0,50,140,0.414,0.582);
 530         fHistMccTauFoundLaPt     = new  TH2F("fHistMccTauFoundLaPt","   Reconstructed Mass vs cTau for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 531         fHistMccTauFoundLbPt     = new  TH2F("fHistMccTauFoundLbPt","   Reconstructed Mass vs cTau for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 532         fHistMccTauAFoundK0Pt = new     TH2F("fHistMccTauAFoundK0Pt","  Reconstructed Mass vs cTau for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",200,0,50,140,0.414,0.582);
 533
 534         fHistDcaLaPt             = new  TH2F("fHistDcaLaPt","   Reconstructed Mass vs Dca for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",200,0,1.5,96,1.08,1.2);
 535         fHistDcaLbPt             = new  TH2F("fHistDcaLbPt","   Reconstructed Mass vs Dca for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,1.5,96,1.08,1.2);
 536         fHistDcaK0Pt             = new  TH2F("fHistDcaK0Pt","   Reconstructed Mass vs Dca for K0Short Candidates; K0 Mass (GeV/c^2)",200,0,1.5,140,0.414,0.582);
 537         fHistMcDcaAllLaPt        = new  TH2F("fHistMcDcaAllLaPt","      Reconstructed Mass vs Dca for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 538         fHistMcDcaAllLbPt        = new  TH2F("fHistMcDcaAllLbPt","      Reconstructed Mass vs Dca for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,50,96,1.08,1.2);
 539         fHistMcDcaAllK0Pt        = new  TH2F("fHistMcDcaAllK0Pt","      Reconstructed Mass vs Dca for all MC primary K0Short; K0 Mass (GeV/c^2)",200,0,50,140,0.414,0.582);
 540         fHistMcDcaFoundLaPt      = new  TH2F("fHistMcDcaFoundLaPt","    Reconstructed Mass vs Dca for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,0,1.5,96,1.08,1.2);
 541         fHistMcDcaFoundLbPt      = new  TH2F("fHistMcDcaFoundLbPt","    Reconstructed Mass vs Dca for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,0,1.5,96,1.08,1.2);
 542         fHistMcDcaAFoundK0Pt = new      TH2F("fHistMcDcaAFoundK0Pt","   Reconstructed Mass vs Dca for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",200,0,1.5,140,0.414,0.582);
 543
 544         fHistNSigmaLaPt          = new  TH2F("fHistNSigmaLaPt","        Reconstructed Mass vs NSigma for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 545         fHistNSigmaLbPt          = new  TH2F("fHistNSigmaLbPt","        Reconstructed Mass vs NSigma for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 546         fHistNSigmaK0Pt          = new  TH2F("fHistNSigmaK0Pt","        Reconstructed Mass vs NSigma for K0Short Candidates; K0 Mass (GeV/c^2)",50,-5,5,140,0.414,0.582);
 547         fHistMcNSigmaAllLaPt     = new  TH2F("fHistMcNSigmaAllLaPt","   Reconstructed Mass vs NSigma for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 548         fHistMcNSigmaAllLbPt     = new  TH2F("fHistMcNSigmaAllLbPt","   Reconstructed Mass vs NSigma for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 549         fHistMcNSigmaAllK0Pt     = new  TH2F("fHistMcNSigmaAllK0Pt","   Reconstructed Mass vs NSigma for all MC primary K0Short; K0 Mass (GeV/c^2)",50,-5,5,140,0.414,0.582);
 550         fHistMcNSigmaFoundLaPt   = new  TH2F("fHistMcNSigmaFoundLaPt"," Reconstructed Mass vs NSigma for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 551         fHistMcNSigmaFoundLbPt   = new  TH2F("fHistMcNSigmaFoundLbPt"," Reconstructed Mass vs NSigma for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",50,-5,5,96,1.08,1.2);
 552         fHistMcNSigmaAFoundK0Pt = new   TH2F("fHistMcNSigmaAFoundK0Pt","        Reconstructed Mass vs NSigma for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",50,-5,5,140,0.414,0.582);
 553
 554         fHistEtaLaPt             = new  TH2F("fHistEtaLaPt","   Reconstructed Mass vs Eta for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 555         fHistEtaLbPt             = new  TH2F("fHistEtaLbPt","   Reconstructed Mass vs Eta for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 556         fHistEtaK0Pt             = new  TH2F("fHistEtaK0Pt","   Reconstructed Mass vs Eta for K0Short Candidates; K0 Mass (GeV/c^2)",200,-3,3,140,0.414,0.582);
 557         fHistMcEtaAllLaPt        = new  TH2F("fHistMcEtaAllLaPt","      Reconstructed Mass vs Eta for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 558         fHistMcEtaAllLbPt        = new  TH2F("fHistMcEtaAllLbPt","      Reconstructed Mass vs Eta for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 559         fHistMcEtaAllK0Pt        = new  TH2F("fHistMcEtaAllK0Pt","      Reconstructed Mass vs Eta for all MC primary K0Short; K0 Mass (GeV/c^2)",200,-3,3,140,0.414,0.582);
 560         fHistMcEtaFoundLaPt      = new  TH2F("fHistMcEtaFoundLaPt","    Reconstructed Mass vs Eta for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 561         fHistMcEtaFoundLbPt      = new  TH2F("fHistMcEtaFoundLbPt","    Reconstructed Mass vs Eta for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-3,3,96,1.08,1.2);
 562         fHistMcEtaAFoundK0Pt = new      TH2F("fHistMcEtaAFoundK0Pt","   Reconstructed Mass vs Eta for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",200,-3,3,140,0.414,0.582);
 563
 564         fHistRapLaPt             = new  TH2F("fHistRapLaPt","   Reconstructed Mass vs Rap for Lambda Candidates; M(p#pi^{-}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 565         fHistRapLbPt             = new  TH2F("fHistRapLbPt","   Reconstructed Mass vs Rap for AntiLambda Candidates; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 566         fHistRapK0Pt             = new  TH2F("fHistRapK0Pt","   Reconstructed Mass vs Rap for K0Short Candidates; K0 Mass (GeV/c^2)",200,-1,1,140,0.414,0.582);
 567         fHistMcRapAllLaPt        = new  TH2F("fHistMcRapAllLaPt","      Reconstructed Mass vs Rap for all MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 568         fHistMcRapAllLbPt        = new  TH2F("fHistMcRapAllLbPt","      Reconstructed Mass vs Rap for all MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 569         fHistMcRapAllK0Pt        = new  TH2F("fHistMcRapAllK0Pt","      Reconstructed Mass vs Rap for all MC primary K0Short; K0 Mass (GeV/c^2)",200,-1,1,140,0.414,0.582);
 570         fHistMcRapFoundLaPt      = new  TH2F("fHistMcRapFoundLaPt","    Reconstructed Mass vs Rap for reconstructed MC primary Lambda; M(p#pi^{-}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 571         fHistMcRapFoundLbPt      = new  TH2F("fHistMcRapFoundLbPt","    Reconstructed Mass vs Rap for reconstructed MC primary AntiLambda; M(#bar{p}#pi^{+}) (GeV/c^2)",200,-1,1,96,1.08,1.2);
 572         fHistMcRapAFoundK0Pt = new      TH2F("fHistMcRapAFoundK0Pt","   Reconstructed Mass vs Rap for reconstructed MC primary K0Short; K0 Mass (GeV/c^2)",200,-1,1,140,0.414,0.582);
 573
 574
 575
 576     // NEW HISTO should be defined here, with a sensible name,
 577
 578     fOutput->Add(fHistPt);
 579     fOutput->Add(fHistEta);
 580     fOutput->Add(fHistLog);
 581         fOutput->Add(fHistNV0);
 582         fOutput->Add(fHistZVertex);
 583         fOutput->Add(fHistMCZVertex);
 584         fOutput->Add(fHistCentrality);
 585
 586         fOutput->Add(fHistBBK0Pos);
 587         fOutput->Add(fHistBBK0Neg);
 588         fOutput->Add(fHistBBLaPos);
 589         fOutput->Add(fHistBBLaNeg);
 590         fOutput->Add(fHistBBLbPos);
 591         fOutput->Add(fHistBBLbNeg);
 592
 593         fOutput->Add(fHistBB3SigProton);
 594         fOutput->Add(fHistMK0Pt);
 595         fOutput->Add(fHistMLaPt);
 596         fOutput->Add(fHistMLbPt);
 597         fOutput->Add(fHistMcPMK0Pt);
 598         fOutput->Add(fHistMcPMLaPt);
 599         fOutput->Add(fHistMcPMLbPt);
 600
 601         fOutput->Add(fHistMcFMLaPt);
 602
 603         fOutput->Add(fHistMK0PtCent0005);
 604         fOutput->Add(fHistMLaPtCent0005);
 605         fOutput->Add(fHistMLbPtCent0005);
 606         fOutput->Add(fHistMcPMK0PtCent0005);
 607         fOutput->Add(fHistMcPMLaPtCent0005);
 608         fOutput->Add(fHistMcPMLbPtCent0005);
 609         fOutput->Add(fHistZVertexCent0005);
 610         fOutput->Add(fHistMCZVertexCent0005);
 611
 612         fOutput->Add(fHistMK0PtCent0510);
 613         fOutput->Add(fHistMLaPtCent0510);
 614         fOutput->Add(fHistMLbPtCent0510);
 615         fOutput->Add(fHistMcPMK0PtCent0510);
 616         fOutput->Add(fHistMcPMLaPtCent0510);
 617         fOutput->Add(fHistMcPMLbPtCent0510);
 618         fOutput->Add(fHistZVertexCent0510);
 619         fOutput->Add(fHistMCZVertexCent0510);
 620
 621         fOutput->Add(fHistMK0PtCent1020);
 622         fOutput->Add(fHistMLaPtCent1020);
 623         fOutput->Add(fHistMLbPtCent1020);
 624         fOutput->Add(fHistMcPMK0PtCent1020);
 625         fOutput->Add(fHistMcPMLaPtCent1020);
 626         fOutput->Add(fHistMcPMLbPtCent1020);
 627         fOutput->Add(fHistZVertexCent1020);
 628         fOutput->Add(fHistMCZVertexCent1020);
 629
 630         fOutput->Add(fHistMK0PtCent2040);
 631         fOutput->Add(fHistMLaPtCent2040);
 632         fOutput->Add(fHistMLbPtCent2040);
 633         fOutput->Add(fHistMcPMK0PtCent2040);
 634         fOutput->Add(fHistMcPMLaPtCent2040);
 635         fOutput->Add(fHistMcPMLbPtCent2040);
 636         fOutput->Add(fHistZVertexCent2040);
 637         fOutput->Add(fHistMCZVertexCent2040);
 638
 639         fOutput->Add(fHistMK0PtCent4060);
 640         fOutput->Add(fHistMLaPtCent4060);
 641         fOutput->Add(fHistMLbPtCent4060);
 642         fOutput->Add(fHistMcPMK0PtCent4060);
 643         fOutput->Add(fHistMcPMLaPtCent4060);
 644         fOutput->Add(fHistMcPMLbPtCent4060);
 645         fOutput->Add(fHistZVertexCent4060);
 646         fOutput->Add(fHistMCZVertexCent4060);
 647
 648         fOutput->Add(fHistMK0PtCent6090);
 649         fOutput->Add(fHistMLaPtCent6090);
 650         fOutput->Add(fHistMLbPtCent6090);
 651         fOutput->Add(fHistMcPMK0PtCent6090);
 652         fOutput->Add(fHistMcPMLaPtCent6090);
 653         fOutput->Add(fHistMcPMLbPtCent6090);
 654         fOutput->Add(fHistZVertexCent6090);
 655         fOutput->Add(fHistMCZVertexCent6090);
 656
 657         fOutput->Add(fHistMK0PtCent0090);
 658         fOutput->Add(fHistMLaPtCent0090);
 659         fOutput->Add(fHistMLbPtCent0090);
 660         fOutput->Add(fHistMcPMK0PtCent0090);
 661         fOutput->Add(fHistMcPMLaPtCent0090);
 662         fOutput->Add(fHistMcPMLbPtCent0090);
 663         fOutput->Add(fHistZVertexCent0090);
 664         fOutput->Add(fHistMCZVertexCent0090);
 665
 666         fOutput->Add(fHistCosPaLaPt);
 667         fOutput->Add(fHistCosPaLbPt);
 668         fOutput->Add(fHistCosPaK0Pt);
 669         fOutput->Add(fHistMcCosPaAllLaPt);
 670         fOutput->Add(fHistMcCosPaAllLbPt);
 671         fOutput->Add(fHistMcCosPaAllK0Pt);
 672         fOutput->Add(fHistMcCosPaFoundLaPt);
 673         fOutput->Add(fHistMcCosPaFoundLbPt);
 674         fOutput->Add(fHistMcCosPaAFoundK0Pt);
 675
 676         fOutput->Add(fHistcTauLaPt);
 677         fOutput->Add(fHistcTauLbPt);
 678         fOutput->Add(fHistcTauK0Pt);
 679         fOutput->Add(fHistMccTauAllLaPt);
 680         fOutput->Add(fHistMccTauAllLbPt);
 681         fOutput->Add(fHistMccTauAllK0Pt);
 682         fOutput->Add(fHistMccTauFoundLaPt);
 683         fOutput->Add(fHistMccTauFoundLbPt);
 684         fOutput->Add(fHistMccTauAFoundK0Pt);
 685
 686         fOutput->Add(fHistDcaLaPt);
 687         fOutput->Add(fHistDcaLbPt);
 688         fOutput->Add(fHistDcaK0Pt);
 689         fOutput->Add(fHistMcDcaAllLaPt);
 690         fOutput->Add(fHistMcDcaAllLbPt);
 691         fOutput->Add(fHistMcDcaAllK0Pt);
 692         fOutput->Add(fHistMcDcaFoundLaPt);
 693         fOutput->Add(fHistMcDcaFoundLbPt);
 694         fOutput->Add(fHistMcDcaAFoundK0Pt);
 695
 696         fOutput->Add(fHistNSigmaLaPt);
 697         fOutput->Add(fHistNSigmaLbPt);
 698         fOutput->Add(fHistNSigmaK0Pt);
 699         fOutput->Add(fHistMcNSigmaAllLaPt);
 700         fOutput->Add(fHistMcNSigmaAllLbPt);
 701         fOutput->Add(fHistMcNSigmaAllK0Pt);
 702         fOutput->Add(fHistMcNSigmaFoundLaPt);
 703         fOutput->Add(fHistMcNSigmaFoundLbPt);
 704         fOutput->Add(fHistMcNSigmaAFoundK0Pt);
 705
 706         fOutput->Add(fHistEtaLaPt);
 707         fOutput->Add(fHistEtaLbPt);
 708         fOutput->Add(fHistEtaK0Pt);
 709         fOutput->Add(fHistMcEtaAllLaPt);
 710         fOutput->Add(fHistMcEtaAllLbPt);
 711         fOutput->Add(fHistMcEtaAllK0Pt);
 712         fOutput->Add(fHistMcEtaFoundLaPt);
 713         fOutput->Add(fHistMcEtaFoundLbPt);
 714         fOutput->Add(fHistMcEtaAFoundK0Pt);
 715
 716         fOutput->Add(fHistRapLaPt);
 717         fOutput->Add(fHistRapLbPt);
 718         fOutput->Add(fHistRapK0Pt);
 719         fOutput->Add(fHistMcRapAllLaPt);
 720         fOutput->Add(fHistMcRapAllLbPt);
 721         fOutput->Add(fHistMcRapAllK0Pt);
 722         fOutput->Add(fHistMcRapFoundLaPt);
 723         fOutput->Add(fHistMcRapFoundLbPt);
 724         fOutput->Add(fHistMcRapAFoundK0Pt);
 725
 726         // NEW HISTO added to fOutput here
 727     PostData(1, fOutput); // Post data for ALL output slots >0 here, to get at least an empty histogram
 728 }
 729
 730 //________________________________________________________________________
 731
 732 static Bool_t AcceptTrack(const AliAODTrack *t, double cutMinNClustersTPC, double cutRatio)
 733 {
 734         if (!t->IsOn(AliAODTrack::kTPCrefit)) return kFALSE;
 735         //if (t->GetKinkIndex(0)>0) return kFALSE;
 736
 737         Float_t nCrossedRowsTPC = t->GetTPCClusterInfo(2,1);
 738         if (nCrossedRowsTPC < cutMinNClustersTPC) return kFALSE;
 739         Int_t findable=t->GetTPCNclsF();
 740         if (findable <= 0) return kFALSE;
 741         if (nCrossedRowsTPC/findable < cutRatio) return kFALSE;
 742
 743         return kTRUE;
 744 }
 745
 746 //________________________________________________________________________
 747 static Bool_t AcceptV0_general(const AliAODv0 *v1, const AliAODEvent *aod, double cutCosPa, double cutNImpact, double cutDCA, double cutEta, double cutMinNClustersTPC, double cutRatio)
 748 {
 749
 750         if (v1->GetOnFlyStatus()) return kFALSE;
 751
 752         int nnum = 1, pnum = 0;
 753         const AliAODTrack *ntracktest=(AliAODTrack *)v1->GetDaughter(nnum);
 754         if(ntracktest->Charge() > 0){nnum = 0; pnum = 1;}
 755
 756         const AliAODTrack *ntrack1=(AliAODTrack *)v1->GetDaughter(nnum);
 757         if (!AcceptTrack(ntrack1, cutMinNClustersTPC, cutRatio)) return kFALSE;
 758
 759         const AliAODTrack *ptrack1=(AliAODTrack *)v1->GetDaughter(pnum);
 760         if (!AcceptTrack(ptrack1, cutMinNClustersTPC, cutRatio)) return kFALSE;
 761
 762         Float_t impact=v1->DcaNegToPrimVertex();
 763         if (TMath::Abs(impact)<0.1) return kFALSE;
 764         if (TMath::Abs(impact)<cutNImpact && cutNImpact != -999) return kFALSE;
 765         impact=v1->DcaPosToPrimVertex();
 766         if (TMath::Abs(impact)<0.1) return kFALSE;
 767         if (TMath::Abs(impact)<cutNImpact && cutNImpact != -999) return kFALSE;
 768
 769         Double_t dca=v1->DcaV0Daughters();
 770         if (TMath::Abs(dca)>cutDCA && cutDCA != -999) return kFALSE;
 771
 772         Double_t cpa=v1->CosPointingAngle(aod->GetPrimaryVertex());
 773         if (cpa<cutCosPa && cutCosPa != -999) return kFALSE;
 774
 775         Double_t etaN = v1->PseudoRapNeg();
 776         Double_t etaP = v1->PseudoRapPos();
 777         if ((TMath::Abs(etaN)>cutEta || TMath::Abs(etaP)>cutEta) && cutEta != -999) return kFALSE;
 778
 779         return kTRUE;
 780 }
 781
 782 //________________________________________________________________________
 783 static Bool_t AcceptV0_particle(const AliAODv0 *v1, int type,  double cutcTau, double cutRapidity, Double_t decayL)
 784 {
 785
 786         Double_t cTau = 0;
 787         if(type == 1)
 788         {cTau = decayL*(v1->MassLambda())/(v1->P());}
 789         if(type == 2)
 790         {cTau = decayL*(v1->MassAntiLambda())/(v1->P());}
 791         if(type == 0)
 792         {cTau = decayL*(v1->MassK0Short())/(v1->P());}
 793
 794         if (cTau < cutcTau && cTau != -999 ) return kFALSE;
 795
 796         Double_t rap = 0;
 797         if(type == 1 || type == 2)
 798         {rap = v1->RapLambda();}
 799         if(type == 0)
 800         {rap = v1->RapK0Short();}
 801         if (TMath::Abs(rap)>cutRapidity && cutRapidity != -999) return kFALSE;
 802
 803         return kTRUE;
 804 }
 805
 806 //________________________________________________________________________
 807 static Bool_t AcceptV0_lowpt(const AliAODv0 *v1, AliPIDResponse *PIDResponse,int type, double cutBetheBloch, Double_t decayL, bool isMonteCarlo)
 808 {
 809
 810
 811         Double_t cTau = 0;
 812         if(type == 1)
 813         {cTau = decayL*(v1->MassLambda())/(v1->P());}
 814         if(type == 2)
 815         {cTau = decayL*(v1->MassAntiLambda())/(v1->P());}
 816         if(type == 0)
 817         {cTau = decayL*(v1->MassK0Short())/(v1->P());}
 818
 819         if (cTau > 30 && (type ==1 || type ==2) && TMath::Sqrt(v1->Pt2V0()) < 1) return kFALSE;
 820
 821         int nnum = 1, pnum = 0;
 822         const AliAODTrack *ntracktest=(AliAODTrack *)v1->GetDaughter(nnum);
 823         if(ntracktest->Charge() > 0){nnum = 0; pnum = 1;}
 824
 825         const AliAODTrack *ntrack1=(AliAODTrack *)v1->GetDaughter(nnum);
 826         const AliAODTrack *ptrack1=(AliAODTrack *)v1->GetDaughter(pnum);
 827
 828         Double_t nsig_p = 0;
 829         Double_t nsig_n = 0;
 830
 831         const AliAODPid *pid_p=ptrack1->GetDetPid();
 832         const AliAODPid *pid_n=ntrack1->GetDetPid();
 833
 834         if (pid_p)
 835         {
 836                 if(type == 1)
 837                 {nsig_p=PIDResponse->NumberOfSigmasTPC(ptrack1,AliPID::kProton);
 838                         if (TMath::Abs(nsig_p) > cutBetheBloch && cutBetheBloch >0 && !isMonteCarlo) return kFALSE;}
 839                 if(type == 0 || type == 2)
 840                 {nsig_p=PIDResponse->NumberOfSigmasTPC(ptrack1,AliPID::kPion);
 841                         if (TMath::Abs(nsig_p) > cutBetheBloch && cutBetheBloch >0 && !isMonteCarlo) return kFALSE;}
 842
 843         }
 844
 845         if (pid_n)
 846         {
 847                 if(type == 2)
 848                 {nsig_n=PIDResponse->NumberOfSigmasTPC(ntrack1,AliPID::kProton);
 849                         if (TMath::Abs(nsig_n) > cutBetheBloch && cutBetheBloch >0 && !isMonteCarlo) return kFALSE;}
 850                 if(type == 0 || type == 1)
 851                 {nsig_n=PIDResponse->NumberOfSigmasTPC(ntrack1,AliPID::kPion);
 852                         if (TMath::Abs(nsig_n) > cutBetheBloch && cutBetheBloch >0 && !isMonteCarlo) return kFALSE;}
 853
 854         }
 855
 856         return kTRUE;
 857 }
 858
 859
 860 //________________________________________________________________________
 861 void AliAnalysisTaskLukeAOD::UserExec(Option_t *)
 862 {
 863     // Main loop
 864     // Called for each event
 865
 866         fHistLog->Fill(1);
 867
 868         // parameters used for most cuts, to minimise editing
 869         double cutCosPa(0.998), cutcTau(2);
 870         double cutNImpact(-999), cutDCA(0.4);
 871         double cutBetheBloch(3); // NOTE - BB cut only applies to data, must be accounted for when constructing corrected yields
 872         double cutMinNClustersTPC(70), cutRatio(0.8);
 873         bool isMonteCarlo(true);
 874         int isMCtype(1);    //1 = Pure Hijing only, 0 = Anything, -1 = Injected only
 875         double cutEta(0.8), cutRapidity(0.5);
 876
 877     // Create pointer to reconstructed event
 878         AliAODEvent *aod=(AliAODEvent *)InputEvent();
 879         if (!aod)
 880         {
 881                 Printf("ERROR: aod not available");
 882                 fHistLog->Fill(98);
 883                 return;
 884         }
 885
 886
 887         //Bool_t isSelected = (maskIsSelected && AliVEvent::kMB);
 888         /*if (!isSelected)
 889          {
 890          Printf("ERROR: failed physics selection");
 891          fHistLog->Fill(88);
 892          return;
 893          }*/
 894
 895         AliCentrality* centrality = aod->GetCentrality();
 896         Double_t centPercentile = centrality->GetCentralityPercentile("V0M");
 897         fHistCentrality->Fill(centPercentile);
 898
 899         /********MC Loop************************************/
 900
 901         int isInjected = -1;
 902
 903         if(isMonteCarlo)
 904         {
 905
 906                 // Create pointer to reconstructed event
 907                 TList *list = aod->GetList();
 908                 TClonesArray *stack = 0x0;
 909                 stack = (TClonesArray*)list->FindObject(AliAODMCParticle::StdBranchName());
 910                 if (!stack) {
 911                         Printf("ERROR: stack not available");
 912                         fHistLog->Fill(84);
 913                 }
 914                 else{
 915
 916                         AliAODMCHeader *mcHdr=(AliAODMCHeader*)list->FindObject(AliAODMCHeader::StdBranchName());
 917
 918                         Double_t mcXv=0., mcYv=0., mcZv=0.;
 919                         mcXv=mcHdr->GetVtxX(); mcYv=mcHdr->GetVtxY(); mcZv=mcHdr->GetVtxZ();
 920                         if (TMath::Abs(mcZv) > 10.)
 921                         {
 922                                 fHistLog->Fill(76);
 923                         }
 924                         else{
 925                                 fHistMCZVertex->Fill(mcZv);
 926
 927                                 if(centPercentile >= 0.0001 && centPercentile <= 5.0)
 928                                 {fHistMCZVertexCent0005->Fill(mcZv);}
 929                                 if(centPercentile > 5.0 && centPercentile <= 10.0)
 930                                 {fHistMCZVertexCent0510->Fill(mcZv);}
 931                                 if(centPercentile > 10.0 && centPercentile <= 20.0)
 932                                 {fHistMCZVertexCent1020->Fill(mcZv);}
 933                                 if(centPercentile > 20.0 && centPercentile <= 40.0)
 934                                 {fHistMCZVertexCent2040->Fill(mcZv);}
 935                                 if(centPercentile > 40.0 && centPercentile <= 60.0)
 936                                 {fHistMCZVertexCent4060->Fill(mcZv);}
 937                                 if(centPercentile > 60.0 && centPercentile <= 90.0)
 938                                 {fHistMCZVertexCent6090->Fill(mcZv);}
 939                                 if(centPercentile >= 0.0001 && centPercentile <= 90.0)
 940                                 {fHistMCZVertexCent0090->Fill(mcZv);}
 941
 942
 943                                 Int_t ntrk=stack->GetEntriesFast(), ntrk0=ntrk;
 944
 945                                 for(int iMCtrack = 0; iMCtrack<ntrk0; iMCtrack++)
 946
 947                                 {
 948
 949                                         //booleans to check if track is La, Lb, K0 and primary
 950                                         bool lambdaMC = false;
 951                                         bool antilambdaMC = false;
 952                                         bool kshortMC = false;
 953                                         bool isprimaryMC = false;
 954
 955                                         AliAODMCParticle *mcPart =(AliAODMCParticle*)stack->UncheckedAt(iMCtrack);
 956
 957                                         if ((mcPart->GetStatus() == 21) || (mcPart->GetPdgCode() == 443 && mcPart->GetMother() == -1))
 958                                         {
 959                                                 isInjected = iMCtrack;
 960                                         }
 961
 962                                         if(isInjected >= 0 && isMCtype == 1)
 963                                         {continue;}
 964                                         if(isInjected < 0 && isMCtype == -1)
 965                                         {continue;}
 966
 967                                         Int_t code=mcPart->GetPdgCode();
 968                                         if (code != kK0Short && code != kLambda0 && code != kLambda0Bar )
 969                                         {continue;}
 970
 971                                         if(code == kLambda0)
 972                                         {
 973                                                 lambdaMC = true;
 974                                         }
 975                                         else if(code == kK0Short)
 976                                         {
 977                                                 kshortMC = true;
 978                                         }
 979                                         else if(code == kLambda0Bar)
 980                                         {
 981                                                 antilambdaMC = true;
 982                                         }
 983
 984
 985                                         Int_t motherLabel = mcPart->GetMother();
 986                                         AliAODMCParticle *mcMother = (AliAODMCParticle *)stack->UncheckedAt(motherLabel);
 987                                         Int_t motherType = -1;
 988                                         if(motherLabel >= 0)
 989                                         {motherType = mcMother->GetPdgCode();}
 990
 991                                         // this block of code is used to include primary Sigma0 decays as primary lambda/antilambda
 992                                         bool sigma0MC = false;
 993                                         if(motherType == 3212 || motherType == -3212)// || motherType == 3322 || motherType == -3322 || motherType == 3312 || motherType == -3312)
 994                                         {
 995                                                 if(mcMother->IsPhysicalPrimary())
 996                                                 {sigma0MC = true;}
 997                                         }
 998
 999                                         Double_t dz=mcZv - mcPart->Zv(), dy=mcYv - mcPart->Yv(), dx=mcXv - mcPart->Xv();
1000                                         Double_t mcDecayLength = TMath::Sqrt(dx*dx + dy*dy + dz*dz);
1001                                         Double_t mccTau = mcDecayLength*(mcPart->M())/(mcPart->P());
1002                                         Double_t mcCosPA = (dx*mcPart->Px()+dy*mcPart->Py()+dz*mcPart->Pz())/(mcDecayLength*mcPart->P());
1003
1004                                         if(mcPart->IsPhysicalPrimary() || sigma0MC)
1005                                         {
1006                                                 isprimaryMC = true;
1007                                                 if(lambdaMC)
1008                                                 {
1009                                                         if(TMath::Abs(mcPart->Y())<=cutRapidity)
1010                                                         {
1011                                                                 fHistMcPMLaPt->Fill(mcPart->Pt(),mcPart->M());
1012
1013                                                                 if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1014                                                                 {fHistMcPMLaPtCent0005->Fill(mcPart->Pt(),mcPart->M());}
1015                                                                 if(centPercentile > 5.0 && centPercentile <= 10.0)
1016                                                                 {fHistMcPMLaPtCent0510->Fill(mcPart->Pt(),mcPart->M());}
1017                                                                 if(centPercentile > 10.0 && centPercentile <= 20.0)
1018                                                                 {fHistMcPMLaPtCent1020->Fill(mcPart->Pt(),mcPart->M());}
1019                                                                 if(centPercentile > 20.0 && centPercentile <= 40.0)
1020                                                                 {fHistMcPMLaPtCent2040->Fill(mcPart->Pt(),mcPart->M());}
1021                                                                 if(centPercentile > 40.0 && centPercentile <= 60.0)
1022                                                                 {fHistMcPMLaPtCent4060->Fill(mcPart->Pt(),mcPart->M());}
1023                                                                 if(centPercentile > 60.0 && centPercentile <= 90.0)
1024                                                                 {fHistMcPMLaPtCent6090->Fill(mcPart->Pt(),mcPart->M());}
1025                                                                 if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1026                                                                 {fHistMcPMLaPtCent0090->Fill(mcPart->Pt(),mcPart->M());}
1027
1028                                                                 fHistMcCosPaAllLaPt->Fill(mcCosPA,mcPart->M());
1029                                                                 fHistMccTauAllLaPt->Fill(mccTau,mcPart->M());
1030                                                                 fHistMcDcaAllLaPt->Fill(mcDecayLength,mcPart->M());
1031                                                                 fHistMcNSigmaAllLaPt->Fill(1.0,mcPart->M());
1032                                                                 fHistMcEtaAllLaPt->Fill(mcPart->Eta(),mcPart->M());
1033                                                                 fHistMcRapAllLaPt->Fill(mcPart->Y(),mcPart->M());
1034                                                         }
1035                                                 }
1036                                                 if(antilambdaMC)
1037                                                 {
1038                                                         if(TMath::Abs(mcPart->Y())<=cutRapidity)
1039                                                         {
1040                                                                 fHistMcPMLbPt->Fill(mcPart->Pt(),mcPart->M());
1041
1042                                                                 if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1043                                                                 {fHistMcPMLbPtCent0005->Fill(mcPart->Pt(),mcPart->M());}
1044                                                                 if(centPercentile > 5.0 && centPercentile <= 10.0)
1045                                                                 {fHistMcPMLbPtCent0510->Fill(mcPart->Pt(),mcPart->M());}
1046                                                                 if(centPercentile > 10.0 && centPercentile <= 20.0)
1047                                                                 {fHistMcPMLbPtCent1020->Fill(mcPart->Pt(),mcPart->M());}
1048                                                                 if(centPercentile > 20.0 && centPercentile <= 40.0)
1049                                                                 {fHistMcPMLbPtCent2040->Fill(mcPart->Pt(),mcPart->M());}
1050                                                                 if(centPercentile > 40.0 && centPercentile <= 60.0)
1051                                                                 {fHistMcPMLbPtCent4060->Fill(mcPart->Pt(),mcPart->M());}
1052                                                                 if(centPercentile > 60.0 && centPercentile <= 90.0)
1053                                                                 {fHistMcPMLbPtCent6090->Fill(mcPart->Pt(),mcPart->M());}
1054                                                                 if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1055                                                                 {fHistMcPMLbPtCent0090->Fill(mcPart->Pt(),mcPart->M());}
1056
1057                                                                 fHistMcCosPaAllLbPt->Fill(mcCosPA,mcPart->M());
1058                                                                 fHistMccTauAllLbPt->Fill(mccTau,mcPart->M());
1059                                                                 fHistMcDcaAllLbPt->Fill(mcDecayLength,mcPart->M());
1060                                                                 fHistMcNSigmaAllLbPt->Fill(1.0,mcPart->M());
1061                                                                 fHistMcEtaAllLbPt->Fill(mcPart->Eta(),mcPart->M());
1062                                                                 fHistMcRapAllLbPt->Fill(mcPart->Y(),mcPart->M());
1063
1064                                                         }
1065                                                 }
1066                                                 if(kshortMC)
1067                                                 {
1068                                                         if(TMath::Abs(mcPart->Y())<=cutRapidity)
1069                                                         {
1070                                                                 fHistMcPMK0Pt->Fill(mcPart->Pt(),mcPart->M());
1071
1072                                                                 if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1073                                                                 {fHistMcPMK0PtCent0005->Fill(mcPart->Pt(),mcPart->M());}
1074                                                                 if(centPercentile > 5.0 && centPercentile <= 10.0)
1075                                                                 {fHistMcPMK0PtCent0510->Fill(mcPart->Pt(),mcPart->M());}
1076                                                                 if(centPercentile > 10.0 && centPercentile <= 20.0)
1077                                                                 {fHistMcPMK0PtCent1020->Fill(mcPart->Pt(),mcPart->M());}
1078                                                                 if(centPercentile > 20.0 && centPercentile <= 40.0)
1079                                                                 {fHistMcPMK0PtCent2040->Fill(mcPart->Pt(),mcPart->M());}
1080                                                                 if(centPercentile > 40.0 && centPercentile <= 60.0)
1081                                                                 {fHistMcPMK0PtCent4060->Fill(mcPart->Pt(),mcPart->M());}
1082                                                                 if(centPercentile > 60.0 && centPercentile <= 90.0)
1083                                                                 {fHistMcPMK0PtCent6090->Fill(mcPart->Pt(),mcPart->M());}
1084                                                                 if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1085                                                                 {fHistMcPMK0PtCent0090->Fill(mcPart->Pt(),mcPart->M());}
1086
1087                                                                 fHistMcCosPaAllK0Pt->Fill(mcCosPA,mcPart->M());
1088                                                                 fHistMccTauAllK0Pt->Fill(mccTau,mcPart->M());
1089                                                                 fHistMcDcaAllK0Pt->Fill(mcDecayLength,mcPart->M());
1090                                                                 fHistMcNSigmaAllK0Pt->Fill(1.0,mcPart->M());
1091                                                                 fHistMcEtaAllK0Pt->Fill(mcPart->Eta(),mcPart->M());
1092                                                                 fHistMcRapAllK0Pt->Fill(mcPart->Y(),mcPart->M());
1093
1094                                                         }
1095                                                 }
1096                                         }
1097
1098
1099
1100                                 }
1101
1102                         }
1103                 }
1104         }
1105
1106         /********End of MC************************************/
1107
1108         // Find vertex, check if its good
1109         const AliAODVertex *vtx=aod->GetPrimaryVertex();
1110
1111         if (!vtx)
1112         {
1113                 fHistLog->Fill(97);
1114                 return;
1115         }
1116
1117
1118         if (vtx->GetNContributors()<3)
1119         {
1120                 fHistLog->Fill(vtx->GetNContributors()+20);
1121                 fHistLog->Fill(97);
1122                 return;
1123         }
1124
1125         Double_t zv=vtx->GetZ(), xv=vtx->GetX(), yv=vtx->GetY();
1126
1127         if (TMath::Abs(zv) > 10.)
1128         {
1129                 fHistLog->Fill(96);
1130                 return;
1131         }
1132
1133         fHistZVertex->Fill(zv);
1134
1135         if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1136         {fHistZVertexCent0005->Fill(zv);}
1137         if(centPercentile > 5.0 && centPercentile <= 10.0)
1138         {fHistZVertexCent0510->Fill(zv);}
1139         if(centPercentile > 10.0 && centPercentile <= 20.0)
1140         {fHistZVertexCent1020->Fill(zv);}
1141         if(centPercentile > 20.0 && centPercentile <= 40.0)
1142         {fHistZVertexCent2040->Fill(zv);}
1143         if(centPercentile > 40.0 && centPercentile <= 60.0)
1144         {fHistZVertexCent4060->Fill(zv);}
1145         if(centPercentile > 60.0 && centPercentile <= 90.0)
1146         {fHistZVertexCent6090->Fill(zv);}
1147         if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1148         {fHistZVertexCent0090->Fill(zv);}
1149
1150     /********V0 loop for reconstructed event************************************/
1151
1152     Int_t nv0s = aod->GetNumberOfV0s();
1153         fHistNV0->Fill(nv0s);
1154
1155         for(Int_t i = 0; i < nv0s; i++)
1156         {
1157                 fHistLog->Fill(7);
1158         AliAODv0 *v0=aod->GetV0(i); // pointer to reconstructed v0
1159         if(!v0)
1160                 {
1161                         //Printf("No V0 ");
1162                         fHistLog->Fill(94);
1163             continue;
1164                 }
1165
1166                 Bool_t lambdaCandidate = kTRUE;
1167                 Bool_t antilambdaCandidate = kTRUE;
1168                 Bool_t k0Candidate = kTRUE;
1169
1170                 if (v0->MassLambda() < 1.08 || v0->MassLambda() > 1.2)
1171                 {lambdaCandidate = kFALSE;}
1172         if (v0->MassAntiLambda() < 1.08 || v0->MassAntiLambda() > 1.2)
1173                 {antilambdaCandidate = kFALSE;}
1174         if (v0->MassK0Short() < 0.414 || v0->MassK0Short() > 0.582)
1175                 {k0Candidate = kFALSE;}
1176
1177                 if(lambdaCandidate == kFALSE && antilambdaCandidate == kFALSE && k0Candidate == kFALSE)
1178                 {continue;}
1179
1180                 Double_t cosPA=v0->CosPointingAngle(aod->GetPrimaryVertex());
1181                 Double_t xyz[3];
1182                 v0->GetSecondaryVtx(xyz);
1183                 Double_t decayL = TMath::Sqrt((xyz[0]-xv)*(xyz[0]-xv)+(xyz[1]-yv)*(xyz[1]-yv)+(xyz[2]-zv)*(xyz[2]-zv));
1184                 Double_t dca=v0->DcaV0Daughters();
1185                 Double_t eta=v0->PseudoRapV0();
1186
1187                 if(!AcceptV0_general(v0,aod,cutCosPa,cutNImpact,cutDCA,cutEta,cutMinNClustersTPC, cutRatio))
1188                 {
1189                         fHistLog->Fill(86);
1190                         continue;
1191                 }
1192
1193                 int nnum = 1, pnum = 0;
1194                 const AliAODTrack *ntracktest=(AliAODTrack *)v0->GetDaughter(nnum);
1195                 if(ntracktest->Charge() > 0){nnum = 0; pnum = 1;}
1196
1197                 const AliAODTrack *ntrack1=(AliAODTrack *)v0->GetDaughter(nnum);
1198                 const AliAODTrack *ptrack1=(AliAODTrack *)v0->GetDaughter(pnum);
1199                 if(ntrack1->Charge()>0)
1200                 {
1201                         fHistLog->Fill(55);
1202                 }
1203                 if(ntrack1->Charge()==0)
1204                 {
1205                         fHistLog->Fill(50);
1206                 }
1207                 if(ntrack1->Charge()<0)
1208                 {
1209                         fHistLog->Fill(45);
1210                 }
1211                 const AliAODPid *pid_p1=ptrack1->GetDetPid();
1212                 const AliAODPid *pid_n1=ntrack1->GetDetPid();
1213
1214
1215                 /*if(peterCuts)
1216                 {
1217                         const AliAODTrack *ptrack1=(AliAODTrack *)v0->GetDaughter(0);
1218                         if(ntrack1->Pt() < 0.160 || ptrack1->Pt() < 0.160) continue;
1219
1220                         Double_t r2=xyz[0]*xyz[0] + xyz[1]*xyz[1];
1221                         Double_t radius = TMath::Sqrt(r2);
1222                         if(radius <= 0.9 || radius >= 100) continue;
1223
1224                 }*/
1225
1226                 if(!AcceptV0_particle(v0,1,cutcTau, cutRapidity, decayL))
1227                 { lambdaCandidate = kFALSE; }
1228                 if(!AcceptV0_particle(v0,2,cutcTau, cutRapidity, decayL))
1229                 { antilambdaCandidate = kFALSE; }
1230                 if(!AcceptV0_particle(v0,0,cutcTau, cutRapidity, decayL))
1231                 { k0Candidate = kFALSE; }
1232
1233                 if(TMath::Sqrt(v0->Pt2V0())<2)
1234                 {
1235                         if(!AcceptV0_lowpt(v0,fPIDResponse,1,cutBetheBloch,decayL,isMonteCarlo))
1236                         { lambdaCandidate = kFALSE; }
1237                         if(!AcceptV0_lowpt(v0,fPIDResponse,2,cutBetheBloch,decayL,isMonteCarlo))
1238                         { antilambdaCandidate = kFALSE; }
1239                         if(!AcceptV0_lowpt(v0,fPIDResponse,0,cutBetheBloch,decayL,isMonteCarlo))
1240                         { k0Candidate = kFALSE; }
1241                 }
1242
1243                 if(lambdaCandidate == kFALSE && antilambdaCandidate == kFALSE && k0Candidate == kFALSE)
1244                 {continue;}
1245
1246                 fHistLog->Fill(7);
1247         fHistPt->Fill(TMath::Sqrt(v0->Pt2V0()));
1248         fHistEta->Fill(v0->PseudoRapV0());
1249
1250                 bool feeddown = false;
1251
1252                 if(isMonteCarlo)
1253                 {
1254                         bool passedTests = false;
1255                         TList *list = aod->GetList();
1256                         TClonesArray *stack = 0x0;
1257                         stack = (TClonesArray*)list->FindObject(AliAODMCParticle::StdBranchName());
1258                         if (!stack)
1259                         {
1260                                 Printf("ERROR: stack not available");
1261                                 fHistLog->Fill(84);
1262                         }
1263                         else
1264
1265                         {
1266                                 Int_t negAssLabel = TMath::Abs(ntrack1->GetLabel());
1267                                 if(negAssLabel>=0 && negAssLabel < stack->GetEntriesFast())
1268                                 {
1269                                 AliAODMCParticle *mcNegPart =(AliAODMCParticle*)stack->UncheckedAt(negAssLabel);
1270                                 Int_t v0Label = mcNegPart->GetMother();
1271                                 if(v0Label >= 0 && v0Label < stack->GetEntriesFast())
1272                                 {
1273                                         AliAODMCParticle *mcv0 = (AliAODMCParticle *)stack->UncheckedAt(v0Label);
1274                                         passedTests = true;
1275
1276                                         if ((v0Label >= isInjected && isInjected >= 0 && isMCtype == 1) || (v0Label < isInjected && isInjected >= 0 && isMCtype == -1))
1277                                         {
1278                                                 lambdaCandidate = false;
1279                                                 k0Candidate = false;
1280                                                 antilambdaCandidate = false;
1281                                         }
1282
1283                                                 if(mcv0->GetPdgCode() != kLambda0)
1284                                                 {
1285                                                         lambdaCandidate = false;
1286                                                 }
1287                                                 if(mcv0->GetPdgCode() != kK0Short)
1288                                                 {
1289                                                         k0Candidate = false;
1290                                                 }
1291                                                 if(mcv0->GetPdgCode() != kLambda0Bar)
1292                                                 {
1293                                                         antilambdaCandidate = false;
1294                                                 }
1295
1296                                         Int_t motherLabel = mcv0->GetMother();
1297                                         Int_t motherType = -1;
1298                                         bool sigma0MC2 = false;
1299
1300                                         if(motherLabel >= 0 && v0Label < stack->GetEntriesFast() )
1301                                         {
1302                                                 AliAODMCParticle *mcMother = (AliAODMCParticle *)stack->UncheckedAt(motherLabel);
1303                                                 motherType = mcMother->GetPdgCode();
1304
1305                                         // this block of code is used to include primary Sigma0 decays as primary lambda/antilambda
1306
1307                                                 if ((motherLabel >= isInjected && isInjected >= 0 && isMCtype == 1) || (motherLabel < isInjected && isInjected >= 0 && isMCtype == -1))
1308                                                 {
1309                                                         lambdaCandidate = false;
1310                                                         k0Candidate = false;
1311                                                         antilambdaCandidate = false;
1312                                                 }
1313                                                 if(motherType == 3212 || motherType == -3212)
1314                                                 {
1315                                                         if(mcMother->IsPhysicalPrimary())
1316                                                         {sigma0MC2 = true;}
1317                                                 }
1318                                                 if(motherType == 3322 || motherType == -3322 || motherType == 3312 || motherType == -3312 )
1319                                                 {
1320                                                         if(mcMother->IsPhysicalPrimary())
1321                                                         {feeddown = true;}
1322                                                 }
1323                                         }
1324
1325                                         if(!sigma0MC2 && !mcv0->IsPhysicalPrimary() && !feeddown)
1326                                         {
1327                                                 lambdaCandidate = false;
1328                                                 k0Candidate = false;
1329                                                 antilambdaCandidate = false;
1330                                         }
1331                                 }
1332                                 }
1333                         }
1334
1335                         if(passedTests == false)
1336                         {
1337                                 lambdaCandidate = false;
1338                                 k0Candidate = false;
1339                                 antilambdaCandidate = false;
1340                         }
1341
1342                 }
1343
1344
1345
1346                 if(lambdaCandidate)
1347                 {
1348
1349                         if(!feeddown)
1350                         {
1351                         fHistMLaPt->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());
1352                         if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1353                         {fHistMLaPtCent0005->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1354                         if(centPercentile > 5.0 && centPercentile <= 10.0)
1355                         {fHistMLaPtCent0510->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1356                         if(centPercentile > 10.0 && centPercentile <= 20.0)
1357                         {fHistMLaPtCent1020->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1358                         if(centPercentile > 20.0 && centPercentile <= 40.0)
1359                         {fHistMLaPtCent2040->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1360                         if(centPercentile > 40.0 && centPercentile <= 60.0)
1361                         {fHistMLaPtCent4060->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1362                         if(centPercentile > 60.0 && centPercentile <= 90.0)
1363                         {fHistMLaPtCent6090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1364                         }
1365
1366                         if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1367                         {
1368                                 if(!feeddown)
1369                                 {
1370                                 fHistMLaPtCent0090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());
1371                                 fHistBBLaPos->Fill(pid_p1->GetTPCmomentum(),pid_p1->GetTPCsignal());
1372                                 fHistBBLaNeg->Fill(pid_n1->GetTPCmomentum(),pid_n1->GetTPCsignal());
1373                                 }
1374                                 if(feeddown)
1375                                 {fHistMcFMLaPt->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassLambda());}
1376                         }
1377                         if(!feeddown)
1378                         {
1379                         fHistCosPaLaPt->Fill(cosPA,v0->MassLambda());
1380                         fHistcTauLaPt->Fill(decayL*(TMath::Sqrt(v0->Pt2V0()))/(v0->P()),v0->MassLambda());
1381                         fHistDcaLaPt->Fill(dca,v0->MassLambda());
1382                         fHistNSigmaLaPt->Fill(1.0,v0->MassLambda());
1383                         fHistEtaLaPt->Fill(eta,v0->MassLambda());
1384                         fHistRapLaPt->Fill(v0->RapLambda(),v0->MassLambda());
1385
1386
1387                         if(isMonteCarlo)
1388                         {
1389                                 fHistMcCosPaFoundLaPt->Fill(1.0,v0->MassLambda());
1390                                 fHistMccTauFoundLaPt->Fill(1.0,v0->MassLambda());
1391                                 fHistMcDcaFoundLaPt->Fill(1.0,v0->MassLambda());
1392                                 fHistMcNSigmaFoundLaPt->Fill(1.0,v0->MassLambda());
1393                                 fHistMcEtaFoundLaPt->Fill(1.0,v0->MassLambda());
1394                                 fHistMcRapFoundLaPt->Fill(1.0,v0->MassLambda());
1395                         }
1396                         }
1397
1398                 }
1399                 if(antilambdaCandidate)
1400                 {
1401                         if(!feeddown)
1402                         {
1403                         fHistMLbPt->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());
1404
1405                         if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1406                         {fHistMLbPtCent0005->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1407                         if(centPercentile > 5.0 && centPercentile <= 10.0)
1408                         {fHistMLbPtCent0510->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1409                         if(centPercentile > 10.0 && centPercentile <= 20.0)
1410                         {fHistMLbPtCent1020->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1411                         if(centPercentile > 20.0 && centPercentile <= 40.0)
1412                         {fHistMLbPtCent2040->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1413                         if(centPercentile > 40.0 && centPercentile <= 60.0)
1414                         {fHistMLbPtCent4060->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1415                         if(centPercentile > 60.0 && centPercentile <= 90.0)
1416                         {fHistMLbPtCent6090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());}
1417
1418                         if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1419                         {
1420                                 fHistMLbPtCent0090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassAntiLambda());
1421                                 fHistBBLbPos->Fill(pid_p1->GetTPCmomentum(),pid_p1->GetTPCsignal());
1422                                 fHistBBLbNeg->Fill(pid_n1->GetTPCmomentum(),pid_n1->GetTPCsignal());
1423                         }
1424
1425
1426                         fHistCosPaLbPt->Fill(cosPA,v0->MassAntiLambda());
1427                         fHistcTauLbPt->Fill(decayL*(v0->MassAntiLambda())/(v0->P()),v0->MassAntiLambda());
1428                         fHistDcaLbPt->Fill(dca,v0->MassAntiLambda());
1429                         fHistNSigmaLbPt->Fill(1.0,v0->MassAntiLambda());
1430                         fHistEtaLbPt->Fill(eta,v0->MassAntiLambda());
1431                         fHistRapLbPt->Fill(v0->RapLambda(),v0->MassAntiLambda());
1432
1433                         if(isMonteCarlo)
1434                         {
1435                                 fHistMcCosPaFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1436                                 fHistMccTauFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1437                                 fHistMcDcaFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1438                                 fHistMcNSigmaFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1439                                 fHistMcEtaFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1440                                 fHistMcRapFoundLbPt->Fill(1.0,v0->MassAntiLambda());
1441                         }
1442                         }
1443                 }
1444                 if(k0Candidate)
1445                 {
1446                         if(!feeddown)
1447                         {
1448                         fHistMK0Pt->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());
1449
1450                         if(centPercentile >= 0.0001 && centPercentile <= 5.0)
1451                         {fHistMK0PtCent0005->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1452                         if(centPercentile > 5.0 && centPercentile <= 10.0)
1453                         {fHistMK0PtCent0510->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1454                         if(centPercentile > 10.0 && centPercentile <= 20.0)
1455                         {fHistMK0PtCent1020->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1456                         if(centPercentile > 20.0 && centPercentile <= 40.0)
1457                         {fHistMK0PtCent2040->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1458                         if(centPercentile > 40.0 && centPercentile <= 60.0)
1459                         {fHistMK0PtCent4060->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1460                         if(centPercentile > 60.0 && centPercentile <= 90.0)
1461                         {fHistMK0PtCent6090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());}
1462
1463                         if(centPercentile >= 0.0001 && centPercentile <= 90.0)
1464                         {
1465                                 fHistMK0PtCent0090->Fill(TMath::Sqrt(v0->Pt2V0()),v0->MassK0Short());
1466                                 fHistBBK0Pos->Fill(pid_p1->GetTPCmomentum(),pid_p1->GetTPCsignal());
1467                                 fHistBBK0Neg->Fill(pid_n1->GetTPCmomentum(),pid_n1->GetTPCsignal());
1468                         }
1469
1470
1471                         fHistCosPaK0Pt->Fill(cosPA,v0->MassK0Short());
1472                         fHistcTauK0Pt->Fill(decayL*(v0->MassK0Short())/(v0->P()),v0->MassK0Short());
1473                         fHistDcaK0Pt->Fill(dca,v0->MassK0Short());
1474                         fHistNSigmaK0Pt->Fill(1.0,v0->MassK0Short());
1475                         fHistEtaK0Pt->Fill(eta,v0->MassK0Short());
1476                         fHistRapK0Pt->Fill(v0->RapK0Short(),v0->MassK0Short());
1477
1478                         if(isMonteCarlo)
1479                         {
1480                                 fHistMcCosPaAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1481                                 fHistMccTauAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1482                                 fHistMcDcaAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1483                                 fHistMcNSigmaAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1484                                 fHistMcEtaAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1485                                 fHistMcRapAFoundK0Pt->Fill(1.0,v0->MassK0Short());
1486                         }
1487                         }
1488                 }
1489     }
1490
1491         /********End of V0 loop for reconstructed event*****************************/
1492
1493
1494
1495
1496         fHistLog->Fill(9);
1497     // NEW HISTO should be filled before this point, as PostData puts the
1498     // information for this iteration of the UserExec in the container
1499     PostData(1, fOutput);
1500 }
1501
1502
1503 //________________________________________________________________________
1504 void AliAnalysisTaskLukeAOD::Terminate(Option_t *)
1505 {
1506     // Draw result to screen, or perform fitting, normalizations
1507     // Called once at the end of the query
1508
1509     fOutput = dynamic_cast<TList*> (GetOutputData(1));
1510     if(!fOutput) { Printf("ERROR: could not retrieve TList fOutput"); return; }
1511
1512     fHistPt = dynamic_cast<TH1F*> (fOutput->FindObject("fHistPt"));
1513     if (!fHistPt) { Printf("ERROR: could not retrieve fHistPt"); return;}
1514     fHistEta = dynamic_cast<TH1F*> (fOutput->FindObject("fHistEta"));
1515     if (!fHistEta) { Printf("ERROR: could not retrieve fHistEta"); return;}
1516
1517     // Get the physics selection histograms with the selection statistics
1518     //AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
1519     //AliESDInputHandler *inputH = dynamic_cast<AliESDInputHandler*>(mgr->GetInputEventHandler());
1520     //TH2F *histStat = (TH2F*)inputH->GetStatistics();
1521
1522
1523     // NEW HISTO should be retrieved from the TList container in the above way,
1524     // so it is available to draw on a canvas such as below
1525
1526     TCanvas *c = new TCanvas("AliAnalysisTaskLukeAOD","P_{T} & #eta",10,10,1020,510);
1527     c->Divide(2,1);
1528     c->cd(1)->SetLogy();
1529     fHistPt->DrawCopy("E");
1530     c->cd(2);
1531     fHistEta->DrawCopy("E");
1532 }