AliAnalysisTaskHJetEmbed.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKHJETEMBED_H
#define ALIANALYSISTASKHJETEMBED_H

#include <vector>

class TH2F;
class TH1F;
class TF1;
class TH3F;
class THnSparse;
class TClonesArray;
class TObject;
class TString;
class AliNamedString;
class AliAODEvent;
class AliESDEvent;
class AliMCEvent;
class AliRhoParameter;
class TRandom3;
class AliEmcalJet;
class AliVTrack;

template<class T> class TParameter;

#include "AliAnalysisTaskSE.h"

class AliAnalysisTaskHJetEmbed : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskHJetEmbed();
  AliAnalysisTaskHJetEmbed(const char *name);
  virtual ~AliAnalysisTaskHJetEmbed();

  void UserCreateOutputObjects();
  void UserExec(Option_t *option);
  void Terminate(Option_t *);
  void PrintConfig();

  void SetMaxVtxZ(Double_t z)                     { fMaxVtxZ=z;                     }
  void SetCollisionSystem(char *s)                { fCollisionSystem=s;             }
  void SetRunPeriod(char *p)                      { fPeriod=p;                      }
  void SetMCParticleArrName(char *s)              { fMCParticleArrName=s;           }
  void SetTrackArrName(char *s)                   { fTrackArrName=s;                }
  void SetTrkPtRange(Double_t min, Double_t max)  { fMinTrkPt=min; fMaxTrkPt=max;   }
  void SetTrkPhiRange(Double_t min, Double_t max) { fMinTrkPhi=min; fMaxTrkPhi=max; }
  void SetTrkEtaRange(Double_t min, Double_t max) { fMinTrkEta=min; fMaxTrkEta=max; }
  void SetTTtype(Int_t type)                      { fTTtype=type;                   }
  void SetRadius(Double_t rad)                    { fRadius=rad;                    }
  void SetPLJetArrName(char *s)                   { fPLJetArrName=s;                }
  void SetDLJetArrName(char *s)                   { fDLJetArrName=s;                }
  void SetJetArrName(char *s)                     { fJetArrName=s;                  }
  void SetRhoName(char *s)                        { fRhoName=s;                     }
  void SetRunQA(Bool_t run)                       { fRunQA=run;                     }
  void SetRunPL(Bool_t run)                       { fRunPL=run;                     }
  void SetRunDL(Bool_t run)                       { fRunDL=run;                     }
  void SetRunHJet(Bool_t run)                     { fRunHJet=run;                   }
  void SetRunMatch(Bool_t run)                    { fRunMatch=run;                  }
  void SetTTRanges(Double_t *min, Double_t *max)
  {
    for(Int_t i=0; i<kNTT; i++)
      {
  fMinTTPt[i] = min[i];
  fMaxTTPt[i] = max[i];
      }
  }



protected:
  void         RunQA();
  void         RunHJet(const Double_t minPt, const Double_t maxPt);
  void         RunMatch(const TClonesArray *tracks, const Int_t leadingIndex);
  void         FillHJetCor(const TClonesArray *tracks, const Int_t leadingIndex, const TClonesArray *jetArray, THnSparse *hTT, THnSparse *hn, Bool_t isBkg = kFALSE);
  Int_t        FindGeoMatchedJet(const AliEmcalJet* jet, const TClonesArray *jetArray, Double_t &dR);
  Int_t        FindEnergyMatchedJet(const AliEmcalJet* jet, const TClonesArray *jetArray, Double_t &dR, Double_t &fraction);
  Bool_t       AcceptTrack(const AliVParticle *track);
  Bool_t       IsGoodJet(const AliEmcalJet* jet);
  Double_t     GetZ(const Double_t trkPx, const Double_t trkPy, const Double_t trkPz, const Double_t jetPx, const Double_t jetPy, const Double_t jetPz);
  Double_t     GetDPhi(const Double_t phi1, const Double_t phi2);
  Double_t     CalculateDPhi(const Double_t phi1, const Double_t phi2);
  Double_t     GetJetDistance(const AliEmcalJet *jet1, const AliEmcalJet* jet2);

  enum { kNTrig = 3  };
  enum { kNTT = 4 };

 private:
  Int_t             fVerbosity;            
  Int_t             fAnaType;              //  0-local; 1-grid
  TString           fPeriod;               //  Run period
  TString           fCollisionSystem;      //  Collision system
  AliVEvent         *fEvent;               
  Int_t             fTriggerType;          
  Double_t          fCentrality;           
  Double_t          fMaxVtxZ;              //  Maximum z of vertices
  TString           fMCParticleArrName;    //
  TClonesArray      *fMCParticleArray;     
  TString           fTrackArrName;         //  Name of the input track array
  TClonesArray      *fTrackArray;          
  Int_t             fTriggerTrkIndex;      
  Double_t          fMinTrkPt;             //
  Double_t          fMaxTrkPt;             //
  Double_t          fMinTrkEta;            //
  Double_t          fMaxTrkEta;            //
  Double_t          fMinTrkPhi;            //
  Double_t          fMaxTrkPhi;            //
  Int_t             fTTtype;               //
  Double_t          fMinTTPt[kNTT];        //
  Double_t          fMaxTTPt[kNTT];        //
  Double_t          fRadius;               //  Jet radius
  TString           fJetArrName;           //  Name of the found jet array
  TString           fPLJetArrName;         //  Name of the embedded PYTHIA jet array on particle level
  TString           fDLJetArrName;         //  Name of the embedded PYTHIA jet array on detector level
  TClonesArray      *fJetArray;            
  TClonesArray      *fPLJetArray;          
  TClonesArray      *fDLJetArray;          
  TString           fRhoName;              //  Name of the rho parameter
  AliRhoParameter   *fRho;                 
  Double_t          fRhoValue;             
  AliNamedString    *fPtHardBinName;       
  Int_t             fPtHardBin;            
  TRandom3          *fRandom;              

  Bool_t            fRunQA;                //  Flag to run QA
  Bool_t            fRunHJet;              //  Flag to run h+jet 
  Bool_t            fRunMatch;             //  Flag to run matching
  Bool_t            fRunPL;                //
  Bool_t            fRunDL;                //

  TList             *fOutputList;                
  TH1F              *fhEventStat;                
  TH1F              *fhPtHardBins;               

  TH1F              *fhVtxZ[kNTrig];             
  TH1F              *fhCentrality[kNTrig];       
  TH2F              *fhRhoVsCent[kNTrig];        

  // QA histograms
  THnSparse         *fhPLJetPtVsCent[kNTrig];    
  THnSparse         *fhDLJetPtVsCent[kNTrig];    

  // HJet
  THnSparse         *fhPLTT[kNTrig];             
  THnSparse         *fhDLTT[kNTrig];             
  THnSparse         *fhPLHJet[kNTrig];           
  THnSparse         *fhDLHJet[kNTrig];           
  THnSparse         *fhTTPtQA[kNTrig];           
  THnSparse         *fhTTPt[kNTrig];             
  THnSparse         *fhHJet[kNTrig];             


  // Matching
  THnSparse         *fhJetPtGeoMatch[kNTrig];    
  THnSparse         *fhJetPtEnMatch[kNTrig];     

  THnSparse         *fhJetPhiGeoMatch[kNTrig];   
  THnSparse         *fhJetPhiEnMatch[kNTrig];    

  AliAnalysisTaskHJetEmbed(const AliAnalysisTaskHJetEmbed&);            // not implemented
  AliAnalysisTaskHJetEmbed &operator=(const AliAnalysisTaskHJetEmbed&); // not implemented

  ClassDef(AliAnalysisTaskHJetEmbed, 3);
};

#endif