Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file source file inheritance tree (.pdf)

Sections: class description function members data members class charts

AliRoot » PWG » FLOW » TASKS » AliAnalysisTaskFlowEvent

class AliAnalysisTaskFlowEvent: public AliAnalysisTaskSE

 AliAnalysisTaskFlowEvent:

 analysis task for filling the flow event
 from MCEvent, ESD, AOD ....
 and put it in an output stream so it can
 be used by the various flow analysis methods
 for cuts the correction framework is used
 which also outputs QA histograms to view
 the effects of the cuts

Function Members (Methods)

public:

	AliAnalysisTaskFlowEvent()
	AliAnalysisTaskFlowEvent(const char* name, TString RPtype = "", Bool_t QAon = kFALSE, UInt_t seed = 666, Bool_t bCandidates = kFALSE)
virtual	~AliAnalysisTaskFlowEvent()
virtual void	TTask::Abort()MENU
void	TObject::AbstractMethod(const char* method) const
virtual void	TTask::Add(TTask* task)
virtual void	AliAnalysisTaskSE::AddAODBranch(const char* cname, void* addobj, const char* fname = "")
virtual AliAODEvent*	AliAnalysisTaskSE::AODEvent() const
virtual void	TObject::AppendPad(Option_t* option = "")
Bool_t	AliAnalysisTask::AreSlotsConnected()
virtual void	TTask::Browse(TBrowser* b)
Bool_t	AliAnalysisTask::CheckCircularDeps()
void	AliAnalysisTask::CheckNotify(Bool_t init = kFALSE)
virtual Bool_t	AliAnalysisTask::CheckOwnership() const
virtual Bool_t	AliAnalysisTask::CheckPostData() const
static TClass*	Class()
virtual const char*	TObject::ClassName() const
virtual void	TTask::CleanTasks()
virtual void	TTask::Clear(Option_t* option = "")
virtual TObject*	TNamed::Clone(const char* newname = "") const
virtual Int_t	TNamed::Compare(const TObject* obj) const
Bool_t	AliAnalysisTask::ConnectInput(Int_t islot, AliAnalysisDataContainer* cont)
virtual void	AliAnalysisTaskSE::ConnectInputData(Option_t* option = "")
Bool_t	AliAnalysisTask::ConnectOutput(Int_t islot, AliAnalysisDataContainer* cont)
virtual void	TTask::Continue()MENU
virtual void	TNamed::Copy(TObject& named) const
virtual void	AliAnalysisTaskSE::CreateOutputObjects()
virtual const char*	AliAnalysisTaskSE::CurrentFileName()
virtual Int_t	AliAnalysisTaskSE::DebugLevel() const
void	DefineDeadZone(Double_t etaMin, Double_t etaMax, Double_t phiMin, Double_t phiMax)
virtual void	TObject::Delete(Option_t* option = "")MENU
virtual Int_t	TObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual void	TObject::Draw(Option_t* option = "")
virtual void	TObject::DrawClass() constMENU
virtual TObject*	TObject::DrawClone(Option_t* option = "") constMENU
virtual void	TObject::Dump() constMENU
virtual Long64_t	AliAnalysisTaskSE::Entry() const
virtual void	TObject::Error(const char* method, const char* msgfmt) const
virtual AliESDfriend*	AliAnalysisTaskSE::ESDfriend() const
virtual const AliEventTag*	AliAnalysisTaskSE::EventTag() const
virtual void	AliAnalysisTaskSE::Exec(Option_t* option)
virtual void	TObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual void	TObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual void	TObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual void	TTask::ExecuteTask(Option_t* option = "0")MENU
virtual void	TTask::ExecuteTasks(Option_t* option)
virtual void	TObject::Fatal(const char* method, const char* msgfmt) const
virtual void	TNamed::FillBuffer(char*& buffer)
virtual TObject*	TObject::FindObject(const char* name) const
virtual TObject*	TObject::FindObject(const TObject* obj) const
virtual void	AliAnalysisTask::FinishTaskOutput()
TString	GetAnalysisType() const
void	AliAnalysisTask::GetBranches(const char* type, TString& result) const
Int_t	TTask::GetBreakin() const
Int_t	TTask::GetBreakout() const
AliCFManager*	GetCFManager1() const
AliCFManager*	GetCFManager2() const
virtual UInt_t	AliAnalysisTaskSE::GetCollisionCandidates() const
AliFlowEventCuts*	GetCutsEvent() const
AliFlowTrackCuts*	GetCutsPOI() const
AliFlowTrackCuts*	GetCutsRP() const
virtual Option_t*	TObject::GetDrawOption() const
static Long_t	TObject::GetDtorOnly()
virtual const char*	TObject::GetIconName() const
TObject*	AliAnalysisTask::GetInputData(Int_t islot) const
AliAnalysisDataSlot*	AliAnalysisTask::GetInputSlot(Int_t islot) const
TClass*	AliAnalysisTask::GetInputType(Int_t islot) const
TList*	TTask::GetListOfTasks() const
Double_t	GetMaxA() const
Double_t	GetMaxB() const
Int_t	GetMaxMult() const
Double_t	GetMinA() const
Double_t	GetMinB() const
Int_t	GetMinMult() const
virtual const char*	TNamed::GetName() const
Int_t	AliAnalysisTask::GetNinputs() const
Int_t	AliAnalysisTask::GetNoutputs() const
virtual char*	TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_t	TObject::GetObjectStat()
virtual Option_t*	TObject::GetOption() const
TObject*	AliAnalysisTask::GetOutputData(Int_t islot) const
AliAnalysisDataSlot*	AliAnalysisTask::GetOutputSlot(Int_t islot) const
TClass*	AliAnalysisTask::GetOutputType(Int_t islot) const
TObject*	AliAnalysisTask::GetPublishedData() const
virtual TList*	AliAnalysisTaskSE::GetQAHistos() const
TList*	GetQAList() const
Bool_t	GetQAOn() const
TString	GetRPType() const
virtual const char*	TNamed::GetTitle() const
virtual UInt_t	TObject::GetUniqueID() const
virtual Bool_t	TObject::HandleTimer(TTimer* timer)
Bool_t	AliAnalysisTask::HasBranches() const
Bool_t	AliAnalysisTask::HasExecuted() const
virtual ULong_t	TNamed::Hash() const
virtual void	TObject::Info(const char* method, const char* msgfmt) const
virtual Bool_t	TObject::InheritsFrom(const char* classname) const
virtual Bool_t	TObject::InheritsFrom(const TClass* cl) const
virtual void	AliAnalysisTaskSE::Init()
virtual AliVEvent*	AliAnalysisTaskSE::InputEvent() const
virtual void	TObject::Inspect() constMENU
void	TObject::InvertBit(UInt_t f)
virtual TClass*	IsA() const
Bool_t	TTask::IsActive() const
Bool_t	AliAnalysisTask::IsChecked() const
virtual Bool_t	TObject::IsEqual(const TObject* obj) const
virtual Bool_t	AliAnalysisTaskSE::IsEventInBinZero()
virtual Bool_t	TTask::IsFolder() const
Bool_t	AliAnalysisTask::IsInitialized() const
Bool_t	TObject::IsOnHeap() const
Bool_t	AliAnalysisTask::IsOutputReady(Int_t islot) const
Bool_t	AliAnalysisTask::IsPostEventLoop() const
Bool_t	AliAnalysisTask::IsReady() const
virtual Bool_t	TNamed::IsSortable() const
virtual Bool_t	AliAnalysisTaskSE::IsStandardAOD() const
Bool_t	AliAnalysisTask::IsUsed() const
Bool_t	AliAnalysisTask::IsZombie() const
void	AliAnalysisTaskSE::LoadBranches() const
virtual void	AliAnalysisTask::LocalInit()
virtual void	TTask::ls(Option_t* option = "*") constMENU
void	TObject::MayNotUse(const char* method) const
virtual AliMCEvent*	AliAnalysisTaskSE::MCEvent() const
virtual Bool_t	AliAnalysisTaskSE::Notify()
virtual Bool_t	AliAnalysisTask::NotifyBinChange()
virtual void	NotifyRun()
void	TObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static void	TObject::operator delete(void* ptr)
static void	TObject::operator delete(void* ptr, void* vp)
static void	TObject::operator delete[](void* ptr)
static void	TObject::operator delete[](void* ptr, void* vp)
void*	TObject::operator new(size_t sz)
void*	TObject::operator new(size_t sz, void* vp)
void*	TObject::operator new[](size_t sz)
void*	TObject::operator new[](size_t sz, void* vp)
virtual TTree*	AliAnalysisTaskSE::OutputTree() const
virtual void	TObject::Paint(Option_t* option = "")
virtual void	TObject::Pop()
virtual void	TNamed::Print(Option_t* option = "") const
void	AliAnalysisTask::PrintContainers(Option_t* option = "all", Int_t indent = 0) const
virtual void	AliAnalysisTask::PrintTask(Option_t* option = "all", Int_t indent = 0) const
Bool_t	AliAnalysisTask::ProducersTouched() const
virtual Int_t	TObject::Read(const char* name)
virtual void	TObject::RecursiveRemove(TObject* obj)
virtual void	AliAnalysisTask::Reset()
void	TObject::ResetBit(UInt_t f)
virtual void	TObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual void	TObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
virtual void	AliAnalysisTaskSE::SelectCollisionCandidates(UInt_t offlineTriggerMask = AliVEvent::kMB)
void	TTask::SetActive(Bool_t active = kTRUE)TOGGLE
void	SetAfterburnerOn(Bool_t b = kTRUE)
void	SetAnalysisType(TString type)
void	TObject::SetBit(UInt_t f)
void	TObject::SetBit(UInt_t f, Bool_t set)
void	AliAnalysisTask::SetBranches(const char* names)
void	TTask::SetBreakin(Int_t breakin = 1)TOGGLE
void	TTask::SetBreakout(Int_t breakout = 1)TOGGLE
void	SetCFManager1(AliCFManager* cfmgr)
void	SetCFManager2(AliCFManager* cfmgr)
void	AliAnalysisTask::SetChecked(Bool_t flag = kTRUE)
void	SetCutsEvent(AliFlowEventCuts* cutsEvent)
void	SetCutsPOI(AliFlowTrackCuts* cutsPOI)
void	SetCutsRP(AliFlowTrackCuts* cutsRP)
virtual void	AliAnalysisTaskSE::SetDebugLevel(Int_t level)
virtual void	TObject::SetDrawOption(Option_t* option = "")MENU
static void	TObject::SetDtorOnly(void* obj)
void	SetEtaMax(Double_t i)
void	SetEtaMin(Double_t i)
void	SetFlow(Double_t v1, Double_t v2, Double_t v3 = 0.0, Double_t v4 = 0.0, Double_t v5 = 0.0)
void	SetHistWeightvsPhiMax(Double_t i)
void	SetHistWeightvsPhiMin(Double_t i)
void	SetMassMax(Double_t i)
void	SetMassMin(Double_t i)
void	SetMaxMult(Int_t multmax)
void	SetMinMult(Int_t multmin)
void	SetMultMax(Double_t i)
void	SetMultMin(Double_t i)
virtual void	TNamed::SetName(const char* name)MENU
virtual void	TNamed::SetNameTitle(const char* name, const char* title)
void	SetNbinsEta(Int_t i)
void	SetNbinsMass(Int_t i)
void	SetNbinsMult(Int_t i)
void	SetNbinsPhi(Int_t i)
void	SetNbinsPt(Int_t i)
void	SetNbinsQ(Int_t i)
void	SetNonFlowNumberOfTrackClones(Int_t n)
static void	TObject::SetObjectStat(Bool_t stat)
void	SetPhiMax(Double_t i)
void	SetPhiMin(Double_t i)
void	AliAnalysisTask::SetPostEventLoop(Bool_t flag = kTRUE)
void	SetPtDifferentialV2(TF1* gPtV2)
void	SetPtMax(Double_t i)
void	SetPtMin(Double_t i)
void	SetQAOn(Bool_t kt)
void	SetQMax(Double_t i)
void	SetQMin(Double_t i)
void	SetRPType(TString rptype)
void	SetShuffleTracks(Bool_t b)
void	SetSubeventEtaRange(Double_t minA, Double_t maxA, Double_t minB, Double_t maxB)
virtual void	TNamed::SetTitle(const char* title = "")MENU
virtual void	TObject::SetUniqueID(UInt_t uid)
void	AliAnalysisTask::SetUsed(Bool_t flag = kTRUE)
void	AliAnalysisTask::SetZombie(Bool_t flag = kTRUE)
virtual void	ShowMembers(TMemberInspector&)
virtual Int_t	TNamed::Sizeof() const
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual void	TObject::SysError(const char* method, const char* msgfmt) const
virtual void	Terminate(Option_t*)
Bool_t	TObject::TestBit(UInt_t f) const
Int_t	TObject::TestBits(UInt_t f) const
virtual void	TObject::UseCurrentStyle()
virtual void	UserCreateOutputObjects()
virtual void	UserExec(Option_t* option)
virtual void	AliAnalysisTaskSE::UserExecMix(Option_t*)
virtual Bool_t	AliAnalysisTaskSE::UserNotify()
virtual void	TObject::Warning(const char* method, const char* msgfmt) const
virtual Int_t	TObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_t	TObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const

protected:

void	AliAnalysisTaskSE::ConnectMultiHandler()
void	AliAnalysisTask::DefineInput(Int_t islot, TClass* type)
void	AliAnalysisTask::DefineOutput(Int_t islot, TClass* type)
void	AliAnalysisTaskSE::DisconnectMultiHandler()
virtual void	TObject::DoError(int level, const char* location, const char* fmt, va_list va) const
void	AliAnalysisTask::EnableBranch(Int_t islot, const char* bname) const
char*	AliAnalysisTask::GetBranchAddress(Int_t islot, const char* branch) const
void	TObject::MakeZombie()
TFile*	AliAnalysisTask::OpenFile(Int_t iout, Option_t* option = "RECREATE") const
Bool_t	AliAnalysisTask::PostData(Int_t iout, TObject* data, Option_t* option = "")
Bool_t	AliAnalysisTask::SetBranchAddress(Int_t islot, const char* branch, void* address) const

private:

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

Data Members

public:

enum AliAnalysisTask::EAnalysisTaskFlags {	kTaskUsed
	kTaskZombie
	kTaskChecked
	kTaskPostEventLoop
};
enum TObject::EStatusBits {	kCanDelete
	kMustCleanup
	kObjInCanvas
	kIsReferenced
	kHasUUID
	kCannotPick
	kNoContextMenu
	kInvalidObject
};
enum TObject::[unnamed] {	kIsOnHeap
	kNotDeleted
	kZombie
	kBitMask
	kSingleKey
	kOverwrite
	kWriteDelete
};

protected:

Bool_t	TTask::fActive	true if task is active
TString	AliAnalysisTask::fBranchNames	List of input branches that need to be loaded for this task
Int_t	TTask::fBreakin	=1 if a break point set at task extry
Int_t	TTask::fBreakout	=1 if a break point set at task exit
Int_t	AliAnalysisTaskSE::fCurrentRunNumber	! Current run number
Int_t	AliAnalysisTaskSE::fDebug	Debug flag
AliESDfriend*	AliAnalysisTaskSE::fESDfriend	! ESD friend
Int_t	AliAnalysisTaskSE::fEntry	Current entry in the chain
Bool_t	TTask::fHasExecuted	True if task has executed
TList*	AliAnalysisTaskSE::fHistosQA	! Output histos for QA
Bool_t	AliAnalysisTask::fInitialized	True if Init() was called
AliVEvent*	AliAnalysisTaskSE::fInputEvent	! VEvent Input
AliInputEventHandler*	AliAnalysisTaskSE::fInputHandler	! Input Handler
TObjArray*	AliAnalysisTask::fInputs	Array of input slots
AliMCEvent*	AliAnalysisTaskSE::fMCEvent	! MC
AliInputEventHandler*	AliAnalysisTaskSE::fMCEventHandler	! pointer to MCEventHandler
AliMultiInputEventHandler*	AliAnalysisTaskSE::fMultiInputHandler	! pointer to multihandler
TString	TNamed::fName	object identifier
Int_t	AliAnalysisTask::fNinputs	Number of inputs
Int_t	AliAnalysisTask::fNoutputs	Number of outputs
UInt_t	AliAnalysisTaskSE::fOfflineTriggerMask	Task processes collision candidates only
TString	TTask::fOption	Option specified in ExecuteTask
AliAODEvent*	AliAnalysisTaskSE::fOutputAOD	! AOD out
Bool_t*	AliAnalysisTask::fOutputReady	[fNoutputs] Flags for output readyness
TObjArray*	AliAnalysisTask::fOutputs	Array of output slots
TObject*	AliAnalysisTask::fPublishedData	! published data
Bool_t	AliAnalysisTask::fReady	Flag if the task is ready
TList*	TTask::fTasks	List of Tasks
TString	TNamed::fTitle	object title
TTree*	AliAnalysisTaskSE::fTreeA	AOD output Tree
static TClonesArray*	AliAnalysisTaskSE::fgAODCaloClusters	! CaloClusters for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODDimuons	! Dimuons replication
static AliAODCaloTrigger*	AliAnalysisTaskSE::fgAODEMCALTrigger	! Emcal Trigger for replication
static AliAODCaloCells*	AliAnalysisTaskSE::fgAODEmcalCells	! Emcal Cell replication
static TClonesArray*	AliAnalysisTaskSE::fgAODFMDClusters	! FMDClusters for replication
static AliAODHeader*	AliAnalysisTaskSE::fgAODHeader	! Header for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODHmpidRings	! HMPID replication
static TClonesArray*	AliAnalysisTaskSE::fgAODJets	! Jets for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODMCParticles	! MC Particles for replicatio
static AliAODCaloTrigger*	AliAnalysisTaskSE::fgAODPHOSTrigger	! Phos Trigger for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODPMDClusters	! PMDClusters for replication
static AliAODCaloCells*	AliAnalysisTaskSE::fgAODPhosCells	! Phos Cell replication
static AliAODTracklets*	AliAnalysisTaskSE::fgAODTracklets	! Tracklets for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODTracks	! Tracks for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODV0s	! V0s for replication
static AliAODVZERO*	AliAnalysisTaskSE::fgAODVZERO	! VZERO for replication
static TClonesArray*	AliAnalysisTaskSE::fgAODVertices	! Vertices for replication
static TTask*	TTask::fgBeginTask	pointer to task initiator
static TTask*	TTask::fgBreakPoint	pointer to current break point
static AliTOFHeader*	AliAnalysisTaskSE::fgTOFHeader	! TOFHeader for replication

private:

Bool_t	fAfterburnerOn	do we afterburn?
TString	fAnalysisType	can be MC, ESD or AOD
AliCFManager*	fCFManager1	correction framework manager
AliCFManager*	fCFManager2	correction framework manager
TList*	fCutContainer	contains the cut objects
AliFlowEventCuts*	fCutsEvent	event cuts
AliFlowTrackCuts*	fCutsPOI	cuts for POIs
AliFlowTrackCuts*	fCutsRP	cuts for RPs
TF1*	fDifferentialV2	pt-differential v2
Double_t	fEtaMax	histogram limit
Double_t	fEtaMin	histogram limit
Double_t	fExcludedEtaMax	excluded region limit
Double_t	fExcludedEtaMin	excluded region limit
Double_t	fExcludedPhiMax	excluded region limit
Double_t	fExcludedPhiMin	excluded region limit
AliFlowEvent*	fFlowEvent	flowevent
Double_t	fHistWeightvsPhiMax	histogram limit
Double_t	fHistWeightvsPhiMin	histogram limit
Bool_t	fLoadCandidates	true if reciving candidates collection
Double_t	fMassMax	histogram limit
Double_t	fMassMin	histogram limit
Double_t	fMaxA	Maximum of eta range for subevent A
Double_t	fMaxB	Maximum of eta range for subevent B
Int_t	fMaxMult	Maximum multiplicity from tracks selected using CORRFW
Double_t	fMinA	Minimum of eta range for subevent A
Double_t	fMinB	Minimum of eta range for subevent B
Int_t	fMinMult	Minimum multiplicity from tracks selected using CORRFW
Double_t	fMultMax	histogram limit
Double_t	fMultMin	histogram limit
TRandom3*	fMyTRandom3	TRandom3 generator
Int_t	fNbinsEta	histogram size
Int_t	fNbinsMass	histogram size
Int_t	fNbinsMult	histogram size
Int_t	fNbinsPhi	histogram size
Int_t	fNbinsPt	histogram size
Int_t	fNbinsQ	histogram size
Int_t	fNonFlowNumberOfTrackClones	number of times to clone the particles (nonflow)
Double_t	fPhiMax	histogram limit
Double_t	fPhiMin	histogram limit
Double_t	fPtMax	histogram limit
Double_t	fPtMin	histogram limit
TList*	fQAList	QA histogram list
Bool_t	fQAon	flag to set the filling of the QA hostograms
Double_t	fQMax	histogram limit
Double_t	fQMin	histogram limit
TString	fRPType	can be Global or Tracklet or FMD
Bool_t	fShuffleTracks	serve the tracks shuffled
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].

Class Charts

Inheritance Chart:

TTask

←

AliAnalysisTask

←

AliAnalysisTaskSE

←

AliAnalysisTaskFlowEvent

Function documentation

AliAnalysisTaskFlowEvent()

  fOutputFile(NULL),
 Constructor

AliAnalysisTaskFlowEvent(const char* name, TString RPtype = "", Bool_t QAon = kFALSE, UInt_t seed = 666, Bool_t bCandidates = kFALSE)

  fOutputFile(NULL),
 Constructor

~AliAnalysisTaskFlowEvent()

 Destructor

void NotifyRun()

at the beginning of each new run

void UserCreateOutputObjects()

 Called at every worker node to initialize

void UserExec(Option_t* option)

 Main loop
 Called for each event
delete fFlowEvent;

void Terminate(Option_t* )

 Called once at the end of the query -- do not call in case of CAF

AliAnalysisTaskFlowEvent()

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)

void SetCutsEvent(AliFlowEventCuts* cutsEvent)

{fCutsEvent=cutsEvent;}

AliFlowEventCuts* GetCutsEvent() const

{return fCutsEvent;}

void SetCutsRP(AliFlowTrackCuts* cutsRP)

{fCutContainer->AddAt(cutsRP,0); fCutsRP=cutsRP; cutsRP->SetPOItype(0); }

AliFlowTrackCuts* GetCutsRP() const

{return fCutsRP;}

void SetCutsPOI(AliFlowTrackCuts* cutsPOI)

{fCutContainer->AddAt(cutsPOI,1); fCutsPOI=cutsPOI; cutsPOI->SetPOItype(1); }

AliFlowTrackCuts* GetCutsPOI() const

{return fCutsPOI;}

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; }

void SetShuffleTracks(Bool_t b)

{fShuffleTracks=b;}

void SetNbinsMult(Int_t i)

 setters for common constants

{ 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)

 end setters common constants

{fHistWeightvsPhiMax=i;}

void SetAfterburnerOn(Bool_t b = kTRUE)

 setters for adding by hand flow values (afterburner)

{fAfterburnerOn=b;}

void SetNonFlowNumberOfTrackClones(Int_t n)

{fNonFlowNumberOfTrackClones=n;}

void SetPtDifferentialV2(TF1* gPtV2)

void SetFlow(Double_t v1, Double_t v2, Double_t v3 = 0.0, Double_t v4 = 0.0, Double_t v5 = 0.0)

 end setters afterburner

{fV1=v1;fV2=v2;fV3=v3;fV4=v4;fV5=v5;}

AliAnalysisTaskFlowEvent& operator=(const AliAnalysisTaskFlowEvent& aAnalysisTask)