added jetArea Cut in FF task, moved from TH3F to THnSparse in JetChem task, added...
[u/mrichter/AliRoot.git] / 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);
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  IsTrackInjected(AliAODv0 *v0, AliAODMCHeader *header, TClonesArray *arrayMC);
121   TString GetGenerator(Int_t label, AliAODMCHeader* header);
122   Double_t SmearJetPt(Double_t jetPt, Int_t cl, Double_t jetRadius, Double_t ptmintrack, Double_t& jetPtSmear);
123   Bool_t IsParticleInCone(const AliVParticle* part1, const AliVParticle* part2, Double_t dRMax) const;
124   Bool_t IsRCJCOverlap(TList* recjetlist, const AliVParticle* part, Double_t dDistance) const;
125   AliAODJet* GetRandomCone(TList* jetlist, Double_t dEtaConeMax, Double_t dDistance) const;
126
127   AliAODJet* GetMedianCluster();
128   Double_t AreaCircSegment(Double_t dRadius, Double_t dDistance) const;  
129
130
131   virtual void SetK0Type(Int_t i){ fK0Type = i; }
132   virtual void SetFilterMaskK0(UInt_t i) {fFilterMaskK0 = i;}
133
134   Bool_t IsLaInvMass(Double_t mass) const; //La and ALa mass check
135   virtual void SetLaType(Int_t i){ fLaType = i; }
136   virtual void SetFilterMaskLa(UInt_t i) {fFilterMaskLa = i;}
137
138   virtual void SetALaType(Int_t i){ fALaType = i; }
139   virtual void SetFilterMaskALa(UInt_t i) {fFilterMaskALa = i;}
140
141   virtual void SetSelectArmenteros(Bool_t b) {IsArmenterosSelected = b;}
142   //virtual void SetEventSelectionMask(UInt_t i){fEvtSelectionMask = i;}  //already inherited by AliAnalysisFragmentationFunctionTask
143   //virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;} //already inherited by AliAnalysisFragmentationFunctionTask
144
145   void CalculateInvMass(AliAODv0* v0vtx, Int_t particletype, Double_t& invM, Double_t& trackPt);
146   
147   Bool_t AcceptBetheBloch(AliAODv0 *v0, AliPIDResponse *PIDResponse, Int_t particletype); //don't use this method for MC Analysis
148
149
150   Double_t MyRapidity(Double_t rE, Double_t rPz) const;
151
152   //-- K0s
153
154   void   SetFFInvMassHistoBins(Int_t nJetPt = 19, Float_t jetPtMin = 5., Float_t jetPtMax = 100., //previous 19, 5.,100.
155                                Int_t nInvM = 400, Float_t invMMin = 0.3,  Float_t invMMax = 0.7, //previous 0.4 to 0.6
156                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20.,         //previous 0. to 10.
157                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
158                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
159   { fFFIMNBinsJetPt = nJetPt; fFFIMJetPtMin = jetPtMin; fFFIMJetPtMax = jetPtMax; 
160     fFFIMNBinsInvM = nInvM; fFFIMInvMMin = invMMin; fFFIMInvMMax = invMMax; fFFIMNBinsPt = nPt; fFFIMPtMin = ptMin; fFFIMPtMax = ptMax; 
161     fFFIMNBinsXi = nXi; fFFIMXiMin = xiMin; fFFIMXiMax = xiMax; fFFIMNBinsZ  = nZ;  fFFIMZMin  = zMin;  fFFIMZMax  = zMax; }
162
163
164   
165   // --La and ALa
166
167   void   SetFFInvMassLaHistoBins(Int_t nJetPt = 19, Float_t jetPtMin = 5., Float_t jetPtMax = 100., //La
168                                  //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
169                                Int_t nInvM = 200, Float_t invMMin = 1.05,  Float_t invMMax = 1.25,
170                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20., 
171                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
172                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
173
174   { fFFIMLaNBinsJetPt = nJetPt; fFFIMLaJetPtMin = jetPtMin; fFFIMLaJetPtMax = jetPtMax; 
175     fFFIMLaNBinsInvM = nInvM; fFFIMLaInvMMin = invMMin; fFFIMLaInvMMax = invMMax; fFFIMLaNBinsPt = nPt; fFFIMLaPtMin = ptMin; fFFIMLaPtMax = ptMax; 
176     fFFIMLaNBinsXi = nXi; fFFIMLaXiMin = xiMin; fFFIMLaXiMax = xiMax; fFFIMLaNBinsZ  = nZ;  fFFIMLaZMin  = zMin;  fFFIMLaZMax  = zMax; }
177
178
179   //TRandom3* nRandom; //random number for UE estimation
180
181   // consts
182
183  
184   //--
185   TRandom3* fRandom;          // TRandom3 for background estimation 
186   Bool_t   fAnalysisMC;
187   Double_t fDeltaVertexZ;
188   Double_t fCutjetEta;
189   Double_t fCuttrackNegNcls;
190   Double_t fCuttrackPosNcls; 
191   Double_t fCutPostrackRap;
192   Double_t fCutNegtrackRap;
193   Double_t fCutRap;
194   Double_t fCutPostrackEta;
195   Double_t fCutNegtrackEta;
196   Double_t fCutEta;
197   Double_t fCutV0cosPointAngle;
198   Bool_t   fKinkDaughters;
199   Bool_t   fRequireTPCRefit;
200   Double_t fCutArmenteros; 
201   Double_t fCutV0DecayMin;
202   Double_t fCutV0DecayMax;
203   Double_t fCutV0totMom;
204   Double_t fCutDcaV0Daughters;
205   Double_t fCutDcaPosToPrimVertex;
206   Double_t fCutDcaNegToPrimVertex;
207   Double_t fCutV0RadiusMin;
208   Double_t fCutV0RadiusMax;
209   Double_t fCutBetheBloch;
210   Double_t fCutRatio;
211
212   // cuts
213   void SetCuttrackPosNcls(Double_t posNcls){fCuttrackPosNcls=posNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosNcls %f",posNcls);}
214   void SetCuttrackNegNcls(Double_t negNcls){fCuttrackNegNcls=negNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegNcls %f",negNcls);}
215   void SetCuttrackPosRap(Double_t posRap){fCutPostrackRap=posRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosRap %f",posRap);}
216   void SetCuttrackNegRap(Double_t negRap){fCutNegtrackRap=negRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegRap %f",negRap);}
217   void SetCutV0Rap(Double_t v0Rap){fCutRap=v0Rap; Printf("AliAnalysisTaskJetChem:: SetCutV0Rap %f",v0Rap);}
218   void SetCuttrackPosEta(Double_t posEta){fCutPostrackEta=posEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosEta %f",posEta);}
219   void SetCuttrackNegEta(Double_t negEta){fCutNegtrackEta=negEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegEta %f",negEta);}
220   void SetCutV0Eta(Double_t v0Eta){fCutEta=v0Eta; Printf("AliAnalysisTaskJetChem:: SetCutV0Eta %f",v0Eta);}
221   void SetCutJetEta(Double_t jetEta){fCutjetEta=jetEta; Printf("AliAnalysisTaskJetChem:: SetCutjetEta %f",jetEta);}
222   void SetCosOfPointingAngle(Double_t cospointAng){fCutV0cosPointAngle=cospointAng; Printf("AliAnalysisTaskJetChem:: SetCosOfPointingAngle %f",cospointAng);}
223   void SetAcceptKinkDaughters(Bool_t isKinkDaughtersAccepted){fKinkDaughters=isKinkDaughtersAccepted; Printf("AliAnalysisTaskJetChem:: SetAcceptKinkDaughters %i", isKinkDaughtersAccepted);}
224   void SetRequireTPCRefit(Bool_t isTPCRefit){fRequireTPCRefit=isTPCRefit; Printf("AliAnalysisTaskJetChem:: SetRequireTPCRefit %i", isTPCRefit);}
225   void SetCutArmenteros(Double_t armenteros){fCutArmenteros=armenteros; Printf("AliAnalysisTaskJetChem:: SetCutArmenteros %f", armenteros);}
226   void SetCutV0DecayMin(Double_t decayMin){fCutV0DecayMin=decayMin; Printf("AliAnalysisTaskJetChem:: SetCutDecayMin %f", decayMin);}
227   void SetCutV0DecayMax(Double_t decayMax){fCutV0DecayMax=decayMax; Printf("AliAnalysisTaskJetChem:: SetCutDecayMax %f", decayMax);}
228   void SetCutV0totMom(Double_t v0totMom){fCutV0totMom=v0totMom; Printf("AliAnalysisTaskJetChem:: SetCutV0totMom %f", v0totMom);}
229   void SetCutDcaV0Daughters(Double_t dcav0daughters){fCutDcaV0Daughters=dcav0daughters; Printf("AliAnalysisTaskJetChem:: SetCutDcaV0Daughters %f", dcav0daughters);}
230   void SetCutDcaPosToPrimVertex(Double_t dcaPosToPrimVertex){fCutDcaPosToPrimVertex=dcaPosToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaPosToPrimVertex %f", dcaPosToPrimVertex);}
231   void SetCutDcaNegToPrimVertex(Double_t dcaNegToPrimVertex){fCutDcaNegToPrimVertex=dcaNegToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaNegToPrimVertex %f", dcaNegToPrimVertex);}
232   void SetCutV0RadiusMin(Double_t v0RadiusMin){fCutV0RadiusMin=v0RadiusMin; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMin %f", v0RadiusMin);}
233   void SetCutV0RadiusMax(Double_t v0RadiusMax){fCutV0RadiusMax=v0RadiusMax; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMax %f", v0RadiusMax);}
234   void SetCutBetheBloch(Double_t cutBetheBloch){fCutBetheBloch=cutBetheBloch; Printf("AliAnalysisTaskJetChem:: SetCutBetheBloch %f", cutBetheBloch);}
235   void SetCutRatioTPC(Double_t cutRatioTPC){fCutRatio=cutRatioTPC; Printf("AliAnalysisTaskJetChem:: SetCutRatioTPC %f", cutRatioTPC);}
236   void SetAnalysisMC(Bool_t analysisMC) {fAnalysisMC = analysisMC;}
237   void SetDeltaZVertexCut(Float_t deltaVtxZ){fDeltaVertexZ = deltaVtxZ;}
238
239  private:
240   
241   Int_t fK0Type;                                           // K0 cuts
242   UInt_t fFilterMaskK0;                                    //! K0 legs cuts
243   TList* fListK0s;                                         //! K0 list 
244   AliPIDResponse *fPIDResponse;                            // PID
245
246   AliFragFuncQATrackHistos*  fV0QAK0;                      //! track QA: V0s in K0 inv mass range
247   AliFragFuncHistos*         fFFHistosRecCutsK0Evt;        //! inclusive FF for K0 evt
248   //AliFragFuncHistosInvMass*  fFFHistosIMK0AllEvt;          //! K0 pt spec for all events
249   //AliFragFuncHistosInvMass*  fFFHistosIMK0Jet;             //! K0 FF all dPhi   
250   //AliFragFuncHistosInvMass*  fFFHistosIMK0Cone;            //! K0 FF jet cone   
251   
252   Int_t fLaType;                                           // La cuts
253   UInt_t fFilterMaskLa;                                    //! La legs cuts
254   TList* fListLa;                                          //! La list 
255   
256   //AliFragFuncHistosInvMass*  fFFHistosIMLaAllEvt;          //! La pt spec for all events
257   //AliFragFuncHistosInvMass*  fFFHistosIMLaJet;             //! La FF all dPhi   
258   //AliFragFuncHistosInvMass*  fFFHistosIMLaCone;            //! La FF jet cone   
259   
260   Int_t fALaType;                                          // ALa cuts
261
262   UInt_t fFilterMaskALa;                                   //! ALa legs cuts
263   TList* fListALa;                                         //! ALa list 
264   TList* fListFeeddownLaCand;                              //! feeddown from Xi (-,0) 
265   TList* fListFeeddownALaCand;                             //! feeddown from Xibar (+,0) 
266   TList* jetConeFDLalist;                                  //! feeddown from Xi (-,0) in jet cone
267   TList* jetConeFDALalist;                                 //! feeddown from Xibar (+,0) in jet cone
268   TList* fListMCgenK0s;                                    //! MC generated K0s
269   TList* fListMCgenLa;                                     //! MC generated La                 
270   TList* fListMCgenALa;                                    //! MC generated ALa              
271   TList* fListMCgenK0sCone;                                //! MC generated K0s in cone around jet axis, particles are from fragmentation but also from underlying event  
272   TList* fListMCgenLaCone;                                 //! MC generated Lambdas in cone around jet axis, particles are from fragmentation but also from underlying event
273   TList* fListMCgenALaCone;                                //! MC generated Antilambdas in cone around jet axis, particles are from fragmentation but also from underlying event
274
275   Bool_t IsArmenterosSelected;                             //Armenteros-Podolanski Cut (is/isn't) applied  
276  
277   //AliFragFuncHistosInvMass*  fFFHistosIMALaAllEvt;          //! ALa pt spec for all events
278   //AliFragFuncHistosInvMass*  fFFHistosIMALaJet;             //! ALa FF all dPhi   
279   // AliFragFuncHistosInvMass*  fFFHistosIMALaCone;            //! ALa FF jet cone   
280   
281   // histogram bins 
282   
283  
284
285   //--K0s 
286   
287   Int_t   fFFIMNBinsJetPt;    // FF histos bins
288   Float_t fFFIMJetPtMin;      // FF histos limits
289   Float_t fFFIMJetPtMax;      // FF histos limits
290   
291   Int_t   fFFIMNBinsInvM;     // FF histos bins
292   Float_t fFFIMInvMMin;       // FF histos bins
293   Float_t fFFIMInvMMax;       // FF histos bins
294   
295   Int_t   fFFIMNBinsPt;       // FF histos bins
296   Float_t fFFIMPtMin;         // FF histos limits
297   Float_t fFFIMPtMax;         // FF histos limits
298   
299   Int_t   fFFIMNBinsXi;       // FF histos bins
300   Float_t fFFIMXiMin;         // FF histos limits
301   Float_t fFFIMXiMax;         // FF histos limits
302   
303   Int_t   fFFIMNBinsZ;        // FF histos bins
304   Float_t fFFIMZMin;          // FF histos limits
305   Float_t fFFIMZMax;          // FF histos limits
306   
307   //--La
308   
309   Int_t   fFFIMLaNBinsJetPt;    // FF histos bins
310   Float_t fFFIMLaJetPtMin;      // FF histos limits
311   Float_t fFFIMLaJetPtMax;      // FF histos limits
312   
313   Int_t   fFFIMLaNBinsInvM;     // FF histos bins
314   Float_t fFFIMLaInvMMin;       // FF histos bins
315   Float_t fFFIMLaInvMMax;       // FF histos bins
316   
317   Int_t   fFFIMLaNBinsPt;       // FF histos bins
318   Float_t fFFIMLaPtMin;         // FF histos limits
319   Float_t fFFIMLaPtMax;         // FF histos limits
320   
321   Int_t   fFFIMLaNBinsXi;       // FF histos bins
322   Float_t fFFIMLaXiMin;         // FF histos limits
323   Float_t fFFIMLaXiMax;         // FF histos limits
324   
325   Int_t   fFFIMLaNBinsZ;        // FF histos bins
326   Float_t fFFIMLaZMin;          // FF histos limits
327   Float_t fFFIMLaZMax;          // FF histos limits
328   
329
330  
331   // Histograms
332   
333   TH1F* fh1EvtAllCent; 
334   TH1F* fh1Evt;                      
335   TH1F* fh1K0Mult;                   
336   TH1F* fh1dPhiJetK0;                
337   TH1F* fh1LaMult;                   
338   TH1F* fh1dPhiJetLa;                
339   TH1F* fh1ALaMult;                  
340   TH1F* fh1dPhiJetALa; 
341   TH1F* fh1JetEta;        
342   TH1F* fh1JetPhi;                   
343   TH2F* fh2JetEtaPhi;  
344   // TH1F* fh1V0JetPt; 
345   TH1F* fh1IMK0Cone; //jet pt distribution for normalisation by number of jets
346   TH1F* fh1IMLaCone;
347   TH1F* fh1IMALaCone;
348   TH2F* fh2FFJetTrackEta; //charged jet track eta distribution                 
349   //  TH1F* fh1trackPosNCls;             
350   //  TH1F* fh1trackNegNCls; 
351   TH1F* fh1trackPosRap;              
352   TH1F* fh1trackNegRap;              
353   // TH1F* fh1V0Rap;              
354   TH1F* fh1trackPosEta;              
355   TH1F* fh1trackNegEta;              
356   TH1F* fh1V0Eta;                    
357   // TH1F* fh1V0totMom;                 
358   TH1F* fh1CosPointAngle;            
359   TH1F* fh1DecayLengthV0;            
360   TH2F* fh2ProperLifetimeK0sVsPtBeforeCut;
361   TH2F* fh2ProperLifetimeK0sVsPtAfterCut;
362   TH1F* fh1V0Radius;                 
363   TH1F* fh1DcaV0Daughters;           
364   TH1F* fh1DcaPosToPrimVertex;       
365   TH1F* fh1DcaNegToPrimVertex;        
366   TH2F* fh2ArmenterosBeforeCuts;     
367   TH2F* fh2ArmenterosAfterCuts;      
368   TH2F* fh2BBLaPos;                  
369   TH2F* fh2BBLaNeg;                  
370   TH1F* fh1PosDaughterCharge;
371   TH1F* fh1NegDaughterCharge;
372   TH1F* fh1PtMCK0s;
373   TH1F* fh1PtMCLa;
374   TH1F* fh1PtMCALa;
375   TH1F* fh1EtaK0s;
376   TH1F* fh1EtaLa;
377   TH1F* fh1EtaALa;  
378   THnSparse* fhnInvMassEtaTrackPtK0s;
379   THnSparse* fhnInvMassEtaTrackPtLa;
380   THnSparse* fhnInvMassEtaTrackPtALa;
381   TH1F* fh1TrackMultCone;
382   TH2F* fh2TrackMultCone;
383   TH2F* fh2NJK0;
384   TH2F* fh2NJLa;
385   TH2F* fh2NJALa;
386   TH2F* fh2MCgenK0Cone;
387   TH2F* fh2MCgenLaCone;
388   TH2F* fh2MCgenALaCone;
389   TH2F* fh2MCEtagenK0Cone;
390   TH2F* fh2MCEtagenLaCone;
391   TH2F* fh2MCEtagenALaCone;
392   TH1F* fh1IMK0ConeSmear; //histos for normalisation by number of smeared jets
393   TH1F* fh1IMLaConeSmear;
394   TH1F* fh1IMALaConeSmear;
395   THnSparse* fhnMCrecK0Cone;
396   THnSparse* fhnMCrecLaCone;
397   THnSparse* fhnMCrecALaCone;
398   THnSparse* fhnMCrecK0ConeSmear;
399   THnSparse* fhnMCrecLaConeSmear;
400   THnSparse* fhnMCrecALaConeSmear;
401   THnSparse* fhnK0sSecContinCone;
402   THnSparse* fhnLaSecContinCone;
403   THnSparse* fhnALaSecContinCone;
404   THnSparse* fhnK0sIncl;
405   THnSparse* fhnK0sCone;
406   THnSparse* fhnLaIncl;
407   THnSparse* fhnLaCone;
408   THnSparse* fhnALaIncl;
409   THnSparse* fhnALaCone;
410   THnSparse* fhnK0sPC;
411   THnSparse* fhnLaPC;
412   THnSparse* fhnALaPC;
413   THnSparse* fhnK0sMCC;
414   THnSparse* fhnLaMCC;
415   THnSparse* fhnALaMCC;
416   THnSparse* fhnK0sRC;
417   THnSparse* fhnLaRC;
418   THnSparse* fhnALaRC;
419   THnSparse* fhnK0sOC;
420   THnSparse* fhnLaOC;
421   THnSparse* fhnALaOC;
422   TH1F* fh1AreaExcluded;
423   TH1F* fh1MedianEta;
424   TH1F* fh1JetPtMedian; //for normalisation by total number of median cluster jets TH3F* fh3IMALaMedianCone;
425   TH1F* fh1MCMultiplicityPrimary;
426   TH1F* fh1MCMultiplicityTracks;
427   THnSparse* fhnFeedDownLa;
428   THnSparse* fhnFeedDownALa;
429   THnSparse* fhnFeedDownLaCone;
430   THnSparse* fhnFeedDownALaCone;
431   TH1F* fh1MCProdRadiusK0s;
432   TH1F* fh1MCProdRadiusLambda;
433   TH1F* fh1MCProdRadiusAntiLambda;
434   TH1F* fh1MCPtV0s;
435   TH1F* fh1MCPtK0s; 
436   TH1F* fh1MCPtLambda; 
437   TH1F* fh1MCPtAntiLambda;
438   TH1F* fh1MCXiPt;
439   TH1F* fh1MCXibarPt;
440   TH2F* fh2MCEtaVsPtK0s;
441   TH2F* fh2MCEtaVsPtLa;
442   TH2F* fh2MCEtaVsPtALa;
443   TH1F* fh1MCRapK0s; 
444   TH1F* fh1MCRapLambda;
445   TH1F* fh1MCRapAntiLambda;
446   TH1F* fh1MCEtaAllK0s; 
447   TH1F* fh1MCEtaK0s; 
448   TH1F* fh1MCEtaLambda;
449   TH1F* fh1MCEtaAntiLambda;
450
451
452   ClassDef(AliAnalysisTaskJetChem, 3);
453 };
454
455 #endif
456
457