AliAnalysisTaskHJetSpectra.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKHJETSPECTRA_H
#define ALIANALYSISTASKHJETSPECTRA_H


class TH1I;
class TH1F;
class TF1;
class TH2F;
class TH2D;
class TH1D;
class TArrayD;
class TArrayF;
class THnSparse;
class TProfile;
class TList;
class TClonesArray;
class TString;
class AliEmcalJet;
class AliRhoParameter;
class AliVParticle;
class AliLog;
class AliAnalysisUtils;
class TRandom3;
class AliJetContainer;
class AliParticleContainer;
class AliClusterContainer;

#include "AliAnalysisTaskEmcalJet.h"

// ANALYSIS OF HIGH PT HADRON TRIGGER ASSOCIATED SPECTRUM OF RECOIL JETS IN P+PB
// Author Filip Krizek   (17.Nov. 2016)

class AliAnalysisTaskHJetSpectra : public AliAnalysisTaskEmcalJet {
   public:

  enum MyContainer {
     kContainerOne = 0, //analyze real data 
     kContainerTwo = 1, //analyze monte carlo
     kContainerThree,   //KT real 
     kContainerFour    //KT MC
  };

  enum MyDataType {
    kReal   = 0,  // reconstructed real data 
    kPythia = 1,  // pythia simulation 
    kHijing = 2,   // hijing simulation
    kDmpjet = 3   // dmpjet simulation
  };

  enum MyAnalType {
    kRec    = 0,  // reconstructed real data 
    kEff    = 1,  // MC true+recontructed 
    kEmb    = 2,  // embedding pythia jet
    kEmbSingl = 3,// embedding single track
    kKine   = 4   // kine 
  };

  enum MyRho {
    kConeRho=0, 
    kCMSRho, 
    kKtRho,
    kZeroRho,   //WITHOUT UE SUBTRACTION 
    kRho
  };

  enum MySystem {  //collision system
    kpp    = 0,  
    kpPb   = 1,  
    kPbPb  = 2   
  };

  enum MyCentBins {  //collision 
    kC0100 = 0,  
    kC020   = 1,  
    kC2050,  
    kC50100,
    kCOverflow, 
    kCAll
  };

  enum {kRef=0, kSig=1, kTT=2}; //trigger track bins

   // ######### CONTRUCTORS/DESTRUCTORS AND STD FUNCTIONS
   AliAnalysisTaskHJetSpectra();
   AliAnalysisTaskHJetSpectra(const char *name);
   virtual ~AliAnalysisTaskHJetSpectra();
   void     UserCreateOutputObjects();
   void     Terminate(Option_t *);

   
  // ######### SETTERS/GETTERS
  void        SetAnalysisType(Int_t sys, Int_t typeOfData, Int_t typeOfAnal){
                 fTypeOfData = typeOfData;
                 fTypeOfAnal = typeOfAnal;
                 fCollisionSystem = sys;
              }

  void        SetUseDefaultVertexCut (Bool_t val) {fUseDefaultVertexCut = val;}  
  void        SetUsePileUpCut (Bool_t val) {fUsePileUpCut = val;} 
  void        SetSignalJetMinArea(Double_t minArea) {fMinJetArea = minArea;} 


  void        SetSignalJetRadius(Double_t radius) {
                 fSignalJetRadius        = radius;
                 fSignalJetRadiusSquared = fSignalJetRadius*fSignalJetRadius;
                 fSignalJetEtaWindow     = fTrackEtaWindow-fSignalJetRadius; 
              }

  void        SetAcceptanceWindows(Double_t trackEta, Double_t signalJetRadius){ 
                 fTrackEtaWindow  = trackEta; 
                 fSignalJetRadius = signalJetRadius; 
                 fSignalJetEtaWindow = fTrackEtaWindow-fSignalJetRadius; 
                 fSignalJetRadiusSquared = fSignalJetRadius*fSignalJetRadius;
              } 

  void        SetCentralityType(const char* type){
                  fCentralityType = type;    
              } 

  void        SetVertexCut(Double_t vz){ fZVertexCut = vz; }   
  void        SetMinTrackPt(Double_t mpt){ fMinTrackPt = mpt;}

  void        SetExternalRhoTaskName(const char* name) {fRhoTaskName = name;}
  void        SetExternalRhoTaskNameMC(const char* name) {fRhoTaskNameMC = name;}

  void SetTT(Double_t tlr, Double_t thr,Double_t tls, Double_t ths);
  void SetTTType(Int_t ttt){ fTTType = ttt;}
  void SetDphi(Double_t dphi){ fDphiCut = TMath::Pi() - dphi;} 
  void SetDoubleBinPrecision(Bool_t db){ fUseDoubleBinPrecision = db;} 


  void SetNofRandomCones(Int_t nrc){ fNofRandomCones = nrc;}
  void SetMinFractionShared(Double_t f)  { fMinFractionShared = f; }

  Bool_t   RetrieveEventObjects();
  Bool_t   Run();
  Bool_t   FillHistograms();

 private:

  // ######### MAIN CALCULATION FUNCTIONS
  void    GetDeltaPt(Int_t nrho,  TArrayD &rho, Double_t *dpt, 
                     Double_t ttPhi, Double_t ttEta, AliParticleContainer *trkArray, Bool_t isGen);
                     //Double_t leadingJetExclusionProbability = 0); 
                     


  Double_t    GetConePt(Double_t eta, Double_t phi, Double_t radius, AliParticleContainer *trkArray, Bool_t isGen); 
  //Double_t    GetPtHard();             
  Double_t    GetImpactParameter();   
  Double_t    GetSimPrimaryVertex(); 


  // ######### CHECK FUNCTIONS
  Bool_t      IsTrackInAcceptance(AliVParticle* track, Bool_t isGen=0);  
  Bool_t      IsEventInAcceptance(AliVEvent* event);     
  Bool_t      IsMCEventInAcceptance(AliVEvent* event);   
  Bool_t      IsSignalJetInAcceptance(AliEmcalJet* jet, Bool_t suppressGhost=1); 
  Bool_t      IsStrange(Int_t ip); //Check particle strangeness

   Double_t RelativePhi(Double_t mphi,Double_t vphi); 
   Double_t EstimateBgCone(AliJetContainer *jetCont, AliParticleContainer *trkArray, AliVParticle* triggerHadron, Bool_t isGen=kFALSE);   
   Double_t EstimateBgKT(AliJetContainer *jetCont, AliParticleContainer  *trkArray, AliVParticle* trackTT);  // median p/A of kt jets
   Double_t EstimateBgKTcms(AliJetContainer *jetCont, AliParticleContainer *trkArray, AliVParticle* triggerHadron); //CMS background
   


  //Double_t GetNcoll(Double_t centr);  //gen Ncoll for given centrality
  Double_t GetDeltaR(Double_t phi1, Double_t phi2, Double_t eta1, Double_t eta2);
  Double_t GetFractionSharedPt(AliEmcalJet *jRec, AliJetContainer *jconRec, AliEmcalJet *jGen, AliJetContainer *jconGen);

  // ######### STANDARD FUNCTIONS
  void      ExecOnceLocal();                    

  // ########## USAGE TRIGGERS 
  Int_t               fCollisionSystem;      // collision system MySystem
  Int_t               fTypeOfData;           //kind of input data   MyDataType
  Int_t               fTypeOfAnal;           //kind of analysis MyAnalType

  Bool_t              fUseDefaultVertexCut;   // trigger if automatic vertex cut from helper class should be done 
  Bool_t              fUsePileUpCut;          // trigger if pileup cut should be done
  

  // ########## SOURCE INFORMATION
  TString             fRhoTaskName;           // name of rho CMS bg task for this analysis
  TString             fRhoTaskNameMC;         // MC name of rho CMS bg task for this analysis
  // ########## JET/DIJET/RC PROPERTIES
  Double_t            fSignalJetRadius;       // Radius for the signal jets
  Double_t            fSignalJetRadiusSquared;       // Radius for the signal jets
  // ########## CUTS 
  Double_t            fSignalJetEtaWindow;    // +- window in eta for signal jets 
  Double_t            fTrackEtaWindow;        //gc +- window in eta for tracks  
  Double_t            fMinTrackPt;            //gc Min track pt to be accepted  
  Double_t            fMinJetArea;            // Min jet area to be accepted
  TString             fCentralityType;        //gc Used centrality estimate (V0A, V0C, V0M, ...) 
  Double_t            fMinFractionShared;     //Minimal fraction shared by embedded and rec jet

  // ########## EVENT PROPERTIES
  Double_t            fCrossSection;          
  Double_t            fTrials;                
  Double_t            fImpParam;              

  // ########## GENERAL ////VARS
  TRandom3*           fRandom;                
  AliAnalysisUtils*   fHelperClass;           
  Bool_t              fInitializedLocal;           


  Double_t            fTTlow[kTT];  //gc trigger particles TT bin lower boundary
  Double_t            fTThigh[kTT]; //gc trigger particles TT bin upper boundary
  Int_t               fTTType;     // 0=TT selection unscaled, 1=TT scaled according to MB
  Double_t            fDphiCut; //minimal azimuthal angle between trigger and assoc jet 
  Bool_t              fUseDoubleBinPrecision; //use double bin precision


   TH1I               *fHistEvtSelection;     
   TH1D               *fh1Ntriggers[kCAll][kTT];  
   TH1D               *fh1TriggerMult[kCAll][kTT]; 
   TH1D               *fh1NtriggersGen[kCAll][kTT];  
   TH1D               *fh1TriggerMultGen[kCAll][kTT];  
   TH2D               *fHJetSpec[kCAll][kTT][kRho];
   TH2D               *fHJetSpecGen[kCAll][kTT][kRho];

   TH1F    *fhRhoTT[kCAll][kTT][kRho]; 
   TH1F    *fhRhoIncl[kCAll][kRho]; 
 
   TH1F    *fARhoTT[kCAll][kTT][kRho]; 
   //TH1F    *fARhoTTGen[kRho-1]; //! #### jet area times rho from perp cone

   TH1D    *fhDeltaPt[kCAll][kTT][kRho]; 
   TH1D    *fhDeltaPtEmb[kCAll][kTT][kRho]; 
   TH2D    *fhDeltaPtEmb2D[kCAll][kTT][kRho]; 
   TH1D    *fhDeltaPtEmbPerp[kCAll][kTT][kRho]; 
   TH2D    *fhDeltaPtEmbPerp2D[kCAll][kTT][kRho]; 
   TH1D    *fhDeltaPtEmbBc2Bc[kCAll][kTT][kRho]; 
   TH2D    *fhDeltaPtEmbBc2Bc2D[kCAll][kTT][kRho]; 

   TH1D    *fhDeltaPtIncl[kCAll][kRho]; 

   TH2F    *fhKTAreaPt;

   TH2F     *fhJetPhi[kCAll][kTT];   
   TH2F     *fhJetPhiGen[kCAll][kTT];   
   TH2F     *fhTrackPhi[kCAll]; 
   TH2F     *fhJetEta[kCAll][kTT];   
   TH2F     *fhJetEtaGen[kCAll][kTT];   
   TH2F     *fhJetEtaRecoil[kCAll][kTT];
   TH2F     *fhJetEtaRecoilGen[kCAll][kTT];
   TH2F     *fhJetPhiRecoil[kCAll][kTT];
   TH2F     *fhJetPhiRecoilGen[kCAll][kTT];
   TH2F     *fhTrackEta[kCAll]; 
   TH1F     *fhTrackPt[kCAll]; 
   TH1F     *fhTrackPtGen[kCAll]; 
   TH1F     *fhVertexZ;  
   TH1F     *fhVertexXAccept; 
   TH1F     *fhVertexYAccept; 
   TH1F     *fhVertexZAccept; 
   TH1F     *fhVertexXAcceptTT; 
   TH1F     *fhVertexYAcceptTT; 
   TH1F     *fhVertexZAcceptTT; 
   TH1F     *fhVertexZMC;  
   TH1F     *fhVertexZAcceptMC; 
   TH2F     *fhDphiTriggerJet[kCAll][kTT][kRho]; 
   TH2F     *fhDphiTriggerJetGen[kCAll][kTT][kRho]; 
   TH1F     *fhDphiTriggerJetAccept; 
   TH1F     *fhDphiTTTT[kTT]; 

   TH2F     *fhJetPhiIncl;
   TH2F     *fhJetEtaIncl;

   TH1F     *fhCentrality[kCAll];     
   TH1F     *fhCentralityTT[kTT];  
   TH1F     *fhCentralityV0M;  
   TH1F     *fhCentralityV0A;  
   TH1F     *fhCentralityV0C;  
   TH1F     *fhCentralityZNA;  
  
   TH1F     *fhVzeroATotMult[kCAll]; 
   TH1F     *fhVzeroATotMultTT[kCAll][kTT];   

   TH1F     *fhZNAEnergy[kCAll]; 
   TH1F     *fhZNAEnergyTT[kCAll][kTT];   

   TH1D     *fhTrackMultiplicity[kCAll]; 
   TH1D     *fhTrackMultiplicityTT[kCAll][kTT]; 

   THnSparse  *fhZNAVzeroATrack[kCAll]; 
   THnSparse  *fhZNAVzeroATrackTT[kCAll][kTT]; 
   

   //TProfile*     fh1Xsec;   //! gc pythia cross section and trials
   //TH1F*         fh1Trials; //! gc trials are added
   //TH1F*         fh1PtHard;  //! Pt har of the event...      
   TH1D*         fhImpactParameter[kCAll]; 
   TH1D*         fhImpactParameterTT[kCAll][kTT]; 

   TH1D*  fhJetPtGen[kCAll][kRho]; 
   TH2D*  fhJetPtGenVsJetPtRec[kCAll][kRho]; 
   TH2D*  fhJetPtResolutionVsPtGen[kCAll][kRho]; 
   TH2D*  fhPtTrkTruePrimRec[kCAll]; 
   TH2D*  fhPtTrkTruePrimGen[kCAll]; 
   TH2D*  fhPtTrkSecOrFakeRec[kCAll]; 
   TH2D*  fhPtJetPrimVsPtJetRec[21]; 
   TH2D*  fhDiffPtVsPtTrackTrue; 

   TH2D*  fhInvPtQVsPhi[2];   
   TH2D*  fhInvPtQVsEta[2];   
   TH2D*  fhInvPtQVsPhiASide[2];   
   TH2D*  fhInvPtQVsPhiCSide[2];   
   TH2D*  fhSigmaPtOverPtVsPt[2]; 
   TH2F  *fhTrackPhiCG; 
   TH2F  *fhTrackPhiTPCG; 
   
   TH2D*  fhDCAinXVsPt;   
   TH2D*  fhDCAinYVsPt;   
   TH2D*  fhDCAinXVsPtStrange;   
   TH2D*  fhDCAinYVsPtStrange;   
   TH2D*  fhDCAinXVsPtNonStrange;   
   TH2D*  fhDCAinYVsPtNonStrange;   
 

   TArrayD  fRhoRec[kTT];   // labels of particles on reconstructed track level
   TArrayD  fRhoMC[kTT];   // labels of particles on reconstructed track level
   TArrayD  fCentralityBins; //bin boaders


   Int_t  fNofRandomCones; // the number of random cones per event
 
   Double_t fZVertexCut; // vertex cut in z 
   Double_t fCutPhi;     // azimuthal cat around TT  to exclude TTjet + recoil jet in perp rho estimate

   AliVParticle* fTrigTracksGen[kTT][999]; //list of trigger particle indices true MC
   AliVParticle* fTrigTracks[kTT][999]; //list pf trigger particle indices

   Int_t ficb[2];  //centrality bin 0=MB 1=CENT bin
   Double_t ftmpArray[2]; //tmp array
   Double_t ftmpArrayX[3]; //tmp array
   Double_t fVtxArray[3]; //tmp array vx,vy,vz
   TArrayF fpyVtx;   //primaru vertex
   Double_t frhovec[999]; //auxiliary array to store pT/A of kT jets

   AliAnalysisTaskHJetSpectra(const AliAnalysisTaskHJetSpectra&);
   AliAnalysisTaskHJetSpectra& operator=(const AliAnalysisTaskHJetSpectra&);

   ClassDef(AliAnalysisTaskHJetSpectra, 26); // Charged jet analysis for pA

};
#endif