PWG/FLOW/Tasks/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 #include "AliFlowTrackSimple.h"
  15
  16 class AliCFManager;
  17 class AliFlowEventCuts;
  18 class AliFlowTrackCuts;
  19 class AliFlowEventSimpleMaker;
  20 class AliFlowEvent;
  21 class TList;
  22 class TF1;
  23 class TRandom3;
  24 class AliAnalysisTaskSE;
  25 class TString;
  26 class AliESDpid;
  27
  28 class AliAnalysisTaskFlowEvent : public AliAnalysisTaskSE {
  29  public:
  30   AliAnalysisTaskFlowEvent();
  31   AliAnalysisTaskFlowEvent(const char *name, TString RPtype = "", Bool_t QAon = kFALSE, UInt_t seed=666, Bool_t bCandidates=kFALSE);
  32   virtual ~AliAnalysisTaskFlowEvent();
  33
  34   virtual void   UserCreateOutputObjects();
  35   virtual void   UserExec(Option_t *option);
  36   virtual void   Terminate(Option_t *);
  37   virtual void   NotifyRun();
  38
  39   void    SetAnalysisType(TString type) { this->fAnalysisType = type; }
  40   TString GetAnalysisType() const       { return this->fAnalysisType; }
  41
  42   void    SetRPType(TString rptype) { this->fRPType = rptype; }
  43   TString GetRPType() const         { return this->fRPType; }
  44
  45   void    SetMinMult(Int_t multmin)    {this->fMinMult = multmin; }
  46   Int_t   GetMinMult() const           {return this->fMinMult; }
  47   void    SetMaxMult(Int_t multmax)    {this->fMaxMult = multmax; }
  48   Int_t   GetMaxMult() const           {return this->fMaxMult; }
  49
  50   void SetSubeventEtaRange(Double_t minA, Double_t maxA, Double_t minB, Double_t maxB)
  51     {this->fMinA = minA; this->fMaxA = maxA; this->fMinB = minB; this->fMaxB = maxB; }
  52   Double_t GetMinA() const {return this->fMinA;}
  53   Double_t GetMaxA() const {return this->fMaxA;}
  54   Double_t GetMinB() const {return this->fMinB;}
  55   Double_t GetMaxB() const {return this->fMaxB;}
  56
  57   void DefineDeadZone( Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax )
  58   {this->fExcludedEtaMin = etaMin; this->fExcludedEtaMax = etaMax;
  59     this->fExcludedPhiMin = phiMin; this->fExcludedPhiMax = phiMax; }
  60
  61   void          SetCutsEvent(AliFlowEventCuts* cutsEvent) {fCutsEvent=cutsEvent;}
  62   AliFlowEventCuts* GetCutsEvent() const {return fCutsEvent;}
  63   void          SetCutsRP(AliFlowTrackCuts* cutsRP) {fCutContainer->AddAt(cutsRP,0); fCutsRP=cutsRP; cutsRP->SetPOItype(0); }
  64   AliFlowTrackCuts* GetCutsRP() const {return fCutsRP;} //to be reimplemented
  65   void          SetCutsPOI(AliFlowTrackCuts* cutsPOI) {fCutContainer->AddAt(cutsPOI,1); fCutsPOI=cutsPOI; cutsPOI->SetPOItype(1); }
  66   AliFlowTrackCuts* GetCutsPOI() const {return fCutsPOI;} //to be reimplemented
  67
  68   void          SetCFManager1(AliCFManager* cfmgr) {this->fCFManager1 = cfmgr; }
  69   AliCFManager* GetCFManager1() const {return this->fCFManager1; }
  70   void          SetCFManager2(AliCFManager* cfmgr) {this->fCFManager2 = cfmgr; }
  71   AliCFManager* GetCFManager2() const       {return this->fCFManager2; }
  72   TList*        GetQAList()      const      {return fQAList; }
  73   void          SetQAOn(Bool_t kt)        {fQAon = kt; }
  74   Bool_t        GetQAOn()   const         {return fQAon; }
  75
  76   void          SetShuffleTracks(Bool_t b)  {fShuffleTracks=b;}
  77
  78   // setters for common constants
  79   void SetNbinsMult( Int_t i ) { fNbinsMult = i; }
  80   void SetNbinsPt( Int_t i )   { fNbinsPt = i; }
  81   void SetNbinsPhi( Int_t i )  { fNbinsPhi = i; }
  82   void SetNbinsEta( Int_t i )  { fNbinsEta = i; }
  83   void SetNbinsQ( Int_t i )    { fNbinsQ = i; }
  84   void SetNbinsMass( Int_t i ) { fNbinsMass = i; }
  85
  86   void SetMultMin( Double_t i ) { fMultMin = i; }
  87   void SetMultMax( Double_t i ) { fMultMax = i; }
  88   void SetPtMin( Double_t i )   { fPtMin = i; }
  89   void SetPtMax( Double_t i )   { fPtMax = i; }
  90   void SetPhiMin( Double_t i )  { fPhiMin = i; }
  91   void SetPhiMax( Double_t i )  { fPhiMax = i; }
  92   void SetEtaMin( Double_t i )  { fEtaMin = i; }
  93   void SetEtaMax( Double_t i )  { fEtaMax = i; }
  94   void SetQMin( Double_t i )    { fQMin = i; }
  95   void SetQMax( Double_t i )    { fQMax = i; }
  96   void SetMassMin( Double_t i ) { fMassMin = i; }
  97   void SetMassMax( Double_t i ) { fMassMax = i; }
  98   void SetHistWeightvsPhiMin( Double_t i ) {fHistWeightvsPhiMin=i;}
  99   void SetHistWeightvsPhiMax( Double_t i ) {fHistWeightvsPhiMax=i;}
 100   // end setters common constants
 101
 102   // setters for adding by hand flow values (afterburner)
 103   void SetAfterburnerOn(Bool_t b=kTRUE) {fAfterburnerOn=b;}
 104   void SetNonFlowNumberOfTrackClones(Int_t n) {fNonFlowNumberOfTrackClones=n;}
 105   void SetPtDifferentialV2( TF1 *gPtV2) {
 106     fDifferentialV2 = gPtV2;}
 107   void SetFlow( Double_t v1, Double_t v2, Double_t v3=0.0, Double_t v4=0.0, Double_t v5=0.0)
 108                {fV1=v1;fV2=v2;fV3=v3;fV4=v4;fV5=v5;}
 109   // end setters afterburner
 110
 111  private:
 112
 113   AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
 114   AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask);
 115
 116   //  TFile*        fOutputFile;    // temporary output file for testing
 117   //  AliESDEvent*  fESD;           // ESD object
 118   //  AliAODEvent*  fAOD;           // AOD object
 119   TString       fAnalysisType;      // can be MC, ESD or AOD
 120   TString       fRPType;            // can be Global or Tracklet or FMD
 121   AliCFManager* fCFManager1;        // correction framework manager
 122   AliCFManager* fCFManager2;        // correction framework manager
 123   AliFlowEventCuts* fCutsEvent;     //event cuts
 124   AliFlowTrackCuts* fCutsRP;        //cuts for RPs
 125   AliFlowTrackCuts* fCutsPOI;       //cuts for POIs
 126   TList*            fCutContainer;  //contains the cut objects
 127   TList*        fQAList;             // QA histogram list
 128   Int_t         fMinMult;           // Minimum multiplicity from tracks selected using CORRFW
 129   Int_t         fMaxMult;           // Maximum multiplicity from tracks selected using CORRFW
 130   Double_t      fMinA;              // Minimum of eta range for subevent A
 131   Double_t      fMaxA;              // Maximum of eta range for subevent A
 132   Double_t      fMinB;              // Minimum of eta range for subevent B
 133   Double_t      fMaxB;              // Maximum of eta range for subevent B
 134
 135   Bool_t fQAon;                       // flag to set the filling of the QA hostograms
 136   Bool_t fLoadCandidates;           // true if reciving candidates collection
 137
 138   // setters for common constants
 139   //histogram sizes
 140   Int_t  fNbinsMult; // histogram size
 141   Int_t  fNbinsPt;   // histogram size
 142   Int_t  fNbinsPhi;  // histogram size
 143   Int_t  fNbinsEta;  // histogram size
 144   Int_t  fNbinsQ;    // histogram size
 145   Int_t  fNbinsMass; // histogram size
 146
 147   // Histograms limits
 148   Double_t  fMultMin;  // histogram limit
 149   Double_t  fMultMax;  // histogram limit
 150   Double_t  fPtMin;    // histogram limit
 151   Double_t  fPtMax;    // histogram limit
 152   Double_t  fPhiMin;   // histogram limit
 153   Double_t  fPhiMax;   // histogram limit
 154   Double_t  fEtaMin;   // histogram limit
 155   Double_t  fEtaMax;   // histogram limit
 156   Double_t  fQMin;     // histogram limit
 157   Double_t  fQMax;     // histogram limit
 158   Double_t  fMassMin;  // histogram limit
 159   Double_t  fMassMax;  // histogram limit
 160   Double_t fHistWeightvsPhiMin; //histogram limit
 161   Double_t fHistWeightvsPhiMax; //histogram limit
 162   // end common constants
 163
 164   // Excluding a range
 165   Double_t  fExcludedEtaMin;  // excluded region limit
 166   Double_t  fExcludedEtaMax;  // excluded region limit
 167   Double_t  fExcludedPhiMin;  // excluded region limit
 168   Double_t  fExcludedPhiMax;  // excluded region limit
 169   // End of excluding a range
 170
 171   // values afterburner
 172   Bool_t    fAfterburnerOn;              // do we afterburn?
 173   Int_t     fNonFlowNumberOfTrackClones; // number of times to clone the particles (nonflow)
 174   Double_t  fV1;        // Add Flow. Must be in range [0,0.5].
 175   Double_t  fV2;        // Add Flow. Must be in range [0,0.5].
 176   Double_t  fV3;        // Add Flow. Must be in range [0,0.5].
 177   Double_t  fV4;        // Add Flow. Must be in range [0,0.5].
 178   Double_t  fV5;        // Add Flow. Must be in range [0,0.5].
 179   TF1 *fDifferentialV2; // pt-differential v2
 180
 181   AliFlowEvent* fFlowEvent; //flowevent
 182   Bool_t fShuffleTracks;    //serve the tracks shuffled
 183
 184   TRandom3* fMyTRandom3;     // TRandom3 generator
 185   // end afterburner
 186
 187   ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
 188 };
 189
 190 #endif
 191