[u/mrichter/AliRoot.git] / PWG / FLOW / Tasks / AliAnalysisTaskFlowEvent.h

/////////////////////////////////////////////////////
// AliAnalysisTaskFlowEvent:
// analysis task to fill the flow event 
// and make it available to the flow analysis methods.
//////////////////////////////////////////////////////

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice */
/* $Id: $ */

#ifndef ALIANALYSISTASKFLOWEVENT_H
#define ALIANALYSISTASKFLOWEVENT_H

#include "AliFlowTrackSimple.h"

class AliCFManager;
class AliFlowEventCuts;
class AliFlowTrackCuts;
class AliFlowEventSimpleMaker;
class AliFlowEvent;
class TList;
class TRandom3;
class AliAnalysisTaskSE;
class TString;
class AliESDpid;

class AliAnalysisTaskFlowEvent : public AliAnalysisTaskSE {
 public:
  AliAnalysisTaskFlowEvent();
  AliAnalysisTaskFlowEvent(const char *name, TString RPtype, Bool_t QAon, UInt_t seed=666, Bool_t bCandidates=kFALSE);
  virtual ~AliAnalysisTaskFlowEvent();
  
  virtual void   UserCreateOutputObjects();
  virtual void   UserExec(Option_t *option);
  virtual void   Terminate(Option_t *);
  virtual void   NotifyRun();

  void    SetAnalysisType(TString type) { this->fAnalysisType = type; }
  TString GetAnalysisType() const       { return this->fAnalysisType; }

  void    SetRPType(TString rptype) { this->fRPType = rptype; }
  TString GetRPType() const         { return this->fRPType; }

  void    SetMinMult(Int_t multmin)    {this->fMinMult = multmin; }
  Int_t   GetMinMult() const           {return this->fMinMult; }
  void    SetMaxMult(Int_t multmax)    {this->fMaxMult = multmax; }
  Int_t   GetMaxMult() const           {return this->fMaxMult; }

  void SetSubeventEtaRange(Double_t minA, Double_t maxA, Double_t minB, Double_t maxB)
    {this->fMinA = minA; this->fMaxA = maxA; this->fMinB = minB; this->fMaxB = maxB; }
  Double_t GetMinA() const {return this->fMinA;}
  Double_t GetMaxA() const {return this->fMaxA;}
  Double_t GetMinB() const {return this->fMinB;}
  Double_t GetMaxB() const {return this->fMaxB;}
  
  void DefineDeadZone( Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax )
  {this->fExcludedEtaMin = etaMin; this->fExcludedEtaMax = etaMax; 
    this->fExcludedPhiMin = phiMin; this->fExcludedPhiMax = phiMax; }

  void          SetCutsEvent(AliFlowEventCuts* cutsEvent) {fCutsEvent=cutsEvent;}
  AliFlowEventCuts* GetCutsEvent() const {return fCutsEvent;}
  void          SetCutsRP(AliFlowTrackCuts* cutsRP) {fCutContainer->Add(cutsRP); fCutsRP=cutsRP; cutsRP->SetFlowTagType(AliFlowTrackSimple::kRP);}
  AliFlowTrackCuts* GetCutsRP() const {return fCutsRP;} //to be reimplemented
  void          SetCutsPOI(AliFlowTrackCuts* cutsPOI) {fCutContainer->Add(cutsPOI); fCutsPOI=cutsPOI; cutsPOI->SetFlowTagType(AliFlowTrackSimple::kPOI);}
  AliFlowTrackCuts* GetCutsPOI() const {return fCutsPOI;} //to be reimplemented

  void          SetCFManager1(AliCFManager* cfmgr) {this->fCFManager1 = cfmgr; } 
  AliCFManager* GetCFManager1() const {return this->fCFManager1; }
  void          SetCFManager2(AliCFManager* cfmgr) {this->fCFManager2 = cfmgr; } 
  AliCFManager* GetCFManager2() const       {return this->fCFManager2; }
  TList*        GetQAList()      const      {return fQAList; }
  void          SetQAOn(Bool_t kt)        {fQAon = kt; }
  Bool_t        GetQAOn()   const         {return fQAon; }

  // setters for common constants
  void SetNbinsMult( Int_t i ) { fNbinsMult = i; }
  void SetNbinsPt( Int_t i )   { fNbinsPt = i; }
  void SetNbinsPhi( Int_t i )  { fNbinsPhi = i; }
  void SetNbinsEta( Int_t i )  { fNbinsEta = i; }
  void SetNbinsQ( Int_t i )    { fNbinsQ = i; }
  void SetNbinsMass( Int_t i ) { fNbinsMass = i; }
   
  void SetMultMin( Double_t i ) { fMultMin = i; }
  void SetMultMax( Double_t i ) { fMultMax = i; }
  void SetPtMin( Double_t i )   { fPtMin = i; }
  void SetPtMax( Double_t i )   { fPtMax = i; }
  void SetPhiMin( Double_t i )  { fPhiMin = i; }
  void SetPhiMax( Double_t i )  { fPhiMax = i; }
  void SetEtaMin( Double_t i )  { fEtaMin = i; }
  void SetEtaMax( Double_t i )  { fEtaMax = i; }
  void SetQMin( Double_t i )    { fQMin = i; }
  void SetQMax( Double_t i )    { fQMax = i; }
  void SetMassMin( Double_t i ) { fMassMin = i; }
  void SetMassMax( Double_t i ) { fMassMax = i; }
  void SetHistWeightvsPhiMin( Double_t i ) {fHistWeightvsPhiMin=i;}
  void SetHistWeightvsPhiMax( Double_t i ) {fHistWeightvsPhiMax=i;}
  // end setters common constants

  // setters for adding by hand flow values (afterburner)
  void SetAfterburnerOn(Bool_t b=kTRUE) {fAfterburnerOn=b;}
  void SetNonFlowNumberOfTrackClones(Int_t n) {fNonFlowNumberOfTrackClones=n;}
  void SetFlow( Double_t v1, Double_t v2, Double_t v3=0.0, Double_t v4=0.0, Double_t v5=0.0)
               {fV1=v1;fV2=v2;fV3=v3;fV4=v4;fV5=v5;}
  // end setters afterburner

 private:

  AliAnalysisTaskFlowEvent(const AliAnalysisTaskFlowEvent& aAnalysisTask);
  AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask); 

  //  TFile*        fOutputFile;    // temporary output file for testing
  //  AliESDEvent*  fESD;           // ESD object
  //  AliAODEvent*  fAOD;           // AOD object
  TString       fAnalysisType;      // can be MC, ESD or AOD
  TString       fRPType;            // can be Global or Tracklet or FMD
  AliCFManager* fCFManager1;        // correction framework manager
  AliCFManager* fCFManager2;        // correction framework manager
  AliFlowEventCuts* fCutsEvent;     //event cuts
  AliFlowTrackCuts* fCutsRP;        //cuts for RPs
  AliFlowTrackCuts* fCutsPOI;       //cuts for POIs
  TList*            fCutContainer;  //contains the cut objects
  TList*        fQAList;             // QA histogram list
  Int_t         fMinMult;           // Minimum multiplicity from tracks selected using CORRFW
  Int_t         fMaxMult;           // Maximum multiplicity from tracks selected using CORRFW 
  Double_t      fMinA;              // Minimum of eta range for subevent A
  Double_t      fMaxA;              // Maximum of eta range for subevent A
  Double_t      fMinB;              // Minimum of eta range for subevent B
  Double_t      fMaxB;              // Maximum of eta range for subevent B

  Bool_t fQAon;                       // flag to set the filling of the QA hostograms
  Bool_t fLoadCandidates;           // true if reciving candidates collection

  // setters for common constants
  //histogram sizes
  Int_t  fNbinsMult; // histogram size
  Int_t  fNbinsPt;   // histogram size
  Int_t  fNbinsPhi;  // histogram size
  Int_t  fNbinsEta;  // histogram size
  Int_t  fNbinsQ;    // histogram size
  Int_t  fNbinsMass; // histogram size
 
  // Histograms limits
  Double_t  fMultMin;  // histogram limit 
  Double_t  fMultMax;  // histogram limit
  Double_t  fPtMin;    // histogram limit
  Double_t  fPtMax;    // histogram limit
  Double_t  fPhiMin;   // histogram limit
  Double_t  fPhiMax;   // histogram limit
  Double_t  fEtaMin;   // histogram limit
  Double_t  fEtaMax;   // histogram limit
  Double_t  fQMin;     // histogram limit
  Double_t  fQMax;     // histogram limit
  Double_t  fMassMin;  // histogram limit
  Double_t  fMassMax;  // histogram limit
  Double_t fHistWeightvsPhiMin; //histogram limit
  Double_t fHistWeightvsPhiMax; //histogram limit
  // end common constants

  // Excluding a range
  Double_t  fExcludedEtaMin;  // excluded region limit 
  Double_t  fExcludedEtaMax;  // excluded region limit 
  Double_t  fExcludedPhiMin;  // excluded region limit 
  Double_t  fExcludedPhiMax;  // excluded region limit 
  // End of excluding a range

  // values afterburner
  Bool_t    fAfterburnerOn;              // do we afterburn?
  Int_t     fNonFlowNumberOfTrackClones; // number of times to clone the particles (nonflow) 
  Double_t  fV1;        // Add Flow. Must be in range [0,0.5].
  Double_t  fV2;        // Add Flow. Must be in range [0,0.5].
  Double_t  fV3;        // Add Flow. Must be in range [0,0.5].
  Double_t  fV4;        // Add Flow. Must be in range [0,0.5].
  Double_t  fV5;        // Add Flow. Must be in range [0,0.5].

  AliFlowEvent* fFlowEvent; //flowevent
    
  TRandom3* fMyTRandom3;     // TRandom3 generator
  // end afterburner
  
  ClassDef(AliAnalysisTaskFlowEvent, 1); // example of analysis
};

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