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=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          SetCFManager1(AliCFManager* cfmgr) {this->fCFManager1 = cfmgr; }
  50   AliCFManager* GetCFManager1()           {return this->fCFManager1; }
  51   void          SetCFManager2(AliCFManager* cfmgr) {this->fCFManager2 = cfmgr; }
  52   AliCFManager* GetCFManager2()           {return this->fCFManager2; }
  53   void          SetQAList1(TList* list)   {this->fQAInt = list; }
  54   TList*        GetQAList1()              {return this->fQAInt; }
  55   void          SetQAList2(TList* list)   {this->fQADiff = list; }
  56   TList*        GetQAList2()              {return this->fQADiff; }
  57   void          SetQAOn(Bool_t kt)        {this->fQA = kt; }
  58   Bool_t        GetQAOn()                 {return this->fQA; }
  59
  60   // setters for common constants
  61   void SetNbinsMult( Int_t i ) { fNbinsMult = i; }
  62   void SetNbinsPt( Int_t i )   { fNbinsPt = i; }
  63   void SetNbinsPhi( Int_t i )  { fNbinsPhi = i; }
  64   void SetNbinsEta( Int_t i )  { fNbinsEta = i; }
  65   void SetNbinsQ( Int_t i )    { fNbinsQ = i; }
  66
  67   void SetMultMin( Double_t i ) { fMultMin = i; }
  68   void SetMultMax( Double_t i ) { fMultMax = i; }
  69   void SetPtMin( Double_t i )   { fPtMin = i; }
  70   void SetPtMax( Double_t i )   { fPtMax = i; }
  71   void SetPhiMin( Double_t i )  { fPhiMin = i; }
  72   void SetPhiMax( Double_t i )  { fPhiMax = i; }
  73   void SetEtaMin( Double_t i )  { fEtaMin = i; }
  74   void SetEtaMax( Double_t i )  { fEtaMax = i; }
  75   void SetQMin( Double_t i )    { fQMin = i; }
  76   void SetQMax( Double_t i )    { fQMax = i; }
  77   // end setters common constants
  78
  79   // setters for adding by hand flow values (afterburner)
  80   void SetMCReactionPlaneAngle(Double_t fPhiRP)  { this->fMCReactionPlaneAngle = fPhiRP; }
  81   void SetNoOfLoops(Int_t noofl) {this->fNoOfLoops = noofl;}
  82   Int_t GetNoOfLoops() const {return this->fNoOfLoops;}
  83   void SetEllipticFlowValue(Double_t elfv) {this->fEllipticFlowValue = elfv;}
  84   Double_t GetEllipticFlowValue() const {return this->fEllipticFlowValue;}
  85   void SetSigmaEllipticFlowValue(Double_t sigelfv) {this->fSigmaEllipticFlowValue = sigelfv;}
  86   Double_t GetSigmaEllipticFlowValue() const {return this->fSigmaEllipticFlowValue;}
  87   void SetMultiplicityOfEvent(Int_t multevnt) {this->fMultiplicityOfEvent = multevnt;}
  88   Int_t GetMultiplicityOfEvent() const {return this->fMultiplicityOfEvent;}
  89   void SetSigmaMultiplicityOfEvent(Int_t sigmultevnt) {this->fSigmaMultiplicityOfEvent = sigmultevnt;}
  90   Int_t GetSigmaMultiplicityOfEvent() const {return this->fSigmaMultiplicityOfEvent;}
  91   // end setters afterburner
  92
  93  private:
  94
  95   AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  96   AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  97
  98   //  TFile*        fOutputFile;    // temporary output file for testing
  99   //  AliESDEvent*  fESD;           // ESD object
 100   //  AliAODEvent*  fAOD;           // AOD object
 101   TString       fAnalysisType;      // can be MC, ESD or AOD
 102   TString       fRPType;            // can be Global or Tracklet or FMD
 103   AliCFManager* fCFManager1;        // correction framework manager
 104   AliCFManager* fCFManager2;        // correction framework manager
 105   TList*        fQAInt;             // QA histogram list
 106   TList*        fQADiff;            // QA histogram list
 107   Int_t         fMinMult;           // Minimum multiplicity from tracks selected using CORRFW
 108   Int_t         fMaxMult;           // Maximum multiplicity from tracks selected using CORRFW
 109   Double_t      fMinA;              // Minimum of eta range for subevent A
 110   Double_t      fMaxA;              // Maximum of eta range for subevent A
 111   Double_t      fMinB;              // Minimum of eta range for subevent B
 112   Double_t      fMaxB;              // Maximum of eta range for subevent B
 113
 114   Bool_t fQA;                       // flag to set the filling of the QA hostograms
 115
 116   // setters for common constants
 117   //histogram sizes
 118   Int_t  fNbinsMult; // histogram size
 119   Int_t  fNbinsPt;   // histogram size
 120   Int_t  fNbinsPhi;  // histogram size
 121   Int_t  fNbinsEta;  // histogram size
 122   Int_t  fNbinsQ;    // histogram size
 123
 124   // Histograms limits
 125   Double_t  fMultMin;  // histogram limit
 126   Double_t  fMultMax;  // histogram limit
 127   Double_t  fPtMin;    // histogram limit
 128   Double_t  fPtMax;    // histogram limit
 129   Double_t  fPhiMin;   // histogram limit
 130   Double_t  fPhiMax;   // histogram limit
 131   Double_t  fEtaMin;   // histogram limit
 132   Double_t  fEtaMax;   // histogram limit
 133   Double_t  fQMin;     // histogram limit
 134   Double_t  fQMax;     // histogram limit
 135   // end common constants
 136
 137   // values afterburner
 138   Double_t  fMCReactionPlaneAngle;     // the angle of the reaction plane from the MC truth
 139   Int_t     fCount;                    // counter for the number of events processed
 140   Int_t     fNoOfLoops;                // number of times to use the same particle (nonflow)
 141   Double_t  fEllipticFlowValue;        // Add Flow. Must be in range [0,1].
 142   Double_t  fSigmaEllipticFlowValue;   // Sigma Flow (Gaussian). Must be in range [0,1].
 143   Int_t     fMultiplicityOfEvent;      // Set maximal multiplicity.
 144   Int_t     fSigmaMultiplicityOfEvent; // Sigma multiplicity (Gaussian).
 145
 146   TRandom3* fMyTRandom3;     // TRandom3 generator
 147   Bool_t    fbAfterburnerOn;
 148   // end afterburner
 149
 150   ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
 151 };
 152
 153 #endif
 154