PWGJE/StrangenessInJets/AliAnalysisTaskJetChem.h

   1 /*************************************************************************
   2  *                                                                       *
   3  * Task for Jet Chemistry Analysis in PWG-JE Jet Task Force Train        *
   4  *                                                                       *
   5  *                                                                       *
   6  *  contact:                                                             *
   7  *  Alice Zimmermann                                                     *
   8  *  zimmermann@physi.uni-heidelberg.de                                   *
   9  *                                                                       *
  10  *                                                                       *
  11  *                                                                       *
  12  *                                                                       *
  13  *************************************************************************/
  14
  15
  16 #ifndef ALIANALYSISTASKJETCHEM_H
  17 #define ALIANALYSISTASKJETCHEM_H
  18
  19 /* Copyright(c) 1998-2013, ALICE Experiment at CERN, All rights reserved. *
  20  * See cxx source for full Copyright notice                               */
  21
  22 /* $Id$ */
  23
  24 class AliAODv0;
  25 class AliAODVertex;
  26 class AliAnalysisCentralitySelector;
  27 class AliPIDResponse;
  28 class TString;
  29 class TList;
  30 class AliAODMCParticle;
  31 class AliAODTrack;
  32 class TRandom3;
  33
  34 #include "AliAnalysisTaskFragmentationFunction.h"
  35 #include "AliPID.h"
  36 #include "AliAnalysisTaskSE.h"
  37 #include "AliAODMCHeader.h"
  38
  39 class AliAnalysisTaskJetChem : public AliAnalysisTaskFragmentationFunction {
  40
  41  public:
  42
  43   //----------------------------------------
  44   class AliFragFuncHistosInvMass : public TObject
  45   {
  46
  47     public:
  48
  49     AliFragFuncHistosInvMass(const char* name = "FFIMhistos",
  50                              Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0,
  51                              Int_t nInvMass = 0, Float_t invMassMin=0, Float_t invMassMax=0,
  52                              Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0,
  53                              Int_t nXi = 0, Float_t xiMin = 0, Float_t xiMax = 0,
  54                              Int_t nZ  = 0, Float_t zMin  = 0, Float_t zMax  = 0);
  55     AliFragFuncHistosInvMass(const AliFragFuncHistosInvMass& copy);
  56     AliFragFuncHistosInvMass& operator=(const AliFragFuncHistosInvMass &o);
  57     virtual ~AliFragFuncHistosInvMass();
  58
  59     virtual void DefineHistos();
  60     virtual void FillFF(Float_t trackPt, Float_t invM, Float_t jetPt,Bool_t incrementJetPt);
  61     virtual void AddToOutput(TList* list) const;
  62
  63   private:
  64
  65     Int_t   fNBinsJetPt;    // FF histos bins
  66     Float_t fJetPtMin;      // FF histos limits
  67     Float_t fJetPtMax;      // FF histos limits
  68     Int_t   fNBinsInvMass;  // FF histos bins
  69     Float_t fInvMassMin;    // FF histos limits
  70     Float_t fInvMassMax;    // FF histos limits
  71     Int_t   fNBinsPt;       // FF histos bins
  72     Float_t fPtMin;         // FF histos limits
  73     Float_t fPtMax;         // FF histos limits
  74     Int_t   fNBinsXi;       // FF histos bins
  75     Float_t fXiMin;         // FF histos limits
  76     Float_t fXiMax;         // FF histos limits
  77     Int_t   fNBinsZ;        // FF histos bins
  78     Float_t fZMin;          // FF histos limits
  79     Float_t fZMax;          // FF histos limits
  80
  81
  82
  83     TH3F*   fh3TrackPt;     //! FF: track transverse momentum
  84     TH3F*   fh3Xi;          //! FF: xi
  85     TH3F*   fh3Z;           //! FF: z
  86     TH1F*   fh1JetPt;       //! jet pt of all jets
  87
  88     TString fNameFF;        // histo names prefix
  89
  90     ClassDef(AliFragFuncHistosInvMass, 1);
  91   };
  92
  93
  94   //----------------------------------------
  95
  96   AliAnalysisTaskJetChem();
  97   AliAnalysisTaskJetChem(const char *name);
  98   AliAnalysisTaskJetChem(const  AliAnalysisTaskJetChem &copy);
  99   AliAnalysisTaskJetChem& operator=(const  AliAnalysisTaskJetChem &o);
 100   virtual ~AliAnalysisTaskJetChem();
 101
 102   virtual void   UserCreateOutputObjects();
 103   virtual void   UserExec(Option_t *option);
 104
 105   enum { kTrackUndef =0, kOnFly, kOnFlyPID, kOnFlydEdx, kOnFlyPrim, kOffl, kOfflPID, kOffldEdx, kOfflPrim };
 106   enum { kK0, kLambda, kAntiLambda };
 107
 108   static  void   SetProperties(TH3F* h,const char* x, const char* y,const char* z);
 109
 110   Bool_t IsAccepteddEdx(Double_t mom, Double_t signal, AliPID::EParticleType n, Double_t cutnSig) const;//not used anymore
 111   Bool_t IsK0InvMass(Double_t mass) const;
 112   Int_t  GetListOfV0s(TList *list, Int_t type, Int_t particletype, AliAODVertex* primVertex, AliAODEvent* aod);
 113   Int_t  GetListOfParticles(TList *list, Int_t type, Int_t particletype, AliAODVertex* primVertex);
 114   Int_t  GetListOfMCParticles(TList *outputlist, Int_t particletype, AliAODEvent* mcaodevent);
 115   void   GetTracksInCone(TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius, Double_t& sumPt, Double_t minPt, Double_t maxPt, Bool_t& isBadPt);
 116   void   GetTracksInPerpCone(TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius, Double_t& sumPerpPt);
 117   Bool_t MCLabelCheck(AliAODv0* v0, Int_t particletype, const AliAODTrack* trackNeg, const AliAODTrack* trackPos, TList *listmc, Int_t& negDaughterpdg, Int_t& posDaughterpdg, Int_t& motherType, Int_t& v0Label, Double_t& MCPt, Bool_t& fPhysicalPrimary, Int_t& MCv0PDGCode, TString& generatorName, Bool_t& isinjected);
 118   Bool_t IsParticleMatching(const AliAODMCParticle* mcp0, Int_t v0Label);
 119   Bool_t DaughterTrackCheck(AliAODv0* v0, Int_t& nnum, Int_t& pnum);
 120   //Int_t  SplitCocktail(AliAODMCParticle *mcv0,  Int_t v0Label, AliAODMCHeader *header, TClonesArray *arrayMC);
 121   TString GetGenerator(Int_t label, AliAODMCHeader* header);
 122   void GetTrackPrimaryGenerator(Int_t lab, AliAODMCHeader *header,TClonesArray *arrayMC,TString &nameGen);
 123   Bool_t IsTrackInjected(Int_t lab, AliAODMCHeader *header,TClonesArray *arrayMC, TString &nameGen);
 124   Double_t SmearJetPt(Double_t jetPt, Int_t cl, Double_t jetRadius, Double_t ptmintrack, Double_t& jetPtSmear);
 125   Bool_t IsParticleInCone(const AliVParticle* part1, const AliVParticle* part2, Double_t dRMax) const;
 126   Bool_t IsRCJCOverlap(TList* recjetlist, const AliVParticle* part, Double_t dDistance) const;
 127   AliAODJet* GetRandomCone(TList* jetlist, Double_t dEtaConeMax, Double_t dDistance) const;
 128
 129   AliAODJet* GetMedianCluster();
 130   Double_t AreaCircSegment(Double_t dRadius, Double_t dDistance) const;
 131
 132
 133   virtual void SetK0Type(Int_t i){ fK0Type = i; }
 134   virtual void SetFilterMaskK0(UInt_t i) {fFilterMaskK0 = i;}
 135
 136   Bool_t IsLaInvMass(Double_t mass) const; //La and ALa mass check
 137   virtual void SetLaType(Int_t i){ fLaType = i; }
 138   virtual void SetFilterMaskLa(UInt_t i) {fFilterMaskLa = i;}
 139
 140   virtual void SetALaType(Int_t i){ fALaType = i; }
 141   virtual void SetFilterMaskALa(UInt_t i) {fFilterMaskALa = i;}
 142
 143   virtual void SetSelectArmenteros(Bool_t b) {IsArmenterosSelected = b;}
 144   //virtual void SetEventSelectionMask(UInt_t i){fEvtSelectionMask = i;}  //already inherited by AliAnalysisFragmentationFunctionTask
 145   //virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;} //already inherited by AliAnalysisFragmentationFunctionTask
 146
 147   void CalculateInvMass(AliAODv0* v0vtx, Int_t particletype, Double_t& invM, Double_t& trackPt);
 148
 149   Bool_t AcceptBetheBloch(AliAODv0 *v0, AliPIDResponse *PIDResponse, Int_t particletype); //don't use this method for MC Analysis
 150
 151
 152   Double_t MyRapidity(Double_t rE, Double_t rPz) const;
 153
 154   //-- K0s
 155
 156   void   SetFFInvMassHistoBins(Int_t nJetPt = 19, Float_t jetPtMin = 5., Float_t jetPtMax = 100., //previous 19, 5.,100.
 157                                Int_t nInvM = 400, Float_t invMMin = 0.3,  Float_t invMMax = 0.7, //previous 0.4 to 0.6
 158                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20.,         //previous 0. to 10.
 159                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
 160                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
 161   { fFFIMNBinsJetPt = nJetPt; fFFIMJetPtMin = jetPtMin; fFFIMJetPtMax = jetPtMax;
 162     fFFIMNBinsInvM = nInvM; fFFIMInvMMin = invMMin; fFFIMInvMMax = invMMax; fFFIMNBinsPt = nPt; fFFIMPtMin = ptMin; fFFIMPtMax = ptMax;
 163     fFFIMNBinsXi = nXi; fFFIMXiMin = xiMin; fFFIMXiMax = xiMax; fFFIMNBinsZ  = nZ;  fFFIMZMin  = zMin;  fFFIMZMax  = zMax; }
 164
 165
 166
 167   // --La and ALa
 168
 169   void   SetFFInvMassLaHistoBins(Int_t nJetPt = 19, Float_t jetPtMin = 5., Float_t jetPtMax = 100., //La
 170                                  //Int_t nInvM = 140, Float_t invMMin = 1.06,  Float_t invMMax = 1.2,//original inv. mass range, now I shifted to Vits slightly larger mass window
 171                                Int_t nInvM = 200, Float_t invMMin = 1.05,  Float_t invMMax = 1.25,
 172                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20.,
 173                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
 174                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
 175
 176   { fFFIMLaNBinsJetPt = nJetPt; fFFIMLaJetPtMin = jetPtMin; fFFIMLaJetPtMax = jetPtMax;
 177     fFFIMLaNBinsInvM = nInvM; fFFIMLaInvMMin = invMMin; fFFIMLaInvMMax = invMMax; fFFIMLaNBinsPt = nPt; fFFIMLaPtMin = ptMin; fFFIMLaPtMax = ptMax;
 178     fFFIMLaNBinsXi = nXi; fFFIMLaXiMin = xiMin; fFFIMLaXiMax = xiMax; fFFIMLaNBinsZ  = nZ;  fFFIMLaZMin  = zMin;  fFFIMLaZMax  = zMax; }
 179
 180
 181   //TRandom3* nRandom; //random number for UE estimation
 182
 183   // consts
 184
 185
 186   //--
 187   TRandom3* fRandom;          // TRandom3 for background estimation
 188   Bool_t   fAnalysisMC;
 189   Double_t fDeltaVertexZ;
 190   Double_t fCutjetEta;
 191   Double_t fCuttrackNegNcls;
 192   Double_t fCuttrackPosNcls;
 193   Double_t fCutPostrackRap;
 194   Double_t fCutNegtrackRap;
 195   Double_t fCutRap;
 196   Double_t fCutPostrackEta;
 197   Double_t fCutNegtrackEta;
 198   Double_t fCutEta;
 199   Double_t fCutV0cosPointAngle;
 200   Bool_t   fKinkDaughters;
 201   Bool_t   fRequireTPCRefit;
 202   Double_t fCutArmenteros;
 203   Double_t fCutV0DecayMin;
 204   Double_t fCutV0DecayMax;
 205   Double_t fCutV0totMom;
 206   Double_t fCutDcaV0Daughters;
 207   Double_t fCutDcaPosToPrimVertex;
 208   Double_t fCutDcaNegToPrimVertex;
 209   Double_t fCutV0RadiusMin;
 210   Double_t fCutV0RadiusMax;
 211   Double_t fCutBetheBloch;
 212   Double_t fCutRatio;
 213
 214   // cuts
 215   void SetCuttrackPosNcls(Double_t posNcls){fCuttrackPosNcls=posNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosNcls %f",posNcls);}
 216   void SetCuttrackNegNcls(Double_t negNcls){fCuttrackNegNcls=negNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegNcls %f",negNcls);}
 217   void SetCuttrackPosRap(Double_t posRap){fCutPostrackRap=posRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosRap %f",posRap);}
 218   void SetCuttrackNegRap(Double_t negRap){fCutNegtrackRap=negRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegRap %f",negRap);}
 219   void SetCutV0Rap(Double_t v0Rap){fCutRap=v0Rap; Printf("AliAnalysisTaskJetChem:: SetCutV0Rap %f",v0Rap);}
 220   void SetCuttrackPosEta(Double_t posEta){fCutPostrackEta=posEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosEta %f",posEta);}
 221   void SetCuttrackNegEta(Double_t negEta){fCutNegtrackEta=negEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegEta %f",negEta);}
 222   void SetCutV0Eta(Double_t v0Eta){fCutEta=v0Eta; Printf("AliAnalysisTaskJetChem:: SetCutV0Eta %f",v0Eta);}
 223   void SetCutJetEta(Double_t jetEta){fCutjetEta=jetEta; Printf("AliAnalysisTaskJetChem:: SetCutjetEta %f",jetEta);}
 224   void SetCosOfPointingAngle(Double_t cospointAng){fCutV0cosPointAngle=cospointAng; Printf("AliAnalysisTaskJetChem:: SetCosOfPointingAngle %f",cospointAng);}
 225   void SetAcceptKinkDaughters(Bool_t isKinkDaughtersAccepted){fKinkDaughters=isKinkDaughtersAccepted; Printf("AliAnalysisTaskJetChem:: SetAcceptKinkDaughters %i", isKinkDaughtersAccepted);}
 226   void SetRequireTPCRefit(Bool_t isTPCRefit){fRequireTPCRefit=isTPCRefit; Printf("AliAnalysisTaskJetChem:: SetRequireTPCRefit %i", isTPCRefit);}
 227   void SetCutArmenteros(Double_t armenteros){fCutArmenteros=armenteros; Printf("AliAnalysisTaskJetChem:: SetCutArmenteros %f", armenteros);}
 228   void SetCutV0DecayMin(Double_t decayMin){fCutV0DecayMin=decayMin; Printf("AliAnalysisTaskJetChem:: SetCutDecayMin %f", decayMin);}
 229   void SetCutV0DecayMax(Double_t decayMax){fCutV0DecayMax=decayMax; Printf("AliAnalysisTaskJetChem:: SetCutDecayMax %f", decayMax);}
 230   void SetCutV0totMom(Double_t v0totMom){fCutV0totMom=v0totMom; Printf("AliAnalysisTaskJetChem:: SetCutV0totMom %f", v0totMom);}
 231   void SetCutDcaV0Daughters(Double_t dcav0daughters){fCutDcaV0Daughters=dcav0daughters; Printf("AliAnalysisTaskJetChem:: SetCutDcaV0Daughters %f", dcav0daughters);}
 232   void SetCutDcaPosToPrimVertex(Double_t dcaPosToPrimVertex){fCutDcaPosToPrimVertex=dcaPosToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaPosToPrimVertex %f", dcaPosToPrimVertex);}
 233   void SetCutDcaNegToPrimVertex(Double_t dcaNegToPrimVertex){fCutDcaNegToPrimVertex=dcaNegToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaNegToPrimVertex %f", dcaNegToPrimVertex);}
 234   void SetCutV0RadiusMin(Double_t v0RadiusMin){fCutV0RadiusMin=v0RadiusMin; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMin %f", v0RadiusMin);}
 235   void SetCutV0RadiusMax(Double_t v0RadiusMax){fCutV0RadiusMax=v0RadiusMax; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMax %f", v0RadiusMax);}
 236   void SetCutBetheBloch(Double_t cutBetheBloch){fCutBetheBloch=cutBetheBloch; Printf("AliAnalysisTaskJetChem:: SetCutBetheBloch %f", cutBetheBloch);}
 237   void SetCutRatioTPC(Double_t cutRatioTPC){fCutRatio=cutRatioTPC; Printf("AliAnalysisTaskJetChem:: SetCutRatioTPC %f", cutRatioTPC);}
 238   void SetAnalysisMC(Bool_t analysisMC) {fAnalysisMC = analysisMC;}
 239   void SetDeltaZVertexCut(Float_t deltaVtxZ){fDeltaVertexZ = deltaVtxZ;}
 240
 241  private:
 242
 243   Int_t fK0Type;                                           // K0 cuts
 244   UInt_t fFilterMaskK0;                                    //! K0 legs cuts
 245   TList* fListK0s;                                         //! K0 list
 246   AliPIDResponse *fPIDResponse;                            // PID
 247
 248   AliFragFuncQATrackHistos*  fV0QAK0;                      //! track QA: V0s in K0 inv mass range
 249   AliFragFuncHistos*         fFFHistosRecCutsK0Evt;        //! inclusive FF for K0 evt
 250   //AliFragFuncHistosInvMass*  fFFHistosIMK0AllEvt;          //! K0 pt spec for all events
 251   //AliFragFuncHistosInvMass*  fFFHistosIMK0Jet;             //! K0 FF all dPhi
 252   //AliFragFuncHistosInvMass*  fFFHistosIMK0Cone;            //! K0 FF jet cone
 253
 254   Int_t fLaType;                                           // La cuts
 255   UInt_t fFilterMaskLa;                                    //! La legs cuts
 256   TList* fListLa;                                          //! La list
 257
 258   //AliFragFuncHistosInvMass*  fFFHistosIMLaAllEvt;          //! La pt spec for all events
 259   //AliFragFuncHistosInvMass*  fFFHistosIMLaJet;             //! La FF all dPhi
 260   //AliFragFuncHistosInvMass*  fFFHistosIMLaCone;            //! La FF jet cone
 261
 262   Int_t fALaType;                                          // ALa cuts
 263
 264   UInt_t fFilterMaskALa;                                   //! ALa legs cuts
 265   TList* fListALa;                                         //! ALa list
 266   TList* fListFeeddownLaCand;                              //! feeddown from Xi (-,0)
 267   TList* fListFeeddownALaCand;                             //! feeddown from Xibar (+,0)
 268   TList* jetConeFDLalist;                                  //! feeddown from Xi (-,0) in jet cone
 269   TList* jetConeFDALalist;                                 //! feeddown from Xibar (+,0) in jet cone
 270   TList* fListMCgenK0s;                                    //! MC generated K0s
 271   TList* fListMCgenLa;                                     //! MC generated La
 272   TList* fListMCgenALa;                                    //! MC generated ALa
 273   TList* fListMCgenK0sCone;                                //! MC generated K0s in cone around jet axis, particles are from fragmentation but also from underlying event
 274   TList* fListMCgenLaCone;                                 //! MC generated Lambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 275   TList* fListMCgenALaCone;                                //! MC generated Antilambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 276
 277   Bool_t IsArmenterosSelected;                             //Armenteros-Podolanski Cut (is/isn't) applied
 278
 279   //AliFragFuncHistosInvMass*  fFFHistosIMALaAllEvt;          //! ALa pt spec for all events
 280   //AliFragFuncHistosInvMass*  fFFHistosIMALaJet;             //! ALa FF all dPhi
 281   // AliFragFuncHistosInvMass*  fFFHistosIMALaCone;            //! ALa FF jet cone
 282
 283   // histogram bins
 284
 285
 286
 287   //--K0s
 288
 289   Int_t   fFFIMNBinsJetPt;    // FF histos bins
 290   Float_t fFFIMJetPtMin;      // FF histos limits
 291   Float_t fFFIMJetPtMax;      // FF histos limits
 292
 293   Int_t   fFFIMNBinsInvM;     // FF histos bins
 294   Float_t fFFIMInvMMin;       // FF histos bins
 295   Float_t fFFIMInvMMax;       // FF histos bins
 296
 297   Int_t   fFFIMNBinsPt;       // FF histos bins
 298   Float_t fFFIMPtMin;         // FF histos limits
 299   Float_t fFFIMPtMax;         // FF histos limits
 300
 301   Int_t   fFFIMNBinsXi;       // FF histos bins
 302   Float_t fFFIMXiMin;         // FF histos limits
 303   Float_t fFFIMXiMax;         // FF histos limits
 304
 305   Int_t   fFFIMNBinsZ;        // FF histos bins
 306   Float_t fFFIMZMin;          // FF histos limits
 307   Float_t fFFIMZMax;          // FF histos limits
 308
 309   //--La
 310
 311   Int_t   fFFIMLaNBinsJetPt;    // FF histos bins
 312   Float_t fFFIMLaJetPtMin;      // FF histos limits
 313   Float_t fFFIMLaJetPtMax;      // FF histos limits
 314
 315   Int_t   fFFIMLaNBinsInvM;     // FF histos bins
 316   Float_t fFFIMLaInvMMin;       // FF histos bins
 317   Float_t fFFIMLaInvMMax;       // FF histos bins
 318
 319   Int_t   fFFIMLaNBinsPt;       // FF histos bins
 320   Float_t fFFIMLaPtMin;         // FF histos limits
 321   Float_t fFFIMLaPtMax;         // FF histos limits
 322
 323   Int_t   fFFIMLaNBinsXi;       // FF histos bins
 324   Float_t fFFIMLaXiMin;         // FF histos limits
 325   Float_t fFFIMLaXiMax;         // FF histos limits
 326
 327   Int_t   fFFIMLaNBinsZ;        // FF histos bins
 328   Float_t fFFIMLaZMin;          // FF histos limits
 329   Float_t fFFIMLaZMax;          // FF histos limits
 330
 331
 332
 333   // Histograms
 334
 335   TH1F* fh1EvtAllCent;
 336   TH1F* fh1Evt;
 337   TH1F* fh1K0Mult;
 338   TH1F* fh1dPhiJetK0;
 339   TH1F* fh1LaMult;
 340   TH1F* fh1dPhiJetLa;
 341   TH1F* fh1ALaMult;
 342   TH1F* fh1dPhiJetALa;
 343   TH1F* fh1JetEta;
 344   TH1F* fh1JetPhi;
 345   TH2F* fh2JetEtaPhi;
 346   // TH1F* fh1V0JetPt;
 347   TH1F* fh1IMK0Cone; //jet pt distribution for normalisation by number of jets
 348   TH1F* fh1IMLaCone;
 349   TH1F* fh1IMALaCone;
 350   TH2F* fh2FFJetTrackEta; //charged jet track eta distribution
 351   //  TH1F* fh1trackPosNCls;
 352   //  TH1F* fh1trackNegNCls;
 353   TH1F* fh1trackPosRap;
 354   TH1F* fh1trackNegRap;
 355   // TH1F* fh1V0Rap;
 356   TH1F* fh1trackPosEta;
 357   TH1F* fh1trackNegEta;
 358   TH1F* fh1V0Eta;
 359   // TH1F* fh1V0totMom;
 360   TH1F* fh1CosPointAngle;
 361   TH1F* fh1DecayLengthV0;
 362   TH2F* fh2ProperLifetimeK0sVsPtBeforeCut;
 363   TH2F* fh2ProperLifetimeK0sVsPtAfterCut;
 364   TH1F* fh1V0Radius;
 365   TH1F* fh1DcaV0Daughters;
 366   TH1F* fh1DcaPosToPrimVertex;
 367   TH1F* fh1DcaNegToPrimVertex;
 368   TH2F* fh2ArmenterosBeforeCuts;
 369   TH2F* fh2ArmenterosAfterCuts;
 370   TH2F* fh2BBLaPos;
 371   TH2F* fh2BBLaNeg;
 372   TH1F* fh1PosDaughterCharge;
 373   TH1F* fh1NegDaughterCharge;
 374   TH1F* fh1PtMCK0s;
 375   TH1F* fh1PtMCLa;
 376   TH1F* fh1PtMCALa;
 377   TH1F* fh1EtaK0s;
 378   TH1F* fh1EtaLa;
 379   TH1F* fh1EtaALa;
 380   TH1F* fh1RC;
 381   TH1F* fh1RCBiasK0;
 382   TH1F* fh1RCBiasLa;
 383   TH1F* fh1RCBiasALa;
 384   TH1F* fh1MCC;
 385   TH1F* fh1OC;
 386   TH1F* fh1NJ;
 387   THnSparse* fhnInvMassEtaTrackPtK0s;
 388   THnSparse* fhnInvMassEtaTrackPtLa;
 389   THnSparse* fhnInvMassEtaTrackPtALa;
 390   TH1F* fh1TrackMultCone;
 391   TH2F* fh2TrackMultCone;
 392   THnSparse* fhnNJK0;
 393   THnSparse* fhnNJLa;
 394   THnSparse* fhnNJALa;
 395   //  TH2F* fh2MCgenK0Cone;
 396   //  TH2F* fh2MCgenLaCone;
 397   //  TH2F* fh2MCgenALaCone;
 398   //  TH2F* fh2MCEtagenK0Cone;
 399   //  TH2F* fh2MCEtagenLaCone;
 400   //  TH2F* fh2MCEtagenALaCone;
 401   TH2F* fh2CorrHijingLaProton;
 402   TH2F* fh2CorrInjectLaProton;
 403   TH2F* fh2CorrHijingALaAProton;
 404   TH2F* fh2CorrInjectALaAProton;
 405   TH1F* fh1IMK0ConeSmear; //histos for normalisation by number of smeared jets
 406   TH1F* fh1IMLaConeSmear;
 407   TH1F* fh1IMALaConeSmear;
 408   TH2F* fh2MCEtaVsPtHijingLa;
 409   TH2F* fh2MCEtaVsPtInjectLa;
 410   TH2F* fh2MCEtaVsPtHijingALa;
 411   TH2F* fh2MCEtaVsPtInjectALa;
 412   THnSparse* fhnrecMCHijingLaIncl;
 413   THnSparse* fhnrecMCHijingLaCone;
 414   THnSparse* fhnrecMCHijingALaIncl;
 415   THnSparse* fhnrecMCHijingALaCone;
 416   THnSparse* fhnrecMCInjectLaIncl;
 417   THnSparse* fhnrecMCInjectLaCone;
 418   THnSparse* fhnrecMCInjectALaIncl;
 419   THnSparse* fhnrecMCInjectALaCone;
 420   THnSparse* fhnMCrecK0Cone;
 421   THnSparse* fhnMCrecLaCone;
 422   THnSparse* fhnMCrecALaCone;
 423   THnSparse* fhnMCrecK0ConeSmear;
 424   THnSparse* fhnMCrecLaConeSmear;
 425   THnSparse* fhnMCrecALaConeSmear;
 426   THnSparse* fhnK0sSecContinCone;
 427   THnSparse* fhnLaSecContinCone;
 428   THnSparse* fhnALaSecContinCone;
 429   THnSparse* fhnK0sIncl;
 430   THnSparse* fhnK0sCone;
 431   THnSparse* fhnLaIncl;
 432   THnSparse* fhnLaCone;
 433   THnSparse* fhnALaIncl;
 434   THnSparse* fhnALaCone;
 435   THnSparse* fhnK0sPC;
 436   THnSparse* fhnLaPC;
 437   THnSparse* fhnALaPC;
 438   THnSparse* fhnK0sMCC;
 439   THnSparse* fhnLaMCC;
 440   THnSparse* fhnALaMCC;
 441   THnSparse* fhnK0sRC;
 442   THnSparse* fhnLaRC;
 443   THnSparse* fhnALaRC;
 444   THnSparse* fhnK0sRCBias;
 445   THnSparse* fhnLaRCBias;
 446   THnSparse* fhnALaRCBias;
 447   THnSparse* fhnK0sOC;
 448   THnSparse* fhnLaOC;
 449   THnSparse* fhnALaOC;
 450   TH1F* fh1AreaExcluded;
 451   TH1F* fh1MedianEta;
 452   TH1F* fh1JetPtMedian; //for normalisation by total number of median cluster jets TH3F* fh3IMALaMedianCone;
 453   TH1F* fh1MCMultiplicityPrimary;
 454   TH1F* fh1MCMultiplicityTracks;
 455   THnSparse* fhnFeedDownLa;
 456   THnSparse* fhnFeedDownALa;
 457   THnSparse* fhnFeedDownLaCone;
 458   THnSparse* fhnFeedDownALaCone;
 459   TH1F* fh1MCProdRadiusK0s;
 460   TH1F* fh1MCProdRadiusLambda;
 461   TH1F* fh1MCProdRadiusAntiLambda;
 462   TH1F* fh1MCPtV0s;
 463   TH1F* fh1MCPtK0s;
 464   TH1F* fh1MCPtLambda;
 465   TH1F* fh1MCPtAntiLambda;
 466   TH1F* fh1MCXiPt;
 467   TH1F* fh1MCXibarPt;
 468   TH2F* fh2MCEtaVsPtK0s;
 469   TH2F* fh2MCEtaVsPtLa;
 470   TH2F* fh2MCEtaVsPtALa;
 471   // TH1F* fh1MCRapK0s;
 472   //TH1F* fh1MCRapLambda;
 473   //TH1F* fh1MCRapAntiLambda;
 474   TH1F* fh1MCEtaAllK0s;
 475   TH1F* fh1MCEtaK0s;
 476   TH1F* fh1MCEtaLambda;
 477   TH1F* fh1MCEtaAntiLambda;
 478
 479
 480   ClassDef(AliAnalysisTaskJetChem, 3);
 481 };
 482
 483 #endif
 484
 485