PWGJE/FlavourJetTasks/AliAnalysisTaskSEPicoV0MakerMC.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2008, 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 // AliAnalysisTaskSE for RecoDecay object (K0 short, Lambda,
  19 // D mesons ...) filtering
  20 //
  21 // Author: X-M. Zhang, xmzhang@lbl.gov
  22 /////////////////////////////////////////////////////////////
  23
  24 #include <iostream>
  25
  26 #include <TString.h>
  27 #include <TH1D.h>
  28 #include <TH2D.h>
  29 #include <THnSparse.h>
  30 #include <TMath.h>
  31 #include <TClonesArray.h>
  32 #include <TDatabasePDG.h>
  33 #include <TParticle.h>
  34
  35 #include "AliAODEvent.h"
  36 #include "AliESDEvent.h"
  37 #include "AliMCEvent.h"
  38 #include "AliStack.h"
  39 #include "AliVVertex.h"
  40 #include "AliAODv0.h"
  41 #include "AliESDv0.h"
  42 #include "AliAODTrack.h"
  43 #include "AliESDtrack.h"
  44 #include "AliStack.h"
  45 #include "AliMCParticle.h"
  46 #include "AliAODMCParticle.h"
  47 #include "AliHeader.h"
  48 #include "AliGenDPMjetEventHeader.h"
  49 #include "AliV0vertexer.h"
  50 #include "AliAnalysisUtils.h"
  51 #include "AliInputEventHandler.h"
  52 #include "AliCentrality.h"
  53 #include "AliPIDResponse.h"
  54
  55 #include "AliPicoHeaderCJ.h"
  56 #include "AliPicoV0MC.h"
  57 #include "AliAnalysisTaskSEPicoV0MakerMC.h"
  58
  59 ClassImp(AliAnalysisTaskSEPicoV0MakerMC)
  60 //=============================================================================
  61
  62 const Double_t AliAnalysisTaskSEPicoV0MakerMC::fgkMassPion   = 0.13957;
  63 const Double_t AliAnalysisTaskSEPicoV0MakerMC::fgkMassKshort = 0.497614;
  64 const Double_t AliAnalysisTaskSEPicoV0MakerMC::fgkMassProton = 0.938272;
  65 const Double_t AliAnalysisTaskSEPicoV0MakerMC::fgkMassLambda = 1.11568;
  66
  67 //_____________________________________________________________________________
  68 AliAnalysisTaskSEPicoV0MakerMC::AliAnalysisTaskSEPicoV0MakerMC() :
  69 AliAnalysisTaskSE(),
  70 fEventAOD(0),
  71 fEventESD(0),
  72 fCentInfo(0),
  73 fRespoPID(0),
  74 fAnaUtils(0),
  75 fEventAcptMask(0),
  76 fTriggerMask(0),
  77 fCollisionType(0),
  78 fCentEst(""),
  79 fIsRefitV0sESD(kFALSE),
  80 fIsSkipFastOnly(kFALSE),
  81 fIsDPMjetMC(kFALSE),
  82 fCutMinEventVtxContr(0),
  83 fCutMaxEventVzAbs(0.),
  84 fCutMinV0Pt(0.),
  85 fCutMaxV0Pt(0.),
  86 fCutMinV0Rap(0.),
  87 fCutMaxV0Rap(0.),
  88 fCutMinDauPt(0.),
  89 fCutMinDauEta(0.),
  90 fCutMaxDauEta(0.),
  91 fCutMaxV0Chi2(0.),
  92 fCutMinV0Radius(0.),
  93 fCutMaxV0Radius(0.),
  94 fCutMaxDausDCA(0.),
  95 fCutMinDauDCAtoPV(0.),
  96 fCutMinDauXrowsTPC(0.),
  97 fCutMinDauXrowsOverFindableClusTPC(0.),
  98 fCutMaxKshortSigmaTPC(0.),
  99 fCutMinKshortCosPA(0.),
 100 fCutMaxKshortCtau(0.),
 101 fCutMaxKshortArmFrac(0.),
 102 fCutMinKshortDeltaM(0.),
 103 fCutMaxLambdaSigmaTPC(0.),
 104 fCutMinLambdaCosPA(0.),
 105 fCutMaxLambdaCtau(0.),
 106 fCutMaxLambdaArmFrac(0.),
 107 fCutMinLambdaDeletaM(0.),
 108 fPicoV0sClArr(0),
 109 fListUserOutputs(0)
 110 {
 111 //
 112 // Default constructor
 113 //
 114
 115   for (Int_t i=3; i--;) fPrimaryVtx[i] = 0.;
 116 }
 117
 118 //_____________________________________________________________________________
 119 AliAnalysisTaskSEPicoV0MakerMC::AliAnalysisTaskSEPicoV0MakerMC(const char *name) :
 120 AliAnalysisTaskSE(name),
 121 fEventAOD(0),
 122 fEventESD(0),
 123 fCentInfo(0),
 124 fRespoPID(0),
 125 fAnaUtils(0),
 126 fEventAcptMask(0),
 127 fTriggerMask(0),
 128 fCollisionType(AliPicoHeaderCJ::kPP),
 129 fCentEst("V0M"),
 130 fIsRefitV0sESD(kFALSE),
 131 fIsSkipFastOnly(kFALSE),
 132 fIsDPMjetMC(kFALSE),
 133 fCutMinEventVtxContr(2),
 134 fCutMaxEventVzAbs(10.),
 135 fCutMinV0Pt(0.),
 136 fCutMaxV0Pt(100.),
 137 fCutMinV0Rap(-10.),
 138 fCutMaxV0Rap(10.),
 139 fCutMinDauPt(0.),
 140 fCutMinDauEta(-10.),
 141 fCutMaxDauEta(10.),
 142 fCutMaxV0Chi2(33.),
 143 fCutMinV0Radius(0.5),
 144 fCutMaxV0Radius(200.),
 145 fCutMaxDausDCA(1.),
 146 fCutMinDauDCAtoPV(0.06),
 147 fCutMinDauXrowsTPC(70.),
 148 fCutMinDauXrowsOverFindableClusTPC(0.8),
 149 fCutMaxKshortSigmaTPC(5.),
 150 fCutMinKshortCosPA(0.97),
 151 fCutMaxKshortCtau(20.),
 152 fCutMaxKshortArmFrac(-1.),
 153 fCutMinKshortDeltaM(0.005),
 154 fCutMaxLambdaSigmaTPC(5.),
 155 fCutMinLambdaCosPA(0.995),
 156 fCutMaxLambdaCtau(30.),
 157 fCutMaxLambdaArmFrac(-1.),
 158 fCutMinLambdaDeletaM(0.01),
 159 fPicoV0sClArr(0),
 160 fListUserOutputs(0)
 161 {
 162 //
 163 // Constructor
 164 //
 165
 166   for (Int_t i=3; i--;) fPrimaryVtx[i] = 0.;
 167
 168   DefineOutput(1, TList::Class());
 169 }
 170
 171 //_____________________________________________________________________________
 172 AliAnalysisTaskSEPicoV0MakerMC::~AliAnalysisTaskSEPicoV0MakerMC()
 173 {
 174 //
 175 // Default destructor
 176 //
 177
 178   if (fEventAOD) { delete fEventAOD; fEventAOD = 0; }
 179   if (fEventESD) { delete fEventESD; fEventESD = 0; }
 180   if (fCentInfo) { delete fCentInfo; fCentInfo = 0; }
 181   if (fRespoPID) { delete fRespoPID; fRespoPID = 0; }
 182   if (fAnaUtils) { delete fAnaUtils; fAnaUtils = 0; }
 183
 184   if (fPicoV0sClArr)    { delete fPicoV0sClArr;    fPicoV0sClArr    = 0; }
 185   if (fListUserOutputs) { delete fListUserOutputs; fListUserOutputs = 0; }
 186 }
 187
 188 //_____________________________________________________________________________
 189 void AliAnalysisTaskSEPicoV0MakerMC::Init()
 190 {
 191 //
 192 //  AliAnalysisTaskSEPicoV0MakerMC::Init
 193 //
 194
 195   return;
 196 }
 197
 198 //_____________________________________________________________________________
 199 void AliAnalysisTaskSEPicoV0MakerMC::UserCreateOutputObjects()
 200 {
 201 //
 202 //  AliAnalysisTaskSEPicoV0MakerMC::UserCreateOutputObjects
 203 //
 204
 205   InitAnalysis();
 206 //=============================================================================
 207
 208   fPicoV0sClArr = new TClonesArray("AliPicoV0MC");
 209   fPicoV0sClArr->SetName("PicoV0s");
 210 //=============================================================================
 211
 212   fListUserOutputs = new TList();
 213   fListUserOutputs->SetOwner();
 214
 215   CreateHistograms();
 216   PostData(1, fListUserOutputs);
 217   return;
 218 }
 219
 220 //_____________________________________________________________________________
 221 void AliAnalysisTaskSEPicoV0MakerMC::UserExec(Option_t */*opt*/)
 222 {
 223 //
 224 //  AliAnalysisTaskSEPicoV0MakerMC::UserExec
 225 //
 226
 227   fPicoV0sClArr->Delete();
 228   if (IsEventNotAcpt()) return;
 229   if (!(InputEvent()->FindListObject("PicoV0s"))) InputEvent()->AddObject(fPicoV0sClArr);
 230 //=============================================================================
 231
 232   FillHistograms(); if (IsEventNotMBsa()) return;
 233 //=============================================================================
 234
 235   FillPicoV0s();
 236   return;
 237 }
 238
 239 //_____________________________________________________________________________
 240 void AliAnalysisTaskSEPicoV0MakerMC::Terminate(Option_t */*opt*/)
 241 {
 242 //
 243 //  AliAnalysisTaskSEPicoV0MakerMC::Terminate
 244 //
 245
 246   return;
 247 }
 248
 249 //_____________________________________________________________________________
 250 void AliAnalysisTaskSEPicoV0MakerMC::NotifyRun()
 251 {
 252 //
 253 //  AliAnalysisTaskSEPicoV0MakerMC::NotifyRun
 254 //
 255
 256   return;
 257 }
 258
 259 //_____________________________________________________________________________
 260 void AliAnalysisTaskSEPicoV0MakerMC::FillPicoV0s()
 261 {
 262 //
 263 //  AliAnalysisTaskSEPicoV0MakerMC::FillPicoRecoV0s
 264 //
 265
 266   Int_t nV0s = 0;
 267   AliAODv0 *pV0AOD = 0;
 268   AliESDv0 *pV0ESD = 0;
 269   if (fEventAOD) nV0s = fEventAOD->GetNumberOfV0s();
 270   if (fEventESD) nV0s = fEventESD->GetNumberOfV0s();
 271   if (nV0s<=0) return;
 272 //=============================================================================
 273
 274   TH2D *hKshortPtInvM = dynamic_cast<TH2D*>(fListUserOutputs->FindObject("hKshortPtInvM"));
 275   TH2D *hLambdaPtInvM = dynamic_cast<TH2D*>(fListUserOutputs->FindObject("hLambdaPtInvM"));
 276   TH2D *hAntiLaPtInvM = dynamic_cast<TH2D*>(fListUserOutputs->FindObject("hAntiLaPtInvM"));
 277 //=============================================================================
 278
 279   AliPicoV0MC *pV0 = 0;
 280   Int_t nAt = fPicoV0sClArr->GetEntriesFast();
 281
 282   for (Int_t iV0=0; iV0<nV0s; iV0++) {
 283
 284     if (fEventAOD) {
 285       pV0AOD = fEventAOD->GetV0(iV0);  if (!pV0AOD) continue;
 286       pV0 = SelectV0Candidate(pV0AOD); if (!pV0) { pV0AOD = 0; continue; }
 287     }
 288
 289     if (fEventESD) {
 290       pV0ESD = fEventESD->GetV0(iV0);  if (!pV0ESD) continue;
 291       pV0 = SelectV0Candidate(pV0ESD); if (!pV0) { pV0ESD = 0; continue; }
 292     }
 293
 294     pV0->FillKshortPtInvM(hKshortPtInvM);
 295     pV0->FillLambdaPtInvM(hLambdaPtInvM);
 296     pV0->FillAntiLaPtInvM(hAntiLaPtInvM);
 297     new ((*fPicoV0sClArr)[nAt++]) AliPicoV0MC(*pV0);
 298
 299     delete pV0; pV0 = 0;
 300     if (pV0AOD) pV0AOD=0;
 301     if (pV0ESD) pV0ESD=0;
 302   }
 303
 304   return;
 305 }
 306
 307 //_____________________________________________________________________________
 308 AliPicoV0MC* AliAnalysisTaskSEPicoV0MakerMC::SelectV0Candidate(AliAODv0 const *pV0RD)
 309 {
 310 //
 311 //  AliAnalysisTaskSEPicoV0MakerMC::SelectV0Candidate
 312 //
 313
 314   if (pV0RD->GetOnFlyStatus()) return 0x0;
 315   if ((pV0RD->Chi2V0())>fCutMaxV0Chi2) return 0x0;
 316
 317   Double_t dV0Pt = pV0RD->Pt(); if ((dV0Pt<fCutMinV0Pt) || (dV0Pt>fCutMaxV0Pt)) return 0x0;
 318 //=============================================================================
 319
 320   Double_t dV0Vtx[3]; pV0RD->GetXYZ(dV0Vtx);
 321   Double_t dV0Radius = TMath::Sqrt(dV0Vtx[0]*dV0Vtx[0] + dV0Vtx[1]*dV0Vtx[1]);
 322   if ((dV0Radius<fCutMinV0Radius) || (dV0Radius>fCutMaxV0Radius)) return 0x0;
 323
 324   Double_t dDausDCA = pV0RD->DcaV0Daughters(); if (dDausDCA>fCutMaxDausDCA) return 0x0;
 325   Double_t dPosDCAtoPV = pV0RD->DcaPosToPrimVertex(); if (dPosDCAtoPV<fCutMinDauDCAtoPV) return 0x0;
 326   Double_t dNegDCAtoPV = pV0RD->DcaNegToPrimVertex(); if (dNegDCAtoPV<fCutMinDauDCAtoPV) return 0x0;
 327 //=============================================================================
 328
 329   AliAODTrack *pDauPosRD = (AliAODTrack*)pV0RD->GetDaughter(0); if (!pDauPosRD) return 0x0;
 330   AliAODTrack *pDauNegRD = (AliAODTrack*)pV0RD->GetDaughter(1); if (!pDauNegRD) return 0x0;
 331
 332   if (!(pDauPosRD->GetStatus() & AliESDtrack::kTPCrefit)) return 0x0;
 333   if (!(pDauNegRD->GetStatus() & AliESDtrack::kTPCrefit)) return 0x0;
 334
 335   if ((pDauPosRD->GetProdVertex()->GetType())==((Char_t)AliAODVertex::kKink)) return 0x0;
 336   if ((pDauNegRD->GetProdVertex()->GetType())==((Char_t)AliAODVertex::kKink)) return 0x0;
 337
 338   Float_t dPosXrowsTPC = pDauPosRD->GetTPCClusterInfo(2,1);
 339   Float_t dNegXrowsTPC = pDauNegRD->GetTPCClusterInfo(2,1);
 340   Float_t dDauXrowsTPC = dPosXrowsTPC; if (dDauXrowsTPC>dNegXrowsTPC) dDauXrowsTPC = dNegXrowsTPC;
 341   if (dDauXrowsTPC<fCutMinDauXrowsTPC) return 0x0;
 342
 343   UShort_t wPosTPCNClsF = pDauPosRD->GetTPCNclsF(); if (wPosTPCNClsF<=0) return 0x0;
 344   UShort_t wNegTPCNClsF = pDauNegRD->GetTPCNclsF(); if (wNegTPCNClsF<=0) return 0x0;
 345   Double_t dPosXrowsOverFindableClusTPC = ((Double_t)dPosXrowsTPC) / ((Double_t)wPosTPCNClsF);
 346   Double_t dNegXrowsOverFindableClusTPC = ((Double_t)dNegXrowsTPC) / ((Double_t)wNegTPCNClsF);
 347
 348   Double_t dDauXrowsOverFindableClusTPC = dPosXrowsOverFindableClusTPC;
 349   if (dDauXrowsOverFindableClusTPC>dNegXrowsOverFindableClusTPC) dDauXrowsOverFindableClusTPC = dNegXrowsOverFindableClusTPC;
 350   if (dDauXrowsOverFindableClusTPC<fCutMinDauXrowsOverFindableClusTPC) return 0x0;
 351 //=============================================================================
 352
 353   Short_t nPosCharge = pDauPosRD->Charge();
 354   Short_t nNegCharge = pDauNegRD->Charge();
 355   if ((nPosCharge==0) || (nNegCharge==0) || (nPosCharge==nNegCharge)) return 0x0;
 356
 357   Double_t dPosPxPyPz[3] = { 0., 0., 0. };
 358   Double_t dNegPxPyPz[3] = { 0., 0., 0. };
 359   if ((nPosCharge<0) && (nNegCharge>0)) {
 360     pDauPosRD = (AliAODTrack*)pV0RD->GetDaughter(1);
 361     pDauNegRD = (AliAODTrack*)pV0RD->GetDaughter(0);
 362
 363     dPosPxPyPz[0] = pV0RD->MomNegX(); dPosPxPyPz[1] = pV0RD->MomNegY(); dPosPxPyPz[2] = pV0RD->MomNegZ();
 364     dNegPxPyPz[0] = pV0RD->MomPosX(); dNegPxPyPz[1] = pV0RD->MomPosY(); dNegPxPyPz[2] = pV0RD->MomPosZ();
 365   } else {
 366     dPosPxPyPz[0] = pV0RD->MomPosX(); dPosPxPyPz[1] = pV0RD->MomPosY(); dPosPxPyPz[2] = pV0RD->MomPosZ();
 367     dNegPxPyPz[0] = pV0RD->MomNegX(); dNegPxPyPz[1] = pV0RD->MomNegY(); dNegPxPyPz[2] = pV0RD->MomNegZ();
 368   }
 369
 370   TVector3 v3Pos(dPosPxPyPz);
 371   TVector3 v3Neg(dNegPxPyPz);
 372
 373   if ((v3Pos.Pt()<fCutMinDauPt) || (v3Neg.Pt()<fCutMinDauPt)) return 0x0;
 374   Double_t dPosEta = v3Pos.Eta(); if ((dPosEta<fCutMinDauEta) || (dPosEta>fCutMaxDauEta)) return 0x0;
 375   Double_t dNegEta = v3Neg.Eta(); if ((dNegEta<fCutMinDauEta) || (dNegEta>fCutMaxDauEta)) return 0x0;
 376 //=============================================================================
 377
 378   Int_t inp = TMath::Abs(pDauPosRD->GetLabel()); if (inp<0) return 0x0;
 379   Int_t inn = TMath::Abs(pDauNegRD->GetLabel()); if (inn<0) return 0x0;
 380   AliAODMCParticle *pDauPosMC = (AliAODMCParticle*)MCEvent()->GetTrack(inp); if (!pDauPosMC) return 0x0;
 381   AliAODMCParticle *pDauNegMC = (AliAODMCParticle*)MCEvent()->GetTrack(inn); if (!pDauNegMC) return 0x0;
 382
 383   Int_t imp = pDauPosMC->GetMother(); if (imp<0) return 0x0;
 384   Int_t imn = pDauNegMC->GetMother(); if (imn<0) return 0x0;
 385   if (imp != imn) return 0x0;
 386
 387   AliAODMCParticle *pV0MC = (AliAODMCParticle*)MCEvent()->GetTrack(imp); if (!pV0MC) return 0x0;
 388   if (((pV0MC->Y())<fCutMinV0Rap) || ((pV0MC->Y())>fCutMaxV0Rap)) return 0x0;
 389
 390   Int_t idvMC = pV0MC->GetPdgCode();
 391   Int_t idp = pDauPosMC->GetPdgCode();
 392   Int_t idn = pDauNegMC->GetPdgCode();
 393   Bool_t bIsKshort = ((idp==211)  && (idn==-211)  && (idvMC== 310));
 394   Bool_t bIsLambda = ((idp==2212) && (idn==-211)  && (idvMC== 3122));
 395   Bool_t bIsAntiLa = ((idp==211)  && (idn==-2212) && (idvMC==-3122));
 396   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 397 //=============================================================================
 398
 399   UInt_t wsvMC = 0;
 400   if (pV0MC->IsPrimary())                wsvMC |= AliPicoHeaderCJ::kPrimary;
 401   if (pV0MC->IsPhysicalPrimary())        wsvMC |= AliPicoHeaderCJ::kPhysicalPrimary;
 402   if (pV0MC->IsSecondaryFromWeakDecay()) wsvMC |= AliPicoHeaderCJ::kSecondaryFromWeakDecay;
 403   if (pV0MC->IsSecondaryFromMaterial())  wsvMC |= AliPicoHeaderCJ::kSecondaryFromMaterial;
 404
 405   Int_t  idmMC = 0;
 406   UInt_t wsmMC = 0;
 407   Double_t dMotherPt  = 0.;
 408   Double_t dMotherEta = 0.;
 409   Double_t dMotherRap = 0.;
 410   if (bIsLambda || bIsAntiLa) {
 411     Int_t imv = pV0MC->GetMother(); if (imv>=0) {
 412       AliAODMCParticle *pMother = (AliAODMCParticle*)MCEvent()->GetTrack(imv);
 413
 414       if (pMother) {
 415         idmMC = pMother->GetPdgCode();
 416         if ((bIsLambda && ((idmMC== 3312) || (idmMC== 3322))) ||
 417             (bIsAntiLa && ((idmMC==-3312) || (idmMC==-3322)))) {
 418           dMotherPt  = pMother->Pt();
 419           dMotherEta = pMother->Eta();
 420           dMotherRap = pMother->Y();
 421
 422           if (pMother->IsPrimary())                wsmMC |= AliPicoHeaderCJ::kPrimary;
 423           if (pMother->IsPhysicalPrimary())        wsmMC |= AliPicoHeaderCJ::kPhysicalPrimary;
 424           if (pMother->IsSecondaryFromWeakDecay()) wsmMC |= AliPicoHeaderCJ::kSecondaryFromWeakDecay;
 425           if (pMother->IsSecondaryFromMaterial())  wsmMC |= AliPicoHeaderCJ::kSecondaryFromMaterial;
 426         }
 427       }
 428     }
 429   }
 430 //=============================================================================
 431
 432   Double_t dV0CosPA = pV0RD->CosPointingAngle(fPrimaryVtx);
 433
 434   if (bIsKshort) if (dV0CosPA<fCutMinKshortCosPA) {
 435     bIsKshort = kFALSE;
 436   }
 437
 438   if (bIsLambda || bIsAntiLa) if (dV0CosPA<fCutMinLambdaCosPA) {
 439     bIsLambda = kFALSE;
 440     bIsAntiLa = kFALSE;
 441   }
 442
 443   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 444 //=============================================================================
 445
 446   Double_t dV0DistToPV = 0.;
 447   for (Int_t i=0; i<3; i++) dV0DistToPV +=  ((dV0Vtx[i]-fPrimaryVtx[i]) * (dV0Vtx[i]-fPrimaryVtx[i]));
 448   Double_t dV0DistToPVoverP = TMath::Sqrt(dV0DistToPV) / (pV0RD->P()+1e-10);
 449
 450   if (bIsKshort) if ((dV0DistToPVoverP*fgkMassKshort)>fCutMaxKshortCtau) {
 451     bIsKshort = kFALSE;
 452   }
 453
 454   if (bIsLambda || bIsAntiLa) if ((dV0DistToPVoverP*fgkMassLambda)>fCutMaxLambdaCtau) {
 455     bIsLambda = kFALSE;
 456     bIsAntiLa = kFALSE;
 457   }
 458
 459   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 460 //=============================================================================
 461
 462   Double_t dV0ArmFrac = pV0RD->PtArmV0() / (TMath::Abs(pV0RD->AlphaV0())+1e-12);
 463
 464   if (bIsKshort && (fCutMaxKshortArmFrac>0.)) if (dV0ArmFrac>fCutMaxKshortArmFrac) {
 465     bIsKshort = kFALSE;
 466   }
 467
 468   if ((bIsLambda || bIsAntiLa) && fCutMaxLambdaArmFrac>0.) if (dV0ArmFrac>fCutMaxLambdaArmFrac) {
 469     bIsLambda = kFALSE;
 470     bIsAntiLa = kFALSE;
 471   }
 472
 473   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 474 //=============================================================================
 475
 476   Int_t wMask = 0;
 477   if (bIsKshort) {
 478     TLorentzVector vPosPion; vPosPion.SetVectM(v3Pos, fgkMassPion);
 479     TLorentzVector vNegPion; vNegPion.SetVectM(v3Neg, fgkMassPion);
 480     TLorentzVector vKshort = vPosPion + vNegPion;
 481
 482     Double_t dKshortInvM = vKshort.M();
 483     Double_t dLower = 0.430006 - 0.0110029*dV0Pt;
 484     Double_t dUpper = 0.563707 + 0.0114979*dV0Pt;
 485     if ((dKshortInvM<dLower) || (dKshortInvM>dUpper)) return 0x0;
 486
 487     if (fCutMinKshortDeltaM>0.) {
 488       TLorentzVector vPosProton; vPosProton.SetVectM(v3Pos, fgkMassProton);
 489       TLorentzVector vNegProton; vNegProton.SetVectM(v3Neg, fgkMassProton);
 490
 491       TLorentzVector vLamvda = vPosProton + vNegPion;
 492       TLorentzVector vAntiLa = vNegProton + vPosPion;
 493
 494       Double_t dLambdaInvM = vLamvda.M();
 495       Double_t dAntiLaInvM = vAntiLa.M();
 496       if ((TMath::Abs(dLambdaInvM-fgkMassLambda)<fCutMinKshortDeltaM) ||
 497           (TMath::Abs(dAntiLaInvM-fgkMassLambda)<fCutMinKshortDeltaM)) return 0x0;
 498     }
 499
 500     wMask = AliPicoHeaderCJ::kKshort;
 501   }
 502
 503   if (bIsLambda) {
 504     TLorentzVector vPosProton; vPosProton.SetVectM(v3Pos, fgkMassProton);
 505     TLorentzVector vNegPion;   vNegPion.SetVectM(v3Neg, fgkMassPion);
 506     TLorentzVector vLamvda = vPosProton + vNegPion;
 507
 508     Double_t dLambdaInvM = vLamvda.M();
 509     Double_t dLower = 1.09501 - 0.00523272*dV0Pt - 0.075269*TMath::Exp(-3.46339*dV0Pt);
 510     Double_t dUpper = 1.13688 + 0.00527838*dV0Pt + 0.084222*TMath::Exp(-3.80595*dV0Pt);
 511     if ((dLambdaInvM<dLower) || (dLambdaInvM>dUpper)) return 0x0;
 512
 513     if (fCutMinLambdaDeletaM>0.) {
 514       TLorentzVector vPosPion; vPosPion.SetVectM(v3Pos, fgkMassPion);
 515       TLorentzVector vKshort = vPosPion + vNegPion;
 516
 517       Double_t dKshortInvM = vKshort.M();
 518       if ((TMath::Abs(dKshortInvM-fgkMassKshort)<fCutMinLambdaDeletaM)) return 0x0;
 519     }
 520
 521     wMask = AliPicoHeaderCJ::kLambda;
 522   }
 523
 524   if (bIsAntiLa) {
 525     TLorentzVector vNegProton; vNegProton.SetVectM(v3Neg, fgkMassProton);
 526     TLorentzVector vPosPion;   vPosPion.SetVectM(v3Pos, fgkMassPion);
 527     TLorentzVector vAntiLa = vNegProton + vPosPion;
 528
 529     Double_t dAntiLaInvM = vAntiLa.M();
 530     Double_t dLower = 1.09501 - 0.00523272*dV0Pt - 0.075269*TMath::Exp(-3.46339*dV0Pt);
 531     Double_t dUpper = 1.13688 + 0.00527838*dV0Pt + 0.084222*TMath::Exp(-3.80595*dV0Pt);
 532     if ((dAntiLaInvM<dLower) || (dAntiLaInvM>dUpper)) return 0x0;
 533
 534     if (fCutMinLambdaDeletaM>0.) {
 535       TLorentzVector vNegPion; vNegPion.SetVectM(v3Neg, fgkMassPion);
 536       TLorentzVector vKshort = vPosPion + vNegPion;
 537
 538       Double_t dKshortInvM = vKshort.M();
 539       if ((TMath::Abs(dKshortInvM-fgkMassKshort)<fCutMinLambdaDeletaM)) return 0x0;
 540     }
 541
 542     wMask = AliPicoHeaderCJ::kAntiLambda;
 543   }
 544 //=============================================================================
 545
 546   Bool_t bPosInJC = kFALSE;
 547   Bool_t bNegInJC = kFALSE;
 548   AliPicoV0MC *pPicoV0 = new AliPicoV0MC(wMask,
 549                                          dV0Radius,
 550                                          dV0CosPA,
 551                                          dV0DistToPVoverP,
 552                                          dDausDCA,
 553                                          dPosDCAtoPV,
 554                                          dNegDCAtoPV,
 555                                          dDauXrowsTPC,
 556                                          dDauXrowsOverFindableClusTPC,
 557                                          v3Pos.Px(), v3Pos.Py(), v3Pos.Pz(),
 558                                          v3Neg.Px(), v3Neg.Py(), v3Neg.Pz(),
 559                                          bPosInJC, bNegInJC,
 560                                          idvMC, wsvMC, pV0MC->Px(), pV0MC->Py(), pV0MC->Pz(), pV0MC->E(),
 561                                          idmMC, wsmMC, dMotherPt, dMotherEta, dMotherRap);
 562
 563
 564   return pPicoV0;
 565 }
 566
 567 //_____________________________________________________________________________
 568 AliPicoV0MC* AliAnalysisTaskSEPicoV0MakerMC::SelectV0Candidate(AliESDv0 const *pV0RD)
 569 {
 570 //
 571 //  AliAnalysisTaskSEPicoV0MakerMC::SelectV0Candidate
 572 //
 573
 574   AliStack *pStack = MCEvent()->Stack(); if (!pStack) return 0x0;
 575   Int_t nPrimary = pStack->GetNprimary();
 576 //=============================================================================
 577
 578   if (pV0RD->GetOnFlyStatus()) return 0x0;
 579   if (pV0RD->GetChi2V0()>fCutMaxV0Chi2) return 0x0;
 580
 581   Double_t dV0Pt = pV0RD->Pt(); if ((dV0Pt<fCutMinV0Pt) || (dV0Pt>fCutMaxV0Pt)) return 0x0;
 582 //=============================================================================
 583
 584   Double_t dV0Vtx[3];  pV0RD->GetXYZ(dV0Vtx[0], dV0Vtx[1], dV0Vtx[2]);
 585   Double_t dV0Radius = TMath::Sqrt(dV0Vtx[0]*dV0Vtx[0] + dV0Vtx[1]*dV0Vtx[1]);
 586   if ((dV0Radius<fCutMinV0Radius) || (dV0Radius>fCutMaxV0Radius)) return 0x0;
 587
 588   Double_t dDausDCA = pV0RD->GetDcaV0Daughters(); if (dDausDCA>fCutMaxDausDCA) return 0x0;
 589 //=============================================================================
 590
 591   Int_t nPosIndex = TMath::Abs(pV0RD->GetPindex()); if (nPosIndex<0) return 0x0;
 592   Int_t nNegIndex = TMath::Abs(pV0RD->GetNindex()); if (nNegIndex<0) return 0x0;
 593
 594   AliESDtrack *pDauPosRD = fEventESD->GetTrack(nPosIndex); if (!pDauPosRD) return 0x0;
 595   AliESDtrack *pDauNegRD = fEventESD->GetTrack(nNegIndex); if (!pDauNegRD) return 0x0;
 596
 597   Double_t dMegField = fEventESD->GetMagneticField();
 598   Double_t dPosDCAtoPV = TMath::Abs(pDauPosRD->GetD(fPrimaryVtx[0],fPrimaryVtx[1],dMegField)); if (dPosDCAtoPV<fCutMinDauDCAtoPV) return 0x0;
 599   Double_t dNegDCAtoPV = TMath::Abs(pDauNegRD->GetD(fPrimaryVtx[0],fPrimaryVtx[1],dMegField)); if (dNegDCAtoPV<fCutMinDauDCAtoPV) return 0x0;
 600 //=============================================================================
 601
 602   if (!(pDauPosRD->GetStatus() & AliESDtrack::kTPCrefit)) return 0x0;
 603   if (!(pDauNegRD->GetStatus() & AliESDtrack::kTPCrefit)) return 0x0;
 604   if ((pDauPosRD->GetKinkIndex(0)>0) || (pDauNegRD->GetKinkIndex(0)>0)) return 0x0;
 605
 606   Float_t dPosXrowsTPC = pDauPosRD->GetTPCClusterInfo(2,1);
 607   Float_t dNegXrowsTPC = pDauNegRD->GetTPCClusterInfo(2,1);
 608   Float_t dDauXrowsTPC = dPosXrowsTPC; if (dDauXrowsTPC>dNegXrowsTPC) dDauXrowsTPC = dNegXrowsTPC;
 609   if (dDauXrowsTPC<fCutMinDauXrowsTPC) return 0x0;
 610
 611   UShort_t wPosTPCNClsF = pDauPosRD->GetTPCNclsF(); if (wPosTPCNClsF<=0) return 0x0;
 612   UShort_t wNegTPCNClsF = pDauNegRD->GetTPCNclsF(); if (wNegTPCNClsF<=0) return 0x0;
 613   Double_t dPosXrowsOverFindableClusTPC = ((Double_t)dPosXrowsTPC) / ((Double_t)wPosTPCNClsF);
 614   Double_t dNegXrowsOverFindableClusTPC = ((Double_t)dNegXrowsTPC) / ((Double_t)wNegTPCNClsF);
 615
 616   Double_t dDauXrowsOverFindableClusTPC = dPosXrowsOverFindableClusTPC;
 617   if (dDauXrowsOverFindableClusTPC>dNegXrowsOverFindableClusTPC) dDauXrowsOverFindableClusTPC = dNegXrowsOverFindableClusTPC;
 618   if (dDauXrowsOverFindableClusTPC<fCutMinDauXrowsOverFindableClusTPC) return 0x0;
 619 //=============================================================================
 620
 621   Short_t nPosCharge = pDauPosRD->Charge();
 622   Short_t nNegCharge = pDauNegRD->Charge();
 623   if ((nPosCharge==0) || (nNegCharge==0) || (nPosCharge==nNegCharge)) return 0x0;
 624
 625   Double_t dPosPxPyPz[3] = { 0., 0., 0. };
 626   Double_t dNegPxPyPz[3] = { 0., 0., 0. };
 627   if ((nPosCharge<0) && (nNegCharge>0)) {
 628     pDauPosRD = fEventESD->GetTrack(nNegIndex);
 629     pDauNegRD = fEventESD->GetTrack(nPosIndex);
 630
 631     pV0RD->GetNPxPyPz(dPosPxPyPz[0], dPosPxPyPz[1], dPosPxPyPz[2]);
 632     pV0RD->GetPPxPyPz(dNegPxPyPz[0], dNegPxPyPz[1], dNegPxPyPz[2]);
 633   } else {
 634     pV0RD->GetPPxPyPz(dPosPxPyPz[0], dPosPxPyPz[1], dPosPxPyPz[2]);
 635     pV0RD->GetNPxPyPz(dNegPxPyPz[0], dNegPxPyPz[1], dNegPxPyPz[2]);
 636   }
 637
 638   TVector3 v3Pos(dPosPxPyPz);
 639   TVector3 v3Neg(dNegPxPyPz);
 640
 641   if ((v3Pos.Pt()<fCutMinDauPt) || (v3Neg.Pt()<fCutMinDauPt)) return 0x0;
 642   Double_t dPosEta = v3Pos.Eta(); if ((dPosEta<fCutMinDauEta) || (dPosEta>fCutMaxDauEta)) return 0x0;
 643   Double_t dNegEta = v3Neg.Eta(); if ((dNegEta<fCutMinDauEta) || (dNegEta>fCutMaxDauEta)) return 0x0;
 644 //=============================================================================
 645
 646   Int_t inp = TMath::Abs(pDauPosRD->GetLabel()); if (inp<0) return 0x0;
 647   Int_t inn = TMath::Abs(pDauNegRD->GetLabel()); if (inn<0) return 0x0;
 648   TParticle *pDauPosMC = ((AliMCParticle*)MCEvent()->GetTrack(inp))->Particle(); if (!pDauPosMC) return 0x0;
 649   TParticle *pDauNegMC = ((AliMCParticle*)MCEvent()->GetTrack(inn))->Particle(); if (!pDauNegMC) return 0x0;
 650
 651   Int_t imp = pDauPosMC->GetFirstMother(); if (imp<0) return 0x0;
 652   Int_t imn = pDauNegMC->GetFirstMother(); if (imn<0) return 0x0;
 653   if (imp != imn) return 0x0;
 654
 655   TParticle *pV0MC = ((AliMCParticle*)MCEvent()->GetTrack(imp))->Particle(); if (!pV0MC) return 0x0;
 656   if (((pV0MC->Y())<fCutMinV0Rap) || ((pV0MC->Y())>fCutMaxV0Rap)) return 0x0;
 657
 658   Int_t idvMC = pV0MC->GetPdgCode();
 659   Int_t idp = pDauPosMC->GetPdgCode();
 660   Int_t idn = pDauNegMC->GetPdgCode();
 661   Bool_t bIsKshort = ((idp==211)  && (idn==-211)  && (idvMC== 310));
 662   Bool_t bIsLambda = ((idp==2212) && (idn==-211)  && (idvMC== 3122));
 663   Bool_t bIsAntiLa = ((idp==211)  && (idn==-2212) && (idvMC==-3122));
 664   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 665 //=============================================================================
 666
 667   UInt_t wsvMC = 0;
 668   if (imp<nPrimary)                          wsvMC |= AliPicoHeaderCJ::kPrimary;
 669   if (pStack->IsPhysicalPrimary(imp))        wsvMC |= AliPicoHeaderCJ::kPhysicalPrimary;
 670   if (pStack->IsSecondaryFromWeakDecay(imp)) wsvMC |= AliPicoHeaderCJ::kSecondaryFromWeakDecay;
 671   if (pStack->IsSecondaryFromMaterial(imp))  wsvMC |= AliPicoHeaderCJ::kSecondaryFromMaterial;
 672
 673   Int_t  idmMC = 0;
 674   UInt_t wsmMC = 0;
 675   Double_t dMotherPt  = 0.;
 676   Double_t dMotherEta = 0.;
 677   Double_t dMotherRap = 0.;
 678   if (bIsLambda || bIsAntiLa) {
 679     Int_t imv = pV0MC->GetFirstMother(); if (imv>=0) {
 680       TParticle *pMother = ((AliMCParticle*)MCEvent()->GetTrack(imv))->Particle();
 681
 682       if (pMother) {
 683         idmMC = pMother->GetPdgCode();
 684         if ((bIsLambda && ((idmMC== 3312) || (idmMC== 3322))) ||
 685             (bIsAntiLa && ((idmMC==-3312) || (idmMC==-3322)))) {
 686           dMotherPt  = pMother->Pt();
 687           dMotherEta = pMother->Eta();
 688           dMotherRap = pMother->Y();
 689
 690           if (imp<nPrimary)                          wsmMC |= AliPicoHeaderCJ::kPrimary;
 691           if (pStack->IsPhysicalPrimary(imv))        wsmMC |= AliPicoHeaderCJ::kPhysicalPrimary;
 692           if (pStack->IsSecondaryFromWeakDecay(imv)) wsmMC |= AliPicoHeaderCJ::kSecondaryFromWeakDecay;
 693           if (pStack->IsSecondaryFromMaterial(imv))  wsmMC |= AliPicoHeaderCJ::kSecondaryFromMaterial;
 694         }
 695       }
 696     }
 697   }
 698 //=============================================================================
 699
 700   Double_t dV0CosPA = pV0RD->GetV0CosineOfPointingAngle(fPrimaryVtx[0], fPrimaryVtx[1], fPrimaryVtx[2]);
 701
 702   if (bIsKshort) if (dV0CosPA<fCutMinKshortCosPA) {
 703     bIsKshort = kFALSE;
 704   }
 705
 706   if (bIsLambda || bIsAntiLa) if (dV0CosPA<fCutMinLambdaCosPA) {
 707     bIsLambda = kFALSE;
 708     bIsAntiLa = kFALSE;
 709   }
 710
 711   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 712 //=============================================================================
 713
 714   Double_t dV0DistToPV = 0.;
 715   for (Int_t i=0; i<3; i++) dV0DistToPV +=  ((dV0Vtx[i]-fPrimaryVtx[i]) * (dV0Vtx[i]-fPrimaryVtx[i]));
 716   Double_t dV0DistToPVoverP = TMath::Sqrt(dV0DistToPV) / (pV0RD->P()+1e-10);
 717
 718   if (bIsKshort) if ((dV0DistToPVoverP*fgkMassKshort)>fCutMaxKshortCtau) {
 719     bIsKshort = kFALSE;
 720   }
 721
 722   if (bIsLambda || bIsAntiLa) if ((dV0DistToPVoverP*fgkMassLambda)>fCutMaxLambdaCtau) {
 723     bIsLambda = kFALSE;
 724     bIsAntiLa = kFALSE;
 725   }
 726
 727   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 728 //=============================================================================
 729
 730   Double_t dV0ArmFrac = pV0RD->PtArmV0() / (TMath::Abs(pV0RD->AlphaV0())+1e-12);
 731
 732   if (bIsKshort && (fCutMaxKshortArmFrac>0.)) if (dV0ArmFrac>fCutMaxKshortArmFrac) {
 733     bIsKshort = kFALSE;
 734   }
 735
 736   if ((bIsLambda && bIsAntiLa) && (fCutMaxLambdaArmFrac>0.)) if (dV0ArmFrac>fCutMaxLambdaArmFrac) {
 737     bIsLambda = kFALSE;
 738     bIsAntiLa = kFALSE;
 739   }
 740
 741   if (!(bIsKshort || bIsLambda || bIsAntiLa)) return 0x0;
 742 //=============================================================================
 743
 744   Int_t wMask = 0;
 745
 746   if (bIsKshort) {
 747     TLorentzVector vPosPion; vPosPion.SetVectM(v3Pos, fgkMassPion);
 748     TLorentzVector vNegPion; vNegPion.SetVectM(v3Neg, fgkMassPion);
 749     TLorentzVector vKshort = vPosPion + vNegPion;
 750
 751     Double_t dKshortInvM = vKshort.M();
 752     Double_t dLower = 0.430006 - 0.0110029*dV0Pt;
 753     Double_t dUpper = 0.563707 + 0.0114979*dV0Pt;
 754     if ((dKshortInvM<dLower) || (dKshortInvM>dUpper)) return 0x0;
 755
 756     if (fCutMinKshortDeltaM>0.) {
 757       TLorentzVector vPosProton; vPosProton.SetVectM(v3Pos, fgkMassProton);
 758       TLorentzVector vNegProton; vNegProton.SetVectM(v3Neg, fgkMassProton);
 759
 760       TLorentzVector vLamvda = vPosProton + vNegPion;
 761       TLorentzVector vAntiLa = vNegProton + vPosPion;
 762
 763       Double_t dLambdaInvM = vLamvda.M();
 764       Double_t dAntiLaInvM = vAntiLa.M();
 765       if ((TMath::Abs(dLambdaInvM-fgkMassLambda)<fCutMinKshortDeltaM) ||
 766           (TMath::Abs(dAntiLaInvM-fgkMassLambda)<fCutMinKshortDeltaM)) return 0x0;
 767     }
 768
 769     wMask = AliPicoHeaderCJ::kKshort;
 770   }
 771
 772   if (bIsLambda) {
 773     TLorentzVector vPosProton; vPosProton.SetVectM(v3Pos, fgkMassProton);
 774     TLorentzVector vNegPion; vNegPion.SetVectM(v3Neg, fgkMassPion);
 775     TLorentzVector vLamvda = vPosProton + vNegPion;
 776
 777     Double_t dLambdaInvM = vLamvda.M();
 778     Double_t dLower = 1.09501 - 0.00523272*dV0Pt - 0.075269*TMath::Exp(-3.46339*dV0Pt);
 779     Double_t dUpper = 1.13688 + 0.00527838*dV0Pt + 0.084222*TMath::Exp(-3.80595*dV0Pt);
 780     if ((dLambdaInvM<dLower) || (dLambdaInvM>dUpper)) return 0x0;
 781
 782     if (fCutMinLambdaDeletaM>0.) {
 783       TLorentzVector vPosPion; vPosPion.SetVectM(v3Pos, fgkMassPion);
 784       TLorentzVector vKshort = vPosPion + vNegPion;
 785
 786       Double_t dKshortInvM = vKshort.M();
 787       if ((TMath::Abs(dKshortInvM-fgkMassKshort)<fCutMinLambdaDeletaM)) return 0x0;
 788     }
 789
 790     wMask = AliPicoHeaderCJ::kLambda;
 791   }
 792
 793   if (bIsAntiLa) {
 794     TLorentzVector vNegProton; vNegProton.SetVectM(v3Neg, fgkMassProton);
 795     TLorentzVector vPosPion; vPosPion.SetVectM(v3Pos, fgkMassPion);
 796     TLorentzVector vAntiLa = vNegProton + vPosPion;
 797
 798     Double_t dAntiLaInvM = vAntiLa.M();
 799     Double_t dLower = 1.09501 - 0.00523272*dV0Pt - 0.075269*TMath::Exp(-3.46339*dV0Pt);
 800     Double_t dUpper = 1.13688 + 0.00527838*dV0Pt + 0.084222*TMath::Exp(-3.80595*dV0Pt);
 801     if ((dAntiLaInvM<dLower) || (dAntiLaInvM>dUpper)) return 0x0;
 802
 803     if (fCutMinLambdaDeletaM>0.) {
 804       TLorentzVector vNegPion; vNegPion.SetVectM(v3Neg, fgkMassPion);
 805       TLorentzVector vKshort = vPosPion + vNegPion;
 806
 807       Double_t dKshortInvM = vKshort.M();
 808       if ((TMath::Abs(dKshortInvM-fgkMassKshort)<fCutMinLambdaDeletaM)) return 0x0;
 809     }
 810
 811     wMask = AliPicoHeaderCJ::kAntiLambda;
 812   }
 813 //=============================================================================
 814
 815   Bool_t bPosInJC = kFALSE;
 816   Bool_t bNegInJC = kFALSE;
 817   AliPicoV0MC *pPicoV0 = new AliPicoV0MC(wMask,
 818                                          dV0Radius,
 819                                          dV0CosPA,
 820                                          dV0DistToPVoverP,
 821                                          dDausDCA,
 822                                          dPosDCAtoPV,
 823                                          dNegDCAtoPV,
 824                                          dDauXrowsTPC,
 825                                          dDauXrowsOverFindableClusTPC,
 826                                          v3Pos.Px(), v3Pos.Py(), v3Pos.Pz(),
 827                                          v3Neg.Px(), v3Neg.Py(), v3Neg.Pz(),
 828                                          bPosInJC, bNegInJC,
 829                                          idvMC, wsvMC, pV0MC->Px(), pV0MC->Py(), pV0MC->Pz(), pV0MC->Energy(),
 830                                          idmMC, wsmMC, dMotherPt, dMotherEta, dMotherRap);
 831
 832
 833   return pPicoV0;
 834 }
 835
 836 //_____________________________________________________________________________
 837 Bool_t AliAnalysisTaskSEPicoV0MakerMC::IsEventNotAcpt()
 838 {
 839 //
 840 //  AliAnalysisTaskSEPicoV0MakerMC::IsEventNotAcpt
 841 //
 842
 843   fEventAcptMask = 0;
 844   if (!InputEvent())  return (fEventAcptMask==0);
 845   if (!fInputHandler) return (fEventAcptMask==0);
 846
 847   if (fCollisionType!=(AliPicoHeaderCJ::kPP)) {
 848     fCentInfo = InputEvent()->GetCentrality();
 849     if (!fCentInfo) return (fEventAcptMask==0);
 850   }
 851
 852   fEventAOD = dynamic_cast<AliAODEvent*>(InputEvent());
 853   fEventESD = dynamic_cast<AliESDEvent*>(InputEvent());
 854   if ((!fEventAOD) && (!fEventESD)) return (fEventAcptMask==0);
 855
 856   fRespoPID = fInputHandler->GetPIDResponse();
 857   if (!fRespoPID) return kTRUE;
 858
 859   if (MCEvent()) {
 860     if (MCEvent()->GetNumberOfTracks()<=0) return (fEventAcptMask==0);
 861   } else {
 862     return (fEventAcptMask==0);
 863   }
 864
 865   AliHeader *pHeader = MCEvent()->Header(); if (!pHeader) return (fEventAcptMask==0);
 866
 867   if (fIsDPMjetMC) {
 868     AliGenDPMjetEventHeader *pDPMjetH = dynamic_cast<AliGenDPMjetEventHeader*>(pHeader->GenEventHeader());
 869
 870     if (pDPMjetH) {
 871       Int_t nd0=0, nd1=0, nd2=0; pDPMjetH->GetNDiffractive(nd1, nd2, nd0);
 872       if ((nd1+nd2) != (pDPMjetH->ProjectileParticipants() + pDPMjetH->TargetParticipants())) return (fEventAcptMask==0);
 873     }
 874   }
 875
 876   fEventAcptMask |= AliPicoHeaderCJ::kEventAccCheck;
 877 //=============================================================================
 878
 879   if (fCollisionType==(AliPicoHeaderCJ::kPP)) {
 880     fEventAcptMask |= AliPicoHeaderCJ::kEventAccMult;
 881   } else {
 882     if (fCentInfo->GetQuality()==0)
 883       fEventAcptMask |= AliPicoHeaderCJ::kEventAccMult;
 884     else
 885       return (fEventAcptMask==0);
 886   }
 887 //=============================================================================
 888
 889   UInt_t wMask = fInputHandler->IsEventSelected();
 890   if ((wMask & fTriggerMask) != fTriggerMask) return (fEventAcptMask==0);
 891   if (fIsSkipFastOnly) if ((wMask & AliVEvent::kFastOnly) == AliVEvent::kFastOnly) return (fEventAcptMask==0);
 892
 893   fEventAcptMask |= AliPicoHeaderCJ::kEventAccTrigger;
 894 //=============================================================================
 895
 896   const AliVVertex *pVertex = InputEvent()->GetPrimaryVertex(); if (!pVertex) return (fEventAcptMask==0);
 897   pVertex->GetXYZ(fPrimaryVtx); if (TMath::Abs(fPrimaryVtx[2])>fCutMaxEventVzAbs) return (fEventAcptMask==0);
 898
 899   if ((fCollisionType==(AliPicoHeaderCJ::kPA)) || (fCollisionType==(AliPicoHeaderCJ::kAP))) {
 900     if ( fAnaUtils->IsFirstEventInChunk(InputEvent()))    return (fEventAcptMask==0);
 901     if (!fAnaUtils->IsVertexSelected2013pA(InputEvent())) return (fEventAcptMask==0);
 902
 903 /*  if (fEventAOD) {
 904       const AliAODVertex *pVtxSPD = fEventAOD->GetPrimaryVertexSPD();
 905       const AliAODVertex *pVtxTrk = fEventAOD->GetPrimaryVertex();
 906       if ((!pVtxSPD) && (!pVtxTrk)) return (fEventAcptMask==0);
 907     }*/
 908
 909 /*  if (fEventESD) {
 910       Bool_t fHasVertex = kFALSE;
 911       const AliESDVertex *pVtxESD = fEventESD->GetPrimaryVertexTracks();
 912       if (pVtxESD->GetNContributors()<1) {
 913         pVtxESD = fEventESD->GetPrimaryVertexSPD();
 914         if (pVtxESD->GetNContributors()<1) fHasVertex = kFALSE;
 915         else fHasVertex = kTRUE;
 916
 917         TString vtxTyp = pVtxESD->GetTitle();
 918         Double_t cov[6] = { 0., 0., 0., 0., 0., 0. };
 919         pVtxESD->GetCovarianceMatrix(cov);
 920         Double_t zRes = TMath::Sqrt(cov[5]);
 921         if (vtxTyp.Contains("vertexer:Z") && (zRes>0.25)) fHasVertex = kFALSE;
 922       } else fHasVertex = kTRUE;
 923
 924       if (!fHasVertex) return (fEventAcptMask==0);
 925     }*/
 926
 927   } else {
 928     if (fEventAOD) {
 929       const AliAODVertex *pVtxSPD = fEventAOD->GetPrimaryVertexSPD(); if (!pVtxSPD) return (fEventAcptMask==0);
 930       const AliAODVertex *pVtxTrk = fEventAOD->GetPrimaryVertex();    if (!pVtxTrk) return (fEventAcptMask==0);
 931     }
 932
 933     if (fEventESD) {
 934       const AliESDVertex *pVtxPri = fEventESD->GetPrimaryVertex();       if (!pVtxPri) return (fEventAcptMask==0);
 935       const AliESDVertex *pVtxSPD = fEventESD->GetPrimaryVertexSPD();    if (!pVtxSPD) return (fEventAcptMask==0);
 936       const AliESDVertex *pVtxTrk = fEventESD->GetPrimaryVertexTracks(); if (!pVtxTrk) return (fEventAcptMask==0);
 937       if ((!(pVtxPri->GetStatus())) && (!(pVtxSPD->GetStatus())) && (!(pVtxTrk->GetStatus()))) return (fEventAcptMask==0);
 938     }
 939   }
 940
 941   fEventAcptMask |= AliPicoHeaderCJ::kEventAccVertex;
 942 //=============================================================================
 943
 944   if ((fCollisionType==AliPicoHeaderCJ::kPP) ||
 945       (fCollisionType==AliPicoHeaderCJ::kPA) ||
 946       (fCollisionType==AliPicoHeaderCJ::kAP)) {
 947     if (fAnaUtils->IsPileUpEvent(InputEvent())) return (fEventAcptMask==0);
 948   }
 949
 950   fEventAcptMask |= AliPicoHeaderCJ::kEventAccPileup;
 951 //=============================================================================
 952
 953   if (fIsRefitV0sESD && fEventESD) {
 954     Double_t dCuts[7] = { fCutMaxV0Chi2,
 955                           fCutMinDauDCAtoPV,
 956                           fCutMinDauDCAtoPV,
 957                           fCutMaxDausDCA,
 958                           fCutMinKshortCosPA,
 959                           fCutMinV0Radius,
 960                           fCutMaxV0Radius };
 961
 962     fEventESD->ResetV0s();
 963     AliV0vertexer aV0vtxer;
 964     aV0vtxer.SetDefaultCuts(dCuts);
 965     aV0vtxer.Tracks2V0vertices(fEventESD);
 966   }
 967
 968   return (fEventAcptMask==0);
 969 }
 970
 971 //_____________________________________________________________________________
 972 Bool_t AliAnalysisTaskSEPicoV0MakerMC::IsEventNotINEL()
 973 {
 974 //
 975 //  AliAnalysisTaskSEPicoV0MakerMC::IsEventNotINEL
 976 //
 977
 978   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccCheck) != AliPicoHeaderCJ::kEventAccCheck) return kTRUE;
 979   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccMult)  != AliPicoHeaderCJ::kEventAccMult)  return kTRUE;
 980
 981   return kFALSE;
 982 }
 983
 984 //_____________________________________________________________________________
 985 Bool_t AliAnalysisTaskSEPicoV0MakerMC::IsEventNotMBsa()
 986 {
 987 //
 988 //  AliAnalysisTaskSEPicoV0MakerMC::IsEventNotMBsa
 989 //
 990
 991   if (IsEventNotINEL()) return kTRUE;
 992
 993   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccTrigger) != AliPicoHeaderCJ::kEventAccTrigger) return kTRUE;
 994   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccVertex)  != AliPicoHeaderCJ::kEventAccVertex)  return kTRUE;
 995   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccPileup)  != AliPicoHeaderCJ::kEventAccPileup)  return kTRUE;
 996
 997   return kFALSE;
 998 }
 999
1000 //_____________________________________________________________________________
1001 void AliAnalysisTaskSEPicoV0MakerMC::FillHistograms()
1002 {
1003 //
1004 //  AliAnalysisTaskSEPicoV0MakerMC::FillHistograms
1005 //
1006
1007   Float_t dV0M = fCentInfo->GetCentralityPercentile("V0M");
1008   Float_t dV0A = fCentInfo->GetCentralityPercentile("V0A");
1009   Float_t dCL1 = fCentInfo->GetCentralityPercentile("CL1");
1010   Float_t dZNA = fCentInfo->GetCentralityPercentile("ZNA");
1011
1012   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccCheck) == AliPicoHeaderCJ::kEventAccCheck) {
1013     ((TH1D*)fListUserOutputs->FindObject("hEventAccCheck_V0M"))->Fill(dV0M);
1014     ((TH1D*)fListUserOutputs->FindObject("hEventAccCheck_V0A"))->Fill(dV0A);
1015     ((TH1D*)fListUserOutputs->FindObject("hEventAccCheck_CL1"))->Fill(dCL1);
1016     ((TH1D*)fListUserOutputs->FindObject("hEventAccCheck_ZNA"))->Fill(dZNA);
1017   }
1018
1019   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccMult) == AliPicoHeaderCJ::kEventAccMult) {
1020     ((TH1D*)fListUserOutputs->FindObject("hEventAccMult_V0M"))->Fill(dV0M);
1021     ((TH1D*)fListUserOutputs->FindObject("hEventAccMult_V0A"))->Fill(dV0A);
1022     ((TH1D*)fListUserOutputs->FindObject("hEventAccMult_CL1"))->Fill(dCL1);
1023     ((TH1D*)fListUserOutputs->FindObject("hEventAccMult_ZNA"))->Fill(dZNA);
1024   }
1025
1026   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccTrigger) == AliPicoHeaderCJ::kEventAccTrigger) {
1027     ((TH1D*)fListUserOutputs->FindObject("hEventAccTrigger_V0M"))->Fill(dV0M);
1028     ((TH1D*)fListUserOutputs->FindObject("hEventAccTrigger_V0A"))->Fill(dV0A);
1029     ((TH1D*)fListUserOutputs->FindObject("hEventAccTrigger_CL1"))->Fill(dCL1);
1030     ((TH1D*)fListUserOutputs->FindObject("hEventAccTrigger_ZNA"))->Fill(dZNA);
1031   }
1032
1033   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccVertex) == AliPicoHeaderCJ::kEventAccVertex) {
1034     ((TH1D*)fListUserOutputs->FindObject("hEventAccVertex_V0M"))->Fill(dV0M);
1035     ((TH1D*)fListUserOutputs->FindObject("hEventAccVertex_V0A"))->Fill(dV0A);
1036     ((TH1D*)fListUserOutputs->FindObject("hEventAccVertex_CL1"))->Fill(dCL1);
1037     ((TH1D*)fListUserOutputs->FindObject("hEventAccVertex_ZNA"))->Fill(dZNA);
1038   }
1039
1040   if ((fEventAcptMask & AliPicoHeaderCJ::kEventAccPileup) == AliPicoHeaderCJ::kEventAccPileup) {
1041     ((TH1D*)fListUserOutputs->FindObject("hEventAccPileup_V0M"))->Fill(dV0M);
1042     ((TH1D*)fListUserOutputs->FindObject("hEventAccPileup_V0A"))->Fill(dV0A);
1043     ((TH1D*)fListUserOutputs->FindObject("hEventAccPileup_CL1"))->Fill(dCL1);
1044     ((TH1D*)fListUserOutputs->FindObject("hEventAccPileup_ZNA"))->Fill(dZNA);
1045   }
1046
1047   return;
1048 }
1049
1050 //_____________________________________________________________________________
1051 void AliAnalysisTaskSEPicoV0MakerMC::CreateHistograms()
1052 {
1053 //
1054 //  AliAnalysisTaskSEPicoV0MakerMC::CreateHistograms
1055 //
1056
1057   Bool_t bStatusTmpH = TH1::AddDirectoryStatus();
1058   TH1::AddDirectory(kFALSE);
1059 //=============================================================================
1060
1061   TH1D *h1 = 0;
1062   h1 = new TH1D("hEventAccCheck_V0M", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1063   h1 = new TH1D("hEventAccCheck_V0A", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1064   h1 = new TH1D("hEventAccCheck_CL1", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1065   h1 = new TH1D("hEventAccCheck_ZNA", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1066
1067   h1 = new TH1D("hEventAccMult_V0M", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1068   h1 = new TH1D("hEventAccMult_V0A", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1069   h1 = new TH1D("hEventAccMult_CL1", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1070   h1 = new TH1D("hEventAccMult_ZNA", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1071
1072   h1 = new TH1D("hEventAccTrigger_V0M", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1073   h1 = new TH1D("hEventAccTrigger_V0A", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1074   h1 = new TH1D("hEventAccTrigger_CL1", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1075   h1 = new TH1D("hEventAccTrigger_ZNA", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1076
1077   h1 = new TH1D("hEventAccVertex_V0M", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1078   h1 = new TH1D("hEventAccVertex_V0A", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1079   h1 = new TH1D("hEventAccVertex_CL1", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1080   h1 = new TH1D("hEventAccVertex_ZNA", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1081
1082   h1 = new TH1D("hEventAccPileup_V0M", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1083   h1 = new TH1D("hEventAccPileup_V0A", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1084   h1 = new TH1D("hEventAccPileup_CL1", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1085   h1 = new TH1D("hEventAccPileup_ZNA", "", 210, -10., 200.); h1->Sumw2(); fListUserOutputs->Add(h1);
1086
1087
1088   TH2D *h2 = 0;
1089   h2 = new TH2D("hKshortPtInvM", "", 1000, 0., 100., 300, fgkMassKshort-0.15, fgkMassKshort+0.15);
1090   h2->Sumw2(); fListUserOutputs->Add(h2); h2=0;
1091
1092   h2 = new TH2D("hLambdaPtInvM", "", 1000, 0., 100., 200, fgkMassLambda-0.10, fgkMassLambda+0.10);
1093   h2->Sumw2(); fListUserOutputs->Add(h2); h2=0;
1094
1095   h2 = new TH2D("hAntiLaPtInvM", "", 1000, 0., 100., 200, fgkMassLambda-0.10, fgkMassLambda+0.10);
1096   h2->Sumw2(); fListUserOutputs->Add(h2); h2=0;
1097
1098   TH1::AddDirectory(bStatusTmpH);
1099   return;
1100 }
1101
1102 //_____________________________________________________________________________
1103 void AliAnalysisTaskSEPicoV0MakerMC::InitAnalysis()
1104 {
1105 //
1106 //  AliAnalysisTaskSEPicoV0MakerMC::InitAnalysis
1107 //
1108
1109   fAnaUtils = new AliAnalysisUtils();
1110   fAnaUtils->SetMinVtxContr(fCutMinEventVtxContr);
1111   fAnaUtils->SetMaxVtxZ(fCutMaxEventVzAbs);
1112
1113   return;
1114 }
1115
1116 //_____________________________________________________________________________
1117 void AliAnalysisTaskSEPicoV0MakerMC::SetV0Cuts(Double_t d[14])
1118 {
1119 //
1120 //  AliAnalysisTaskSEPicoV0MakerMC::SetCuts
1121 //
1122
1123   fCutMinV0Radius = d[0];
1124   fCutMaxV0Radius = d[1];
1125
1126   fCutMaxDausDCA                     = d[2];
1127   fCutMinDauDCAtoPV                  = d[3];
1128   fCutMinDauXrowsTPC                 = d[4];
1129   fCutMinDauXrowsOverFindableClusTPC = d[5];
1130
1131   fCutMaxKshortSigmaTPC = d[6];
1132   fCutMinKshortCosPA    = d[7];
1133   fCutMaxKshortCtau     = d[8];
1134   fCutMinKshortDeltaM   = d[9];
1135
1136   fCutMaxLambdaSigmaTPC = d[10];
1137   fCutMinLambdaCosPA    = d[11];
1138   fCutMaxLambdaCtau     = d[12];
1139   fCutMinLambdaDeletaM  = d[13];
1140
1141   return;
1142 }