Bastian Bathen:
[u/mrichter/AliRoot.git] / PWG4 / JetTasks / AliAnalysisTaskFragmentationFunction.h
index 4c9e329b0f6108a7057884f0f32181b805daaf9a..3577b6ecb7d4fe33716ebb069b7d657288e828ac 100644 (file)
@@ -15,6 +15,7 @@ class AliAODEvent;
 class TList;
 class TH1F;
 class TH2F;
+class TProfile;
 
 #include "THnSparse.h"
 #include "AliAnalysisTaskSE.h"
@@ -319,9 +320,11 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   virtual void   LocalInit() {Init();}
   virtual void   UserExec(Option_t *option);
   virtual void   Terminate(Option_t* );
+  virtual Bool_t Notify();
   
   virtual void   SetTrackTypeGen(Int_t i){fTrackTypeGen = i;}
   virtual void   SetJetTypeGen(Int_t i){fJetTypeGen = i;}
+  virtual void   SetJetTypeRecEff(Int_t i){fJetTypeRecEff = i;}
 
   virtual void   SetBranchGenJets(const char* c){fBranchGenJets = c;}
   virtual void   SetBranchRecJets(const char* c){fBranchRecJets = c;}
@@ -331,6 +334,7 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   {fTrackPtCut = trackPt; fTrackEtaMin = trackEtaMin; fTrackEtaMax = trackEtaMax; 
     fTrackPhiMin = trackPhiMin; fTrackPhiMax = trackPhiMax;}
   virtual void   SetFilterMask(UInt_t i) {fFilterMask = i;}
+  virtual void   UsePhysicsSelection(Bool_t b) {fUsePhysicsSelection = b;}
   virtual void   SetJetCuts(Float_t jetPt = 5., Float_t jetEtaMin = -0.5, Float_t jetEtaMax = 0.5, 
                            Float_t jetPhiMin = 0., Float_t jetPhiMax = 2*TMath::Pi())
   {fJetPtCut = jetPt; fJetEtaMin = jetEtaMin; fJetEtaMax = jetEtaMax; 
@@ -339,19 +343,19 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
                              Float_t cdfCut = 0.5, Float_t ptFractionCut = 0.6)
   {fDiJetCut = cutType; fDiJetDeltaPhiCut = deltaPhiCut;  
     fDiJetCDFCut = cdfCut; fDiJetPtFractionCut = ptFractionCut;}
-  virtual void   SetKindSlices(Int_t slice) {fDiJetKindBins = slice;}
+  virtual void   SetKindSlices(Int_t slice = 1) {fDiJetKindBins = slice;}
 
   virtual void   SetFFRadius(Float_t r = 0.4) { fFFRadius = r; }
 
   static  void   SetProperties(TH1* h,const char* x, const char* y);
   static  void   SetProperties(TH2* h,const char* x, const char* y,const char* z);
-  static  void   SetProperties(THnSparse* h, Int_t dim, const char** labels);
+  static  void   SetProperties(THnSparse* h,const Int_t dim, const char** labels);
 
   void   SetHighPtThreshold(Float_t pt = 5.) { fQATrackHighPtThreshold = pt; }
 
 
-  void   SetFFHistoBins(Int_t nJetPt = 55, Float_t jetPtMin = 5, Float_t jetPtMax = 60, 
-                       Int_t nPt = 70, Float_t ptMin = 0., Float_t ptMax = 70., 
+  void   SetFFHistoBins(Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, 
+                       Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., 
                        Int_t nXi = 70, Float_t xiMin = 0., Float_t xiMax = 7.,
                        Int_t nZ = 22,  Float_t zMin = 0.,  Float_t zMax = 1.1)
   { fFFNBinsJetPt = nJetPt; fFFJetPtMin = jetPtMin; fFFJetPtMax = jetPtMax; 
@@ -359,22 +363,22 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
     fFFNBinsXi = nXi; fFFXiMin = xiMin; fFFXiMax = xiMax;
     fFFNBinsZ  = nZ;  fFFZMin  = zMin;  fFFZMax  = zMax; }
   
-  void  SetQAJetHistoBins(Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200.,
+  void  SetQAJetHistoBins(Int_t nPt = 300, Float_t ptMin = 0., Float_t ptMax = 300.,
                          Int_t nEta = 20, Float_t etaMin = -1.0, Float_t etaMax = 1.0,
                          Int_t nPhi = 60, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi())
     { fQAJetNBinsPt = nPt; fQAJetPtMin = ptMin; fQAJetPtMax = ptMax;
       fQAJetNBinsEta = nEta; fQAJetEtaMin = etaMin; fQAJetEtaMax = etaMax;
       fQAJetNBinsPhi = nPhi; fQAJetPhiMin = phiMin; fQAJetPhiMax = phiMax; }
   
-  void  SetQATrackHistoBins(Int_t nPt = 70, Float_t ptMin = 0., Float_t ptMax = 70.,
+  void  SetQATrackHistoBins(Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200.,
                            Int_t nEta = 20, Float_t etaMin = -1.0, Float_t etaMax = 1.0,
                            Int_t nPhi = 60, Float_t phiMin = 0., Float_t phiMax = 2*TMath::Pi())
   { fQATrackNBinsPt = nPt; fQATrackPtMin = ptMin; fQATrackPtMax = ptMax;
     fQATrackNBinsEta = nEta; fQATrackEtaMin = etaMin; fQATrackEtaMax = etaMax;
     fQATrackNBinsPhi = nPhi; fQATrackPhiMin = phiMin; fQATrackPhiMax = phiMax; }
   
-  void   SetIJHistoBins(Int_t nJetPt = 55, Float_t jetPtMin = 5, Float_t jetPtMax = 60, 
-                       Int_t nPt = 70, Float_t ptMin = 0., Float_t ptMax = 70., 
+  void   SetIJHistoBins(Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, 
+                       Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., 
                        Int_t nZ = 22,  Float_t zMin = 0.,  Float_t zMax = 1.1,
                        Int_t nCosTheta = 100,  Float_t costhetaMin = 0.,  Float_t costhetaMax = 1.,
                        Int_t nTheta = 200,  Float_t thetaMin = -0.5,  Float_t thetaMax = 1.5,
@@ -386,9 +390,9 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
     fIJNBinsTheta  = nTheta;  fIJThetaMin  = thetaMin;  fIJThetaMax  = thetaMax;
     fIJNBinsJt  = nJt;  fIJJtMin  = jtMin;  fIJJtMax  = jtMax; }
 
-  void SetDiJetHistoBins(Int_t nJetInvMass = 55, Float_t jetInvMassMin = 5, Float_t jetInvMassMax = 60, 
-                        Int_t nJetPt = 55, Float_t jetPtMin = 5, Float_t jetPtMax = 60, 
-                        Int_t nPt = 70, Float_t ptMin = 0., Float_t ptMax = 70., 
+  void SetDiJetHistoBins(Int_t nJetInvMass = 245, Float_t jetInvMassMin = 5, Float_t jetInvMassMax = 250, 
+                        Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, 
+                        Int_t nPt = 200, Float_t ptMin = 0., Float_t ptMax = 200., 
                         Int_t nXi = 70, Float_t xiMin = 0., Float_t xiMax = 7.,
                         Int_t nZ = 22,  Float_t zMin = 0.,  Float_t zMax = 1.1)
   {
@@ -399,8 +403,8 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
     fDiJetNBinsZ = nZ; fDiJetZMin = zMin; fDiJetZMax = zMax;
   }
 
-  void SetQADiJetHistoBins(Int_t nInvMass = 55, Float_t invMassMin = 5., Float_t invMassMax = 60.,
-                          Int_t nJetPt = 55, Float_t jetPtMin = 5, Float_t jetPtMax = 60, 
+  void SetQADiJetHistoBins(Int_t nInvMass = 245, Float_t invMassMin = 5., Float_t invMassMax = 250.,
+                          Int_t nJetPt = 245, Float_t jetPtMin = 5, Float_t jetPtMax = 250, 
                           Int_t nDeltaPhi = 100, Float_t deltaPhiMin = 0., Float_t deltaPhiMax = TMath::Pi(),
                           Int_t nDeltaEta = 22, Float_t deltaEtaMin = 0., Float_t deltaEtaMax = 1.1,
                           Int_t nDeltaPt = 100, Float_t deltaPtMin = 0., Float_t deltaPtMax = 100.)
@@ -418,15 +422,20 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   void    GetJetTracksPointing(TList* in, TList* out, AliAODJet* j, const Double_t r, Double_t& pt);  
   Double_t GetDiJetBin(Double_t invMass, Double_t leadingJetPt, Double_t eMean, Int_t kindSlices); // function to find which bin fill
   Double_t InvMass(AliAODJet* jet1, AliAODJet* jet2);
+  void     AssociateGenRec(TList* tracksAODMCCharged,TList* tracksRec, TArrayI& indexAODTr,TArrayI& indexMCTr,TArrayS& isGenPrim);
+  void     FillSingleTrackRecEffHisto(THnSparse* histo, TList* tracksGen, TList* tracksRec, TArrayI& indexAODTr, TArrayS& isGenPrim);
+  void     FillJetTrackRecEffHisto(THnSparse* histo,Double_t jetPhi,Double_t jetEta,Double_t jetPt,TList* jetTrackList, TList* tracksGen,
+                                  TArrayI& indexAODTr,TArrayS& isGenPrim);
 
-
- private:
     
   // Consts
   
-  enum {kTrackUndef=0, kTrackAOD, kTrackAODCuts, kTrackKineAll, kTrackKineCharged, kTrackKineChargedAcceptance, kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance};
+  enum {kTrackUndef=0, kTrackAOD, kTrackAODQualityCuts, kTrackAODCuts, kTrackKineAll, kTrackKineCharged, kTrackKineChargedAcceptance, 
+       kTrackAODMCAll, kTrackAODMCCharged, kTrackAODMCChargedAcceptance};
   enum {kJetsUndef=0, kJetsRec, kJetsRecAcceptance, kJetsGen, kJetsGenAcceptance, kJetsKine, kJetsKineAcceptance};
-  
+ private:
   
   Int_t   GetListOfTracks(TList* list, Int_t type);
   Int_t          GetListOfJets(TList* list, Int_t type);
@@ -441,7 +450,10 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   Int_t   fTrackTypeGen;  // type of generated tracks
   Int_t   fJetTypeGen;    // type of generated jets
 
+  Int_t   fJetTypeRecEff; // type of jets used for filling reconstruction efficiency histos
+
   UInt_t  fFilterMask;   // filter bit for selected tracks
+  Bool_t  fUsePhysicsSelection; // switch for event selection
        
   // track cuts
   Float_t fTrackPtCut;    // track transverse momentum cut
@@ -468,13 +480,17 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
 
   Float_t fFFRadius;        // if radius > 0 construct FF from tracks within cone around jet axis, otherwise use trackRefs  
   
-  TList* fTracksRec;      //! reconstructed tracks
-  TList* fTracksRecCuts;  //! reconstructed tracks after cuts
-  TList* fTracksGen;      //! generated tracks 
+  TList* fTracksRec;            //! reconstructed tracks
+  TList* fTracksRecCuts;        //! reconstructed tracks after cuts
+  TList* fTracksGen;            //! generated tracks 
+  TList* fTracksAODMCCharged;   //! AOD MC tracks 
+  TList* fTracksRecQualityCuts; //! reconstructed tracks after quality cuts, no acceptance/pt cut
+
   
   TList* fJetsRec;        //! jets from reconstructed tracks
   TList* fJetsRecCuts;    //! jets from reonstructed tracks after jet cuts 
   TList* fJetsGen;        //! jets from generated tracks
+  TList* fJetsRecEff;     //! jets used for reconstruction efficiency histos 
   
   
   AliFragFuncQATrackHistos* fQATrackHistosRec;      //! track QA: reconstructed tracks
@@ -486,7 +502,9 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   AliFragFuncQAJetHistos*  fQAJetHistosRecCutsLeading;  //! jet QA: leading jet from reconstructed tracks after jet cuts 
   AliFragFuncQAJetHistos*  fQAJetHistosGen;             //! jet QA: jets from generated tracks  
   AliFragFuncQAJetHistos*  fQAJetHistosGenLeading;      //! jet QA: leading jet from generated tracks  
+  AliFragFuncQAJetHistos*  fQAJetHistosRecEffLeading;   //! jet QA: leading jet used for reconstruction efficiency histos  
   
+
   AliFragFuncHistos*  fFFHistosRecCuts;         //! FF reconstructed tracks after cuts 
   AliFragFuncHistos*  fFFHistosRecLeading;      //! FF reconstructed tracks after cuts: all reconstructed tracks pt / leading track pt  
   AliFragFuncHistos*  fFFHistosRecLeadingTrack; //! FF reconstructed tracks after cuts: leading track pt / jet pt
@@ -625,10 +643,22 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE {
   TH1F *fh1VertexNContributors;  //! NContributors to prim vertex
   TH1F *fh1VertexZ;              //! prim vertex z distribution
   TH1F *fh1EvtMult;              //! number of reconstructed tracks after cuts 
+
+  TProfile* fh1Xsec;              //! pythia cross section and trials
+  TH1F*     fh1Trials;            //! sum of trials
+  TH1F*     fh1PtHard;            //! pt hard of the event
+  TH1F*     fh1PtHardTrials;      //! pt hard of the event
+
   TH1F  *fh1nRecJetsCuts;         //! number of jets from reconstructed tracks per event 
   TH1F  *fh1nGenJets;             //! number of jets from generated tracks per event
+  TH1F  *fh1nRecEffJets;          //! number of jets for reconstruction eff per event
+
+  // tracking efficiency 
+
+  THnSparseF *fhnSingleTrackRecEffHisto; //! track reconstruction efficiency 
+  THnSparseF *fhnJetTrackRecEffHisto;    //! reconstruction efficiency jet tracks 
 
-  ClassDef(AliAnalysisTaskFragmentationFunction, 3);
+  ClassDef(AliAnalysisTaskFragmentationFunction, 5);
 };
 
 #endif