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,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    SetMinMult(Int_t multmin)    {this->fMinMult = multmin; }
  35   Int_t   GetMinMult() const           {return this->fMinMult; }
  36   void    SetMaxMult(Int_t multmax)    {this->fMaxMult = multmax; }
  37   Int_t   GetMaxMult() const           {return this->fMaxMult; }
  38
  39   void SetSubeventEtaRange(Double_t minA, Double_t maxA, Double_t minB, Double_t maxB)
  40     {this->fMinA = minA; this->fMaxA = maxA; this->fMinB = minB; this->fMaxB = maxB; }
  41   Double_t GetMinA() const {return this->fMinA;}
  42   Double_t GetMaxA() const {return this->fMaxA;}
  43   Double_t GetMinB() const {return this->fMinB;}
  44   Double_t GetMaxB() const {return this->fMaxB;}
  45
  46   void          SetCFManager1(AliCFManager* cfmgr) {this->fCFManager1 = cfmgr; }
  47   AliCFManager* GetCFManager1()           {return this->fCFManager1; }
  48   void          SetCFManager2(AliCFManager* cfmgr) {this->fCFManager2 = cfmgr; }
  49   AliCFManager* GetCFManager2()           {return this->fCFManager2; }
  50   void          SetQAList1(TList* list)   {this->fQAInt = list; }
  51   TList*        GetQAList1()              {return this->fQAInt; }
  52   void          SetQAList2(TList* list)   {this->fQADiff = list; }
  53   TList*        GetQAList2()              {return this->fQADiff; }
  54   void          SetQAOn(Bool_t kt)        {this->fQA = kt; }
  55   Bool_t        GetQAOn()                 {return this->fQA; }
  56
  57   //setters for adding by hand flow values (afterburner)
  58   void SetMCReactionPlaneAngle(Double_t fPhiRP)  { this->fMCReactionPlaneAngle = fPhiRP; }
  59   void SetNoOfLoops(Int_t noofl) {this->fNoOfLoops = noofl;}
  60   Int_t GetNoOfLoops() const {return this->fNoOfLoops;}
  61   void SetEllipticFlowValue(Double_t elfv) {this->fEllipticFlowValue = elfv;}
  62   Double_t GetEllipticFlowValue() const {return this->fEllipticFlowValue;}
  63   void SetSigmaEllipticFlowValue(Double_t sigelfv) {this->fSigmaEllipticFlowValue = sigelfv;}
  64   Double_t GetSigmaEllipticFlowValue() const {return this->fSigmaEllipticFlowValue;}
  65   void SetMultiplicityOfEvent(Int_t multevnt) {this->fMultiplicityOfEvent = multevnt;}
  66   Int_t GetMultiplicityOfEvent() const {return this->fMultiplicityOfEvent;}
  67   void SetSigmaMultiplicityOfEvent(Int_t sigmultevnt) {this->fSigmaMultiplicityOfEvent = sigmultevnt;}
  68   Int_t GetSigmaMultiplicityOfEvent() const {return this->fSigmaMultiplicityOfEvent;}
  69   //end setters afterburner
  70
  71  private:
  72
  73   AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  74   AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  75
  76   //  TFile*        fOutputFile;              // temporary output file for testing
  77   //  AliESDEvent*  fESD;                   // ESD object
  78   //  AliAODEvent*  fAOD;                   // AOD object
  79   AliFlowEventSimpleMaker* fEventMaker; // FlowEventSimple maker object
  80   TString       fAnalysisType;          // can be MC, ESD or AOD
  81   AliCFManager* fCFManager1;            // correction framework manager
  82   AliCFManager* fCFManager2;            // correction framework manager
  83   TList*        fQAInt;                 // QA histogram list
  84   TList*        fQADiff;                // QA histogram list
  85   Int_t         fMinMult;               // Minimum multiplicity from tracks selected using CORRFW
  86   Int_t         fMaxMult;               // Maximum multiplicity from tracks selected using CORRFW
  87   Double_t      fMinA;                  // Minimum of eta range for subevent A
  88   Double_t      fMaxA;                  // Maximum of eta range for subevent A
  89   Double_t      fMinB;                  // Minimum of eta range for subevent B
  90   Double_t      fMaxB;                  // Maximum of eta range for subevent B
  91
  92   Bool_t fQA;                             // flag to set the filling of the QA hostograms
  93   // values afterburner
  94   Double_t  fMCReactionPlaneAngle;   // the angle of the reaction plane from the MC truth
  95   Int_t     fCount;   // counter for the number of events processed
  96   Int_t     fNoOfLoops; // number of times to use the same particle (nonflow)
  97   Double_t  fEllipticFlowValue; // Add Flow. Must be in range [0,1].
  98   Double_t  fSigmaEllipticFlowValue; // Sigma Flow (Gaussian). Must be in range [0,1].
  99   Int_t     fMultiplicityOfEvent; // Set maximal multiplicity.
 100   Int_t     fSigmaMultiplicityOfEvent; // Sigma multiplicity (Gaussian).
 101
 102   TRandom3* fMyTRandom3; // our TRandom3 generator
 103   Bool_t fbAfterburnerOn;
 104   // end afterburner
 105
 106   ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
 107 };
 108
 109 #endif
 110