AliAnalysisTaskCmeEse.h

Go to the documentation of this file.

#ifndef ALIANALYSISTASKCMEESE_H
#define ALIANALYSISTASKCMEESE_H

// ROOT includes
#include <TList.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TF1.h>
#include <TSpline.h>
#include <THnSparse.h>

// AliRoot includes
#include "AliAnalysisTaskSE.h"
#include "AliAODEvent.h"
#include "AliVHeader.h"
#include "AliVVertex.h"
#include "AliVEvent.h"
#include "AliVTrack.h"


class AliAnalysisTaskCmeEse : public AliAnalysisTaskSE {
    public:
        AliAnalysisTaskCmeEse();
        AliAnalysisTaskCmeEse(const char *name);

        virtual ~AliAnalysisTaskCmeEse();

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

        virtual void  SetVtxCut(Double_t vtxCut){fVtxCut = vtxCut;}
        virtual void  SetFilterbit(UInt_t filterbit){fFilterbit = filterbit;} 
        virtual void  SetNoClus(Int_t noclus){fNoClus = noclus;}  
        virtual void  SetEtaCut(Double_t etaCut){fEtaCut = etaCut;}
        virtual void  SetMinPt(Double_t minPt){fMinPt = minPt;}
        virtual void  SetMaxPt(Double_t maxPt){fMaxPt = maxPt;}
        virtual void  SetFlagLHC10h(Bool_t IsLHC10h){fLHC10h = IsLHC10h;}
        virtual void  SetFlagPileUp(Bool_t IsPileUP){fPileUp = IsPileUP;}
        virtual void  SetCentFlag(Short_t nCent){fCent = nCent;}
        virtual void  SetFlagRecEff(Bool_t IsRec){fRecEff = IsRec;}
        virtual void  SetFlagQAV0(Bool_t isQAV0){fQAV0 = isQAV0;}
        virtual void  SetFlagQATrk(Bool_t isTrkQA){fTrkQA = isTrkQA;}


    private:
        virtual Float_t GetVertex(AliAODEvent* aod) const;
        virtual void Analyze(AliAODEvent* aod, Float_t vtxZ);
        void OpenInfoCalbration(Int_t run);
        Short_t GetPercCode(Double_t perc) const;
        virtual Int_t GetTPCMult(AliVEvent* ev) const;
        virtual Int_t GetGlobalMult(AliVEvent* ev) const;
        Double_t GetWDist(const AliVVertex* v0, const AliVVertex* v1);
        Bool_t plpMV(const AliVEvent *event);


        AliAODEvent* fAOD;                

        Int_t        fRun;                // run number - for calibration
        TH1D*        fMultV0;             // profile from V0 multiplicity

        TH1D*        fQx2mV0A;            // <Qx2> V0A
        TH1D*        fQy2mV0A;            // <Qy2> V0A
        TH1D*        fQx2sV0A;            // sigma Qx2 V0A
        TH1D*        fQy2sV0A;            // sigma Qy2 V0A
        TH1D*        fQx2mV0C;            // <Qx2> V0C
        TH1D*        fQy2mV0C;            // <Qy2> V0C
        TH1D*        fQx2sV0C;            // sigma Qx2 V0C
        TH1D*        fQy2sV0C;            // sigma Qy2 V0C

        // Cuts and options
        TF1*         fFitRecLow;          // rec eff fit 1
        TF1*         fFitRecHigh;         // rec eff fit 2
        Bool_t       fRecEff;             // rec eff flag
        Double_t     fVtxCut;             // Vtx cut on z position in cm
        UInt_t       fFilterbit;          // filter bit
        Double_t     fEtaCut;             // Eta cut used to select particles
        Int_t        fNoClus;           // No of TPC clusters
        Double_t     fMinPt;              // Min pt - for histogram limits
        Double_t     fMaxPt;              // Max pt - for histogram limits
        Bool_t       fLHC10h;             // flag to LHC10h data
        Bool_t       fPileUp;             // flag for pileup
        Short_t      fCent;               // centrality flag
        Bool_t       fQAV0;               // qa V0 flag
        Bool_t       fTrkQA;              // qa for tracks
        TSpline3*    fSplQ2c[90];         // splines for q2 V0C

        // Output objects
        TList*        fListOfObjects;     
        TH1I*         fVtx;               
        TH1F*         fVtxBeforeCuts;     
        TH1F*         fVtxAfterCuts;      
        TH2F*         fMultCorBeforeCuts; 
        TH2F*         fMultCorAfterCuts;  

        TH2D*         fPercqc2;          

        THnSparseF*    fAllQA;               

        TH2D*         fQxavsV0Bef;          
        TH2D*         fQyavsV0Bef;          
        TH2D*         fQxcvsV0Bef;          
        TH2D*         fQycvsV0Bef;          

        TH2D*         fQxavsVtxZBef;          
        TH2D*         fQyavsVtxZBef;          
        TH2D*         fQxcvsVtxZBef;          
        TH2D*         fQycvsVtxZBef;          


        TH2D*         fQxavsV0Aft;          
        TH2D*         fQyavsV0Aft;          
        TH2D*         fQxcvsV0Aft;          
        TH2D*         fQycvsV0Aft;          

        TH2D*         fQxavsVtxZAft;          
        TH2D*         fQyavsVtxZAft;          
        TH2D*         fQxcvsVtxZAft;          
        TH2D*         fQycvsVtxZAft;          


        TProfile*     fV2A;              
        TProfile*     fV0AV0Cv2;         
        TProfile*     fV0ATPCv2;         
        TProfile*     fV0CTPCv2;         

        TProfile*     fCMESameQPos;  
        TProfile*     fCMESameQNeg;  
        TProfile*     fCMEOppQ;      

        TProfile*     fCMESameQPosCos;  
        TProfile*     fCMESameQPosSin;  
        TProfile*     fCMESameQPosv1;   

        TProfile*     fCMESameQNegCos;  
        TProfile*     fCMESameQNegSin;  
        TProfile*     fCMESameQNegv1;   

        TProfile*     fCMEOppQCos;  
        TProfile*     fCMEOppQSin;  
        TProfile*     fCMEOppQv1;   



        TProfile*     fV2Aqc2[10];        
        TProfile*     fV0AV0Cv2qc2[10];   
        TProfile*     fV0ATPCv2qc2[10];   
        TProfile*     fV0CTPCv2qc2[10];   

        TProfile*     fCMESameQPosqc2[10];  
        TProfile*     fCMESameQNegqc2[10];  
        TProfile*     fCMEOppQqc2[10];      

        TProfile*     fCMESameQPosCosqc2[10];  
        TProfile*     fCMESameQPosSinqc2[10];  
        TProfile*     fCMESameQPosv1qc2[10];   

        TProfile*     fCMESameQNegCosqc2[10];  
        TProfile*     fCMESameQNegSinqc2[10];  
        TProfile*     fCMESameQNegv1qc2[10];   

        TProfile*     fCMEOppQCosqc2[10];  
        TProfile*     fCMEOppQSinqc2[10];  
        TProfile*     fCMEOppQv1qc2[10];   


        TProfile*     fV2Pt[9];              

        TProfile*     fCMESameQPosEta[9];    
        TProfile*     fCMESameQPosPtDif[9];  
        TProfile*     fCMESameQPosPtSum[9];  

        TProfile*     fCMESameQNegEta[9];    
        TProfile*     fCMESameQNegPtDif[9];  
        TProfile*     fCMESameQNegPtSum[9];  

        TProfile*     fCMEOppQEta[9];        
        TProfile*     fCMEOppQPtDif[9];      
        TProfile*     fCMEOppQPtSum[9];      


        TH1D*         fPsiA[10];               
        TH1D*         fPsiC[10];               
        TH2D*         fPsiAvsPsiC[10];         


        TProfile*     fV2Ptqc2[9][10];            

        TProfile*     fCMESameQPosEtaqc2[9][10];  
        TProfile*     fCMESameQPosPtDifqc2[9][10];  
        TProfile*     fCMESameQPosPtSumqc2[9][10];  

        TProfile*     fCMESameQNegEtaqc2[9][10];  
        TProfile*     fCMESameQNegPtDifqc2[9][10];  
        TProfile*     fCMESameQNegPtSumqc2[9][10];  

        TProfile*     fCMEOppQEtaqc2[9][10];      
        TProfile*     fCMEOppQPtDifqc2[9][10];      
        TProfile*     fCMEOppQPtSumqc2[9][10];      


        AliAnalysisTaskCmeEse(const AliAnalysisTaskCmeEse&);
        AliAnalysisTaskCmeEse& operator=(const AliAnalysisTaskCmeEse&);

        ClassDef(AliAnalysisTaskCmeEse, 1);
};

#endif