PWGLF/STRANGENESS/Correlations/AliAnalysisTaskLambdaOverK0sJets.h

   1
   2 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  * See cxx source for full Copyright notice */
   4
   5 /*
   6                 AliAnalysisTaskLambdaOverK0sJets class
   7
   8                 This program obtains the production of K0s and Lambdas and calculates
   9                 the correlation (in the variables phi and eta) with respect to the
  10                 triggers particles (high-pt charged particles).
  11                 It works with MC information and AOD tree.
  12                 Origin: X. Sanchez Castro August2012, xsanchez@cern.ch
  13 */
  14
  15
  16 #ifndef ALIANALYSISTASKLAMBDAOVERK0SJETS_H
  17 #define ALIANALYSISTASKLAMBDAOVERK0SJETS_H
  18
  19 #include "AliAnalysisTaskSE.h"
  20
  21 class AliAODEvent;
  22 class AliPIDResponse;
  23 class AliAODTrack;
  24 class AliAODVertex;
  25 class AliAODv0;
  26
  27 class TH1F;
  28 class TH2F;
  29 class TH3F;
  30 class THnSparse;
  31 class TList;
  32 class TString;
  33
  34 class TObjArray;
  35
  36 // pt for V0
  37 const int    kN1 = 8;
  38 const float  kPtBinV0[kN1+1] = {2.0,2.25,2.5,2.75,3.0,3.5,4.0,5.0,7.0};
  39
  40 const int    kNVtxZ = 10;
  41 const double kBinVtxZ[kNVtxZ+1] = {-10.,-8.,-6.,-4.,-2.,0.,2.,4.,6.,8.,10.};
  42
  43 const int    kNCent  = 4;
  44 const double kBinCent[kNCent+1] = {0.0,5.0,10.0,20.0,40.0};
  45
  46 //  ------------------------------------
  47 //  Inv. Mass width as function of the centrality
  48 //  Linear polimomial dependence: sigma(pt) = a0 * a1*pt
  49
  50 const double kCteK0s2010[kNCent] = {0.00348, 0.00351, 0.00346, 0.00318};
  51 const double kLinearK0s2010[kNCent] = {8.024E-4, 7.403E-4, 7.250E-4, 7.665E-4};
  52
  53 const double kCteK0s2011[kNCent] = {0.00338, 0.00328, 0.00333, 0.00326};
  54 const double kLinearK0s2011[kNCent] = {8.336E-4, 8.385E-4, 7.891E-4, 7.851E-4};
  55
  56 const double kCteLambda2010[kNCent] = {0.00145, 0.00122, 0.00140, 0.00135};
  57 const double kLinearLambda2010[kNCent] = {2.233E-4, 2.836-4, 2.105-4, 2.076E-4};
  58
  59 const double kCteLambda2011[kNCent] = {0.00130, 0.00123, 0.00114, 0.00121};
  60 const double kLinearLambda2011[kNCent] = {3.002E-4, 3.067E-4, 3.207E-4, 2.813E-4};
  61
  62 const double kCteAntiLambda2010[kNCent] = {0.00109, 0.00134, 0.00117, 0.00116};
  63 const double kLinearAntiLambda2010[kNCent] = {3.245E-4, 2.308E-4, 2.707E-4, 2.562E-4};
  64
  65 const double kCteAntiLambda2011[kNCent] = {9.859E-4, 0.00111, 0.00104, 0.00110};
  66 const double kLinearAntiLambda2011[kNCent] = {3.881E-4, 3.379E-4, 3.490E-4, 3.166E-4};
  67
  68 // -------------------------------------
  69
  70 class AliAnalysisTaskLambdaOverK0sJets : public AliAnalysisTaskSE {
  71
  72  public:
  73
  74   enum V0LoopStep_t  { kTriggerCheck=1, kReconstruction=2 };
  75
  76   AliAnalysisTaskLambdaOverK0sJets(const char *name = "AliAnalysisTaskLambdaOverK0sJets");
  77   virtual ~AliAnalysisTaskLambdaOverK0sJets();
  78
  79   // Setter for global variables in the event
  80   void SetCollisionType(TString data="PbPb2010") {fCollision=data;}
  81   void SetMC(Bool_t isMC=kTRUE) {fIsMC=isMC;}
  82   void SetPID(Bool_t usePID=kTRUE) {fUsePID=usePID;}
  83   void SetCentrality(Float_t min=0., Float_t max=90.) {fCentMin=min;fCentMax=max;}
  84   void SetQA(Bool_t doQA=kFALSE){fDoQA=doQA;}
  85   void SetDoMix(Bool_t doMixEvt=kTRUE) {fDoMixEvt=doMixEvt;}
  86   void SetTriggerFilterBit(Int_t triggerFB=768){fTriggerFB=triggerFB;}
  87   void SetTriggerPt(Float_t ptMinTrig=8., Float_t ptMaxTrig=50.) {fTrigPtMin=ptMinTrig;fTrigPtMax=ptMaxTrig;}
  88   void SetTriggerEta(Float_t etaMaxTrig=0.8){fTrigEtaMax=etaMaxTrig;}
  89   void SetCheckIDTrig(Bool_t checkIDTrig=kFALSE){fCheckIDTrig=checkIDTrig;}
  90   void SetSeparateInjectedPart(Bool_t doSep=kTRUE) {fSeparateInjPart=doSep;}
  91
  92   //   1.  Daughter cuts
  93   void SetMinPtDaughter(Float_t minPtDaughter=0.160) {fMinPtDaughter=minPtDaughter;}
  94   void SetMaxEtaDaughter(Float_t maxEta=0.8) {fMaxEtaDaughter=maxEta;}
  95   void SetMaxDCADaughter(Float_t maxDCA=1.0) {fMaxDCADaughter=maxDCA;}
  96   void SetDCAToPrimVtx(Float_t dcaToPrimVtx=0.1) {fDCAToPrimVtx=dcaToPrimVtx;}
  97   void SetNSigmaPID(Float_t nSigma=3) {fNSigma=nSigma;}
  98   void SetNClsTPC(Float_t nClsTPC=70.) {fDaugNClsTPC=nClsTPC;}
  99   //   2.  V0 candidate
 100   void SetEtaCut(Bool_t etaCut=kFALSE) {fUseEtaCut=etaCut;}
 101   void SetMaxY(Float_t yMax=0.5) {fYMax=yMax;}
 102   void SetMinCPA(Float_t minCPA=0.998) {fMinCPA=minCPA;}
 103   void SetCtau(Float_t minCtau = 0., Float_t maxCtau = 3.) {fMinCtau=minCtau;fMaxCtau=maxCtau;}
 104
 105   // Setting variables for splitting cut
 106   void SetTPCRadius(Float_t tpcRadius=125.) {fTPCRadius=tpcRadius;}
 107   void SetFracSharedTPCcls(Float_t fracSharedTPCcls=0.4) {fFracTPCcls=fracSharedTPCcls;}
 108   void SetDiffSharedTPCcls(Float_t diffSharedTPCcls=0.06) {fDiffTrigDaugFracTPCSharedCls=diffSharedTPCcls;}
 109
 110   // Getters
 111   Float_t GetMinCentr() { return fCentMin; }
 112   Float_t GetMaxCentr() { return fCentMax; }
 113
 114   // Main functions
 115   virtual void     UserCreateOutputObjects();
 116   virtual Bool_t   AcceptTrack(const AliAODTrack *t);
 117   virtual Bool_t   AcceptTrackV0(const AliAODTrack *t);
 118   virtual Bool_t   AcceptV0(AliAODVertex *vtx, const AliAODv0 *v0);
 119   virtual Double_t ThetaS(TString part);
 120   virtual Double_t EtaS(TString part);
 121   virtual Float_t  dEtaS();
 122   virtual Float_t  dPhiSAtR125();
 123   virtual void     SetSftPosR125(const AliAODTrack *track,const Float_t bfield,const Float_t priVtx[3], TString part);
 124   virtual void     RecCascade(const AliAODTrack *trk1,const AliAODTrack *trk2,const AliAODTrack *trkBch,TString histo);
 125   virtual void     V0Loop(V0LoopStep_t step, Bool_t isTriggered, Int_t iArray, Int_t idTrig);
 126   virtual void     TriggerParticle();
 127
 128   virtual void     UserExec(Option_t *option);
 129   virtual void     Terminate(Option_t *);
 130
 131  private:
 132
 133   AliAnalysisTaskLambdaOverK0sJets(const AliAnalysisTaskLambdaOverK0sJets&);           //not implemented
 134   AliAnalysisTaskLambdaOverK0sJets& operator=(const AliAnalysisTaskLambdaOverK0sJets&);//not implemented
 135
 136   AliAODEvent *fAOD;
 137   TString  fCollision;                   //  Data: PbPb2010 / PbPb2011
 138   Bool_t   fIsMC;                        //  Use MC data
 139   Bool_t   fUsePID;                      //  Use PID for tracks
 140   Float_t  fCentMin;                     //  Minimum centrality
 141   Float_t  fCentMax;                     //  Maximum centrality
 142   Bool_t   fDoQA;                        //  Do Auality Assurance?
 143   Bool_t   fDoMixEvt;                    //  Do Mixed Events
 144   Int_t    fTriggerFB;                   //  Trigger track filter bit
 145   Float_t  fTrigPtMin;                   //  Minimum pt for trigger particle
 146   Float_t  fTrigPtMax;                   //  Maximum pt for trigger particle
 147   Float_t  fTrigPtMCMin;                 //  Minimum pt for trigger particle in MC
 148   Float_t  fTrigPtMCMax;                 //  Maximum pt for trigger particle in MC
 149   Float_t  fTrigEtaMax;                  //  Maximum eta for trigger particle
 150   Bool_t   fCheckIDTrig;                 //  Do comparison with V0's daughter tracks?
 151   Bool_t   fSeparateInjPart;             //  Separate MC injected particles in case of correlation
 152   Int_t    fEndOfHijingEvent;            //  Limit natural-injected MC  particles
 153   AliPIDResponse *fPIDResponse;          //  PID Response
 154
 155   Float_t fMinPtDaughter;                //  Minimum transverse momentum for V0's daughters
 156   Float_t fMaxEtaDaughter;               //  Maximum pseudo-rapidity for V0's daughters
 157   Float_t fMaxDCADaughter;               //  Maximum Distance of Closest Approach between daughters (given in sigmas)
 158   Bool_t  fUseEtaCut;                    //  Swicth between rapidity or pseudo-rapidity cut
 159   Float_t fYMax;                         //  Maximum rapidity for V0
 160   Float_t fDCAToPrimVtx;                 //  Mimimum distance of closest approach of daughters to the vertex
 161   Float_t fMinCPA;                       //  Minimum Cosine of the Pointing Angle to the vertex for V0
 162   Float_t fNSigma;                       //  Number of sigmas for PID wi dE/dx
 163   Float_t fDaugNClsTPC;                  //  Number of TPC clusters for daughters
 164   Float_t fMinCtau;                      //  Minimum ctau
 165   Float_t fMaxCtau;                      //  Maximum ctau
 166
 167   Int_t   fIdTrigger;                    //  ID track of the trigger particle
 168   Int_t   fIsV0LP;                       //  Flag: V0 has the highest pt in the event
 169   Float_t fPtV0LP;                       //  Pt of the leading V0
 170   Int_t   fIsSndCheck;                   //  Flag: trigger particle is the second leaidng particle
 171
 172   Float_t fTPCRadius;                    // Radial position of TPC to obtain the separation between the trigger particle and the daughter particle
 173   Float_t fTrigSftR125[3];               // Shifted position of the daughter track to the Primary verterx
 174   Float_t fDaugSftR125[3];               // Shifted position of the trigger track to the Primary verterx
 175   Float_t fFracTPCcls;                   // Threshold for the fraction of TPC shared clusters for single track
 176   Float_t fDiffTrigDaugFracTPCSharedCls; // Allowed dispertion in the fraction of TPC shared clusters between trigger particle and the daughter track
 177
 178
 179   TList*  fOutput;                       //! List of histograms for main analysis
 180   TList*  fOutputQA;                     //! List of histograms for Quality Assurance
 181   TList*  fOutputME;                     //! List of histograms for Mixed Events
 182   TList** fMEList;                       //![] List of Mixed Events
 183
 184   TObjArray* fTriggerParticles;          // Trigger particle array
 185   TObjArray* fTriggerPartMC;             // MC Trigger particle array
 186   TObjArray* fAssocParticles;            // Associated particle array
 187   TObjArray* fAssocPartMC;               // MC Associated particle array
 188
 189   TH1F*   fEvents;                       //! Counter for the number of events in each step
 190   TH2F*   fEvtPerCent;                   //! Counter for the number of events in each step per centrality bin
 191   TH1F*   fCentrality;                   //! Event centrality per centil
 192   TH1F*   fCentrality2;                  //! Event centrality per centil with |VtxZ|<10cm
 193   TH2F*   fCentralityTrig;               //! Event centrality per trigger
 194   TH2F*   fPrimayVtxGlobalvsSPD;         //! Zvtx tracking vs Zvtx SPD
 195   TH1F*   fPrimaryVertexX;               //! Primary vertex position in X
 196   TH1F*   fPrimaryVertexY;               //! Primary vertex position in Y
 197   TH1F*   fPrimaryVertexZ;               //! Primary vertex position in Z
 198
 199   TH1F*   fTriggerEventPlane;            //! Distance between the trigger particle direction and the event plane angle
 200
 201   TH2F*   fTriggerMCPtCent;              //! Trigger particle MC: pt vs centrality
 202   TH3F*   fTriggerMCResPt;               //! Trigger particle MC: pt resolution
 203   TH3F*   fTriggerMCResEta;              //! Trigger particle MC: eta resolution
 204   TH3F*   fTriggerMCResPhi;              //! Trigger particle MC: phi resolution
 205   TH3F*   fTriggerPtCent;                //! Trigger particle: pt vs centrality vs Z vertex
 206   TH3F*   fTriggerPtCentCh;              //! Trigger particle: pt vs centrality vs Z vertex for hh correlations
 207   TH2F*   fNTrigPerEvt;                  //! Trigger particle: Number of particle triggers per event
 208   TH1F*   fTriggerWiSPDHit;              //! Trigger particle: Has Hits in the SPD?
 209   TH2F*   fTriggerEtaPhi;                //! Trigger particle: eta vs phi
 210   TH2F*   fTrigFracShTPCcls;             //! Trigger particle: pt vs fraction of shared TPC cls
 211   TH2F*   fTriggerDCA;                   //! Trigger particle: dca to primary vertex
 212   TH1F*   fCheckTriggerFromV0Daug;       //! Trigger particle: it is a daughter from a V0-candidate
 213   TH1F*   fTriggerComingFromDaug;        //! Trigger particle: pt when LP is a daughter from a V0-candidate
 214   TH1F*   fTriggerIsV0;                  //! Trigger particle: the V0 is the highest-pt particle
 215   TH3F*   fCheckIDTrigPtK0s;             //! Trigger particle: pt comparison between trigger track and K0s daughter track
 216   TH3F*   fCheckIDTrigPhiK0s;            //! Trigger particle: phi comparison between trigger track and K0s daughter track
 217   TH3F*   fCheckIDTrigEtaK0s;            //! Trigger particle: eta comparison between trigger track and K0s daughter track
 218   TH3F*   fCheckIDTrigNclsK0s;           //! Trigger particle: number of cluster of the daughter particle
 219   TH3F*   fCheckIDTrigPtLambda;          //! Trigger particle: pt comparison between trigger track and Lambda daughter track
 220   TH3F*   fCheckIDTrigPhiLambda;         //! Trigger particle: phi comparison between trigger track and Lambda daughter track
 221   TH3F*   fCheckIDTrigEtaLambda;         //! Trigger particle: eta comparison between trigger track and Lambda daughter track
 222   TH3F*   fCheckIDTrigNclsLambda;        //! Trigger particle: number of cluster of the daughter particle
 223   TH3F*   fCheckIDTrigPtAntiLambda;      //! Trigger particle: pt comparison between trigger track and AntiLambda daughter track
 224   TH3F*   fCheckIDTrigPhiAntiLambda;     //! Trigger particle: phi comparison between trigger track and AntiLambda daughter track
 225   TH3F*   fCheckIDTrigEtaAntiLambda;     //! Trigger particle: eta comparison between trigger track and AntiLambda daughter track
 226   TH3F*   fCheckIDTrigNclsAntiLambda;    //! Trigger particle: number of cluster of the daughter particle
 227
 228   // ==============  Monte Carlo  ================= //
 229   TH1F*   fInjectedParticles;            //! Number of injected particles
 230
 231   //           K0s            //
 232   TH1F*   fK0sMCPt;                      //! K0s MC: pt
 233   TH3F*   fK0sMCPtRap;                   //! K0s MC: pt vs rapidity
 234   TH3F*   fK0sMCPtRap2;                  //! K0s MC: pt vs rapidity (is Natural)
 235   TH3F*   fK0sMCPtRapVtx[kNCent];        //! K0s MC: pt vs Z vtx position  vs centrality
 236   TH3F*   fK0sMCPtRapEmbeded;            //! K0s MC: pt vs rapidity  (embeded particles)
 237   TH3F*   fK0sMCPtRapVtxEmbeded[kNCent]; //! K0s MC: pt vs Z vtx position rapidity  vs centrality (embeded particles)
 238   THnSparse* fK0sMCPtRapPtDaugPt[kNCent]; //! K0s MC: pt vs rapidity vs transverse momemtum of daughters
 239   THnSparse* fK0sMCPtRapPtDaugPtEmbeded[kNCent]; //! K0s MC: pt vs rapidity vs transverse momemtum of daughters
 240   TH3F*   fK0sMCPtPhiEta[kNCent];        //! K0s MC: pt vs pseudo-rapidity
 241
 242   TH1F*   fK0sAssocPt;                         //! K0s Assoc: pt
 243   TH3F*   fK0sAssocPtArm;                      //! K0s Assoc: pt vs rapidity vs centrality (arm. pod. cut)
 244   TH3F*   fK0sAssocPtRap;                      //! K0s Assoc: pt vs rapidity vs centrality
 245   TH3F*   fK0sAssocPtRapEmbeded;               //! K0s Assoc: pt vs rapidity vs centrality  (embeded particles)
 246   TH3F*   fK0sAssocPtPhiEta[kNCent];           //! K0s Assoc: pt vs pseudo-rapidity
 247
 248   THnSparse*  fK0sAssocPtMassArm[kNCent];          //! K0s Assoc: mass vs pt vs centrality
 249   THnSparse*  fK0sAssocMassPtVtx[kNCent];          //! K0s Assoc: mass vs pt vs Z vertex position
 250   THnSparse*  fK0sAssocMassPtDCADaug[kNCent];      //! K0s Assoc: mass vs pt vs dca between daughters
 251   THnSparse*  fK0sAssocMassPtCPA[kNCent];          //! K0s Assoc: mass vs pt vs cpa
 252   THnSparse*  fK0sAssocMassPtDCAPV[kNCent];        //! K0s Assoc: mass vs pt vs dca to prim. vtx
 253   THnSparse*  fK0sAssocMassPtDaugNClsTPC[kNCent];  //! K0s Assoc: mass vs pt vs num. of tpc clusters
 254   THnSparse*  fK0sAssocMassPtShTPCcls[kNCent];     //! K0s Assoc: mass vs pt vs fraction of shared TPC cls
 255   THnSparse*  fK0sAssocMassPtDaugPt[kNCent];       //! K0s Assoc: mass vs pt vs transverse momemtum of daughters
 256   THnSparse*  fK0sAssocMassPtCtau[kNCent];         //! K0s Assoc: mass vs pt vs proper time of life
 257   THnSparse*  fK0sAssocMassPtFidVolume[kNCent];    //! K0s Assoc: mass vs pt vs fiducial volume
 258
 259   THnSparse*  fK0sAssocPtMassArmEmbeded[kNCent];          //! K0s Assoc: mass vs pt vs rapidity  (embeded particles)
 260   THnSparse*  fK0sAssocMassPtVtxEmbeded[kNCent];          //! K0s Assoc: mass vs pt vs Z vertex position  (embeded particles)
 261   THnSparse*  fK0sAssocMassPtDCADaugEmbeded[kNCent];      //! K0s Assoc: mass vs pt vs dca between daughters  (embeded particles)
 262   THnSparse*  fK0sAssocMassPtCPAEmbeded[kNCent];          //! K0s Assoc: mass vs pt vs cpa  (embeded particles)
 263   THnSparse*  fK0sAssocMassPtDCAPVEmbeded[kNCent];        //! K0s Assoc: mass vs pt vs dca to prim. vtx  (embeded particles)
 264   THnSparse*  fK0sAssocMassPtDaugNClsTPCEmbeded[kNCent];  //! K0s Assoc: mass vs pt vs num. o ftpc clusters (embeded particles)
 265   THnSparse*  fK0sAssocMassPtShTPCclsEmbeded[kNCent];     //! K0s Assoc: mass vs pt vs fraction of shared TPC cls
 266   THnSparse*  fK0sAssocMassPtDaugPtEmbeded[kNCent];       //! K0s Assoc: mass vs pt vs transverse momemtum of daughters
 267   THnSparse*  fK0sAssocMassPtCtauEmbeded[kNCent];         //! K0s Assoc: mass vs pt vs proper time of life
 268   THnSparse*  fK0sAssocMassPtFidVolumeEmbeded[kNCent];    //! K0s Assoc: mass vs pt vs fiducial volume
 269
 270
 271   TH3F*   fK0sMCResEta;                 //! K0s Assoc: eta resolution
 272   TH3F*   fK0sMCResPhi;                 //! K0s Assoc: phi resolution
 273   TH3F*   fK0sMCResPt;                  //! K0s Assoc: pt resolution
 274   TH3F*   fK0sPosMCResEta;              //! K0s Pos. Daughter: eta resolution
 275   TH3F*   fK0sPosMCResPhi;              //! K0s Pos. Daughter: phi resolution
 276   TH3F*   fK0sPosMCResPt;               //! K0s Pos. Daughter: pt resolution
 277   TH3F*   fK0sNegMCResEta;              //! K0s Neg. Daughter: eta resolution
 278   TH3F*   fK0sNegMCResPhi;              //! K0s Neg. Daughter: phi resolution
 279   TH3F*   fK0sNegMCResPt;               //! K0s Neg. Daughter: pt resolution
 280
 281   //           Lambda            //
 282   TH1F*   fLambdaMCPt;                        //! Lambda MC: pt
 283   TH3F*   fLambdaMCPtRap;                     //! Lambda MC: pt vs rapidity
 284   TH3F*   fLambdaMCPtRap2;                    //! Lambda MC: pt vs rapidity  (is Natural)
 285   TH3F*   fLambdaMCPtRapVtx[kNCent];          //! Lambda MC: pt vs Z vtx position rapidity vs centrality
 286   TH3F*   fLambdaMCPtRapEmbeded;              //! Lambda MC: pt vs rapidity (embeded particles)
 287   TH3F*   fLambdaMCPtRapVtxEmbeded[kNCent];   //! Lambda MC: pt vs Z vtx position vs centrality  (embeded particles)
 288   THnSparse*  fLambdaMCPtRapPtDaugPt[kNCent]; //! Lambda MC: pt vs rapidity vs transverse momemtum of daughters
 289   THnSparse*  fLambdaMCPtRapPtDaugPtEmbeded[kNCent]; //! Lambda MC: pt vs rapidity vs transverse momemtum of daughters
 290   TH2F*   fLambdaMCFromXi;                    //! Lambda MC: coming from Xi
 291   TH3F*   fLambdaMCPtPhiEta[kNCent];          //! Lambda MC: pt vs pseudo-rapidity
 292
 293   TH1F*   fLambdaAssocPt;                //! Lambda Assoc: pt
 294   TH3F*   fLambdaAssocPtRap;             //! Lambda Assoc: pt vs rapidity
 295   TH2F*   fLambdaAssocFromXi;            //! Lambda Assoc: coming from Xi
 296   TH3F*   fLambdaAssocPtPhiEta[kNCent];  //! Lambda Assoc: pt vs pseudo-rapidity
 297
 298   THnSparse*  fLambdaAssocMassPtRap[kNCent];          //! Lambda Assoc: pt vs rapidity vs mass
 299   THnSparse*  fLambdaAssocMassPtRap2[kNCent];         //! Lambda Assoc: pt vs rapidity vs mass (wo Cross contamination)
 300   THnSparse*  fLambdaAssocMassPtVtx[kNCent];          //! Lambda Assoc: mass vs pt vs Z vertex position
 301   THnSparse*  fLambdaAssocMassPtDCADaug[kNCent];      //! Lambda Assoc: mass vs pt vs dca btween daughters
 302   THnSparse*  fLambdaAssocMassPtCPA[kNCent];          //! Lambda Assoc: mass vs pt vs cpa
 303   THnSparse*  fLambdaAssocMassPtDCAPV[kNCent];        //! Lambda Assoc: mass vs pt vs dca to prim vtx
 304   THnSparse*  fLambdaAssocMassPtDaugNClsTPC[kNCent];  //! Lambda Assoc: mass vs pt vs num.of tpc clusters
 305   THnSparse*  fLambdaAssocMassPtShTPCcls[kNCent];     //! Lambda Assoc: mass vs pt vs fraction of shared TPC cls
 306   THnSparse*  fLambdaAssocMassPtDaugPt[kNCent];       //! Lambda Assoc: mass vs pt vs transverse momemtum of daughters
 307   THnSparse*  fLambdaAssocMassPtCtau[kNCent];         //! Lambda Assoc: mass vs pt vs proper time of life
 308   THnSparse*  fLambdaAssocMassPtFidVolume[kNCent];    //! Lambda Assoc: mass vs pt vs fiducial volume
 309
 310   THnSparse*  fLambdaAssocMassPtRapEmbeded[kNCent];          //! Lambda Assoc: pt vs rapidity vs mass (embeded)
 311   THnSparse*  fLambdaAssocMassPtRapEmbeded2[kNCent];         //! Lambda Assoc: pt vs rapidity vs mass  (wo Cross contamination) (embeded)
 312   THnSparse*  fLambdaAssocMassPtVtxEmbeded[kNCent];          //! Lambda Assoc: mass vs pt vs Z vertex position  (embeded particles)
 313   THnSparse*  fLambdaAssocMassPtDCADaugEmbeded[kNCent];      //! Lambda Assoc: mass vs pt vs dca between daughters  (embeded particles)
 314   THnSparse*  fLambdaAssocMassPtCPAEmbeded[kNCent];          //! Lambda Assoc: mass vs pt vs cpa  (embeded particles)
 315   THnSparse*  fLambdaAssocMassPtDCAPVEmbeded[kNCent];        //! Lambda Assoc: mass vs pt vs dca to prim vtx  (embeded particles)
 316   THnSparse*  fLambdaAssocMassPtDaugNClsTPCEmbeded[kNCent];  //! Lambda Assoc: mass vs pt vs num. of tpc clusters  (embeded particles)
 317   THnSparse*  fLambdaAssocMassPtShTPCclsEmbeded[kNCent];     //! Lambda Assoc: mass vs pt vs fraction of shared TPC cls
 318   THnSparse*  fLambdaAssocMassPtDaugPtEmbeded[kNCent];       //! Lambda Assoc: mass vs pt vs transverse momemtum of daughters
 319   THnSparse*  fLambdaAssocMassPtCtauEmbeded[kNCent];         //! Lambda Assoc: mass vs pt vs proper time of life
 320   THnSparse*  fLambdaAssocMassPtFidVolumeEmbeded[kNCent];    //! Lambda Assoc: mass vs pt vs fiducial volume
 321
 322
 323   TH3F*   fLambdaMCResEta;                 //! Lambda Assoc: eta resolution
 324   TH3F*   fLambdaMCResPhi;                 //! Lambda Assoc: phi resolution
 325   TH3F*   fLambdaMCResPt;                  //! Lambda Assoc: pt resolution
 326   TH3F*   fLambdaPosMCResEta;              //! Lambda Pos. Daughter: eta resolution
 327   TH3F*   fLambdaPosMCResPhi;              //! Lambda Pos. Daughter: phi resolution
 328   TH3F*   fLambdaPosMCResPt;               //! Lambda Pos. Daughter: pt resolution
 329   TH3F*   fLambdaNegMCResEta;              //! Lambda Neg. Daughter: eta resolution
 330   TH3F*   fLambdaNegMCResPhi;              //! Lambda Neg. Daughter: phi resolution
 331   TH3F*   fLambdaNegMCResPt;               //! Lambda Neg. Daughter: pt resolution
 332
 333   //           AntiLambda            //
 334   TH1F*   fAntiLambdaMCPt;                  //! AntiLambda MC: pt
 335   TH3F*   fAntiLambdaMCPtRap;               //! AntiLambda MC: pt vs rapidity
 336   TH3F*   fAntiLambdaMCPtRap2;              //! AntiLambda MC: pt vs rapidity  (is Natural)
 337   TH3F*   fAntiLambdaMCPtRapVtx[kNCent];          //! AntiLambda MC: pt vs rapidity vs Z vtx position
 338   TH3F*   fAntiLambdaMCPtRapEmbeded;              //! AntiLambda MC: pt vs rapidity (embeded particles)
 339   TH3F*   fAntiLambdaMCPtRapVtxEmbeded[kNCent];   //! AntiLambda MC: pt vs rapidity  vs Z vtx position
 340   THnSparse*  fAntiLambdaMCPtRapPtDaugPt[kNCent]; //! AntiLambda MC: pt vs rapidity vs transverse momemtum of daughters
 341   THnSparse*  fAntiLambdaMCPtRapPtDaugPtEmbeded[kNCent]; //! AntiLambda MC: pt vs rapidity vs transverse momemtum of daughters
 342   TH2F*   fAntiLambdaMCFromXi;                    //! AntiLambda MC: coming from Xi
 343   TH3F*   fAntiLambdaMCPtPhiEta[kNCent];          //! AntiLambda MC: pt vs pseudo-rapidity
 344
 345   TH1F*   fAntiLambdaAssocPt;                 //! AntiLambda Assoc: pt
 346   TH3F*   fAntiLambdaAssocPtRap;              //! AntiLambda Assoc: pt vs rapidity vscentrality
 347   TH2F*   fAntiLambdaAssocFromXi;             //! AntiLambda Assoc: coming from Xi
 348   TH3F*   fAntiLambdaAssocPtPhiEta[kNCent];   //! AntiLambda Assoc: pt vs pseudo-rapidity
 349
 350   THnSparse*  fAntiLambdaAssocMassPtRap[kNCent];          //! AntiLambda Assoc: mass vs pt vs rapidity
 351   THnSparse*  fAntiLambdaAssocMassPtRap2[kNCent];         //! AntiLambda Assoc: mass vs pt vs rapidity  (wo Cross contamination)
 352   THnSparse*  fAntiLambdaAssocMassPtVtx[kNCent];          //! AntiLambda Assoc: mass vs pt vs Z vtx position
 353   THnSparse*  fAntiLambdaAssocMassPtDCADaug[kNCent];      //! AntiLambda Assoc: mass vs pt vs Dca between daughters
 354   THnSparse*  fAntiLambdaAssocMassPtCPA[kNCent];          //! AntiLambda Assoc: mass vs pt vs cpa
 355   THnSparse*  fAntiLambdaAssocMassPtDCAPV[kNCent];        //! AntiLambda Assoc: mass vs pt vs dca to prim. vtx
 356   THnSparse*  fAntiLambdaAssocMassPtDaugNClsTPC[kNCent];  //! AntiLambda Assoc: mass vs pt vs num. of tpc clusters
 357   THnSparse*  fAntiLambdaAssocMassPtShTPCcls[kNCent];     //! AntiLambda Assoc: mass vs pt vs fraction of shared TPC cls
 358   THnSparse*  fAntiLambdaAssocMassPtDaugPt[kNCent];       //! AntiLambda Assoc: mass vs pt vs transverse momemtum of daughters
 359   THnSparse*  fAntiLambdaAssocMassPtCtau[kNCent];         //! AntiLambda Assoc: mass vs pt vs proper time of life
 360   THnSparse*  fAntiLambdaAssocMassPtFidVolume[kNCent];    //! AntiLambda Assoc: mass vs pt vs fiducial volume
 361
 362   THnSparse*  fAntiLambdaAssocMassPtRapEmbeded[kNCent];          //! AntiLambda Assoc: mass vs pt vs rapidity  (embeded)
 363   THnSparse*  fAntiLambdaAssocMassPtRapEmbeded2[kNCent];         //! AntiLambda Assoc: mass vs pt vs rapidity  (wo Cross contamination) (embeded)
 364   THnSparse*  fAntiLambdaAssocMassPtVtxEmbeded[kNCent];          //! AntiLambda Assoc: mass vs pt vs Z vtx. position  (embeded particles)
 365   THnSparse*  fAntiLambdaAssocMassPtDCADaugEmbeded[kNCent];      //! AntiLambda Assoc: mass vs pt vs dca between daughters  (embeded particles)
 366   THnSparse*  fAntiLambdaAssocMassPtCPAEmbeded[kNCent];          //! AntiLambda Assoc: mass vs pt vs cpa  (embeded particles)
 367   THnSparse*  fAntiLambdaAssocMassPtDCAPVEmbeded[kNCent];        //! AntiLambda Assoc: mass vs pt vs dca to prim. vtx  (embeded particles)
 368   THnSparse*  fAntiLambdaAssocMassPtDaugNClsTPCEmbeded[kNCent];  //! AntiLambda Assoc: mass vs pt vs num. of tpc clusters  (embeded particles)
 369   THnSparse*  fAntiLambdaAssocMassPtShTPCclsEmbeded[kNCent];    //! AntiLambda Assoc: mass vs pt vs fraction of shared TPC cls
 370   THnSparse*  fAntiLambdaAssocMassPtDaugPtEmbeded[kNCent];       //! AntiLambda Assoc: mass vs pt vs transverse momemtum of daughters
 371   THnSparse*  fAntiLambdaAssocMassPtCtauEmbeded[kNCent];         //! AntiLambda Assoc: mass vs pt vs proper time of life
 372   THnSparse*  fAntiLambdaAssocMassPtFidVolumeEmbeded[kNCent];    //! AntiLambda Assoc: mass vs pt vs fiducial volume
 373
 374
 375   TH3F*   fAntiLambdaMCResEta;              //! AntiLambda Assoc: eta resolution
 376   TH3F*   fAntiLambdaMCResPhi;              //! AntiLambda Assoc: phi resolution
 377   TH3F*   fAntiLambdaMCResPt;               //! AntiLambda Assoc: pt resolution
 378   TH3F*   fAntiLambdaPosMCResEta;           //! AntiLambda Pos. Daughter: eta resolution
 379   TH3F*   fAntiLambdaPosMCResPhi;           //! AntiLambda Pos. Daughter: phi resolution
 380   TH3F*   fAntiLambdaPosMCResPt;            //! AntiLambda Pos. Daughter: pt resolution
 381   TH3F*   fAntiLambdaNegMCResEta;           //! AntiLambda Neg. Daughter: eta resolution
 382   TH3F*   fAntiLambdaNegMCResPhi;           //! AntiLambda Neg. Daughter: phi resolution
 383   TH3F*   fAntiLambdaNegMCResPt;            //! AntiLambda Neg. Daughter: pt resolution
 384
 385
 386
 387   /// ====== Histograms for Correlations ====== ///
 388
 389   TH3F*   fHistArmenterosPodolanski;     //! Armenteros-Podolanski plot inside 3 sigma of the signal
 390   TH3F*   fHistArmPodBckg;               //! Armenteros-Podolanski plot outside 3 sigma of the signal
 391
 392   //           K0s            //
 393   TH3F*   fK0sMass;                      //! Mass for K0s
 394   TH3F*   fK0sMassEmbeded;               //! Mass for K0s embeded
 395   TH3F*   fK0sMassPtEta;                 //! K0s: mass vs pt vs eta
 396   TH3F*   fK0sMassPtRap[kNCent];         //! K0s: mass vs pt vs rap vs centrality
 397   TH3F*   fK0sMassPtPhi;                 //! K0s: mass vs pt vs phi
 398   TH3F*   fK0sPosDaugFracShTPCcls;       //! K0s Pos. Daug: mass vs pt vs fraction of shared TPC cls
 399   TH3F*   fK0sNegDaugFracShTPCcls;       //! K0s Neg Daug: mass vs pt vs fraction of shared TPC cls
 400
 401   TH2F*   fK0sDaughtersPt;                       //! K0s: pt of daughters
 402   THnSparse* fK0sPosDaugdPhiSdEtaS[kNCent];      //! K0s: Positive daughter: delta(phi)* delta(eta)*
 403   THnSparse* fK0sNegDaugdPhiSdEtaS[kNCent];      //! K0s: Negative daughter: delta(phi)* delta(eta)*
 404   THnSparse* fK0sPosDaugSplCheckCovMat[kNCent];  //! K0s: Check Covariance Matrix elemenets between trigger trcak and daughter track
 405   THnSparse* fK0sNegDaugSplCheckCovMat[kNCent];  //! K0s: Check Covariance Matrix elemenets between trigger trcak and daughter track
 406   THnSparse* fK0sPosMCResdEtaSdPhiS[kNCent];     //! K0s: Positive daughter: resolution for  delta(phi)* delta(eta)*
 407   THnSparse* fK0sNegMCResdEtaSdPhiS[kNCent];     //! K0s: Negative daughter: resolution for  delta(phi)* delta(eta)*
 408   TH3F*   fK0sPosDaugFracShTPCclsTrig;           //! K0s Pos. Daug: mass vs pt vs fraction of shared TPC cls
 409   TH3F*   fK0sNegDaugFracShTPCclsTrig;           //! K0s Neg Daug: mass vs pt vs fraction of shared TPC cls
 410   TH3F*   fK0sDCADaugToPrimVtx;                  //! K0s: DCA to primary vertex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 411   TH3F*   fK0sSpatialRes;                        //! K0s: Spatial resolution
 412
 413   TH3F*   fK0sdPhidEtaMC[kNCent*kN1];             //! K0s MC: Delta phi,Delta eta vs Z vertex position
 414   TH3F*   fK0sdPhidEtaPtL[kNVtxZ*kNCent*kN1];     //! K0s: Delta phi,Delta eta vs Z vertex position
 415   //TH3F*   fK0sdPhidEtaPtLBckg[kNCent*kN1];      //! K0s background: Delta phi,Delta eta vs Z vertex position
 416
 417   TH2F*   fK0sBckgDecLength;             //! K0s background: Decay lenght vs leading particle's pt inside a radio wrt the near-side peak
 418   TH3F*   fK0sBckgDCADaugToPrimVtx;      //! K0s background: DCA to primary vrtex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 419   TH2F*   fK0sBckgEtaPhi;                //! K0s background: Phi vs Eta inside a radio wrt the near-side peak
 420   TH2F*   fK0sBckgPhiRadio;              //! K0s background: Phi vs radio inside a radio wrt the near-side peak
 421   TH2F*   fK0sBckgDCANegDaugToPrimVtx;   //! K0s background: DCA of Negative daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 422   TH2F*   fK0sBckgDCAPosDaugToPrimVtx;   //! K0s background: DCA of Positive daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 423   TH2F*   fV0MassCascade;                //! V0s candiates: Possible mismatching of tracks due to cascades decays
 424
 425
 426   //           Lambda            //
 427   TH3F*   fLambdaMass;                   //! Mass for Lambda
 428   TH3F*   fLambdaMassEmbeded;            //! Mass for Lambda embeded
 429   TH3F*   fLambdaMass2;                  //! Mass for Lambda (rejecting crosscontamination)
 430   TH3F*   fLambdaMass2Embeded;           //! Mass for Lambda embded (rejecting crosscontamination)
 431   TH3F*   fLambdaMassPtEta;              //! Lambda: mass vs pt vs eta
 432   TH3F*   fLambdaMassPtRap[kNCent];      //! Lambda: mass vs pt vs rap
 433   TH3F*   fLambdaMassPtPhi;              //! Lambda: mass vs pt vs phi
 434   TH3F*   fLambdaPosDaugFracShTPCcls;    //! Lambda Pos. Daug: mass vs pt vs fraction of shared TPC cls
 435   TH3F*   fLambdaNegDaugFracShTPCcls;    //! Lambda Neg Daug: mass vs pt vs fraction of shared TPC cls
 436
 437   TH2F*   fLambdaDaughtersPt;                       //! Lambda: pt of daughters
 438   THnSparse* fLambdaPosDaugdPhiSdEtaS[kNCent];      //! Lambda:Positive daughter: delta(phi)* delta(eta)*
 439   THnSparse* fLambdaNegDaugdPhiSdEtaS[kNCent];      //! Lambda: Negative daughter: delta(phi)* delta(eta)*
 440   THnSparse* fLambdaPosDaugSplCheckCovMat[kNCent];  //! Lambda: Check Covariance Matrix elemenets between trigger trcak and daughter track
 441   THnSparse* fLambdaNegDaugSplCheckCovMat[kNCent];  //! Lambda: Check Covariance Matrix elemenets between trigger trcak and daughter track
 442   THnSparse* fLambdaPosMCResdEtaSdPhiS[kNCent];     //! Lambda: Positive daughter: resolution for  delta(phi)* delta(eta)*
 443   THnSparse* fLambdaNegMCResdEtaSdPhiS[kNCent];     //! Lambda: Negative daughter: resolution for  delta(phi)* delta(eta)*
 444   TH3F*   fLambdaPosDaugFracShTPCclsTrig;           //! Lambda Pos. Daug: mass vs pt vs fraction of shared TPC cls
 445   TH3F*   fLambdaNegDaugFracShTPCclsTrig;           //! Lambda Neg Daug: mass vs pt vs fraction of shared TPC cls
 446   TH3F*   fLambdaDCADaugToPrimVtx;                  //! Lambda: DCA to primary vrtex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 447   TH3F*   fLambdaSpatialRes;                        //! Lambda: Spatial resolution
 448
 449   TH3F*   fLambdadPhidEtaMC[kNCent*kN1];            //! Lambda MC: Delta phi,Delta eta vs Z vertex position
 450   TH3F*   fLambdadPhidEtaPtL[kNVtxZ*kNCent*kN1];    //! Lambda: Delta phi,Delta eta vs Z vertex position
 451   //TH3F*   fLambdadPhidEtaPtLBckg[kNCent*kN1];     //! Lambda background: Delta phi,Delta eta vs Z vertex position
 452
 453
 454   TH2F*   fLambdaBckgDecLength;            //! Lambda background: Decay lenght vs leading particle's pt inside a radio wrt the near-side peak
 455   TH3F*   fLambdaBckgDCADaugToPrimVtx;     //! Lambda background: DCA to primary vrtex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 456   TH2F*   fLambdaBckgEtaPhi;               //! Lambda background: Phi vs Eta inside a radio wrt the near-side peak
 457   TH2F*   fLambdaBckgPhiRadio ;            //! Lambda background: Phi vs radio inside a radio wrt the near-side peak
 458   TH2F*   fLambdaBckgDCANegDaugToPrimVtx;  //! Lambda background: DCA of Negative daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 459   TH2F*   fLambdaBckgDCAPosDaugToPrimVtx;  //! Lambda background: DCA of Positive daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 460
 461
 462   //           AntiLambda            //
 463   TH3F*   fAntiLambdaMass;                     //! Mass for AntiLambda
 464   TH3F*   fAntiLambdaMassEmbeded;              //! Mass for AntiLambda embeded
 465   TH3F*   fAntiLambdaMass2;                    //! Mass for AntiLambda (rejecting crosscontamination)
 466   TH3F*   fAntiLambdaMass2Embeded;             //! Mass for AntiLambda embded (rejecting crosscontamination)
 467
 468   TH3F*   fAntiLambdaMassPtEta;                //! AntiLambda: pt vs eta
 469   TH3F*   fAntiLambdaMassPtRap[kNCent];        //! AntiLambda: pt vs rap
 470   TH3F*   fAntiLambdaMassPtPhi;                //! AntiLambda: mass vs phi
 471   TH3F*   fAntiLambdaPosDaugFracShTPCcls;      //! AntiLambda Pos. Daug: mass vs pt vs fraction of shared TPC cls
 472   TH3F*   fAntiLambdaNegDaugFracShTPCcls;      //! AntiLambda Neg Daug: mass vs pt vs fraction of shared TPC cls
 473
 474   TH2F*   fAntiLambdaDaughtersPt;                       //! AntiLambda: pt of daughters
 475   THnSparse* fAntiLambdaPosDaugdPhiSdEtaS[kNCent];      //! AntiLambda: Positive daughter: delta(phi)* delta(eta)*
 476   THnSparse* fAntiLambdaNegDaugdPhiSdEtaS[kNCent];      //! AntiLambda: Negative daughter: delta(phi)* delta(eta)*
 477   THnSparse* fAntiLambdaPosDaugSplCheckCovMat[kNCent];  //! AntiLambda: Check Covariance Matrix elemenets between trigger trcak and daughter track
 478   THnSparse* fAntiLambdaNegDaugSplCheckCovMat[kNCent];  //! AntiLambda: Check Covariance Matrix elemenets between trigger trcak and daughter track
 479   THnSparse* fAntiLambdaPosMCResdEtaSdPhiS[kNCent];     //! AntiLambda: Positive daughter: resolution for  delta(phi)* delta(eta)*
 480   THnSparse* fAntiLambdaNegMCResdEtaSdPhiS[kNCent];     //! AntiLambda: Negative daughter: resolution for  delta(phi)* delta(eta)*
 481   TH3F*   fAntiLambdaPosDaugFracShTPCclsTrig;           //! AntiLambda Pos. Daug: mass vs pt vs fraction of shared TPC cls
 482   TH3F*   fAntiLambdaNegDaugFracShTPCclsTrig;           //! AntiLambda Neg Daug: mass vs pt vs fraction of shared TPC cls
 483   TH3F*   fAntiLambdaDCADaugToPrimVtx;                  //! AntiLambda: DCA to primary vrtex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 484   TH3F*   fAntiLambdaSpatialRes;                        //! AntiLambda: Spatial resolution
 485
 486   TH3F*   fAntiLambdadPhidEtaMC[kNCent*kN1];            //! AntiLambda MC: Delta phi,Delta eta vs Z vertex position
 487   TH3F*   fAntiLambdadPhidEtaPtL[kNVtxZ*kNCent*kN1];    //! AntiLambda: Delta phi,Delta eta vs pt of the leading particle
 488   //TH3F*   fAntiLambdadPhidEtaPtLBckg[kNCent*kN1];     //! AntiLambda background: Delta phi,Delta eta vs Z vertex position
 489
 490   TH2F*   fAntiLambdaBckgDecLength;            //! AntiLambda background: Decay lenght vs leading particle's pt inside a radio wrt the near-side peak
 491   TH3F*   fAntiLambdaBckgDCADaugToPrimVtx;     //! AntiLambda background: DCA to primary vrtex of daughters vs leading particle's pt inside a radio wrt the near-side peak
 492   TH2F*   fAntiLambdaBckgEtaPhi;               //! AntiLambda background: Phi vs Eta inside a radio wrt the near-side peak
 493   TH2F*   fAntiLambdaBckgPhiRadio ;            //! AntiLambda background: Phi vs radio inside a radio wrt the near-side peak
 494   TH2F*   fAntiLambdaBckgDCANegDaugToPrimVtx;  //! AntiLambda background: DCA of Negative daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 495   TH2F*   fAntiLambdaBckgDCAPosDaugToPrimVtx;  //! AntiLambda background: DCA of Positive daughter to the primary vertex inside the radio 0.4 wrt the near-side peak
 496
 497
 498   ///  ==== Quality Assurance plots === ///
 499
 500   //           K0s            //
 501   TH2F*   fK0sPtPosDaug;                     //! K0s: Pos. pt
 502   TH2F*   fK0sPtNegDaug;                     //! K0s: Neg. pt
 503   TH2F*   fK0sBckgPtPosDaug;                 //! K0s Bckg: Pos. pt
 504   TH2F*   fK0sBckgPtNegDaug;                 //! K0s Bckg: Neg. pt
 505
 506   TH3F*   fK0sPhiEtaPosDaug;                 //! K0s: Pos. track phi vs eta
 507   TH3F*   fK0sPhiEtaNegDaug;                 //! K0s: Neg. track phi vs eta
 508   TH3F*   fK0sBckgPhiEtaPosDaug;             //! K0s Bckg: Pos. track phi vs eta
 509   TH3F*   fK0sBckgPhiEtaNegDaug;             //! K0s Bckg: Neg. track phi vs eta
 510
 511   TH2F*   fK0sDCAPosDaug;                    //! K0s: Pos. track DCA to primary vertex
 512   TH2F*   fK0sDCANegDaug;                    //! K0s: Neg. track DCA to primary vertex
 513   TH2F*   fK0sBckgDCAPosDaug;                //! K0s Bckg: Pos. track DCA to primary vertex
 514   TH2F*   fK0sBckgDCANegDaug;                //! K0s Bckg: Neg. track DCA to primary vertex
 515
 516   TH3F*   fK0sDecayPos;                      //! K0s: 2D decay position
 517   TH3F*   fK0sBckgDecayPos;                  //! K0s Bckg: 2D decay position
 518   TH2F*   fK0sDecayVertex;                   //! K0s: decay lenght
 519   TH2F*   fK0sBckgDecayVertex;               //! K0s Bckg: decay lenght
 520
 521   TH2F*   fK0sCPA;                           //! K0s: cosine of the pointing angle
 522   TH2F*   fK0sBckgCPA;                       //! K0s Bckg: cosine of the pointing angle
 523   TH2F*   fK0sDCAV0Daug;                     //! K0s: distance of the closest approach to the primary vertex
 524   TH2F*   fK0sBckgDCAV0Daug;                 //! K0s Bckg: distance of the closest approach to the primary vertex
 525
 526   TH3F*   fK0sNClustersTPC;                  //! K0s: Numbers of TPC clusters of the daughter tracks
 527   TH3F*   fK0sBckgNClustersTPC;              //! K0s Bckg: Numbers of TPC clusters of the daughter tracks
 528   TH3F*   fK0sNClustersITSPos;               //! K0s: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 529   TH3F*   fK0sNClustersITSNeg;               //! K0s: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 530   TH3F*   fK0sBckgNClustersITSPos;           //! K0s Bckg: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 531   TH3F*   fK0sBckgNClustersITSNeg;           //! K0s Bckg: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 532
 533
 534   //          Lambda          //
 535   TH2F*   fLambdaPtPosDaug;                     //! Lambda: Pos. pt
 536   TH2F*   fLambdaPtNegDaug;                     //! Lambda: Neg. pt
 537   TH2F*   fLambdaBckgPtPosDaug;                 //! Lambda Bckg: Pos. pt
 538   TH2F*   fLambdaBckgPtNegDaug;                 //! Lambda Bckg: Neg. pt
 539
 540   TH3F*   fLambdaPhiEtaPosDaug;                 //! Lambda: Pos. track phi vs eta
 541   TH3F*   fLambdaPhiEtaNegDaug;                 //! Lambda: Neg. track phi vs eta
 542   TH3F*   fLambdaBckgPhiEtaPosDaug;             //! Lambda Bckg: Pos. track phi vs eta
 543   TH3F*   fLambdaBckgPhiEtaNegDaug;             //! Lambda Bckg: Neg. track phi vs eta
 544
 545   TH2F*   fLambdaDCAPosDaug;                    //! Lambda: Pos. track DCA to primary vertex
 546   TH2F*   fLambdaDCANegDaug;                    //! Lambda: Neg. track DCA to primary vertex
 547   TH2F*   fLambdaBckgDCAPosDaug;                //! Lambda Bckg: Pos. track DCA to primary vertex
 548   TH2F*   fLambdaBckgDCANegDaug;                //! Lambda Bckg: Neg. track DCA to primary vertex
 549
 550   TH3F*   fLambdaDecayPos;                      //! Lambda: 2D decay position
 551   TH3F*   fLambdaBckgDecayPos;                  //! Lambda Bckg: 2D decay position
 552   TH2F*   fLambdaDecayVertex;                   //! Lambda: decay lenght
 553   TH2F*   fLambdaBckgDecayVertex;               //! Lambda Bckg: decay lenght
 554
 555   TH2F*   fLambdaCPA;                           //! Lambda: cosine of the pointing angle
 556   TH2F*   fLambdaBckgCPA;                       //! Lambda Bckg: cosine of the pointing angle
 557   TH2F*   fLambdaDCAV0Daug;                     //! Lambda: distance of the closest approach to the primary vertex
 558   TH2F*   fLambdaBckgDCAV0Daug;                 //! Lambda Bckg: distance of the closest approach to the primary vertex
 559
 560   TH3F*   fLambdaNClustersTPC;                  //! Lambda: Numbers of TPC clusters of the daughter tracks
 561   TH3F*   fLambdaBckgNClustersTPC;              //! Lambda Bckg: Numbers of TPC clusters of the daughter tracks
 562   TH3F*   fLambdaNClustersITSPos;               //! Lambda: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 563   TH3F*   fLambdaNClustersITSNeg;               //! Lambda: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 564   TH3F*   fLambdaBckgNClustersITSPos;           //! Lambda Bckg: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 565   TH3F*   fLambdaBckgNClustersITSNeg;           //! Lambda Bckg: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 566
 567
 568   //        AntiLambda        //
 569   TH2F*   fAntiLambdaPtPosDaug;                     //! AntiLambda: Pos. pt
 570   TH2F*   fAntiLambdaPtNegDaug;                     //! AntiLambda: Neg. pt
 571   TH2F*   fAntiLambdaBckgPtPosDaug;                 //! AntiLambda Bckg: Pos. pt
 572   TH2F*   fAntiLambdaBckgPtNegDaug;                 //! AntiLambda Bckg: Neg. pt
 573
 574   TH3F*   fAntiLambdaPhiEtaPosDaug;                 //! AntiLambda: Pos. track phi vs eta
 575   TH3F*   fAntiLambdaPhiEtaNegDaug;                 //! AntiLambda: Neg. track phi vs eta
 576   TH3F*   fAntiLambdaBckgPhiEtaPosDaug;             //! AntiLambda Bckg: Pos. track phi vs eta
 577   TH3F*   fAntiLambdaBckgPhiEtaNegDaug;             //! AntiLambda Bckg: Neg. track phi vs eta
 578
 579   TH2F*   fAntiLambdaDCAPosDaug;                    //! AntiLambda: Pos. track DCA to primary vertex
 580   TH2F*   fAntiLambdaDCANegDaug;                    //! AntiLambda: Neg. track DCA to primary vertex
 581   TH2F*   fAntiLambdaBckgDCAPosDaug;                //! AntiLambda Bckg: Pos. track DCA to primary vertex
 582   TH2F*   fAntiLambdaBckgDCANegDaug;                //! AntiLambda Bckg: Neg. track DCA to primary vertex
 583
 584   TH3F*   fAntiLambdaDecayPos;                      //! AntiLambda: 2D decay position
 585   TH3F*   fAntiLambdaBckgDecayPos;                  //! AntiLambda Bckg: 2D decay position
 586   TH2F*   fAntiLambdaDecayVertex;                   //! AntiLambda: decay lenght
 587   TH2F*   fAntiLambdaBckgDecayVertex;               //! AntiLambda Bckg: decay lenght
 588
 589   TH2F*   fAntiLambdaCPA;                           //! AntiLambda: cosine of the pointing angle
 590   TH2F*   fAntiLambdaBckgCPA;                       //! AntiLambda Bckg: cosine of the pointing angle
 591   TH2F*   fAntiLambdaDCAV0Daug;                     //! AntiLambda: distance of the closest approach to the primary vertex
 592   TH2F*   fAntiLambdaBckgDCAV0Daug;                 //! AntiLambda Bckg: distance of the closest approach to the primary vertex
 593
 594   TH3F*   fAntiLambdaNClustersTPC;                  //! AntiLambda: Numbers of TPC clusters of the daughter tracks
 595   TH3F*   fAntiLambdaBckgNClustersTPC;              //! AntiLambda Bckg: Numbers of TPC clusters of the daughter tracks
 596   TH3F*   fAntiLambdaNClustersITSPos;               //! AntiLambda: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 597   TH3F*   fAntiLambdaNClustersITSNeg;               //! AntiLambda: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 598   TH3F*   fAntiLambdaBckgNClustersITSPos;           //! AntiLambda Bckg: Pos. Daug. Numbers of ITS clusters of the daughter tracks
 599   TH3F*   fAntiLambdaBckgNClustersITSNeg;           //! AntiLambda Bckg: Neg. Daug. Numbers of ITS clusters of the daughter tracks
 600
 601
 602   ///  ==== Mixed Events plots === ///
 603   TH3F*  fK0sdPhidEtaME[kNVtxZ*kNCent*kN1+1];             //! K0s Mixed Events
 604   TH3F*  fLambdadPhidEtaME[kNVtxZ*kNCent*kN1+1];          //! Lambda Mixed Events
 605   TH3F*  fAntiLambdadPhidEtaME[kNVtxZ*kNCent*kN1+1];      //! AntiLambda Mixed Events
 606
 607   ClassDef(AliAnalysisTaskLambdaOverK0sJets,1);
 608
 609 };
 610
 611
 612 /*
 613     Based on AliV0ChBasicParticle class of AliAnalysisTaskV0ChCorrelations.
 614     Keeps basic information to reduce memory consumption for event mixing.
 615 */
 616 class AliMiniParticle : public AliVParticle
 617 {
 618  public:
 619  AliMiniParticle(Float_t centrality, Float_t vtxZ, Int_t id,Double_t pt, Double_t phi,
 620                  Double_t eta, Int_t negDaugMC, Int_t posDaugMC, Short_t candidate)
 621    :fCentrality(centrality), fVtxZ(vtxZ),  fId(id), fPt(pt),
 622     fPhi(phi), fEta(eta), fNegDaugMC(negDaugMC), fPosDaugMC(posDaugMC), fCandidate(candidate)
 623   {
 624   }
 625
 626   virtual ~AliMiniParticle() {}
 627
 628   // event
 629   virtual Float_t Centrality() const { return fCentrality; }
 630   virtual Float_t VtxZ() const { return fVtxZ; }
 631
 632   virtual Int_t   ID()  const { return fId; }
 633   // kinematics
 634   virtual Double_t Px() const { AliFatal("Not implemented"); return 0; }
 635   virtual Double_t Py() const { AliFatal("Not implemented"); return 0; }
 636   virtual Double_t Pz() const { AliFatal("Not implemented"); return 0; }
 637
 638   virtual Double_t Pt() const { return fPt; }
 639   virtual Double_t P()  const { AliFatal("Not implemented"); return 0; }
 640   virtual Bool_t   PxPyPz(Double_t[3]) const { AliFatal("Not implemented"); return 0; }
 641
 642   virtual Double_t Xv() const { AliFatal("Not implemented"); return 0; }
 643   virtual Double_t Yv() const { AliFatal("Not implemented"); return 0; }
 644   virtual Double_t Zv() const { AliFatal("Not implemented"); return 0; }
 645   virtual Bool_t   XvYvZv(Double_t[3]) const { AliFatal("Not implemented"); return 0; }
 646
 647   virtual Double_t OneOverPt()  const { AliFatal("Not implemented"); return 0; }
 648
 649   virtual Double_t Phi()        const { return fPhi; }
 650   virtual Double_t Theta()      const { AliFatal("Not implemented"); return 0; }
 651   virtual Double_t E()          const { AliFatal("Not implemented"); return 0; }
 652   virtual Double_t M()          const { AliFatal("Not implemented"); return 0; }
 653
 654   virtual Double_t Eta()        const { return fEta; }
 655   virtual Double_t Y()          const { AliFatal("Not implemented"); return 0; }
 656
 657   virtual Short_t Charge()      const { AliFatal("Not implemented"); return 0; }
 658   virtual Int_t   GetLabel()    const { AliFatal("Not implemented"); return 0; }
 659   // PID
 660   virtual Int_t   PdgCode()     const { AliFatal("Not implemented"); return 0; }
 661   virtual const Double_t *PID() const { AliFatal("Not implemented"); return 0; }
 662   virtual Int_t   NegDaugMCLabel() const { return fNegDaugMC; }
 663   virtual Int_t   PosDaugMCLabel() const { return fPosDaugMC; }
 664   virtual Short_t WhichCandidate() const { return fCandidate; }
 665
 666  private:
 667   Float_t fCentrality; // centrality of the event
 668   Float_t fVtxZ;       // vertex postition in the event
 669   Int_t   fId;         // ID related either to AliAODtrack or AliAODv0
 670   Float_t fPt;         // pt
 671   Float_t fPhi;        // phi
 672   Float_t fEta;        // eta
 673   Int_t   fNegDaugMC;  // MC origin of negative daughter
 674   Int_t   fPosDaugMC;  // MC origin of positive daughter
 675   Short_t fCandidate;  // Candidate: 0-Not trigger, 1-Trigger, 2-Gamma Conversion, 3-K0s candidates, 4-Lambda candidates, 5-AntiLambda candidates
 676
 677   ClassDef( AliMiniParticle, 1); // class required for event mixing
 678 };
 679
 680 #endif