PWG2/FLOW/AliFlowTasks/AliAnalysisTaskFlowEvent.h

   1 /////////////////////////////////////////////////////
   2 // AliAnalysisTaskFlowEvent:
   3 // analysis task to fill the flow event
   4 // and make it available to the flow analysis methods.
   5 //////////////////////////////////////////////////////
   6
   7 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   8 * See cxx source for full Copyright notice */
   9 /* $Id: $ */
  10
  11 #ifndef AliAnalysisTaskFlowEvent_H
  12 #define AliAnalysisTaskFlowEvent_H
  13
  14 class AliCFManager;
  15 class AliFlowEventSimpleMaker;
  16 class TList;
  17 class TRandom3;
  18 class AliAnalysisTaskSE;
  19 class TString;
  20
  21 class AliAnalysisTaskFlowEvent : public AliAnalysisTaskSE {
  22  public:
  23   AliAnalysisTaskFlowEvent();
  24   AliAnalysisTaskFlowEvent(const char *name, TString RPtype, Bool_t QAon, UInt_t seed=666);
  25   virtual ~AliAnalysisTaskFlowEvent();
  26
  27   virtual void   UserCreateOutputObjects();
  28   virtual void   UserExec(Option_t *option);
  29   virtual void   Terminate(Option_t *);
  30
  31   void    SetAnalysisType(TString type) { this->fAnalysisType = type; }
  32   TString GetAnalysisType() const       { return this->fAnalysisType; }
  33
  34   void    SetRPType(TString rptype) { this->fRPType = rptype; }
  35   TString GetRPType() const         { return this->fRPType; }
  36
  37   void    SetMinMult(Int_t multmin)    {this->fMinMult = multmin; }
  38   Int_t   GetMinMult() const           {return this->fMinMult; }
  39   void    SetMaxMult(Int_t multmax)    {this->fMaxMult = multmax; }
  40   Int_t   GetMaxMult() const           {return this->fMaxMult; }
  41
  42   void SetSubeventEtaRange(Double_t minA, Double_t maxA, Double_t minB, Double_t maxB)
  43     {this->fMinA = minA; this->fMaxA = maxA; this->fMinB = minB; this->fMaxB = maxB; }
  44   Double_t GetMinA() const {return this->fMinA;}
  45   Double_t GetMaxA() const {return this->fMaxA;}
  46   Double_t GetMinB() const {return this->fMinB;}
  47   Double_t GetMaxB() const {return this->fMaxB;}
  48
  49   void DefineDeadZone( Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax )
  50   {this->fExcludedEtaMin = etaMin; this->fExcludedEtaMax = etaMax;
  51     this->fExcludedPhiMin = phiMin; this->fExcludedPhiMax = phiMax; }
  52
  53   void          SetCFManager1(AliCFManager* cfmgr) {this->fCFManager1 = cfmgr; }
  54   AliCFManager* GetCFManager1()           {return this->fCFManager1; }
  55   void          SetCFManager2(AliCFManager* cfmgr) {this->fCFManager2 = cfmgr; }
  56   AliCFManager* GetCFManager2()           {return this->fCFManager2; }
  57   void          SetQAList1(TList* list)   {this->fQAInt = list; }
  58   TList*        GetQAList1()              {return this->fQAInt; }
  59   void          SetQAList2(TList* list)   {this->fQADiff = list; }
  60   TList*        GetQAList2()              {return this->fQADiff; }
  61   void          SetQAOn(Bool_t kt)        {this->fQA = kt; }
  62   Bool_t        GetQAOn()                 {return this->fQA; }
  63
  64   // setters for common constants
  65   void SetNbinsMult( Int_t i ) { fNbinsMult = i; }
  66   void SetNbinsPt( Int_t i )   { fNbinsPt = i; }
  67   void SetNbinsPhi( Int_t i )  { fNbinsPhi = i; }
  68   void SetNbinsEta( Int_t i )  { fNbinsEta = i; }
  69   void SetNbinsQ( Int_t i )    { fNbinsQ = i; }
  70
  71   void SetMultMin( Double_t i ) { fMultMin = i; }
  72   void SetMultMax( Double_t i ) { fMultMax = i; }
  73   void SetPtMin( Double_t i )   { fPtMin = i; }
  74   void SetPtMax( Double_t i )   { fPtMax = i; }
  75   void SetPhiMin( Double_t i )  { fPhiMin = i; }
  76   void SetPhiMax( Double_t i )  { fPhiMax = i; }
  77   void SetEtaMin( Double_t i )  { fEtaMin = i; }
  78   void SetEtaMax( Double_t i )  { fEtaMax = i; }
  79   void SetQMin( Double_t i )    { fQMin = i; }
  80   void SetQMax( Double_t i )    { fQMax = i; }
  81   // end setters common constants
  82
  83   // setters for adding by hand flow values (afterburner)
  84   void SetAfterburnerOn(Bool_t b=kTRUE) {fAfterburnerOn=b;}
  85   void SetNonFlowNumberOfTrackClones(Int_t n) {fNonFlowNumberOfTrackClones=n;}
  86   void SetFlow(Double_t v1, Double_t v2, Double_t v3, Double_t v4) {fV1=v1;fV2=v2;fV3=v3;fV4=v4;}
  87   // end setters afterburner
  88
  89  private:
  90
  91   AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  92   AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  93
  94   //  TFile*        fOutputFile;    // temporary output file for testing
  95   //  AliESDEvent*  fESD;           // ESD object
  96   //  AliAODEvent*  fAOD;           // AOD object
  97   TString       fAnalysisType;      // can be MC, ESD or AOD
  98   TString       fRPType;            // can be Global or Tracklet or FMD
  99   AliCFManager* fCFManager1;        // correction framework manager
 100   AliCFManager* fCFManager2;        // correction framework manager
 101   TList*        fQAInt;             // QA histogram list
 102   TList*        fQADiff;            // QA histogram list
 103   Int_t         fMinMult;           // Minimum multiplicity from tracks selected using CORRFW
 104   Int_t         fMaxMult;           // Maximum multiplicity from tracks selected using CORRFW
 105   Double_t      fMinA;              // Minimum of eta range for subevent A
 106   Double_t      fMaxA;              // Maximum of eta range for subevent A
 107   Double_t      fMinB;              // Minimum of eta range for subevent B
 108   Double_t      fMaxB;              // Maximum of eta range for subevent B
 109
 110   Bool_t fQA;                       // flag to set the filling of the QA hostograms
 111
 112   // setters for common constants
 113   //histogram sizes
 114   Int_t  fNbinsMult; // histogram size
 115   Int_t  fNbinsPt;   // histogram size
 116   Int_t  fNbinsPhi;  // histogram size
 117   Int_t  fNbinsEta;  // histogram size
 118   Int_t  fNbinsQ;    // histogram size
 119
 120   // Histograms limits
 121   Double_t  fMultMin;  // histogram limit
 122   Double_t  fMultMax;  // histogram limit
 123   Double_t  fPtMin;    // histogram limit
 124   Double_t  fPtMax;    // histogram limit
 125   Double_t  fPhiMin;   // histogram limit
 126   Double_t  fPhiMax;   // histogram limit
 127   Double_t  fEtaMin;   // histogram limit
 128   Double_t  fEtaMax;   // histogram limit
 129   Double_t  fQMin;     // histogram limit
 130   Double_t  fQMax;     // histogram limit
 131   // end common constants
 132
 133   // Excluding a range
 134   Double_t  fExcludedEtaMin;  // excluded region limit
 135   Double_t  fExcludedEtaMax;  // excluded region limit
 136   Double_t  fExcludedPhiMin;  // excluded region limit
 137   Double_t  fExcludedPhiMax;  // excluded region limit
 138   // End of excluding a range
 139
 140   // values afterburner
 141   Bool_t    fAfterburnerOn;              // do we afterburn?
 142   Int_t     fNonFlowNumberOfTrackClones; // number of times to clone the particles (nonflow)
 143   Double_t  fV1;        // Add Flow. Must be in range [0,0.5].
 144   Double_t  fV2;        // Add Flow. Must be in range [0,0.5].
 145   Double_t  fV3;        // Add Flow. Must be in range [0,0.5].
 146   Double_t  fV4;        // Add Flow. Must be in range [0,0.5].
 147
 148   TRandom3* fMyTRandom3;     // TRandom3 generator
 149   // end afterburner
 150
 151   ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
 152 };
 153
 154 #endif
 155