PWG/FLOW/Tasks/AliAnalysisTaskJetFlow.h

   1 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. */
   2 /* See cxx source for full Copyright notice */
   3 /* $Id$ */
   4
   5 #ifndef AliAnalysisTaskJetFlow_H
   6 #define AliAnalysisTaskJetFlow_H
   7
   8 // root includes
   9 #include <TMath.h>
  10 //aliroot includes
  11 #include <AliAnalysisTaskSE.h>
  12 // forward declarations
  13 class TString;
  14 class TList;
  15 class TArrayD;
  16 class TClonesArray;
  17 class AliFlowTrackCuts;
  18 class AliFlowEventCuts;
  19 class AliFlowEvent;
  20 class TH1;
  21 class AliAnalysisTaskRhoVnModulation;
  22
  23 class AliAnalysisTaskJetFlow : public AliAnalysisTaskSE
  24 {
  25     public:
  26         // enumerators
  27         enum dataType           {kESD, kAOD, kESDMC, kAODMC };  // data type
  28         // constructors, destructor
  29                                 AliAnalysisTaskJetFlow();
  30                                 AliAnalysisTaskJetFlow(
  31                                         const char* name,
  32                                         AliAnalysisTaskRhoVnModulation* rhoTask,
  33                                         Bool_t VPart,           // use jets or tracks as pois
  34                                         Bool_t VZEROEP,         // do vzero ep method
  35                                         Bool_t QC2,             // do qc2 method
  36                                         Bool_t QC4,             // do simple qc4 method FIXME not implemented yet
  37                                         Bool_t FlowPackageSP,   // call flow package vzero scalar product
  38                                         Bool_t FlowPackageQC    // call flow package nth order q-cumulants
  39                                         );
  40         virtual                 ~AliAnalysisTaskJetFlow();
  41         // virtual methods
  42         virtual void            UserCreateOutputObjects();
  43         virtual void            UserExec(Option_t* option);
  44         virtual void            Terminate(Option_t* option);
  45         // setters
  46         void                    SetDebugMode(Int_t d)                   {fDebug         = d;}
  47         void                    SetCCMinPt(Float_t m)                   {fCCMinPt       = m;}
  48         void                    SetCCMaxPt(Float_t m)                   {fCCMaxPt       = m;}
  49         void                    SetCCBinsInPt(Int_t b)                  {fCCBinsInPt    = b;}
  50         void                    SetMinMaxCentrality(Float_t min, Float_t max)   {fCentralityMin = min; fCentralityMax = max; }
  51         void                    SetMinimizeDiffBins(Bool_t b)           {fMinimizeDiffBins = b; }
  52         void                    SetPtBins(TArrayD* pt)                  {fPtBins = pt; }
  53         void                    SetDoMultWeight(Bool_t m)               {fDoMultWeight = m; }
  54         void                    SetDoPtWeight(Bool_t p)                 {fDoPtWeight = p; }
  55         // cuts
  56         Bool_t                  PassesCuts();
  57         // analysis details
  58         void                    DoVZEROFlowAnalysis();
  59         void                    DoQC2FlowAnalysis();
  60         void                    DoQC4FlowAnalysis();
  61         Bool_t                  DoFlowPackageFlowAnalysis();
  62         // q-cumulant helper calculations TODO move to AliAnlaysisTaskRhoVnModulation for consistency
  63         void                    QCnDiffentialFlowVectors(Double_t* repn, Double_t* impn, Double_t *mp, Double_t *reqn, Double_t *imqn, Double_t* mq, Int_t n);
  64
  65     private:
  66
  67         // analysis flags and task setup specifics
  68         Int_t                   fDebug;                 // debug level (0 none, 1 fcn calls, 2 verbose)
  69         TString                 fJetsName;              // name of jet list
  70         TString                 fTracksName;            // name of track list
  71         TClonesArray*           fPois;                  //! array with pois
  72         TList*                  fOutputList;            //! output list
  73         dataType                fDataType;              //! data type
  74         Bool_t                  fVParticleAnalysis;     // do the analysis on vparticles instead of jets
  75         Bool_t                  fMinimizeDiffBins;      // minimize variables (for low statistics)
  76         Bool_t                  fDoVZEROFlowAnalysis;   // do vzero flow analysis
  77         Bool_t                  fDoQC2FlowAnalysis;     // do qc2 flow analysis
  78         Bool_t                  fDoQC4FlowAnalysis;     // do qc4 flow analysis
  79         Bool_t                  fDoQCFPAnalysis;        // do qc fp analysis
  80         Bool_t                  fDoSPFPAnalysis;        // do sp fp analyis
  81         Bool_t                  fDoMultWeight;          // weight events with multiplicity
  82         Bool_t                  fDoPtWeight;            // introduce pt weighting for rp's and poi's
  83         Bool_t                  fInitialized;           //! check if the analysis is initialized
  84         // members
  85         Bool_t                  fUsePtWeight;           // use pt weights for the qc analysis
  86         Float_t                 fCCMinPt;               // min pt for flow analysis(common constants)
  87         Float_t                 fCCMaxPt;               // max pt for flow analysis (common constants)
  88         Int_t                   fCCBinsInPt;            // bins in pt for flow analysis (common constants)
  89         Float_t                 fCentralityMin;         // minimium centrality
  90         Float_t                 fCentralityMax;         // maximum centrality
  91         TArrayD*                fPtBins;                // custom pt bins for flow analysis
  92         // cut objects
  93         AliFlowTrackCuts*       fCutsRP_VZERO;          //! rp cuts for fzero
  94         AliFlowTrackCuts*       fCutsNull;              //! empty cuts
  95         AliFlowEventCuts*       fCutsEvent;             //! event cuts
  96         // containers, setup
  97         AliFlowEvent*           fFlowEvent_TPC;         //! container for flow analysis
  98         AliFlowEvent*           fFlowEvent_VZERO;       //! container for flow analysis
  99         AliAnalysisTaskRhoVnModulation* fRhoVn;         // common cuts and settings master object, see class header
 100         // histograms
 101         TH1F*                   fHistAnalysisSummary;   //! analysis summary
 102         TH1F*                   fCentralitySelection;   //! centrality selection
 103         // for event plane flow analysis
 104         TH1F*                   fVZEROAEP;              //! VZEROA EP
 105         TH1F*                   fVZEROCEP;              //! VZEROC EP
 106         TProfile*               fv2VZEROA;              //! v2 from VZEROA
 107         TProfile*               fv2VZEROC;              //! v2 from VZEROC
 108         // for qc flow analysis
 109         TProfile*               fRefCumulants;          //! (weighted) reference cumulant
 110         TProfile*               fDiffCumlantsV2;        //! (weighted) differential cumulant
 111         TProfile*               fDiffCumlantsV3;        //! (weighted) differential cumulant
 112         TH1F*                   fQC2v2;                 //! final qc2 result
 113         TH1F*                   fQC2v3;                 //! final qc2 result
 114         // additional histograms
 115         TProfile*               fTempA;                 //! internal bookkeeping
 116         TProfile*               fTempC;                 //! internal bookkeeping
 117
 118         AliAnalysisTaskJetFlow(const AliAnalysisTaskJetFlow&);                  // not implemented
 119         AliAnalysisTaskJetFlow& operator=(const AliAnalysisTaskJetFlow&);       // not implemented
 120
 121         ClassDef(AliAnalysisTaskJetFlow, 4);
 122 };
 123
 124 #endif