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
  33 #include "AliAnalysisTaskFragmentationFunction.h"
  34 #include "AliPID.h"
  35 #include "AliAnalysisTaskSE.h"
  36 #include "AliAODMCHeader.h"
  37
  38 class AliAnalysisTaskJetChem : public AliAnalysisTaskFragmentationFunction {
  39
  40  public:
  41
  42   //----------------------------------------
  43   class AliFragFuncHistosInvMass : public TObject
  44   {
  45
  46     public:
  47
  48     AliFragFuncHistosInvMass(const char* name = "FFIMhistos",
  49                              Int_t nJetPt = 0, Float_t jetPtMin = 0, Float_t jetPtMax = 0,
  50                              Int_t nInvMass = 0, Float_t invMassMin=0, Float_t invMassMax=0,
  51                              Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0,
  52                              Int_t nXi = 0, Float_t xiMin = 0, Float_t xiMax = 0,
  53                              Int_t nZ  = 0, Float_t zMin  = 0, Float_t zMax  = 0);
  54     AliFragFuncHistosInvMass(const AliFragFuncHistosInvMass& copy);
  55     AliFragFuncHistosInvMass& operator=(const AliFragFuncHistosInvMass &o);
  56     virtual ~AliFragFuncHistosInvMass();
  57
  58     virtual void DefineHistos();
  59     virtual void FillFF(Float_t trackPt, Float_t invM, Float_t jetPt,Bool_t incrementJetPt);
  60     virtual void AddToOutput(TList* list) const;
  61
  62   private:
  63
  64     Int_t   fNBinsJetPt;    // FF histos bins
  65     Float_t fJetPtMin;      // FF histos limits
  66     Float_t fJetPtMax;      // FF histos limits
  67     Int_t   fNBinsInvMass;  // FF histos bins
  68     Float_t fInvMassMin;    // FF histos limits
  69     Float_t fInvMassMax;    // FF histos limits
  70     Int_t   fNBinsPt;       // FF histos bins
  71     Float_t fPtMin;         // FF histos limits
  72     Float_t fPtMax;         // FF histos limits
  73     Int_t   fNBinsXi;       // FF histos bins
  74     Float_t fXiMin;         // FF histos limits
  75     Float_t fXiMax;         // FF histos limits
  76     Int_t   fNBinsZ;        // FF histos bins
  77     Float_t fZMin;          // FF histos limits
  78     Float_t fZMax;          // FF histos limits
  79
  80
  81
  82     TH3F*   fh3TrackPt;     //! FF: track transverse momentum
  83     TH3F*   fh3Xi;          //! FF: xi
  84     TH3F*   fh3Z;           //! FF: z
  85     TH1F*   fh1JetPt;       //! jet pt of all jets
  86
  87     TString fNameFF;        // histo names prefix
  88
  89     ClassDef(AliFragFuncHistosInvMass, 1);
  90   };
  91
  92
  93  //----------------------------------------
  94   class AliFragFuncHistosPhiCorrInvMass : public TObject
  95   {
  96
  97     public:
  98
  99     AliFragFuncHistosPhiCorrInvMass(const char* name = "FFPhiCorrIMhistos",
 100                                     Int_t nPt = 0, Float_t ptMin = 0, Float_t ptMax = 0,
 101                                     Int_t nPhi = 0, Float_t phiMin = 0, Float_t phiMax = 0,
 102                                     Int_t nInvMass = 0, Float_t invMassMin=0, Float_t invMassMax=0);
 103
 104     AliFragFuncHistosPhiCorrInvMass(const AliFragFuncHistosPhiCorrInvMass& copy);
 105     AliFragFuncHistosPhiCorrInvMass& operator=(const AliFragFuncHistosPhiCorrInvMass &o);
 106     virtual ~AliFragFuncHistosPhiCorrInvMass();
 107
 108     virtual void DefineHistos();
 109     virtual void FillPhiCorr(Float_t pt, Float_t phi, Float_t invM);
 110     virtual void AddToOutput(TList* list) const;
 111
 112
 113
 114   private:
 115
 116     Int_t   fNBinsPt;       // FF histos bins
 117     Float_t fPtMin;         // FF histos limits
 118     Float_t fPtMax;         // FF histos limits
 119
 120     Int_t   fNBinsPhi;      // FF histos bins
 121     Float_t fPhiMin;        // FF histos limits
 122     Float_t fPhiMax;        // FF histos limits
 123
 124     Int_t   fNBinsInvMass;  // FF histos bins
 125     Float_t fInvMassMin;    // FF histos limits
 126     Float_t fInvMassMax;    // FF histos limits
 127
 128     TH3F*   fh3PhiCorr;     //! FF: phi correlation histo
 129
 130     TString fNamePhiCorr;   // histo names prefix
 131
 132     ClassDef(AliFragFuncHistosPhiCorrInvMass, 1);
 133   };
 134
 135   //----------------------------------------
 136
 137   AliAnalysisTaskJetChem();
 138   AliAnalysisTaskJetChem(const char *name);
 139   AliAnalysisTaskJetChem(const  AliAnalysisTaskJetChem &copy);
 140   AliAnalysisTaskJetChem& operator=(const  AliAnalysisTaskJetChem &o);
 141   virtual ~AliAnalysisTaskJetChem();
 142
 143   virtual void   UserCreateOutputObjects();
 144   virtual void   UserExec(Option_t *option);
 145
 146   enum { kTrackUndef =0, kOnFly, kOnFlyPID, kOnFlydEdx, kOnFlyPrim, kOffl, kOfflPID, kOffldEdx, kOfflPrim };
 147   enum { kK0, kLambda, kAntiLambda };
 148
 149   static  void   SetProperties(TH3F* h,const char* x, const char* y,const char* z);
 150
 151   Bool_t IsAccepteddEdx(Double_t mom, Double_t signal, AliPID::EParticleType n, Double_t cutnSig) const;//not used anymore
 152   Bool_t IsK0InvMass(Double_t mass) const;
 153   Int_t  GetListOfV0s(TList *list, Int_t type, Int_t particletype, AliAODVertex* primVertex, AliAODEvent* aod);
 154   Int_t  GetListOfParticles(TList *list, Int_t type, Int_t particletype, AliAODVertex* primVertex);
 155   Int_t  GetListOfMCParticles(TList *outputlist, Int_t particletype, AliAODEvent* mcaodevent);
 156   void   GetTracksInCone(TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius, Double_t& sumPt, Double_t minPt, Double_t maxPt, Bool_t& isBadPt);
 157   void   GetTracksInPerpCone(TList* inputlist, TList* outputlist, const AliAODJet* jet, Double_t radius, Double_t& sumPerpPt);
 158   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);
 159   Bool_t IsParticleMatching(const AliAODMCParticle* mcp0, Int_t v0Label);
 160   Bool_t DaughterTrackCheck(AliAODv0* v0, Int_t& nnum, Int_t& pnum);
 161   Int_t  IsTrackInjected(AliAODv0 *v0, AliAODMCHeader *header, TClonesArray *arrayMC);
 162   TString GetGenerator(Int_t label, AliAODMCHeader* header);
 163   Double_t SmearJetPt(Double_t jetPt, Int_t cl, Double_t jetRadius, Double_t ptmintrack, Double_t& jetPtSmear);
 164   AliAODJet* GetMedianCluster();
 165
 166   virtual void SetK0Type(Int_t i){ fK0Type = i; }
 167   virtual void SetFilterMaskK0(UInt_t i) {fFilterMaskK0 = i;}
 168
 169   Bool_t IsLaInvMass(Double_t mass) const; //La and ALa mass check
 170   virtual void SetLaType(Int_t i){ fLaType = i; }
 171   virtual void SetFilterMaskLa(UInt_t i) {fFilterMaskLa = i;}
 172
 173   virtual void SetALaType(Int_t i){ fALaType = i; }
 174   virtual void SetFilterMaskALa(UInt_t i) {fFilterMaskALa = i;}
 175
 176   virtual void SetSelectArmenteros(Bool_t b) {IsArmenterosSelected = b;}
 177   //virtual void SetEventSelectionMask(UInt_t i){fEvtSelectionMask = i;}  //already inherited by AliAnalysisFragmentationFunctionTask
 178   //virtual void UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;} //already inherited by AliAnalysisFragmentationFunctionTask
 179
 180   void CalculateInvMass(AliAODv0* v0vtx, Int_t particletype, Double_t& invM, Double_t& trackPt);
 181
 182   Bool_t AcceptBetheBloch(AliAODv0 *v0, AliPIDResponse *PIDResponse, Int_t particletype); //don't use this method for MC Analysis
 183
 184
 185   Double_t MyRapidity(Double_t rE, Double_t rPz) const;
 186
 187   //-- K0s
 188
 189   void   SetFFInvMassHistoBins(Int_t nJetPt = 39, Float_t jetPtMin = 5., Float_t jetPtMax = 200., //previous 19, 5.,100.
 190                                Int_t nInvM = 400, Float_t invMMin = 0.4,  Float_t invMMax = 0.6, //previous 0.4 to 0.6
 191                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20.,         //previous 0. to 10.
 192                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
 193                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
 194   { fFFIMNBinsJetPt = nJetPt; fFFIMJetPtMin = jetPtMin; fFFIMJetPtMax = jetPtMax;
 195     fFFIMNBinsInvM = nInvM; fFFIMInvMMin = invMMin; fFFIMInvMMax = invMMax; fFFIMNBinsPt = nPt; fFFIMPtMin = ptMin; fFFIMPtMax = ptMax;
 196     fFFIMNBinsXi = nXi; fFFIMXiMin = xiMin; fFFIMXiMax = xiMax; fFFIMNBinsZ  = nZ;  fFFIMZMin  = zMin;  fFFIMZMax  = zMax; }
 197
 198
 199   void   SetPhiCorrInvMassHistoBins(Int_t nPt = 40, Float_t ptMin = 0., Float_t ptMax = 20.,
 200                                     Int_t nPhi = 20, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi(),
 201                                     Int_t nInvM = 240, Float_t invMMin = 0.4,  Float_t invMMax = 0.6)
 202
 203   { fPhiCorrIMNBinsPt = nPt; fPhiCorrIMPtMin = ptMin; fPhiCorrIMPtMax = ptMax;
 204     fPhiCorrIMNBinsPhi = nPhi; fPhiCorrIMPhiMin = phiMin; fPhiCorrIMPhiMax = phiMax;
 205     fPhiCorrIMNBinsInvM = nInvM; fPhiCorrIMInvMMin = invMMin; fPhiCorrIMInvMMax = invMMax;
 206   }
 207
 208   // --La and ALa
 209
 210   void   SetFFInvMassLaHistoBins(Int_t nJetPt = 39, Float_t jetPtMin = 5., Float_t jetPtMax = 200., //La
 211                                  //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
 212                                Int_t nInvM = 200, Float_t invMMin = 1.05,  Float_t invMMax = 1.25,
 213                                Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 20.,
 214                                Int_t nXi = 35, Float_t xiMin = 0., Float_t xiMax = 7.,
 215                                Int_t nZ = 11,  Float_t zMin = 0.,  Float_t zMax = 1.1)
 216
 217   { fFFIMLaNBinsJetPt = nJetPt; fFFIMLaJetPtMin = jetPtMin; fFFIMLaJetPtMax = jetPtMax;
 218     fFFIMLaNBinsInvM = nInvM; fFFIMLaInvMMin = invMMin; fFFIMLaInvMMax = invMMax; fFFIMLaNBinsPt = nPt; fFFIMLaPtMin = ptMin; fFFIMLaPtMax = ptMax;
 219     fFFIMLaNBinsXi = nXi; fFFIMLaXiMin = xiMin; fFFIMLaXiMax = xiMax; fFFIMLaNBinsZ  = nZ;  fFFIMLaZMin  = zMin;  fFFIMLaZMax  = zMax; }
 220
 221
 222   void   SetPhiCorrInvMassLaHistoBins(Int_t nPt = 40, Float_t ptMin = 0., Float_t ptMax = 20.,    //La
 223                                     Int_t nPhi = 20, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi(),
 224                                     Int_t nInvM = 50, Float_t invMMin = 1.06,  Float_t invMMax = 1.2)
 225
 226   { fPhiCorrIMLaNBinsPt = nPt; fPhiCorrIMLaPtMin = ptMin; fPhiCorrIMLaPtMax = ptMax;
 227     fPhiCorrIMLaNBinsPhi = nPhi; fPhiCorrIMLaPhiMin = phiMin; fPhiCorrIMLaPhiMax = phiMax;
 228     fPhiCorrIMLaNBinsInvM = nInvM; fPhiCorrIMLaInvMMin = invMMin; fPhiCorrIMLaInvMMax = invMMax;
 229   }
 230
 231
 232
 233   // consts
 234
 235
 236   //--
 237   Bool_t   fAnalysisMC;
 238   Double_t fDeltaVertexZ;
 239   Double_t fCuttrackNegNcls;
 240   Double_t fCuttrackPosNcls;
 241   Double_t fCutPostrackRap;
 242   Double_t fCutNegtrackRap;
 243   Double_t fCutRap;
 244   Double_t fCutPostrackEta;
 245   Double_t fCutNegtrackEta;
 246   Double_t fCutEta;
 247   Double_t fCutV0cosPointAngle;
 248   Double_t fCutChi2PosDaughter;
 249   Double_t fCutChi2NegDaughter;
 250   Bool_t   fKinkDaughters;
 251   Bool_t   fRequireTPCRefit;
 252   Double_t fCutArmenteros;
 253   Double_t fCutV0DecayMin;
 254   Double_t fCutV0DecayMax;
 255   Double_t fCutV0totMom;
 256   Double_t fCutDcaV0Daughters;
 257   Double_t fCutDcaPosToPrimVertex;
 258   Double_t fCutDcaNegToPrimVertex;
 259   Double_t fCutV0RadiusMin;
 260   Double_t fCutV0RadiusMax;
 261   Double_t fCutBetheBloch;
 262   Double_t fCutRatio;
 263
 264   // cuts
 265   void SetCuttrackPosNcls(Double_t posNcls){fCuttrackPosNcls=posNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosNcls %f",posNcls);}
 266   void SetCuttrackNegNcls(Double_t negNcls){fCuttrackNegNcls=negNcls; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegNcls %f",negNcls);}
 267   void SetCuttrackPosRap(Double_t posRap){fCutPostrackRap=posRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosRap %f",posRap);}
 268   void SetCuttrackNegRap(Double_t negRap){fCutNegtrackRap=negRap; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegRap %f",negRap);}
 269   void SetCutV0Rap(Double_t v0Rap){fCutRap=v0Rap; Printf("AliAnalysisTaskJetChem:: SetCutV0Rap %f",v0Rap);}
 270   void SetCuttrackPosEta(Double_t posEta){fCutPostrackEta=posEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackPosEta %f",posEta);}
 271   void SetCuttrackNegEta(Double_t negEta){fCutNegtrackEta=negEta; Printf("AliAnalysisTaskJetChem:: SetCuttrackNegEta %f",negEta);}
 272   void SetCutV0Eta(Double_t v0Eta){fCutEta=v0Eta; Printf("AliAnalysisTaskJetChem:: SetCutV0Eta %f",v0Eta);}
 273   void SetCosOfPointingAngle(Double_t cospointAng){fCutV0cosPointAngle=cospointAng; Printf("AliAnalysisTaskJetChem:: SetCosOfPointingAngle %f",cospointAng);}
 274   void SetChi2CutPosDaughter(Double_t chi2PosDaughter){fCutChi2PosDaughter=chi2PosDaughter; Printf("AliAnalysisTaskJetChem:: SetChi2CutPosDaughter %f",chi2PosDaughter);}
 275   void SetChi2CutNegDaughter(Double_t chi2NegDaughter){fCutChi2NegDaughter=chi2NegDaughter; Printf("AliAnalysisTaskJetChem:: SetChi2CutNegDaughter %f",chi2NegDaughter);}
 276   void SetAcceptKinkDaughters(Bool_t isKinkDaughtersAccepted){fKinkDaughters=isKinkDaughtersAccepted; Printf("AliAnalysisTaskJetChem:: SetAcceptKinkDaughters %i", isKinkDaughtersAccepted);}
 277   void SetRequireTPCRefit(Bool_t isTPCRefit){fRequireTPCRefit=isTPCRefit; Printf("AliAnalysisTaskJetChem:: SetRequireTPCRefit %i", isTPCRefit);}
 278   void SetCutArmenteros(Double_t armenteros){fCutArmenteros=armenteros; Printf("AliAnalysisTaskJetChem:: SetCutArmenteros %f", armenteros);}
 279   void SetCutV0DecayMin(Double_t decayMin){fCutV0DecayMin=decayMin; Printf("AliAnalysisTaskJetChem:: SetCutDecayMin %f", decayMin);}
 280   void SetCutV0DecayMax(Double_t decayMax){fCutV0DecayMax=decayMax; Printf("AliAnalysisTaskJetChem:: SetCutDecayMax %f", decayMax);}
 281   void SetCutV0totMom(Double_t v0totMom){fCutV0totMom=v0totMom; Printf("AliAnalysisTaskJetChem:: SetCutV0totMom %f", v0totMom);}
 282   void SetCutDcaV0Daughters(Double_t dcav0daughters){fCutDcaV0Daughters=dcav0daughters; Printf("AliAnalysisTaskJetChem:: SetCutDcaV0Daughters %f", dcav0daughters);}
 283   void SetCutDcaPosToPrimVertex(Double_t dcaPosToPrimVertex){fCutDcaPosToPrimVertex=dcaPosToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaPosToPrimVertex %f", dcaPosToPrimVertex);}
 284   void SetCutDcaNegToPrimVertex(Double_t dcaNegToPrimVertex){fCutDcaNegToPrimVertex=dcaNegToPrimVertex; Printf("AliAnalysisTaskJetChem:: SetCutDcaNegToPrimVertex %f", dcaNegToPrimVertex);}
 285   void SetCutV0RadiusMin(Double_t v0RadiusMin){fCutV0RadiusMin=v0RadiusMin; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMin %f", v0RadiusMin);}
 286   void SetCutV0RadiusMax(Double_t v0RadiusMax){fCutV0RadiusMax=v0RadiusMax; Printf("AliAnalysisTaskJetChem:: SetCutV0RadiusMax %f", v0RadiusMax);}
 287   void SetCutBetheBloch(Double_t cutBetheBloch){fCutBetheBloch=cutBetheBloch; Printf("AliAnalysisTaskJetChem:: SetCutBetheBloch %f", cutBetheBloch);}
 288   void SetCutRatioTPC(Double_t cutRatioTPC){fCutRatio=cutRatioTPC; Printf("AliAnalysisTaskJetChem:: SetCutRatioTPC %f", cutRatioTPC);}
 289   void SetAnalysisMC(Bool_t analysisMC) {fAnalysisMC = analysisMC;}
 290   void SetDeltaZVertexCut(Float_t deltaVtxZ){fDeltaVertexZ = deltaVtxZ;}
 291
 292  private:
 293
 294   Int_t fK0Type;                                           //! K0 cuts
 295   UInt_t fFilterMaskK0;                                    //! K0 legs cuts
 296   TList* fListK0s;                                         //! K0 list
 297   AliPIDResponse *fPIDResponse;                            // PID
 298
 299   AliFragFuncQATrackHistos*  fV0QAK0;                      //! track QA: V0s in K0 inv mass range
 300   AliFragFuncHistos*         fFFHistosRecCutsK0Evt;        //! inclusive FF for K0 evt
 301   AliFragFuncHistosInvMass*  fFFHistosIMK0AllEvt;          //! K0 pt spec for all events
 302   AliFragFuncHistosInvMass*  fFFHistosIMK0Jet;             //! K0 FF all dPhi
 303   AliFragFuncHistosInvMass*  fFFHistosIMK0Cone;            //! K0 FF jet cone
 304   AliFragFuncHistosPhiCorrInvMass*  fFFHistosPhiCorrIMK0;  //! K0 correlation to jet axis
 305
 306   Int_t fLaType;                                           //! La cuts
 307   UInt_t fFilterMaskLa;                                    //! La legs cuts
 308   TList* fListLa;                                          //! La list
 309
 310   AliFragFuncHistosInvMass*  fFFHistosIMLaAllEvt;          //! La pt spec for all events
 311   AliFragFuncHistosInvMass*  fFFHistosIMLaJet;             //! La FF all dPhi
 312   AliFragFuncHistosInvMass*  fFFHistosIMLaCone;            //! La FF jet cone
 313   AliFragFuncHistosPhiCorrInvMass*  fFFHistosPhiCorrIMLa;  //! La correlation to jet axis
 314
 315   Int_t fALaType;                                          //! ALa cuts
 316
 317   UInt_t fFilterMaskALa;                                   //! ALa legs cuts
 318   TList* fListALa;                                         //! ALa list
 319   TList* fListFeeddownLaCand;                              //! feeddown from Xi (-,0)
 320   TList* fListFeeddownALaCand;                             //! feeddown from Xibar (+,0)
 321   TList* jetConeFDLalist;                                  //! feeddown from Xi (-,0) in jet cone
 322   TList* jetConeFDALalist;                                 //! feeddown from Xibar (+,0) in jet cone
 323   TList* fListMCgenK0s;                                    //! MC generated K0s
 324   TList* fListMCgenLa;                                     //! MC generated La
 325   TList* fListMCgenALa;                                    //! MC generated ALa
 326   TList* fListMCgenK0sCone;                                //! MC generated K0s in cone around jet axis, particles are from fragmentation but also from underlying event
 327   TList* fListMCgenLaCone;                                 //! MC generated Lambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 328   TList* fListMCgenALaCone;                                //! MC generated Antilambdas in cone around jet axis, particles are from fragmentation but also from underlying event
 329
 330   Bool_t IsArmenterosSelected;                             //Armenteros-Podolanski Cut (is/isn't) applied
 331
 332   AliFragFuncHistosInvMass*  fFFHistosIMALaAllEvt;          //! ALa pt spec for all events
 333   AliFragFuncHistosInvMass*  fFFHistosIMALaJet;             //! ALa FF all dPhi
 334   AliFragFuncHistosInvMass*  fFFHistosIMALaCone;            //! ALa FF jet cone
 335   AliFragFuncHistosPhiCorrInvMass*  fFFHistosPhiCorrIMALa;  //! ALa corelation to jet axis
 336
 337   // histogram bins
 338
 339
 340
 341   //--K0s
 342
 343   Int_t   fFFIMNBinsJetPt;    // FF histos bins
 344   Float_t fFFIMJetPtMin;      // FF histos limits
 345   Float_t fFFIMJetPtMax;      // FF histos limits
 346
 347   Int_t   fFFIMNBinsInvM;     // FF histos bins
 348   Float_t fFFIMInvMMin;       // FF histos bins
 349   Float_t fFFIMInvMMax;       // FF histos bins
 350
 351   Int_t   fFFIMNBinsPt;       // FF histos bins
 352   Float_t fFFIMPtMin;         // FF histos limits
 353   Float_t fFFIMPtMax;         // FF histos limits
 354
 355   Int_t   fFFIMNBinsXi;       // FF histos bins
 356   Float_t fFFIMXiMin;         // FF histos limits
 357   Float_t fFFIMXiMax;         // FF histos limits
 358
 359   Int_t   fFFIMNBinsZ;        // FF histos bins
 360   Float_t fFFIMZMin;          // FF histos limits
 361   Float_t fFFIMZMax;          // FF histos limits
 362
 363   //--La
 364
 365   Int_t   fFFIMLaNBinsJetPt;    // FF histos bins
 366   Float_t fFFIMLaJetPtMin;      // FF histos limits
 367   Float_t fFFIMLaJetPtMax;      // FF histos limits
 368
 369   Int_t   fFFIMLaNBinsInvM;     // FF histos bins
 370   Float_t fFFIMLaInvMMin;       // FF histos bins
 371   Float_t fFFIMLaInvMMax;       // FF histos bins
 372
 373   Int_t   fFFIMLaNBinsPt;       // FF histos bins
 374   Float_t fFFIMLaPtMin;         // FF histos limits
 375   Float_t fFFIMLaPtMax;         // FF histos limits
 376
 377   Int_t   fFFIMLaNBinsXi;       // FF histos bins
 378   Float_t fFFIMLaXiMin;         // FF histos limits
 379   Float_t fFFIMLaXiMax;         // FF histos limits
 380
 381   Int_t   fFFIMLaNBinsZ;        // FF histos bins
 382   Float_t fFFIMLaZMin;          // FF histos limits
 383   Float_t fFFIMLaZMax;          // FF histos limits
 384
 385
 386   //--K0s
 387
 388   Int_t fPhiCorrIMNBinsPt;    // FF histos bins
 389   Float_t fPhiCorrIMPtMin;    // FF histos limits
 390   Float_t fPhiCorrIMPtMax;    // FF histos limits
 391
 392   Int_t fPhiCorrIMNBinsPhi;   // FF histos bins
 393   Float_t fPhiCorrIMPhiMin;   // FF histos limits
 394   Float_t fPhiCorrIMPhiMax;   // FF histos limits
 395
 396   Int_t fPhiCorrIMNBinsInvM;  // FF histos bins
 397   Float_t fPhiCorrIMInvMMin;  // FF histos limits
 398   Float_t fPhiCorrIMInvMMax;  // FF histos limits
 399
 400   //--La
 401
 402   Int_t fPhiCorrIMLaNBinsPt;    // FF histos bins
 403   Float_t fPhiCorrIMLaPtMin;    // FF histos limits
 404   Float_t fPhiCorrIMLaPtMax;    // FF histos limits
 405
 406   Int_t fPhiCorrIMLaNBinsPhi;   // FF histos bins
 407   Float_t fPhiCorrIMLaPhiMin;   // FF histos limits
 408   Float_t fPhiCorrIMLaPhiMax;   // FF histos limits
 409
 410   Int_t   fPhiCorrIMLaNBinsInvM;  // FF histos bins
 411   Float_t fPhiCorrIMLaInvMMin;  // FF histos limits
 412   Float_t fPhiCorrIMLaInvMMax;  // FF histos limits
 413
 414
 415   // Histograms
 416
 417   TH1F* fh1EvtAllCent;
 418   TH1F* fh1Evt;
 419   TH1F* fh1K0Mult;
 420   TH1F* fh1dPhiJetK0;
 421   TH1F* fh1LaMult;
 422   TH1F* fh1dPhiJetLa;
 423   TH1F* fh1ALaMult;
 424   TH1F* fh1dPhiJetALa;
 425   TH1F* fh1JetEta;
 426   TH1F* fh1JetPhi;
 427   TH2F* fh2JetEtaPhi;
 428   TH1F* fh1V0JetPt;
 429   TH2F* fh2FFJetTrackEta; //charged jet track eta distribution
 430   TH1F* fh1trackPosNCls;
 431   TH1F* fh1trackNegNCls;
 432   TH1F* fh1trackPosRap;
 433   TH1F* fh1trackNegRap;
 434   TH1F* fh1V0Rap;
 435   TH1F* fh1trackPosEta;
 436   TH1F* fh1trackNegEta;
 437   TH1F* fh1V0Eta;
 438   TH1F* fh1V0totMom;
 439   TH1F* fh1CosPointAngle;
 440   TH1F* fh1Chi2Pos;
 441   TH1F* fh1Chi2Neg;
 442   TH1F* fh1DecayLengthV0;
 443   TH2F* fh2ProperLifetimeK0sVsPtBeforeCut;
 444   TH2F* fh2ProperLifetimeK0sVsPtAfterCut;
 445   TH1F* fh1ProperLifetimeV0BeforeCut;
 446   TH1F* fh1ProperLifetimeV0AfterCut;
 447   TH1F* fh1V0Radius;
 448   TH1F* fh1DcaV0Daughters;
 449   TH1F* fh1DcaPosToPrimVertex;
 450   TH1F* fh1DcaNegToPrimVertex;
 451   TH2F* fh2ArmenterosBeforeCuts;
 452   TH2F* fh2ArmenterosAfterCuts;
 453   TH2F* fh2BBLaPos;
 454   TH2F* fh2BBLaNeg;
 455   TH1F* fh1CrossedRowsOverFindableNeg;
 456   TH1F* fh1CrossedRowsOverFindablePos;
 457   TH1F* fh1PosDaughterCharge;
 458   TH1F* fh1NegDaughterCharge;
 459   TH1F* fh1PtMCK0s;
 460   TH1F* fh1PtMCLa;
 461   TH1F* fh1PtMCALa;
 462   TH1F* fh1EtaK0s;
 463   TH1F* fh1EtaLa;
 464   TH1F* fh1EtaALa;
 465   TH3F* fh3InvMassEtaTrackPtK0s;
 466   TH3F* fh3InvMassEtaTrackPtLa;
 467   TH3F* fh3InvMassEtaTrackPtALa;
 468   TH1F* fh1TrackMultCone;
 469   TH2F* fh2TrackMultCone;
 470   TH2F* fh2MCgenK0Cone;
 471   TH2F* fh2MCgenLaCone;
 472   TH2F* fh2MCgenALaCone;
 473   TH2F* fh2MCEtagenK0Cone;
 474   TH2F* fh2MCEtagenLaCone;
 475   TH2F* fh2MCEtagenALaCone;
 476   TH1F* fh1FFIMK0ConeSmear;
 477   TH1F* fh1FFIMLaConeSmear;
 478   TH1F* fh1FFIMALaConeSmear;
 479   TH3F* fh3MCrecK0Cone;
 480   TH3F* fh3MCrecLaCone;
 481   TH3F* fh3MCrecALaCone;
 482   TH3F* fh3MCrecK0ConeSmear;
 483   TH3F* fh3MCrecLaConeSmear;
 484   TH3F* fh3MCrecALaConeSmear;
 485   TH3F* fh3SecContinCone;
 486   TH3F* fh3StrContinCone;
 487   TH3F* fh3IMK0PerpCone;
 488   TH3F* fh3IMLaPerpCone;
 489   TH3F* fh3IMALaPerpCone;
 490   TH3F* fh3IMK0MedianCone;
 491   TH3F* fh3IMLaMedianCone;
 492   TH3F* fh3IMALaMedianCone;
 493   TH1F* fh1MCMultiplicityPrimary;
 494   TH1F* fh1MCMultiplicityTracks;
 495   TH1F* fh1MCmotherLa;
 496   TH1F* fh1MCmotherALa;
 497   TH3F* fh3FeedDownLa;
 498   TH3F* fh3FeedDownALa;
 499    TH3F* fh3FeedDownLaCone;
 500   TH3F* fh3FeedDownALaCone;
 501   TH1F* fh1MCProdRadiusK0s;
 502   TH1F* fh1MCProdRadiusLambda;
 503   TH1F* fh1MCProdRadiusAntiLambda;
 504   TH1F* fh1MCPtV0s;
 505   TH1F* fh1MCPtK0s;
 506   TH1F* fh1MCPtLambda;
 507   TH1F* fh1MCPtAntiLambda;
 508   TH1F* fh1MCXiPt;
 509   TH1F* fh1MCXibarPt;
 510   TH2F* fh2MCEtaVsPtK0s;
 511   TH2F* fh2MCEtaVsPtLa;
 512   TH2F* fh2MCEtaVsPtALa;
 513   TH1F* fh1MCRapK0s;
 514   TH1F* fh1MCRapLambda;
 515   TH1F* fh1MCRapAntiLambda;
 516   TH1F* fh1MCEtaAllK0s;
 517   TH1F* fh1MCEtaK0s;
 518   TH1F* fh1MCEtaLambda;
 519   TH1F* fh1MCEtaAntiLambda;
 520
 521
 522
 523   ClassDef(AliAnalysisTaskJetChem, 3);
 524 };
 525
 526 #endif
 527
 528