PWGLF/STRANGENESS/LambdaK0/AliAnalysisTaskExtractV0.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 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  17 //
  18 // Modified version of AliAnalysisTaskCheckCascade.cxx.
  19 // This is a 'hybrid' output version, in that it uses a classic TTree
  20 // ROOT object to store the candidates, plus a couple of histograms filled on
  21 // a per-event basis for storing variables too numerous to put in a tree.
  22 //
  23 // --- Added bits of code for checking V0s
  24 //      (from AliAnalysisTaskCheckStrange.cxx)
  25 //
  26 //  --- Algorithm Description
  27 //   1. Perform Physics Selection
  28 //   2. Perform Primary Vertex |z|<10cm selection
  29 //   3. Perform Primary Vertex NoTPCOnly vertexing selection (>0 contrib.)
  30 //   4. Perform Pileup Rejection
  31 //   5. Analysis Loops:
  32 //    5a. Fill TTree object with V0 information, candidates
  33 //
  34 //  Please Report Any Bugs!
  35 //
  36 //   --- David Dobrigkeit Chinellato
  37 //        (david.chinellato@gmail.com)
  38 //
  39 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  40
  41 class TTree;
  42 class TParticle;
  43 class TVector3;
  44
  45 //class AliMCEventHandler;
  46 //class AliMCEvent;
  47 //class AliStack;
  48
  49 class AliESDVertex;
  50 class AliAODVertex;
  51 class AliESDv0;
  52 class AliAODv0;
  53
  54 #include <Riostream.h>
  55 #include "TList.h"
  56 #include "TH1.h"
  57 #include "TH2.h"
  58 #include "TH3.h"
  59 #include "THnSparse.h"
  60 #include "TVector3.h"
  61 #include "TCanvas.h"
  62 #include "TMath.h"
  63 #include "TLegend.h"
  64 #include "AliLog.h"
  65 #include "AliCentrality.h"
  66 #include "AliESDEvent.h"
  67 #include "AliAODEvent.h"
  68 #include "AliV0vertexer.h"
  69 #include "AliCascadeVertexer.h"
  70 #include "AliESDpid.h"
  71 #include "AliESDtrack.h"
  72 #include "AliESDtrackCuts.h"
  73 #include "AliInputEventHandler.h"
  74 #include "AliAnalysisManager.h"
  75 #include "AliMCEventHandler.h"
  76
  77 #include "AliCFContainer.h"
  78 #include "AliMultiplicity.h"
  79
  80 #include "AliESDcascade.h"
  81 #include "AliAODcascade.h"
  82 #include "AliESDUtils.h"
  83 #include "AliESDHeader.h"
  84
  85 #include "AliAnalysisUtils.h"
  86 #include "AliAnalysisTaskExtractV0.h"
  87
  88 //debugging purposes
  89 #include "TObjectTable.h"
  90
  91 ClassImp(AliAnalysisTaskExtractV0)
  92
  93 AliAnalysisTaskExtractV0::AliAnalysisTaskExtractV0()
  94   : AliAnalysisTaskSE(), fListHistV0(0), fTree(0), fPIDResponse(0),fESDtrackCuts(0), fUtils(0),
  95   fkIsNuclear     ( kFALSE ),
  96   fkSwitchINT7    ( kFALSE ),
  97   fkUseOnTheFly   ( kFALSE ),
  98   fkTakeAllTracks ( kFALSE ),
  99   fCentralityEstimator("V0M"),
 100   fkLightWeight   ( kFALSE ),
 101   fkFastOnly      ( "" ),
 102   fkpAVertexSelection( kFALSE ),
 103   fkRunV0Vertexer ( kFALSE ),
 104   fkRejectPileup  ( kTRUE ),
 105   fkSpecialExecution( kFALSE ),
 106   fkSkipTrigger   ( kFALSE ),
 107   fExtraDCAHeavyToPrimVertex(0),
 108   fExtraDCALightToPrimVertex(0),
 109 //------------------------------------------------
 110 // Initialize
 111         fTreeVariableChi2V0(0),
 112         fTreeVariableDcaV0Daughters(0),
 113         fTreeVariableDcaV0ToPrimVertex(0),
 114         fTreeVariableDcaPosToPrimVertex(0),
 115         fTreeVariableDcaNegToPrimVertex(0),
 116         fTreeVariableV0CosineOfPointingAngle(0),
 117         fTreeVariableV0Radius(0),
 118         fTreeVariablePt(0),
 119         fTreeVariableRapK0Short(0),
 120         fTreeVariableRapLambda(0),
 121         fTreeVariableInvMassK0s(0),
 122         fTreeVariableInvMassLambda(0),
 123         fTreeVariableInvMassAntiLambda(0),
 124         fTreeVariableAlphaV0(0),
 125         fTreeVariablePtArmV0(0),
 126         fTreeVariableNegTotMomentum(0),
 127         fTreeVariablePosTotMomentum(0),
 128         fTreeVariableNegdEdxSig(0),
 129         fTreeVariablePosdEdxSig(0),
 130         fTreeVariableNegEta(0),
 131         fTreeVariablePosEta(0),
 132
 133         fTreeVariableNSigmasPosProton(0),
 134         fTreeVariableNSigmasPosPion(0),
 135         fTreeVariableNSigmasNegProton(0),
 136         fTreeVariableNSigmasNegPion(0),
 137
 138         fTreeVariableDistOverTotMom(0),
 139         fTreeVariableLeastNbrCrossedRows(0),
 140         fTreeVariableLeastRatioCrossedRowsOverFindable(0),
 141         fTreeVariableMultiplicity(0),
 142         fTreeVariableMultiplicityV0A(0),
 143         fTreeVariableMultiplicityZNA(0),
 144         fTreeVariableMultiplicityTRK(0),
 145         fTreeVariableMultiplicitySPD(0),
 146
 147   fTreeVariableRunNumber(0),
 148   fTreeVariableEventNumber(0),
 149
 150   fTreeVariableV0x(0),
 151   fTreeVariableV0y(0),
 152   fTreeVariableV0z(0),
 153
 154   fTreeVariableV0Px(0),
 155   fTreeVariableV0Py(0),
 156   fTreeVariableV0Pz(0),
 157
 158   fTreeVariablePVx(0),
 159   fTreeVariablePVy(0),
 160   fTreeVariablePVz(0),
 161
 162   fTreeVariableNegTrackStatus(0),
 163   fTreeVariablePosTrackStatus(0),
 164
 165   fTreeVariableNegTPCSignal(0),
 166   fTreeVariablePosTPCSignal(0),
 167   fTreeVariableNegInnerP(0),
 168   fTreeVariablePosInnerP(0),
 169
 170   fTreeVariableNegPx(0),
 171   fTreeVariableNegPy(0),
 172   fTreeVariableNegPz(0),
 173   fTreeVariablePosPx(0),
 174   fTreeVariablePosPy(0),
 175   fTreeVariablePosPz(0),
 176
 177
 178 //------------------------------------------------
 179 // HISTOGRAMS
 180 // --- Filled on an Event-by-event basis
 181 //------------------------------------------------
 182    fHistV0MultiplicityBeforeTrigSel(0),
 183    fHistV0MultiplicityForTrigEvt(0),
 184    fHistV0MultiplicityForSelEvt(0),
 185    fHistV0MultiplicityForSelEvtNoTPCOnly(0),
 186    fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup(0),
 187    fHistMultiplicityBeforeTrigSel(0),
 188    fHistMultiplicityForTrigEvt(0),
 189    fHistMultiplicity(0),
 190    fHistMultiplicityNoTPCOnly(0),
 191    fHistMultiplicityNoTPCOnlyNoPileup(0),
 192
 193 //V0A Centrality
 194 fHistMultiplicityV0ABeforeTrigSel(0),
 195 fHistMultiplicityV0AForTrigEvt(0),
 196 fHistMultiplicityV0A(0),
 197 fHistMultiplicityV0ANoTPCOnly(0),
 198 fHistMultiplicityV0ANoTPCOnlyNoPileup(0),
 199
 200 //ZNA Centrality
 201 fHistMultiplicityZNABeforeTrigSel(0),
 202 fHistMultiplicityZNAForTrigEvt(0),
 203 fHistMultiplicityZNA(0),
 204 fHistMultiplicityZNANoTPCOnly(0),
 205 fHistMultiplicityZNANoTPCOnlyNoPileup(0),
 206
 207 //TRK Centrality
 208 fHistMultiplicityTRKBeforeTrigSel(0),
 209 fHistMultiplicityTRKForTrigEvt(0),
 210 fHistMultiplicityTRK(0),
 211 fHistMultiplicityTRKNoTPCOnly(0),
 212 fHistMultiplicityTRKNoTPCOnlyNoPileup(0),
 213
 214 //SPD Centrality
 215 fHistMultiplicitySPDBeforeTrigSel(0),
 216 fHistMultiplicitySPDForTrigEvt(0),
 217 fHistMultiplicitySPD(0),
 218 fHistMultiplicitySPDNoTPCOnly(0),
 219 fHistMultiplicitySPDNoTPCOnlyNoPileup(0),
 220
 221   //Raw Data for Vertex Z position estimator change
 222         f2dHistMultiplicityVsVertexZBeforeTrigSel(0),
 223         f2dHistMultiplicityVsVertexZForTrigEvt(0),
 224         f2dHistMultiplicityVsVertexZ(0),
 225         f2dHistMultiplicityVsVertexZNoTPCOnly(0),
 226         f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup(0),
 227
 228    fHistPVx(0),
 229    fHistPVy(0),
 230    fHistPVz(0),
 231    fHistPVxAnalysis(0),
 232    fHistPVyAnalysis(0),
 233    fHistPVzAnalysis(0),
 234    fHistSwappedV0Counter(0),
 235   f2dHistdEdxPos(0),
 236   f2dHistdEdxNeg(0)
 237 {
 238   // Dummy Constructor
 239   for(Int_t iV0selIdx   = 0; iV0selIdx   < 7; iV0selIdx++   ) { fV0Sels          [iV0selIdx   ] = -1.; }
 240 }
 241
 242 AliAnalysisTaskExtractV0::AliAnalysisTaskExtractV0(const char *name)
 243   : AliAnalysisTaskSE(name), fListHistV0(0), fTree(0), fPIDResponse(0),fESDtrackCuts(0), fUtils(0),
 244   fkIsNuclear     ( kFALSE ),
 245   fkSwitchINT7    ( kFALSE ),
 246   fkUseOnTheFly   ( kFALSE ),
 247   fkTakeAllTracks ( kFALSE ),
 248   fCentralityEstimator("V0M"),
 249   fkLightWeight   ( kFALSE ),
 250   fkFastOnly      ( "" ),
 251   fkpAVertexSelection( kFALSE ),
 252   fkRunV0Vertexer ( kFALSE ),
 253   fkRejectPileup  ( kTRUE ),
 254   fkSpecialExecution( kFALSE ),
 255   fkSkipTrigger   ( kFALSE ),
 256   fExtraDCAHeavyToPrimVertex(0),
 257   fExtraDCALightToPrimVertex(0),
 258 //------------------------------------------------
 259 // Initialize
 260         fTreeVariableChi2V0(0),
 261         fTreeVariableDcaV0Daughters(0),
 262         fTreeVariableDcaV0ToPrimVertex(0),
 263         fTreeVariableDcaPosToPrimVertex(0),
 264         fTreeVariableDcaNegToPrimVertex(0),
 265         fTreeVariableV0CosineOfPointingAngle(0),
 266         fTreeVariableV0Radius(0),
 267         fTreeVariablePt(0),
 268         fTreeVariableRapK0Short(0),
 269         fTreeVariableRapLambda(0),
 270         fTreeVariableInvMassK0s(0),
 271         fTreeVariableInvMassLambda(0),
 272         fTreeVariableInvMassAntiLambda(0),
 273         fTreeVariableAlphaV0(0),
 274         fTreeVariablePtArmV0(0),
 275         fTreeVariableNegTotMomentum(0),
 276         fTreeVariablePosTotMomentum(0),
 277         fTreeVariableNegdEdxSig(0),
 278         fTreeVariablePosdEdxSig(0),
 279         fTreeVariableNegEta(0),
 280         fTreeVariablePosEta(0),
 281
 282         fTreeVariableNSigmasPosProton(0),
 283         fTreeVariableNSigmasPosPion(0),
 284         fTreeVariableNSigmasNegProton(0),
 285         fTreeVariableNSigmasNegPion(0),
 286
 287         fTreeVariableDistOverTotMom(0),
 288         fTreeVariableLeastNbrCrossedRows(0),
 289         fTreeVariableLeastRatioCrossedRowsOverFindable(0),
 290         fTreeVariableMultiplicity(0),
 291   fTreeVariableMultiplicityV0A(0),
 292   fTreeVariableMultiplicityZNA(0),
 293   fTreeVariableMultiplicityTRK(0),
 294   fTreeVariableMultiplicitySPD(0),
 295
 296   fTreeVariableRunNumber(0),
 297   fTreeVariableEventNumber(0),
 298
 299   fTreeVariableV0x(0),
 300   fTreeVariableV0y(0),
 301   fTreeVariableV0z(0),
 302
 303   fTreeVariableV0Px(0),
 304   fTreeVariableV0Py(0),
 305   fTreeVariableV0Pz(0),
 306
 307   fTreeVariablePVx(0),
 308   fTreeVariablePVy(0),
 309   fTreeVariablePVz(0),
 310
 311   fTreeVariableNegTrackStatus(0),
 312   fTreeVariablePosTrackStatus(0),
 313
 314   fTreeVariableNegTPCSignal(0),
 315   fTreeVariablePosTPCSignal(0),
 316   fTreeVariableNegInnerP(0),
 317   fTreeVariablePosInnerP(0),
 318
 319   fTreeVariableNegPx(0),
 320   fTreeVariableNegPy(0),
 321   fTreeVariableNegPz(0),
 322   fTreeVariablePosPx(0),
 323   fTreeVariablePosPy(0),
 324   fTreeVariablePosPz(0),
 325
 326 //------------------------------------------------
 327 // HISTOGRAMS
 328 // --- Filled on an Event-by-event basis
 329 //------------------------------------------------
 330    fHistV0MultiplicityBeforeTrigSel(0),
 331    fHistV0MultiplicityForTrigEvt(0),
 332    fHistV0MultiplicityForSelEvt(0),
 333    fHistV0MultiplicityForSelEvtNoTPCOnly(0),
 334    fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup(0),
 335    fHistMultiplicityBeforeTrigSel(0),
 336    fHistMultiplicityForTrigEvt(0),
 337    fHistMultiplicity(0),
 338    fHistMultiplicityNoTPCOnly(0),
 339    fHistMultiplicityNoTPCOnlyNoPileup(0),
 340
 341
 342 //V0A Centrality
 343 fHistMultiplicityV0ABeforeTrigSel(0),
 344 fHistMultiplicityV0AForTrigEvt(0),
 345 fHistMultiplicityV0A(0),
 346 fHistMultiplicityV0ANoTPCOnly(0),
 347 fHistMultiplicityV0ANoTPCOnlyNoPileup(0),
 348
 349 //ZNA Centrality
 350 fHistMultiplicityZNABeforeTrigSel(0),
 351 fHistMultiplicityZNAForTrigEvt(0),
 352 fHistMultiplicityZNA(0),
 353 fHistMultiplicityZNANoTPCOnly(0),
 354 fHistMultiplicityZNANoTPCOnlyNoPileup(0),
 355
 356 //TRK Centrality
 357 fHistMultiplicityTRKBeforeTrigSel(0),
 358 fHistMultiplicityTRKForTrigEvt(0),
 359 fHistMultiplicityTRK(0),
 360 fHistMultiplicityTRKNoTPCOnly(0),
 361 fHistMultiplicityTRKNoTPCOnlyNoPileup(0),
 362
 363 //SPD Centrality
 364 fHistMultiplicitySPDBeforeTrigSel(0),
 365 fHistMultiplicitySPDForTrigEvt(0),
 366 fHistMultiplicitySPD(0),
 367 fHistMultiplicitySPDNoTPCOnly(0),
 368 fHistMultiplicitySPDNoTPCOnlyNoPileup(0),
 369
 370   //Raw Data for Vertex Z position estimator change
 371         f2dHistMultiplicityVsVertexZBeforeTrigSel(0),
 372         f2dHistMultiplicityVsVertexZForTrigEvt(0),
 373         f2dHistMultiplicityVsVertexZ(0),
 374         f2dHistMultiplicityVsVertexZNoTPCOnly(0),
 375         f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup(0),
 376
 377    fHistPVx(0),
 378    fHistPVy(0),
 379    fHistPVz(0),
 380    fHistPVxAnalysis(0),
 381    fHistPVyAnalysis(0),
 382    fHistPVzAnalysis(0),
 383    fHistSwappedV0Counter(0),
 384   f2dHistdEdxPos(0),
 385   f2dHistdEdxNeg(0)
 386 {
 387   // Constructor
 388   // Set Loose cuts or not here...
 389   // REALLY LOOSE? Be careful when attempting to run over PbPb if fkRunV0Vertexer is set!
 390   fV0Sels[0] =  33.  ;  // max allowed chi2
 391   fV0Sels[1] =   0.02;  // min allowed impact parameter for the 1st daughter (LHC09a4 : 0.05)
 392   fV0Sels[2] =   0.02;  // min allowed impact parameter for the 2nd daughter (LHC09a4 : 0.05)
 393   fV0Sels[3] =   2.0 ;  // max allowed DCA between the daughter tracks       (LHC09a4 : 0.5)
 394   fV0Sels[4] =   0.95;  // min allowed cosine of V0's pointing angle         (LHC09a4 : 0.99)
 395   fV0Sels[5] =   0.5 ;  // min radius of the fiducial volume                 (LHC09a4 : 0.2)
 396   fV0Sels[6] = 200.  ;  // max radius of the fiducial volume                 (LHC09a4 : 100.0)
 397
 398   // Output slot #0 writes into a TList container (Lambda Histos and fTree)
 399    DefineOutput(1, TList::Class());
 400    DefineOutput(2, TTree::Class());
 401 }
 402
 403
 404 AliAnalysisTaskExtractV0::~AliAnalysisTaskExtractV0()
 405 {
 406 //------------------------------------------------
 407 // DESTRUCTOR
 408 //------------------------------------------------
 409
 410    if (fListHistV0){
 411       delete fListHistV0;
 412       fListHistV0 = 0x0;
 413    }
 414    if (fTree){
 415       delete fTree;
 416       fTree = 0x0;
 417    }
 418     //cleanup esd track cuts object too...
 419    if (fESDtrackCuts){
 420     delete fESDtrackCuts;
 421     fESDtrackCuts = 0x0;
 422   }
 423   if (fUtils){
 424     delete fUtils;
 425     fUtils = 0x0;
 426   }
 427
 428 }
 429
 430
 431
 432 //________________________________________________________________________
 433 void AliAnalysisTaskExtractV0::UserCreateOutputObjects()
 434 {
 435
 436    //Create File-resident Tree, please.
 437    OpenFile(2);
 438    // Called once
 439    fTree = new TTree("fTree","V0Candidates");
 440
 441 //------------------------------------------------
 442 // fTree Branch definitions
 443 //------------------------------------------------
 444
 445 //-----------BASIC-INFO---------------------------
 446 /* 1*/  fTree->Branch("fTreeVariableChi2V0",&fTreeVariableChi2V0,"fTreeVariableChi2V0/F");
 447 /* 2*/  fTree->Branch("fTreeVariableDcaV0Daughters",&fTreeVariableDcaV0Daughters,"fTreeVariableDcaV0Daughters/F");
 448 /* 3*/  fTree->Branch("fTreeVariableDcaPosToPrimVertex",&fTreeVariableDcaPosToPrimVertex,"fTreeVariableDcaPosToPrimVertex/F");
 449 /* 4*/  fTree->Branch("fTreeVariableDcaNegToPrimVertex",&fTreeVariableDcaNegToPrimVertex,"fTreeVariableDcaNegToPrimVertex/F");
 450 /* 5*/  fTree->Branch("fTreeVariableV0Radius",&fTreeVariableV0Radius,"fTreeVariableV0Radius/F");
 451 /* 6*/  fTree->Branch("fTreeVariablePt",&fTreeVariablePt,"fTreeVariablePt/F");
 452 /* 7*/  fTree->Branch("fTreeVariableRapK0Short",&fTreeVariableRapK0Short,"fTreeVariableRapK0Short/F");
 453 /* 8*/  fTree->Branch("fTreeVariableRapLambda",&fTreeVariableRapLambda,"fTreeVariableRapLambda/F");
 454 /* 9*/  fTree->Branch("fTreeVariableInvMassK0s",&fTreeVariableInvMassK0s,"fTreeVariableInvMassK0s/F");
 455 /*10*/  fTree->Branch("fTreeVariableInvMassLambda",&fTreeVariableInvMassLambda,"fTreeVariableInvMassLambda/F");
 456 /*11*/  fTree->Branch("fTreeVariableInvMassAntiLambda",&fTreeVariableInvMassAntiLambda,"fTreeVariableInvMassAntiLambda/F");
 457 /*12*/  fTree->Branch("fTreeVariableV0CosineOfPointingAngle",&fTreeVariableV0CosineOfPointingAngle,"fTreeVariableV0CosineOfPointingAngle/F");
 458 /*13*/  fTree->Branch("fTreeVariableAlphaV0",&fTreeVariableAlphaV0,"fTreeVariableAlphaV0/F");
 459 /*14*/  fTree->Branch("fTreeVariablePtArmV0",&fTreeVariablePtArmV0,"fTreeVariablePtArmV0/F");
 460 /*15*/  fTree->Branch("fTreeVariableLeastNbrCrossedRows",&fTreeVariableLeastNbrCrossedRows,"fTreeVariableLeastNbrCrossedRows/I");
 461 /*16*/  fTree->Branch("fTreeVariableLeastRatioCrossedRowsOverFindable",&fTreeVariableLeastRatioCrossedRowsOverFindable,"fTreeVariableLeastRatioCrossedRowsOverFindable/F");
 462 //-----------MULTIPLICITY-INFO--------------------
 463 /*17*/  fTree->Branch("fTreeVariableMultiplicity",&fTreeVariableMultiplicity,"fTreeVariableMultiplicity/I");
 464   /*17*/        fTree->Branch("fTreeVariableMultiplicityV0A",&fTreeVariableMultiplicityV0A,"fTreeVariableMultiplicityV0A/I");
 465   /*17*/        fTree->Branch("fTreeVariableMultiplicityZNA",&fTreeVariableMultiplicityZNA,"fTreeVariableMultiplicityZNA/I");
 466   /*17*/        fTree->Branch("fTreeVariableMultiplicityTRK",&fTreeVariableMultiplicityTRK,"fTreeVariableMultiplicityTRK/I");
 467   /*17*/        fTree->Branch("fTreeVariableMultiplicitySPD",&fTreeVariableMultiplicitySPD,"fTreeVariableMultiplicitySPD/I");
 468 //------------------------------------------------
 469 /*18*/  fTree->Branch("fTreeVariableDistOverTotMom",&fTreeVariableDistOverTotMom,"fTreeVariableDistOverTotMom/F");
 470 /*19*/  fTree->Branch("fTreeVariableNSigmasPosProton",&fTreeVariableNSigmasPosProton,"fTreeVariableNSigmasPosProton/F");
 471 /*20*/  fTree->Branch("fTreeVariableNSigmasPosPion",&fTreeVariableNSigmasPosPion,"fTreeVariableNSigmasPosPion/F");
 472 /*21*/  fTree->Branch("fTreeVariableNSigmasNegProton",&fTreeVariableNSigmasNegProton,"fTreeVariableNSigmasNegProton/F");
 473 /*22*/  fTree->Branch("fTreeVariableNSigmasNegPion",&fTreeVariableNSigmasNegPion,"fTreeVariableNSigmasNegPion/F");
 474 /*23*/  fTree->Branch("fTreeVariableNegEta",&fTreeVariableNegEta,"fTreeVariableNegEta/F");
 475 /*24*/  fTree->Branch("fTreeVariablePosEta",&fTreeVariablePosEta,"fTreeVariablePosEta/F");
 476 /*25*/  fTree->Branch("fTreeVariableRunNumber",&fTreeVariableRunNumber,"fTreeVariableRunNumber/I");
 477 /*26*/  fTree->Branch("fTreeVariableEventNumber",&fTreeVariableEventNumber,"fTreeVariableEventNumber/l");
 478
 479   if( fkLightWeight == kFALSE ){
 480 //-----------FOR CTAU DEBUGGING: Full Phase Space + Decay Position Info
 481         fTree->Branch("fTreeVariablePVx",&fTreeVariablePVx,"fTreeVariablePVx/F");
 482         fTree->Branch("fTreeVariablePVy",&fTreeVariablePVy,"fTreeVariablePVy/F");
 483         fTree->Branch("fTreeVariablePVz",&fTreeVariablePVz,"fTreeVariablePVz/F");
 484
 485         fTree->Branch("fTreeVariableV0x",&fTreeVariableV0x,"fTreeVariableV0x/F");
 486         fTree->Branch("fTreeVariableV0y",&fTreeVariableV0y,"fTreeVariableV0y/F");
 487         fTree->Branch("fTreeVariableV0z",&fTreeVariableV0z,"fTreeVariableV0z/F");
 488
 489         fTree->Branch("fTreeVariableV0Px",&fTreeVariableV0Px,"fTreeVariableV0Px/F");
 490         fTree->Branch("fTreeVariableV0Py",&fTreeVariableV0Py,"fTreeVariableV0Py/F");
 491         fTree->Branch("fTreeVariableV0Pz",&fTreeVariableV0Pz,"fTreeVariableV0Pz/F");
 492
 493         fTree->Branch("fTreeVariableNegTrackStatus",&fTreeVariableNegTrackStatus,"fTreeVariableNegTrackStatus/l");
 494         fTree->Branch("fTreeVariablePosTrackStatus",&fTreeVariablePosTrackStatus,"fTreeVariablePosTrackStatus/l");
 495   }
 496   if( fkSpecialExecution == kTRUE ){
 497     fTree->Branch("fTreeVariablePosTPCSignal",&fTreeVariablePosTPCSignal,"fTreeVariablePosTPCSignal/F");
 498     fTree->Branch("fTreeVariableNegTPCSignal",&fTreeVariableNegTPCSignal,"fTreeVariableNegTPCSignal/F");
 499     fTree->Branch("fTreeVariablePosInnerP",&fTreeVariablePosInnerP,"fTreeVariablePosInnerP/F");
 500     fTree->Branch("fTreeVariableNegInnerP",&fTreeVariableNegInnerP,"fTreeVariableNegInnerP/F");
 501
 502     fTree->Branch("fTreeVariablePosPx",&fTreeVariablePosPx,"fTreeVariablePosPx/F");
 503     fTree->Branch("fTreeVariablePosPy",&fTreeVariablePosPy,"fTreeVariablePosPy/F");
 504     fTree->Branch("fTreeVariablePosPz",&fTreeVariablePosPz,"fTreeVariablePosPz/F");
 505     fTree->Branch("fTreeVariableNegPx",&fTreeVariableNegPx,"fTreeVariableNegPx/F");
 506     fTree->Branch("fTreeVariableNegPy",&fTreeVariableNegPy,"fTreeVariableNegPy/F");
 507     fTree->Branch("fTreeVariableNegPz",&fTreeVariableNegPz,"fTreeVariableNegPz/F");
 508   }
 509
 510 //------------------------------------------------
 511 // Particle Identification Setup
 512 //------------------------------------------------
 513
 514   AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
 515   AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
 516   fPIDResponse = inputHandler->GetPIDResponse();
 517
 518   // Multiplicity
 519
 520   if(! fESDtrackCuts ){
 521     fESDtrackCuts = new AliESDtrackCuts();
 522   }
 523   if(! fUtils ){
 524     fUtils = new AliAnalysisUtils();
 525   }
 526
 527 //------------------------------------------------
 528 // V0 Multiplicity Histograms
 529 //------------------------------------------------
 530
 531    // Create histograms
 532    //Create File-resident Tree, please.
 533    OpenFile(1);
 534
 535    fListHistV0 = new TList();
 536    fListHistV0->SetOwner();  // See http://root.cern.ch/root/html/TCollection.html#TCollection:SetOwner
 537
 538    if(! fHistV0MultiplicityBeforeTrigSel) {
 539       fHistV0MultiplicityBeforeTrigSel = new TH1F("fHistV0MultiplicityBeforeTrigSel",
 540          "V0s per event (before Trig. Sel.);Nbr of V0s/Evt;Events",
 541          25, 0, 25);
 542       fListHistV0->Add(fHistV0MultiplicityBeforeTrigSel);
 543    }
 544
 545    if(! fHistV0MultiplicityForTrigEvt) {
 546       fHistV0MultiplicityForTrigEvt = new TH1F("fHistV0MultiplicityForTrigEvt",
 547          "V0s per event (for triggered evt);Nbr of V0s/Evt;Events",
 548          25, 0, 25);
 549       fListHistV0->Add(fHistV0MultiplicityForTrigEvt);
 550    }
 551
 552    if(! fHistV0MultiplicityForSelEvt) {
 553       fHistV0MultiplicityForSelEvt = new TH1F("fHistV0MultiplicityForSelEvt",
 554          "V0s per event;Nbr of V0s/Evt;Events",
 555          25, 0, 25);
 556       fListHistV0->Add(fHistV0MultiplicityForSelEvt);
 557    }
 558
 559    if(! fHistV0MultiplicityForSelEvtNoTPCOnly) {
 560       fHistV0MultiplicityForSelEvtNoTPCOnly = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnly",
 561          "V0s per event;Nbr of V0s/Evt;Events",
 562          25, 0, 25);
 563       fListHistV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnly);
 564    }
 565
 566    if(! fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup) {
 567       fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup = new TH1F("fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup",
 568          "V0s per event;Nbr of V0s/Evt;Events",
 569          25, 0, 25);
 570       fListHistV0->Add(fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup);
 571    }
 572
 573 //------------------------------------------------
 574 // Track Multiplicity Histograms
 575 //------------------------------------------------
 576
 577   //Default V0M Centrality (if PbPb)
 578    if(! fHistMultiplicityBeforeTrigSel) {
 579       fHistMultiplicityBeforeTrigSel = new TH1F("fHistMultiplicityBeforeTrigSel",
 580          "Tracks per event;Nbr of Tracks;Events",
 581          200, 0, 200);
 582       fListHistV0->Add(fHistMultiplicityBeforeTrigSel);
 583    }
 584    if(! fHistMultiplicityForTrigEvt) {
 585       fHistMultiplicityForTrigEvt = new TH1F("fHistMultiplicityForTrigEvt",
 586          "Tracks per event;Nbr of Tracks;Events",
 587          200, 0, 200);
 588       fListHistV0->Add(fHistMultiplicityForTrigEvt);
 589    }
 590    if(! fHistMultiplicity) {
 591       fHistMultiplicity = new TH1F("fHistMultiplicity",
 592          "Tracks per event;Nbr of Tracks;Events",
 593          200, 0, 200);
 594       fListHistV0->Add(fHistMultiplicity);
 595    }
 596    if(! fHistMultiplicityNoTPCOnly) {
 597       fHistMultiplicityNoTPCOnly = new TH1F("fHistMultiplicityNoTPCOnly",
 598          "Tracks per event;Nbr of Tracks;Events",
 599          200, 0, 200);
 600       fListHistV0->Add(fHistMultiplicityNoTPCOnly);
 601    }
 602    if(! fHistMultiplicityNoTPCOnlyNoPileup) {
 603       fHistMultiplicityNoTPCOnlyNoPileup = new TH1F("fHistMultiplicityNoTPCOnlyNoPileup",
 604          "Tracks per event;Nbr of Tracks;Events",
 605          200, 0, 200);
 606       fListHistV0->Add(fHistMultiplicityNoTPCOnlyNoPileup);
 607    }
 608
 609   //V0A Centrality (if PbPb / pPb)
 610   if(! fHistMultiplicityV0ABeforeTrigSel) {
 611     fHistMultiplicityV0ABeforeTrigSel = new TH1F("fHistMultiplicityV0ABeforeTrigSel",
 612                                               "Centrality Distribution: V0A;V0A Centrality;Events",
 613                                               200, 0, 200);
 614     fListHistV0->Add(fHistMultiplicityV0ABeforeTrigSel);
 615   }
 616   if(! fHistMultiplicityV0AForTrigEvt) {
 617     fHistMultiplicityV0AForTrigEvt = new TH1F("fHistMultiplicityV0AForTrigEvt",
 618                                               "Centrality Distribution: V0A;V0A Centrality;Events",
 619                                            200, 0, 200);
 620     fListHistV0->Add(fHistMultiplicityV0AForTrigEvt);
 621   }
 622   if(! fHistMultiplicityV0A) {
 623     fHistMultiplicityV0A = new TH1F("fHistMultiplicityV0A",
 624                                               "Centrality Distribution: V0A;V0A Centrality;Events",
 625                                  200, 0, 200);
 626     fListHistV0->Add(fHistMultiplicityV0A);
 627   }
 628   if(! fHistMultiplicityV0ANoTPCOnly) {
 629     fHistMultiplicityV0ANoTPCOnly = new TH1F("fHistMultiplicityV0ANoTPCOnly",
 630                                               "Centrality Distribution: V0A;V0A Centrality;Events",
 631                                           200, 0, 200);
 632     fListHistV0->Add(fHistMultiplicityV0ANoTPCOnly);
 633   }
 634   if(! fHistMultiplicityV0ANoTPCOnlyNoPileup) {
 635     fHistMultiplicityV0ANoTPCOnlyNoPileup = new TH1F("fHistMultiplicityV0ANoTPCOnlyNoPileup",
 636                                               "Centrality Distribution: V0A;V0A Centrality;Events",
 637                                                   200, 0, 200);
 638     fListHistV0->Add(fHistMultiplicityV0ANoTPCOnlyNoPileup);
 639   }
 640
 641   //ZNA Centrality (if PbPb / pPb)
 642   if(! fHistMultiplicityZNABeforeTrigSel) {
 643     fHistMultiplicityZNABeforeTrigSel = new TH1F("fHistMultiplicityZNABeforeTrigSel",
 644                                                  "Centrality Distribution: ZNA;ZNA Centrality;Events",
 645                                                  200, 0, 200);
 646     fListHistV0->Add(fHistMultiplicityZNABeforeTrigSel);
 647   }
 648   if(! fHistMultiplicityZNAForTrigEvt) {
 649     fHistMultiplicityZNAForTrigEvt = new TH1F("fHistMultiplicityZNAForTrigEvt",
 650                                               "Centrality Distribution: ZNA;ZNA Centrality;Events",
 651                                               200, 0, 200);
 652     fListHistV0->Add(fHistMultiplicityZNAForTrigEvt);
 653   }
 654   if(! fHistMultiplicityZNA) {
 655     fHistMultiplicityZNA = new TH1F("fHistMultiplicityZNA",
 656                                     "Centrality Distribution: ZNA;ZNA Centrality;Events",
 657                                     200, 0, 200);
 658     fListHistV0->Add(fHistMultiplicityZNA);
 659   }
 660   if(! fHistMultiplicityZNANoTPCOnly) {
 661     fHistMultiplicityZNANoTPCOnly = new TH1F("fHistMultiplicityZNANoTPCOnly",
 662                                              "Centrality Distribution: ZNA;ZNA Centrality;Events",
 663                                              200, 0, 200);
 664     fListHistV0->Add(fHistMultiplicityZNANoTPCOnly);
 665   }
 666   if(! fHistMultiplicityZNANoTPCOnlyNoPileup) {
 667     fHistMultiplicityZNANoTPCOnlyNoPileup = new TH1F("fHistMultiplicityZNANoTPCOnlyNoPileup",
 668                                                      "Centrality Distribution: ZNA;ZNA Centrality;Events",
 669                                                      200, 0, 200);
 670     fListHistV0->Add(fHistMultiplicityZNANoTPCOnlyNoPileup);
 671   }
 672
 673   //TRK Centrality (if PbPb / pPb)
 674   if(! fHistMultiplicityTRKBeforeTrigSel) {
 675     fHistMultiplicityTRKBeforeTrigSel = new TH1F("fHistMultiplicityTRKBeforeTrigSel",
 676                                                  "Centrality Distribution: TRK;TRK Centrality;Events",
 677                                                  200, 0, 200);
 678     fListHistV0->Add(fHistMultiplicityTRKBeforeTrigSel);
 679   }
 680   if(! fHistMultiplicityTRKForTrigEvt) {
 681     fHistMultiplicityTRKForTrigEvt = new TH1F("fHistMultiplicityTRKForTrigEvt",
 682                                               "Centrality Distribution: TRK;TRK Centrality;Events",
 683                                               200, 0, 200);
 684     fListHistV0->Add(fHistMultiplicityTRKForTrigEvt);
 685   }
 686   if(! fHistMultiplicityTRK) {
 687     fHistMultiplicityTRK = new TH1F("fHistMultiplicityTRK",
 688                                     "Centrality Distribution: TRK;TRK Centrality;Events",
 689                                     200, 0, 200);
 690     fListHistV0->Add(fHistMultiplicityTRK);
 691   }
 692   if(! fHistMultiplicityTRKNoTPCOnly) {
 693     fHistMultiplicityTRKNoTPCOnly = new TH1F("fHistMultiplicityTRKNoTPCOnly",
 694                                              "Centrality Distribution: TRK;TRK Centrality;Events",
 695                                              200, 0, 200);
 696     fListHistV0->Add(fHistMultiplicityTRKNoTPCOnly);
 697   }
 698   if(! fHistMultiplicityTRKNoTPCOnlyNoPileup) {
 699     fHistMultiplicityTRKNoTPCOnlyNoPileup = new TH1F("fHistMultiplicityTRKNoTPCOnlyNoPileup",
 700                                                      "Centrality Distribution: TRK;TRK Centrality;Events",
 701                                                      200, 0, 200);
 702     fListHistV0->Add(fHistMultiplicityTRKNoTPCOnlyNoPileup);
 703   }
 704
 705   //SPD Centrality (if PbPb / pPb)
 706   if(! fHistMultiplicitySPDBeforeTrigSel) {
 707     fHistMultiplicitySPDBeforeTrigSel = new TH1F("fHistMultiplicitySPDBeforeTrigSel",
 708                                                  "Centrality Distribution: SPD;SPD Centrality;Events",
 709                                                  200, 0, 200);
 710     fListHistV0->Add(fHistMultiplicitySPDBeforeTrigSel);
 711   }
 712   if(! fHistMultiplicitySPDForTrigEvt) {
 713     fHistMultiplicitySPDForTrigEvt = new TH1F("fHistMultiplicitySPDForTrigEvt",
 714                                               "Centrality Distribution: SPD;SPD Centrality;Events",
 715                                               200, 0, 200);
 716     fListHistV0->Add(fHistMultiplicitySPDForTrigEvt);
 717   }
 718   if(! fHistMultiplicitySPD) {
 719     fHistMultiplicitySPD = new TH1F("fHistMultiplicitySPD",
 720                                     "Centrality Distribution: SPD;SPD Centrality;Events",
 721                                     200, 0, 200);
 722     fListHistV0->Add(fHistMultiplicitySPD);
 723   }
 724   if(! fHistMultiplicitySPDNoTPCOnly) {
 725     fHistMultiplicitySPDNoTPCOnly = new TH1F("fHistMultiplicitySPDNoTPCOnly",
 726                                              "Centrality Distribution: SPD;SPD Centrality;Events",
 727                                              200, 0, 200);
 728     fListHistV0->Add(fHistMultiplicitySPDNoTPCOnly);
 729   }
 730   if(! fHistMultiplicitySPDNoTPCOnlyNoPileup) {
 731     fHistMultiplicitySPDNoTPCOnlyNoPileup = new TH1F("fHistMultiplicitySPDNoTPCOnlyNoPileup",
 732                                                      "Centrality Distribution: SPD;SPD Centrality;Events",
 733                                                      200, 0, 200);
 734     fListHistV0->Add(fHistMultiplicitySPDNoTPCOnlyNoPileup);
 735   }
 736
 737   //Raw Data for Vertex Z position estimator change
 738         //TH2F    *f2dHistMultiplicityVsVertexZBeforeTrigSel;           //! multiplicity distribution
 739         //TH2F    *f2dHistMultiplicityVsVertexZForTrigEvt;                      //! multiplicity distribution
 740         //TH2F    *f2dHistMultiplicityVsVertexZ;                                                //! multiplicity distribution
 741         //TH2F    *f2dHistMultiplicityVsVertexZNoTPCOnly;                               //! multiplicity distribution
 742         //TH2F    *f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup;                       //! multiplicity distribution
 743
 744    if(! f2dHistMultiplicityVsVertexZBeforeTrigSel) {
 745       f2dHistMultiplicityVsVertexZBeforeTrigSel = new TH2F("f2dHistMultiplicityVsVertexZBeforeTrigSel",
 746          "Tracks per event", 200, 0, 200,400, -20, 20);
 747       fListHistV0->Add(f2dHistMultiplicityVsVertexZBeforeTrigSel);
 748    }
 749    if(! f2dHistMultiplicityVsVertexZForTrigEvt) {
 750       f2dHistMultiplicityVsVertexZForTrigEvt = new TH2F("f2dHistMultiplicityVsVertexZForTrigEvt",
 751          "Tracks per event", 200, 0, 200, 400, -20, 20);
 752       fListHistV0->Add(f2dHistMultiplicityVsVertexZForTrigEvt);
 753    }
 754    if(! f2dHistMultiplicityVsVertexZ) {
 755       f2dHistMultiplicityVsVertexZ = new TH2F("f2dHistMultiplicityVsVertexZ",
 756          "Tracks per event", 200, 0, 200, 400, -20, 20);
 757       fListHistV0->Add(f2dHistMultiplicityVsVertexZ);
 758    }
 759    if(! f2dHistMultiplicityVsVertexZNoTPCOnly) {
 760       f2dHistMultiplicityVsVertexZNoTPCOnly = new TH2F("f2dHistMultiplicityVsVertexZNoTPCOnly",
 761          "Tracks per event", 200, 0, 200, 400, -20, 20);
 762       fListHistV0->Add(f2dHistMultiplicityVsVertexZNoTPCOnly);
 763    }
 764    if(! f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup) {
 765       f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup = new TH2F("f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup",
 766          "Tracks per event", 200, 0, 200, 400, -20, 20);
 767       fListHistV0->Add(f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup);
 768    }
 769
 770 //-----------------------------------------------------
 771
 772    if(! fHistPVx) {
 773       fHistPVx = new TH1F("fHistPVx",
 774          "PV x position;Nbr of Evts;x",
 775          2000, -0.5, 0.5);
 776       fListHistV0->Add(fHistPVx);
 777    }
 778    if(! fHistPVy) {
 779       fHistPVy = new TH1F("fHistPVy",
 780          "PV y position;Nbr of Evts;y",
 781          2000, -0.5, 0.5);
 782       fListHistV0->Add(fHistPVy);
 783    }
 784    if(! fHistPVz) {
 785       fHistPVz = new TH1F("fHistPVz",
 786          "PV z position;Nbr of Evts;z",
 787          400, -20, 20);
 788       fListHistV0->Add(fHistPVz);
 789    }
 790    if(! fHistPVxAnalysis) {
 791       fHistPVxAnalysis = new TH1F("fHistPVxAnalysis",
 792          "PV x position;Nbr of Evts;x",
 793          2000, -0.5, 0.5);
 794       fListHistV0->Add(fHistPVxAnalysis);
 795    }
 796    if(! fHistPVyAnalysis) {
 797       fHistPVyAnalysis = new TH1F("fHistPVyAnalysis",
 798          "PV y position;Nbr of Evts;y",
 799          2000, -0.5, 0.5);
 800       fListHistV0->Add(fHistPVyAnalysis);
 801    }
 802    if(! fHistPVzAnalysis) {
 803       fHistPVzAnalysis = new TH1F("fHistPVzAnalysis",
 804          "PV z position;Nbr of Evts;z",
 805          400, -20, 20);
 806       fListHistV0->Add(fHistPVzAnalysis);
 807    }
 808    if(! fHistSwappedV0Counter) {
 809       fHistSwappedV0Counter = new TH1F("fHistSwappedV0Counter",
 810          "Swap or not histo;Swapped (1) or not (0); count",
 811          2, 0, 2);
 812       fListHistV0->Add(fHistSwappedV0Counter);
 813    }
 814
 815   //Create dE/dx histograms
 816   if(! f2dHistdEdxPos ){
 817     f2dHistdEdxPos = new TH2F("f2dHistdEdxPos","Pos. Daughter dE/dx;p (GeV/c);TPC Signal",
 818                               200,0,10,500,0,1000);
 819     if (fkSpecialExecution) fListHistV0->Add(f2dHistdEdxPos);
 820   }
 821   if(! f2dHistdEdxNeg ){
 822     f2dHistdEdxNeg = new TH2F("f2dHistdEdxNeg","Neg. Daughter dE/dx;p (GeV/c);TPC Signal",
 823                               200,0,10,500,0,1000);
 824     if (fkSpecialExecution) fListHistV0->Add(f2dHistdEdxNeg);
 825   }
 826
 827    //Regular output: Histograms
 828    PostData(1, fListHistV0);
 829    //TTree Object: Saved to base directory. Should cache to disk while saving.
 830    //(Important to avoid excessive memory usage, particularly when merging)
 831    PostData(2, fTree);
 832
 833 }// end UserCreateOutputObjects
 834
 835
 836 //________________________________________________________________________
 837 void AliAnalysisTaskExtractV0::UserExec(Option_t *)
 838 {
 839    // Main loop
 840    // Called for each event
 841    //gObjectTable->Print();
 842    AliESDEvent *lESDevent = 0x0;
 843
 844    //AliAODEvent *lAODevent = 0x0;
 845    Int_t    nV0s                        = -1;
 846
 847    Double_t lTrkgPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
 848    Double_t lBestPrimaryVtxPos[3]          = {-100.0, -100.0, -100.0};
 849    Double_t lMagneticField                 = -10.;
 850
 851    // Connect to the InputEvent
 852    // After these lines, we should have an ESD/AOD event + the number of cascades in it.
 853
 854    // Appropriate for ESD analysis!
 855
 856    lESDevent = dynamic_cast<AliESDEvent*>( InputEvent() );
 857    if (!lESDevent) {
 858       AliWarning("ERROR: lESDevent not available \n");
 859       return;
 860    }
 861
 862   //------------------------------------------------
 863   // Rerun V0 vertexer, if asked for
 864   // --- WARNING: Be careful when using in PbPb
 865   //------------------------------------------------
 866   if( fkRunV0Vertexer ){
 867     lESDevent->ResetV0s();
 868     AliV0vertexer lV0vtxer;
 869     lV0vtxer.SetDefaultCuts(fV0Sels);
 870     lV0vtxer.Tracks2V0vertices(lESDevent);
 871   }
 872
 873    fTreeVariableRunNumber = lESDevent->GetRunNumber();
 874    fTreeVariableEventNumber =
 875     ( ( ((ULong64_t)lESDevent->GetPeriodNumber() ) << 36 ) |
 876       ( ((ULong64_t)lESDevent->GetOrbitNumber () ) << 12 ) |
 877         ((ULong64_t)lESDevent->GetBunchCrossNumber() )  );
 878
 879    //REVISED multiplicity estimator after 'multiplicity day' (2011)
 880    Int_t lMultiplicity = -100;
 881    Int_t lMultiplicityV0A = -100;
 882    Int_t lMultiplicityZNA = -100;
 883    Int_t lMultiplicityTRK = -100;
 884    Int_t lMultiplicitySPD = -100;
 885
 886    if(fkIsNuclear == kFALSE) lMultiplicity = fESDtrackCuts->GetReferenceMultiplicity(lESDevent, AliESDtrackCuts::kTrackletsITSTPC,0.5);
 887
 888    //---> If this is a nuclear collision, then go nuclear on "multiplicity" variable...
 889    //---> Warning: Experimental
 890    if(fkIsNuclear == kTRUE){
 891       AliCentrality* centrality;
 892       centrality = lESDevent->GetCentrality();
 893       lMultiplicity = ( ( Int_t ) ( centrality->GetCentralityPercentile(   fCentralityEstimator.Data() ) ) );
 894       lMultiplicityV0A = ( ( Int_t ) ( centrality->GetCentralityPercentile(   "V0A" ) ) );
 895       lMultiplicityZNA = ( ( Int_t ) ( centrality->GetCentralityPercentile(   "ZNA" ) ) );
 896       lMultiplicityTRK = ( ( Int_t ) ( centrality->GetCentralityPercentile(   "TRK" ) ) );
 897       lMultiplicitySPD = ( ( Int_t ) ( centrality->GetCentralityPercentile(   "CL1" ) ) );
 898       if (centrality->GetQuality()>1) {
 899         PostData(1, fListHistV0);
 900         PostData(2, fTree);
 901         return;
 902       }
 903    }
 904
 905    //Set variable for filling tree afterwards!
 906    //---> pp case......: GetReferenceMultiplicity
 907    //---> Pb-Pb case...: Centrality by V0M
 908   fTreeVariableMultiplicity = lMultiplicity;
 909   fTreeVariableMultiplicityV0A = lMultiplicityV0A;
 910   fTreeVariableMultiplicityZNA = lMultiplicityZNA;
 911   fTreeVariableMultiplicityTRK = lMultiplicityTRK;
 912   fTreeVariableMultiplicitySPD = lMultiplicitySPD;
 913
 914   fHistMultiplicityBeforeTrigSel->Fill ( lMultiplicity );
 915   fHistMultiplicityV0ABeforeTrigSel->Fill ( lMultiplicityV0A );
 916   fHistMultiplicityZNABeforeTrigSel->Fill ( lMultiplicityZNA );
 917   fHistMultiplicityTRKBeforeTrigSel->Fill ( lMultiplicityTRK );
 918   fHistMultiplicitySPDBeforeTrigSel->Fill ( lMultiplicitySPD );
 919
 920   fHistV0MultiplicityBeforeTrigSel->Fill ( lESDevent->GetNumberOfV0s() );
 921
 922 //------------------------------------------------
 923 // Physics Selection
 924 //------------------------------------------------
 925
 926   // new method
 927   UInt_t maskIsSelected = ((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected();
 928   Bool_t isSelected = 0;
 929   Bool_t isSelectedExtra = kTRUE; //extra sel, default YES
 930   isSelected = (maskIsSelected & AliVEvent::kMB) == AliVEvent::kMB;
 931
 932   if( fkSkipTrigger == kFALSE ){
 933     //pA triggering: CINT7
 934     if( fkSwitchINT7 ) isSelected = (maskIsSelected & AliVEvent::kINT7) == AliVEvent::kINT7;
 935
 936     //Extra selection applies if with/without SDD is to be dealth with
 937     if( fkFastOnly == "kFastOnly"){
 938       //If not kFastOnly, isSelectedExtra will be kFALSE; procedure will reject it
 939       isSelectedExtra = (maskIsSelected & AliVEvent::kFastOnly) == AliVEvent::kFastOnly;
 940     }
 941     if( fkFastOnly == "NotkFastOnly"){
 942       //If not kFastOnly, isSelectedExtra will be kTRUE; procedure will accept it
 943       isSelectedExtra = !( (maskIsSelected & AliVEvent::kFastOnly) == AliVEvent::kFastOnly );
 944     }
 945
 946     //Standard Min-Bias Selection
 947     if ( !isSelected ) {
 948       PostData(1, fListHistV0);
 949       PostData(2, fTree);
 950       return;
 951     }
 952     //Check if goes through extra selections
 953     //isSelectedExtra will be true in case -> fkFastOnly==""
 954     //isSelectedExtra will be true in case -> fkFastOnly=="kFastOnly"    && bit kFastOnly ON
 955     //isSelectedExtra will be true in case -> fkFastOnly=="NotkFastOnly" && bit kFastOnly OFF
 956     if ( !isSelectedExtra ) {
 957       PostData(1, fListHistV0);
 958       PostData(2, fTree);
 959       return;
 960     }
 961   }
 962
 963 //------------------------------------------------
 964 // After Trigger Selection
 965 //------------------------------------------------
 966
 967         nV0s = lESDevent->GetNumberOfV0s();
 968
 969   fHistV0MultiplicityForTrigEvt     ->Fill( nV0s       );
 970   fHistMultiplicityForTrigEvt       ->Fill( lMultiplicity  );
 971   fHistMultiplicityV0AForTrigEvt       ->Fill( lMultiplicityV0A  );
 972   fHistMultiplicityZNAForTrigEvt       ->Fill( lMultiplicityZNA  );
 973   fHistMultiplicityTRKForTrigEvt       ->Fill( lMultiplicityTRK  );
 974   fHistMultiplicitySPDForTrigEvt       ->Fill( lMultiplicitySPD  );
 975
 976 //------------------------------------------------
 977 // Getting: Primary Vertex + MagField Info
 978 //------------------------------------------------
 979
 980         const AliESDVertex *lPrimaryTrackingESDVtx = lESDevent->GetPrimaryVertexTracks();
 981         // get the vtx stored in ESD found with tracks
 982         lPrimaryTrackingESDVtx->GetXYZ( lTrkgPrimaryVtxPos );
 983
 984         const AliESDVertex *lPrimaryBestESDVtx = lESDevent->GetPrimaryVertex();
 985   // get the best primary vertex available for the event
 986         // As done in AliCascadeVertexer, we keep the one which is the best one available.
 987         // between : Tracking vertex > SPD vertex > TPC vertex > default SPD vertex
 988         // This one will be used for next calculations (DCA essentially)
 989    lPrimaryBestESDVtx->GetXYZ( lBestPrimaryVtxPos );
 990
 991    Double_t tPrimaryVtxPosition[3];
 992    const AliVVertex *primaryVtx = lESDevent->GetPrimaryVertex();
 993    tPrimaryVtxPosition[0] = primaryVtx->GetX();
 994    tPrimaryVtxPosition[1] = primaryVtx->GetY();
 995    tPrimaryVtxPosition[2] = primaryVtx->GetZ();
 996    fHistPVx->Fill( tPrimaryVtxPosition[0] );
 997    fHistPVy->Fill( tPrimaryVtxPosition[1] );
 998    fHistPVz->Fill( tPrimaryVtxPosition[2] );
 999
1000    f2dHistMultiplicityVsVertexZForTrigEvt->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
1001
1002 //------------------------------------------------
1003 // Primary Vertex Z position: SKIP
1004 //------------------------------------------------
1005
1006   if(TMath::Abs(lBestPrimaryVtxPos[2]) > 10.0 && fkpAVertexSelection==kFALSE) {
1007     AliWarning("Pb / | Z position of Best Prim Vtx | > 10.0 cm ... return !");
1008     PostData(1, fListHistV0);
1009     PostData(2, fTree);
1010     return;
1011   }
1012   if(fkpAVertexSelection==kTRUE && fUtils->IsFirstEventInChunk(lESDevent)) {
1013     AliWarning("Pb / | This is the first event in the chunk!");
1014     PostData(1, fListHistV0);
1015     PostData(2, fTree);
1016     return;
1017   }
1018   if(fkpAVertexSelection==kTRUE && !fUtils->IsVertexSelected2013pA(lESDevent)) {
1019     AliWarning("Pb / | Vertex not selected by 2013 pA criteria!");
1020     PostData(1, fListHistV0);
1021     PostData(2, fTree);
1022     return;
1023   }
1024
1025   f2dHistMultiplicityVsVertexZ->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
1026
1027   lMagneticField = lESDevent->GetMagneticField( );
1028   fHistV0MultiplicityForSelEvt ->Fill( nV0s );
1029   fHistMultiplicity->Fill(lMultiplicity);
1030   fHistMultiplicityV0A->Fill(lMultiplicityV0A);
1031   fHistMultiplicityZNA->Fill(lMultiplicityZNA);
1032   fHistMultiplicityTRK->Fill(lMultiplicityTRK);
1033   fHistMultiplicitySPD->Fill(lMultiplicitySPD);
1034
1035 //------------------------------------------------
1036 // Only look at events with well-established PV
1037 //------------------------------------------------
1038
1039    const AliESDVertex *lPrimaryTrackingESDVtxCheck = lESDevent->GetPrimaryVertexTracks();
1040    const AliESDVertex *lPrimarySPDVtx = lESDevent->GetPrimaryVertexSPD();
1041    if (!lPrimarySPDVtx->GetStatus() && !lPrimaryTrackingESDVtxCheck->GetStatus() && fkpAVertexSelection==kFALSE ){
1042       AliWarning("Pb / No SPD prim. vertex nor prim. Tracking vertex ... return !");
1043       PostData(1, fListHistV0);
1044       PostData(2, fTree);
1045       return;
1046    }
1047
1048
1049    f2dHistMultiplicityVsVertexZNoTPCOnly->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
1050   fHistV0MultiplicityForSelEvtNoTPCOnly ->Fill( nV0s );
1051   fHistMultiplicityNoTPCOnly->Fill(lMultiplicity);
1052   fHistMultiplicityV0ANoTPCOnly->Fill(lMultiplicityV0A);
1053   fHistMultiplicityZNANoTPCOnly->Fill(lMultiplicityZNA);
1054   fHistMultiplicityTRKNoTPCOnly->Fill(lMultiplicityTRK);
1055   fHistMultiplicitySPDNoTPCOnly->Fill(lMultiplicitySPD);
1056
1057 //------------------------------------------------
1058 // Pileup Rejection
1059 //------------------------------------------------
1060
1061    // FIXME : quality selection regarding pile-up rejection
1062    if(lESDevent->IsPileupFromSPD() && !fkIsNuclear && fkRejectPileup){// minContributors=3, minZdist=0.8, nSigmaZdist=3., nSigmaDiamXY=2., nSigmaDiamZ=5.  -> see http://alisoft.cern.ch/viewvc/trunk/STEER/AliESDEvent.h?root=AliRoot&r1=41914&r2=42199&pathrev=42199
1063       PostData(1, fListHistV0);
1064       PostData(2, fTree);
1065       return;
1066    }
1067
1068   f2dHistMultiplicityVsVertexZNoTPCOnlyNoPileup->Fill( lMultiplicity, tPrimaryVtxPosition[2] );
1069   fHistV0MultiplicityForSelEvtNoTPCOnlyNoPileup ->Fill( nV0s );
1070   fHistMultiplicityNoTPCOnlyNoPileup->Fill(lMultiplicity);
1071   fHistMultiplicityV0ANoTPCOnlyNoPileup->Fill(lMultiplicityV0A);
1072   fHistMultiplicityZNANoTPCOnlyNoPileup->Fill(lMultiplicityZNA);
1073   fHistMultiplicityTRKNoTPCOnlyNoPileup->Fill(lMultiplicityTRK);
1074   fHistMultiplicitySPDNoTPCOnlyNoPileup->Fill(lMultiplicitySPD);
1075
1076 //------------------------------------------------
1077 // MAIN LAMBDA LOOP STARTS HERE
1078 //------------------------------------------------
1079
1080    if( ! (lESDevent->GetPrimaryVertex()->IsFromVertexerZ() )     ){
1081       fHistPVxAnalysis->Fill( tPrimaryVtxPosition[0] );
1082       fHistPVyAnalysis->Fill( tPrimaryVtxPosition[1] );
1083       fHistPVzAnalysis->Fill( tPrimaryVtxPosition[2] );
1084    }
1085
1086   fTreeVariablePVx = tPrimaryVtxPosition[0];
1087   fTreeVariablePVy = tPrimaryVtxPosition[1];
1088   fTreeVariablePVz = tPrimaryVtxPosition[2];
1089
1090 //Variable definition
1091    Int_t    lOnFlyStatus = 0;// nv0sOn = 0, nv0sOff = 0;
1092    Double_t lChi2V0 = 0;
1093    Double_t lDcaV0Daughters = 0, lDcaV0ToPrimVertex = 0;
1094    Double_t lDcaPosToPrimVertex = 0, lDcaNegToPrimVertex = 0;
1095    Double_t lV0CosineOfPointingAngle = 0;
1096    Double_t lV0Radius = 0, lPt = 0;
1097    Double_t lRapK0Short = 0, lRapLambda = 0;
1098    Double_t lInvMassK0s = 0, lInvMassLambda = 0, lInvMassAntiLambda = 0;
1099    Double_t lAlphaV0 = 0, lPtArmV0 = 0;
1100
1101    Double_t fMinV0Pt = 0;
1102    Double_t fMaxV0Pt = 100;
1103
1104    Int_t nv0s = 0;
1105    nv0s = lESDevent->GetNumberOfV0s();
1106
1107    //for (Int_t iV0 = 0; iV0 < nv0s; iV0++)
1108    for (Int_t iV0 = 0; iV0 < nv0s; iV0++) //extra-crazy test
1109    {// This is the begining of the V0 loop
1110       AliESDv0 *v0 = ((AliESDEvent*)lESDevent)->GetV0(iV0);
1111       if (!v0) continue;
1112
1113       //---> Fix On-the-Fly candidates, count how many swapped
1114       if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ){
1115         fHistSwappedV0Counter -> Fill( 1 );
1116       }else{
1117         fHistSwappedV0Counter -> Fill( 0 );
1118       }
1119       if ( fkUseOnTheFly ) CheckChargeV0(v0);
1120
1121       Double_t tDecayVertexV0[3]; v0->GetXYZ(tDecayVertexV0[0],tDecayVertexV0[1],tDecayVertexV0[2]);
1122
1123       Double_t tV0mom[3];
1124       v0->GetPxPyPz( tV0mom[0],tV0mom[1],tV0mom[2] );
1125       Double_t lV0TotalMomentum = TMath::Sqrt(
1126       tV0mom[0]*tV0mom[0]+tV0mom[1]*tV0mom[1]+tV0mom[2]*tV0mom[2] );
1127
1128       lV0Radius = TMath::Sqrt(tDecayVertexV0[0]*tDecayVertexV0[0]+tDecayVertexV0[1]*tDecayVertexV0[1]);
1129
1130       //Set Variables for later filling
1131       fTreeVariableV0x = tDecayVertexV0[0];
1132       fTreeVariableV0y = tDecayVertexV0[1];
1133       fTreeVariableV0z = tDecayVertexV0[2];
1134
1135       //Set Variables for later filling
1136       fTreeVariableV0Px = tV0mom[0];
1137       fTreeVariableV0Py = tV0mom[1];
1138       fTreeVariableV0Pz = tV0mom[2];
1139
1140       lPt = v0->Pt();
1141       lRapK0Short = v0->RapK0Short();
1142       lRapLambda  = v0->RapLambda();
1143       if ((lPt<fMinV0Pt)||(fMaxV0Pt<lPt)) continue;
1144
1145       UInt_t lKeyPos = (UInt_t)TMath::Abs(v0->GetPindex());
1146       UInt_t lKeyNeg = (UInt_t)TMath::Abs(v0->GetNindex());
1147
1148       Double_t lMomPos[3]; v0->GetPPxPyPz(lMomPos[0],lMomPos[1],lMomPos[2]);
1149       Double_t lMomNeg[3]; v0->GetNPxPyPz(lMomNeg[0],lMomNeg[1],lMomNeg[2]);
1150
1151       AliESDtrack *pTrack=((AliESDEvent*)lESDevent)->GetTrack(lKeyPos);
1152       AliESDtrack *nTrack=((AliESDEvent*)lESDevent)->GetTrack(lKeyNeg);
1153       if (!pTrack || !nTrack) {
1154          Printf("ERROR: Could not retreive one of the daughter track");
1155          continue;
1156       }
1157
1158       //Daughter Eta for Eta selection, afterwards
1159       fTreeVariableNegEta = nTrack->Eta();
1160       fTreeVariablePosEta = pTrack->Eta();
1161
1162      if( fkSpecialExecution ){
1163        fTreeVariableNegPx = lMomNeg[0]; fTreeVariableNegPy = lMomNeg[1]; fTreeVariableNegPz = lMomNeg[2];
1164        fTreeVariablePosPx = lMomPos[0]; fTreeVariablePosPy = lMomPos[1]; fTreeVariablePosPz = lMomPos[2];
1165        //Need to acquire info to do dEdx cut afterwards...
1166        fTreeVariablePosTPCSignal = pTrack->GetTPCsignal();
1167        fTreeVariableNegTPCSignal = nTrack->GetTPCsignal();
1168        //Get Inner momentum if possible
1169        fTreeVariableNegInnerP = nTrack->GetP();
1170        fTreeVariablePosInnerP = pTrack->GetP();
1171        const AliExternalTrackParam *innerpos=pTrack->GetInnerParam();
1172        const AliExternalTrackParam *innerneg=nTrack->GetInnerParam();
1173        if(innerpos) { fTreeVariablePosInnerP = innerpos->GetP(); }
1174        if(innerneg) { fTreeVariableNegInnerP = innerneg->GetP(); }
1175
1176        f2dHistdEdxPos->Fill( fTreeVariablePosInnerP , fTreeVariablePosdEdxSig );
1177        f2dHistdEdxNeg->Fill( fTreeVariableNegInnerP , fTreeVariableNegdEdxSig );
1178      }
1179
1180       // Filter like-sign V0 (next: add counter and distribution)
1181       if ( pTrack->GetSign() == nTrack->GetSign()){
1182          continue;
1183       }
1184
1185       //________________________________________________________________________
1186       // Track quality cuts
1187       Float_t lPosTrackCrossedRows = pTrack->GetTPCClusterInfo(2,1);
1188       Float_t lNegTrackCrossedRows = nTrack->GetTPCClusterInfo(2,1);
1189       fTreeVariableLeastNbrCrossedRows = (Int_t) lPosTrackCrossedRows;
1190       if( lNegTrackCrossedRows < fTreeVariableLeastNbrCrossedRows )
1191          fTreeVariableLeastNbrCrossedRows = (Int_t) lNegTrackCrossedRows;
1192
1193       // TPC refit condition (done during reconstruction for Offline but not for On-the-fly)
1194       if( !(pTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
1195       if( !(nTrack->GetStatus() & AliESDtrack::kTPCrefit)) continue;
1196
1197       //Get status flags
1198       fTreeVariablePosTrackStatus = pTrack->GetStatus();
1199       fTreeVariableNegTrackStatus = nTrack->GetStatus();
1200
1201       if ( ( ( ( pTrack->GetTPCClusterInfo(2,1) ) < 70 ) || ( ( nTrack->GetTPCClusterInfo(2,1) ) < 70 ) )&&(fkTakeAllTracks==kFALSE) ) continue;
1202
1203       //GetKinkIndex condition
1204       if( pTrack->GetKinkIndex(0)>0 || nTrack->GetKinkIndex(0)>0 ) continue;
1205
1206       //Findable clusters > 0 condition
1207       if( pTrack->GetTPCNclsF()<=0 || nTrack->GetTPCNclsF()<=0 ) continue;
1208
1209       //Compute ratio Crossed Rows / Findable clusters
1210       //Note: above test avoids division by zero!
1211       Float_t lPosTrackCrossedRowsOverFindable = lPosTrackCrossedRows / ((double)(pTrack->GetTPCNclsF()));
1212       Float_t lNegTrackCrossedRowsOverFindable = lNegTrackCrossedRows / ((double)(nTrack->GetTPCNclsF()));
1213
1214       fTreeVariableLeastRatioCrossedRowsOverFindable = lPosTrackCrossedRowsOverFindable;
1215       if( lNegTrackCrossedRowsOverFindable < fTreeVariableLeastRatioCrossedRowsOverFindable )
1216          fTreeVariableLeastRatioCrossedRowsOverFindable = lNegTrackCrossedRowsOverFindable;
1217
1218       //Lowest Cut Level for Ratio Crossed Rows / Findable = 0.8, set here
1219       if ( (fTreeVariableLeastRatioCrossedRowsOverFindable < 0.8)&&(fkTakeAllTracks==kFALSE) ) continue;
1220
1221       //End track Quality Cuts
1222       //________________________________________________________________________
1223
1224       lDcaPosToPrimVertex = TMath::Abs(pTrack->GetD(tPrimaryVtxPosition[0],
1225                                                         tPrimaryVtxPosition[1],
1226                                                         lMagneticField) );
1227
1228       lDcaNegToPrimVertex = TMath::Abs(nTrack->GetD(tPrimaryVtxPosition[0],
1229                                                         tPrimaryVtxPosition[1],
1230                                                         lMagneticField) );
1231
1232       lOnFlyStatus = v0->GetOnFlyStatus();
1233       lChi2V0 = v0->GetChi2V0();
1234       lDcaV0Daughters = v0->GetDcaV0Daughters();
1235       lDcaV0ToPrimVertex = v0->GetD(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
1236       lV0CosineOfPointingAngle = v0->GetV0CosineOfPointingAngle(tPrimaryVtxPosition[0],tPrimaryVtxPosition[1],tPrimaryVtxPosition[2]);
1237       fTreeVariableV0CosineOfPointingAngle=lV0CosineOfPointingAngle;
1238
1239       // Getting invariant mass infos directly from ESD
1240       v0->ChangeMassHypothesis(310);
1241       lInvMassK0s = v0->GetEffMass();
1242       v0->ChangeMassHypothesis(3122);
1243       lInvMassLambda = v0->GetEffMass();
1244       v0->ChangeMassHypothesis(-3122);
1245       lInvMassAntiLambda = v0->GetEffMass();
1246       lAlphaV0 = v0->AlphaV0();
1247       lPtArmV0 = v0->PtArmV0();
1248
1249       fTreeVariablePt = v0->Pt();
1250       fTreeVariableChi2V0 = lChi2V0;
1251       fTreeVariableDcaV0ToPrimVertex = lDcaV0ToPrimVertex;
1252       fTreeVariableDcaV0Daughters = lDcaV0Daughters;
1253       fTreeVariableV0CosineOfPointingAngle = lV0CosineOfPointingAngle;
1254       fTreeVariableV0Radius = lV0Radius;
1255       fTreeVariableDcaPosToPrimVertex = lDcaPosToPrimVertex;
1256       fTreeVariableDcaNegToPrimVertex = lDcaNegToPrimVertex;
1257       fTreeVariableInvMassK0s = lInvMassK0s;
1258       fTreeVariableInvMassLambda = lInvMassLambda;
1259       fTreeVariableInvMassAntiLambda = lInvMassAntiLambda;
1260       fTreeVariableRapK0Short = lRapK0Short;
1261       fTreeVariableRapLambda = lRapLambda;
1262       fTreeVariableAlphaV0 = lAlphaV0;
1263       fTreeVariablePtArmV0 = lPtArmV0;
1264
1265       //Official means of acquiring N-sigmas
1266       fTreeVariableNSigmasPosProton = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kProton );
1267       fTreeVariableNSigmasPosPion   = fPIDResponse->NumberOfSigmasTPC( pTrack, AliPID::kPion );
1268       fTreeVariableNSigmasNegProton = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kProton );
1269       fTreeVariableNSigmasNegPion   = fPIDResponse->NumberOfSigmasTPC( nTrack, AliPID::kPion );
1270
1271 //This requires an Invariant Mass Hypothesis afterwards
1272       fTreeVariableDistOverTotMom = TMath::Sqrt(
1273                                                 TMath::Power( tDecayVertexV0[0] - lBestPrimaryVtxPos[0] , 2) +
1274                                                 TMath::Power( tDecayVertexV0[1] - lBestPrimaryVtxPos[1] , 2) +
1275                                                 TMath::Power( tDecayVertexV0[2] - lBestPrimaryVtxPos[2] , 2)
1276                                         );
1277       fTreeVariableDistOverTotMom /= (lV0TotalMomentum+1e-10); //avoid division by zero, to be sure
1278
1279 //------------------------------------------------
1280 // Fill Tree!
1281 //------------------------------------------------
1282
1283      // The conditionals are meant to decrease excessive
1284      // memory usage!
1285
1286      //First Selection: Reject OnFly
1287      if( (lOnFlyStatus == 0 && fkUseOnTheFly == kFALSE) || (lOnFlyStatus != 0 && fkUseOnTheFly == kTRUE ) ){
1288        //Second Selection: rough 20-sigma band, parametric.
1289        //K0Short: Enough to parametrize peak broadening with linear function.
1290        Double_t lUpperLimitK0Short = (5.63707e-01) + (1.14979e-02)*fTreeVariablePt;
1291        Double_t lLowerLimitK0Short = (4.30006e-01) - (1.10029e-02)*fTreeVariablePt;
1292        //Lambda: Linear (for higher pt) plus exponential (for low-pt broadening)
1293        //[0]+[1]*x+[2]*TMath::Exp(-[3]*x)
1294        Double_t lUpperLimitLambda = (1.13688e+00) + (5.27838e-03)*fTreeVariablePt + (8.42220e-02)*TMath::Exp(-(3.80595e+00)*fTreeVariablePt);
1295        Double_t lLowerLimitLambda = (1.09501e+00) - (5.23272e-03)*fTreeVariablePt - (7.52690e-02)*TMath::Exp(-(3.46339e+00)*fTreeVariablePt);
1296        //Do Selection
1297        if( (fTreeVariableInvMassLambda     < lUpperLimitLambda  && fTreeVariableInvMassLambda     > lLowerLimitLambda     ) ||
1298           (fTreeVariableInvMassAntiLambda < lUpperLimitLambda  && fTreeVariableInvMassAntiLambda > lLowerLimitLambda     ) ||
1299           (fTreeVariableInvMassK0s        < lUpperLimitK0Short && fTreeVariableInvMassK0s        > lLowerLimitK0Short    ) ){
1300          //Pre-selection in case this is AA...
1301          if( fkIsNuclear == kFALSE ) fTree->Fill();
1302          if( fkIsNuclear == kTRUE){
1303            //If this is a nuclear collision___________________
1304            // ... pre-filter with TPC, daughter eta selection
1305            if( (fTreeVariableInvMassLambda     < lUpperLimitLambda  && fTreeVariableInvMassLambda     > lLowerLimitLambda
1306                 && TMath::Abs(fTreeVariableNSigmasPosProton) < 6.0 && TMath::Abs(fTreeVariableNSigmasNegPion) < 6.0 ) ||
1307               (fTreeVariableInvMassAntiLambda < lUpperLimitLambda  && fTreeVariableInvMassAntiLambda > lLowerLimitLambda
1308                && TMath::Abs(fTreeVariableNSigmasNegProton) < 6.0 && TMath::Abs(fTreeVariableNSigmasPosPion) < 6.0 ) ||
1309               (fTreeVariableInvMassK0s        < lUpperLimitK0Short && fTreeVariableInvMassK0s        > lLowerLimitK0Short
1310                && TMath::Abs(fTreeVariableNSigmasNegPion)   < 6.0 && TMath::Abs(fTreeVariableNSigmasPosPion) < 6.0 ) ){
1311                 //insane test
1312                 if ( TMath::Abs(fTreeVariableNegEta)<0.8 && TMath::Abs(fTreeVariablePosEta)<0.8 && !fkSpecialExecution) fTree->Fill();
1313               }
1314          }//end nuclear_____________________________________
1315        }
1316      }
1317
1318      if(lOnFlyStatus == 0 && fkSpecialExecution){
1319        if(
1320           (fTreeVariableNSigmasPosProton > 6 && TMath::Abs(fTreeVariableNSigmasNegPion)< 6
1321            && fTreeVariableDcaPosToPrimVertex > fExtraDCAHeavyToPrimVertex && fTreeVariableDcaNegToPrimVertex > fExtraDCALightToPrimVertex ) ||
1322           (fTreeVariableNSigmasNegProton > 6 && TMath::Abs(fTreeVariableNSigmasPosPion)< 6
1323            && fTreeVariableDcaPosToPrimVertex > fExtraDCALightToPrimVertex && fTreeVariableDcaNegToPrimVertex > fExtraDCAHeavyToPrimVertex ) ){
1324          fTree->Fill();
1325        }
1326      }
1327
1328 //------------------------------------------------
1329 // Fill tree over.
1330 //------------------------------------------------
1331
1332    }// This is the end of the V0 loop
1333
1334   // Post output data.
1335     PostData(1, fListHistV0);
1336     PostData(2, fTree);
1337
1338
1339 }
1340
1341 //________________________________________________________________________
1342 void AliAnalysisTaskExtractV0::Terminate(Option_t *)
1343 {
1344    // Draw result to the screen
1345    // Called once at the end of the query
1346    // This will draw the V0 candidate multiplicity, whose
1347    // number of entries corresponds to the number of triggered events.
1348    TList *cRetrievedList = 0x0;
1349    cRetrievedList = (TList*)GetOutputData(1);
1350    if(!cRetrievedList){
1351       Printf("ERROR - AliAnalysisTaskExtractV0 : ouput data container list not available\n");
1352       return;
1353    }
1354    fHistV0MultiplicityForTrigEvt = dynamic_cast<TH1F*> (  cRetrievedList->FindObject("fHistV0MultiplicityForTrigEvt")  );
1355    if (!fHistV0MultiplicityForTrigEvt) {
1356       Printf("ERROR - AliAnalysisTaskExtractV0 : fHistV0MultiplicityForTrigEvt not available");
1357       return;
1358    }
1359    TCanvas *canCheck = new TCanvas("AliAnalysisTaskExtractV0","V0 Multiplicity",10,10,510,510);
1360    canCheck->cd(1)->SetLogy();
1361    fHistV0MultiplicityForTrigEvt->SetMarkerStyle(22);
1362    fHistV0MultiplicityForTrigEvt->DrawCopy("E");
1363 }
1364
1365 //________________________________________________________________________
1366 void AliAnalysisTaskExtractV0::CheckChargeV0(AliESDv0 *v0)
1367 {
1368    // This function checks charge of negative and positive daughter tracks.
1369    // If incorrectly defined (onfly vertexer), swaps out.
1370    if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ){
1371       //V0 daughter track swapping is required! Note: everything is swapped here... P->N, N->P
1372       Long_t lCorrectNidx = v0->GetPindex();
1373       Long_t lCorrectPidx = v0->GetNindex();
1374       Double32_t        lCorrectNmom[3];
1375       Double32_t        lCorrectPmom[3];
1376       v0->GetPPxPyPz( lCorrectNmom[0], lCorrectNmom[1], lCorrectNmom[2] );
1377       v0->GetNPxPyPz( lCorrectPmom[0], lCorrectPmom[1], lCorrectPmom[2] );
1378
1379       AliExternalTrackParam     lCorrectParamN(
1380         v0->GetParamP()->GetX() ,
1381         v0->GetParamP()->GetAlpha() ,
1382         v0->GetParamP()->GetParameter() ,
1383         v0->GetParamP()->GetCovariance()
1384       );
1385       AliExternalTrackParam     lCorrectParamP(
1386         v0->GetParamN()->GetX() ,
1387         v0->GetParamN()->GetAlpha() ,
1388         v0->GetParamN()->GetParameter() ,
1389         v0->GetParamN()->GetCovariance()
1390       );
1391       lCorrectParamN.SetMostProbablePt( v0->GetParamP()->GetMostProbablePt() );
1392       lCorrectParamP.SetMostProbablePt( v0->GetParamN()->GetMostProbablePt() );
1393
1394       //Get Variables___________________________________________________
1395       Double_t lDcaV0Daughters = v0 -> GetDcaV0Daughters();
1396       Double_t lCosPALocal     = v0 -> GetV0CosineOfPointingAngle();
1397       Bool_t lOnFlyStatusLocal = v0 -> GetOnFlyStatus();
1398
1399       //Create Replacement Object_______________________________________
1400       AliESDv0 *v0correct = new AliESDv0(lCorrectParamN,lCorrectNidx,lCorrectParamP,lCorrectPidx);
1401       v0correct->SetDcaV0Daughters          ( lDcaV0Daughters   );
1402       v0correct->SetV0CosineOfPointingAngle ( lCosPALocal       );
1403       v0correct->ChangeMassHypothesis       ( kK0Short          );
1404       v0correct->SetOnFlyStatus             ( lOnFlyStatusLocal );
1405
1406       //Reverse Cluster info..._________________________________________
1407       v0correct->SetClusters( v0->GetClusters( 1 ), v0->GetClusters ( 0 ) );
1408
1409       *v0 = *v0correct;
1410       //Proper cleanup..._______________________________________________
1411       v0correct->Delete();
1412       v0correct = 0x0;
1413
1414       //Just another cross-check and output_____________________________
1415       if( v0->GetParamN()->Charge() > 0 && v0->GetParamP()->Charge() < 0 ) {
1416         AliWarning("Found Swapped Charges, tried to correct but something FAILED!");
1417       }else{
1418         //AliWarning("Found Swapped Charges and fixed.");
1419       }
1420       //________________________________________________________________
1421    }else{
1422       //Don't touch it! ---
1423       //Printf("Ah, nice. Charges are already ordered...");
1424    }
1425    return;
1426 }