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