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
 244
 245
 246
 247   Int_t fK0Type;                                           // K0 cuts
 248   UInt_t fFilterMaskK0;
 249   TList* jettracklist;
 250   TList* jetConeK0list;
 251   TList* jetConeLalist;
 252   TList* jetConeALalist;
 253   TList* jetPerpConeK0list;
 254   TList* jetPerpConeLalist;
 255   TList* jetPerpConeALalist;
 256   TList* jetMedianConeK0list;
 257   TList* jetMedianConeLalist;
 258   TList* jetMedianConeALalist;
 259   TList* fListK0sRC;
 260   TList* fListLaRC;
 261   TList* fListALaRC;
 262
 263                                   //! K0 legs cuts
 264   TList* fListK0s;                                         //! K0 list
 265   AliPIDResponse *fPIDResponse;                            // PID
 266
 267   AliFragFuncQATrackHistos*  fV0QAK0;                      //! track QA: V0s in K0 inv mass range
 268   AliFragFuncHistos*         fFFHistosRecCutsK0Evt;        //! inclusive FF for K0 evt
 269   //AliFragFuncHistosInvMass*  fFFHistosIMK0AllEvt;          //! K0 pt spec for all events
 270   //AliFragFuncHistosInvMass*  fFFHistosIMK0Jet;             //! K0 FF all dPhi
 271   //AliFragFuncHistosInvMass*  fFFHistosIMK0Cone;            //! K0 FF jet cone
 272
 273   Int_t fLaType;                                           // La cuts
 274   UInt_t fFilterMaskLa;                                    //! La legs cuts
 275   TList* fListLa;                                          //! La list
 276
 277   //AliFragFuncHistosInvMass*  fFFHistosIMLaAllEvt;          //! La pt spec for all events
 278   //AliFragFuncHistosInvMass*  fFFHistosIMLaJet;             //! La FF all dPhi
 279   //AliFragFuncHistosInvMass*  fFFHistosIMLaCone;            //! La FF jet cone
 280
 281   Int_t fALaType;                                          // ALa cuts
 282
 283   UInt_t fFilterMaskALa;                                   //! ALa legs cuts
 284   TList* fListALa;                                         //! ALa list
 285   TList* fListFeeddownLaCand;                              //! feeddown from Xi (-,0)
 286   TList* fListFeeddownALaCand;                             //! feeddown from Xibar (+,0)
 287   TList* jetConeFDLalist;                                  //! feeddown from Xi (-,0) in jet cone
 288   TList* jetConeFDALalist;                                 //! feeddown from Xibar (+,0) in jet cone
 289   TList* fListMCgenK0s;                                    //! MC generated K0s
 290   TList* fListMCgenLa;                                     //! MC generated La
 291   TList* fListMCgenALa;                                    //! MC generated ALa
 292   TList* fListMCgenK0sCone;                                //! MC generated K0s in cone around jet axis, particles are from fragmentation but also from underlying event
 293   TList* fListMCgenLaCone;                                 //! MC generated Lambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 294   TList* fListMCgenALaCone;                                //! MC generated Antilambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 295
 296   Bool_t IsArmenterosSelected;                             //Armenteros-Podolanski Cut (is/isn't) applied
 297
 298   //AliFragFuncHistosInvMass*  fFFHistosIMALaAllEvt;          //! ALa pt spec for all events
 299   //AliFragFuncHistosInvMass*  fFFHistosIMALaJet;             //! ALa FF all dPhi
 300   // AliFragFuncHistosInvMass*  fFFHistosIMALaCone;            //! ALa FF jet cone
 301
 302   // histogram bins
 303
 304
 305
 306   //--K0s
 307
 308   Int_t   fFFIMNBinsJetPt;    // FF histos bins
 309   Float_t fFFIMJetPtMin;      // FF histos limits
 310   Float_t fFFIMJetPtMax;      // FF histos limits
 311
 312   Int_t   fFFIMNBinsInvM;     // FF histos bins
 313   Float_t fFFIMInvMMin;       // FF histos bins
 314   Float_t fFFIMInvMMax;       // FF histos bins
 315
 316   Int_t   fFFIMNBinsPt;       // FF histos bins
 317   Float_t fFFIMPtMin;         // FF histos limits
 318   Float_t fFFIMPtMax;         // FF histos limits
 319
 320   Int_t   fFFIMNBinsXi;       // FF histos bins
 321   Float_t fFFIMXiMin;         // FF histos limits
 322   Float_t fFFIMXiMax;         // FF histos limits
 323
 324   Int_t   fFFIMNBinsZ;        // FF histos bins
 325   Float_t fFFIMZMin;          // FF histos limits
 326   Float_t fFFIMZMax;          // FF histos limits
 327
 328   //--La
 329
 330   Int_t   fFFIMLaNBinsJetPt;    // FF histos bins
 331   Float_t fFFIMLaJetPtMin;      // FF histos limits
 332   Float_t fFFIMLaJetPtMax;      // FF histos limits
 333
 334   Int_t   fFFIMLaNBinsInvM;     // FF histos bins
 335   Float_t fFFIMLaInvMMin;       // FF histos bins
 336   Float_t fFFIMLaInvMMax;       // FF histos bins
 337
 338   Int_t   fFFIMLaNBinsPt;       // FF histos bins
 339   Float_t fFFIMLaPtMin;         // FF histos limits
 340   Float_t fFFIMLaPtMax;         // FF histos limits
 341
 342   Int_t   fFFIMLaNBinsXi;       // FF histos bins
 343   Float_t fFFIMLaXiMin;         // FF histos limits
 344   Float_t fFFIMLaXiMax;         // FF histos limits
 345
 346   Int_t   fFFIMLaNBinsZ;        // FF histos bins
 347   Float_t fFFIMLaZMin;          // FF histos limits
 348   Float_t fFFIMLaZMax;          // FF histos limits
 349
 350
 351
 352   // Histograms
 353
 354   TH1F* fh1EvtAllCent;
 355   TH1F* fh1Evt;
 356   TH1F* fh1K0Mult;
 357   TH1F* fh1dPhiJetK0;
 358   TH1F* fh1LaMult;
 359   TH1F* fh1dPhiJetLa;
 360   TH1F* fh1ALaMult;
 361   TH1F* fh1dPhiJetALa;
 362   TH1F* fh1JetEta;
 363   TH1F* fh1JetPhi;
 364   TH2F* fh2JetEtaPhi;
 365   // TH1F* fh1V0JetPt;
 366   TH1F* fh1IMK0Cone; //jet pt distribution for normalisation by number of jets
 367   TH1F* fh1IMLaCone;
 368   TH1F* fh1IMALaCone;
 369   TH2F* fh2FFJetTrackEta; //charged jet track eta distribution
 370   //  TH1F* fh1trackPosNCls;
 371   //  TH1F* fh1trackNegNCls;
 372   TH1F* fh1trackPosRap;
 373   TH1F* fh1trackNegRap;
 374   // TH1F* fh1V0Rap;
 375   TH1F* fh1trackPosEta;
 376   TH1F* fh1trackNegEta;
 377   TH1F* fh1V0Eta;
 378   // TH1F* fh1V0totMom;
 379   TH1F* fh1CosPointAngle;
 380   TH1F* fh1DecayLengthV0;
 381   TH2F* fh2ProperLifetimeK0sVsPtBeforeCut;
 382   TH2F* fh2ProperLifetimeK0sVsPtAfterCut;
 383   TH1F* fh1V0Radius;
 384   TH1F* fh1DcaV0Daughters;
 385   TH1F* fh1DcaPosToPrimVertex;
 386   TH1F* fh1DcaNegToPrimVertex;
 387   TH2F* fh2ArmenterosBeforeCuts;
 388   TH2F* fh2ArmenterosAfterCuts;
 389   TH2F* fh2BBLaPos;
 390   TH2F* fh2BBLaNeg;
 391   TH1F* fh1PosDaughterCharge;
 392   TH1F* fh1NegDaughterCharge;
 393   TH1F* fh1PtMCK0s;
 394   TH1F* fh1PtMCLa;
 395   TH1F* fh1PtMCALa;
 396   TH1F* fh1EtaK0s;
 397   TH1F* fh1EtaLa;
 398   TH1F* fh1EtaALa;
 399   TH1F* fh1RC;
 400   TH1F* fh1RCBiasK0;
 401   TH1F* fh1RCBiasLa;
 402   TH1F* fh1RCBiasALa;
 403   TH1F* fh1MCC;
 404   TH1F* fh1OC;
 405   TH1F* fh1NJ;
 406   THnSparse* fhnInvMassEtaTrackPtK0s;
 407   THnSparse* fhnInvMassEtaTrackPtLa;
 408   THnSparse* fhnInvMassEtaTrackPtALa;
 409   TH1F* fh1TrackMultCone;
 410   TH2F* fh2TrackMultCone;
 411   THnSparse* fhnNJK0;
 412   THnSparse* fhnNJLa;
 413   THnSparse* fhnNJALa;
 414   //  TH2F* fh2MCgenK0Cone;
 415   //  TH2F* fh2MCgenLaCone;
 416   //  TH2F* fh2MCgenALaCone;
 417   //  TH2F* fh2MCEtagenK0Cone;
 418   //  TH2F* fh2MCEtagenLaCone;
 419   //  TH2F* fh2MCEtagenALaCone;
 420   TH2F* fh2CorrHijingLaProton;
 421   TH2F* fh2CorrInjectLaProton;
 422   TH2F* fh2CorrHijingALaAProton;
 423   TH2F* fh2CorrInjectALaAProton;
 424   TH1F* fh1IMK0ConeSmear; //histos for normalisation by number of smeared jets
 425   TH1F* fh1IMLaConeSmear;
 426   TH1F* fh1IMALaConeSmear;
 427   TH2F* fh2MCEtaVsPtHijingLa;
 428   TH2F* fh2MCEtaVsPtInjectLa;
 429   TH2F* fh2MCEtaVsPtHijingALa;
 430   TH2F* fh2MCEtaVsPtInjectALa;
 431   THnSparse* fhnrecMCHijingLaIncl;
 432   THnSparse* fhnrecMCHijingLaCone;
 433   THnSparse* fhnrecMCHijingALaIncl;
 434   THnSparse* fhnrecMCHijingALaCone;
 435   THnSparse* fhnrecMCInjectLaIncl;
 436   THnSparse* fhnrecMCInjectLaCone;
 437   THnSparse* fhnrecMCInjectALaIncl;
 438   THnSparse* fhnrecMCInjectALaCone;
 439   THnSparse* fhnMCrecK0Cone;
 440   THnSparse* fhnMCrecLaCone;
 441   THnSparse* fhnMCrecALaCone;
 442   THnSparse* fhnMCrecK0ConeSmear;
 443   THnSparse* fhnMCrecLaConeSmear;
 444   THnSparse* fhnMCrecALaConeSmear;
 445   THnSparse* fhnK0sSecContinCone;
 446   THnSparse* fhnLaSecContinCone;
 447   THnSparse* fhnALaSecContinCone;
 448   THnSparse* fhnK0sIncl;
 449   THnSparse* fhnK0sCone;
 450   THnSparse* fhnLaIncl;
 451   THnSparse* fhnLaCone;
 452   THnSparse* fhnALaIncl;
 453   THnSparse* fhnALaCone;
 454   THnSparse* fhnK0sPC;
 455   THnSparse* fhnLaPC;
 456   THnSparse* fhnALaPC;
 457   THnSparse* fhnK0sMCC;
 458   THnSparse* fhnLaMCC;
 459   THnSparse* fhnALaMCC;
 460   THnSparse* fhnK0sRC;
 461   THnSparse* fhnLaRC;
 462   THnSparse* fhnALaRC;
 463   THnSparse* fhnK0sRCBias;
 464   THnSparse* fhnLaRCBias;
 465   THnSparse* fhnALaRCBias;
 466   THnSparse* fhnK0sOC;
 467   THnSparse* fhnLaOC;
 468   THnSparse* fhnALaOC;
 469   TH1F* fh1AreaExcluded;
 470   TH1F* fh1MedianEta;
 471   TH1F* fh1JetPtMedian; //for normalisation by total number of median cluster jets TH3F* fh3IMALaMedianCone;
 472   TH1F* fh1MCMultiplicityPrimary;
 473   TH1F* fh1MCMultiplicityTracks;
 474   THnSparse* fhnFeedDownLa;
 475   THnSparse* fhnFeedDownALa;
 476   THnSparse* fhnFeedDownLaCone;
 477   THnSparse* fhnFeedDownALaCone;
 478   TH1F* fh1MCProdRadiusK0s;
 479   TH1F* fh1MCProdRadiusLambda;
 480   TH1F* fh1MCProdRadiusAntiLambda;
 481   TH1F* fh1MCPtV0s;
 482   TH1F* fh1MCPtK0s;
 483   TH1F* fh1MCPtLambda;
 484   TH1F* fh1MCPtAntiLambda;
 485   TH1F* fh1MCXiPt;
 486   TH1F* fh1MCXibarPt;
 487   TH2F* fh2MCEtaVsPtK0s;
 488   TH2F* fh2MCEtaVsPtLa;
 489   TH2F* fh2MCEtaVsPtALa;
 490   // TH1F* fh1MCRapK0s;
 491   //TH1F* fh1MCRapLambda;
 492   //TH1F* fh1MCRapAntiLambda;
 493   TH1F* fh1MCEtaAllK0s;
 494   TH1F* fh1MCEtaK0s;
 495   TH1F* fh1MCEtaLambda;
 496   TH1F* fh1MCEtaAntiLambda;
 497
 498
 499   ClassDef(AliAnalysisTaskJetChem, 3);
 500 };
 501
 502 #endif
 503
 504