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 » BASE » AliFlowAnalysisWithCumulants

class AliFlowAnalysisWithCumulants

Function Members (Methods)

public:

	AliFlowAnalysisWithCumulants()
virtual	~AliFlowAnalysisWithCumulants()
virtual void	AccessConstants()
virtual void	AccessSettings()
virtual void	BookAndFillWeightsHistograms()
virtual void	BookAndNestAllLists()
virtual void	BookCommonHistograms()
virtual void	BookEverythingForCalculationVsMultiplicity()
virtual void	BookEverythingForDiffFlow()
virtual void	BookEverythingForReferenceFlow()
virtual void	BookEverythingForTuning()
virtual void	BookProfileHoldingSettings()
virtual void	CalculateCumulantsForDiffFlow(TString rpPoi, TString ptEta)
virtual void	CalculateCumulantsForReferenceFlow()
virtual void	CalculateDifferentialFlow(TString rpPoi, TString ptEta)
virtual void	CalculateDifferentialFlowErrors(TString rpPoi, TString ptEta)
virtual void	CalculateIntegratedFlow(TString rpPoi)
virtual void	CalculateReferenceFlow()
virtual void	CalculateReferenceFlowError()
virtual void	CheckPointersUsedInFinish()
virtual void	CheckPointersUsedInMake()
static TClass*	Class()
virtual void	CrossCheckSettings()
virtual void	FillCommonHistResultsForDifferentialFlow(TString rpPoi)
virtual void	FillCommonHistResultsForReferenceFlow()
virtual void	FillGeneratingFunctionForDiffFlow(AliFlowEventSimple* anEvent)
virtual void	FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple* anEvent)
virtual void	FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple* anEvent)
virtual void	FillQvectorComponents(AliFlowEventSimple* anEvent)
virtual void	FinalizeTuning()
virtual void	Finish()
TProfile*	GetAnalysisSettings() const
virtual void	GetAvMultAndNoOfEvts()
TProfile*	GetAvMVsM() const
Bool_t	GetCalculateVsMultiplicity() const
TH1D*	GetChi() const
AliFlowCommonHist*	GetCommonHists() const
AliFlowCommonHistResults*	GetCommonHistsResults2nd() const
AliFlowCommonHistResults*	GetCommonHistsResults4th() const
AliFlowCommonHistResults*	GetCommonHistsResults6th() const
AliFlowCommonHistResults*	GetCommonHistsResults8th() const
TH1D*	GetDiffFlow(Int_t rp, Int_t pe, Int_t co) const
TH1D*	GetDiffFlowCumulants(Int_t rp, Int_t pe, Int_t co) const
TProfile*	GetDiffFlowFlags() const
TProfile3D*	GetDiffFlowGenFun(Int_t ri, Int_t rp, Int_t pe) const
TH1D*	GetEtaWeights() const
Int_t	GetHarmonic() const
TList*	GetHistList() const
TString*	GetHistListName() const
Double_t	GetMaxMult() const
Double_t	GetMinMult() const
Int_t	GetMultiple() const
Int_t	GetnBinsMult() const
TProfile*	GetNoOfParticlesInBin(Int_t rp, Int_t pe) const
virtual void	GetOutputHistograms(TList* outputListHistos)
TH1F*	GetPhiWeights() const
virtual void	GetPointersForBaseHistograms()
virtual void	GetPointersForCommonControlHistograms()
virtual void	GetPointersForCommonResultsHistograms()
virtual void	GetPointersForDiffFlowObjects()
virtual void	GetPointersForReferenceFlowObjects()
virtual void	GetPointersForTuningObjects()
Bool_t	GetPrintFinalResults(Int_t i) const
TH1D*	GetPtWeights() const
TProfile*	GetQvectorComponents() const
TProfile2D*	GetQvectorComponentsVsM() const
Double_t	GetR0() const
TH1D*	GetReferenceFlow() const
TH1D*	GetReferenceFlowCumulants() const
TH1D*	GetReferenceFlowCumulantsVsM(Int_t co) const
TProfile*	GetReferenceFlowFlags() const
TProfile2D*	GetReferenceFlowGenFun() const
TProfile3D*	GetReferenceFlowGenFunVsM() const
TProfile*	GetSumOfSquaredWeight() const
TProfile2D*	GetSumOfSquaredWeightVsM() const
Bool_t	GetTuneParameters() const
TProfile*	GetTuningAvM() const
TH1D*	GetTuningCumulants(Int_t r, Int_t pq) const
TProfile*	GetTuningFlags() const
TH1D*	GetTuningFlow(Int_t r, Int_t pq) const
TProfile2D*	GetTuningGenFun(Int_t r, Int_t pq) const
Double_t	GetTuningR0(Int_t r) const
Bool_t	GetUseEtaWeights() const
Bool_t	GetUsePhiWeights() const
Bool_t	GetUsePtWeights() const
TList*	GetWeightsList() const
virtual void	Init()
virtual void	InitializeArrays()
virtual TClass*	IsA() const
virtual void	Make(AliFlowEventSimple* anEvent)
virtual void	PrintFinalResults(TString rpPoi)
void	SetAnalysisSettings(TProfile *const as)
void	SetAverageOfSquaredWeight(TProfile *const aosw)
void	SetAverageOfSquaredWeightVsM(TProfile2D *const aoswVsM)
void	SetAvMVsM(TProfile *const amVsM)
void	SetCalculateVsMultiplicity(Bool_t ecvm)
void	SetChi(TH1D *const c)
void	SetCommonHists(AliFlowCommonHist *const ch)
void	SetCommonHistsResults2nd(AliFlowCommonHistResults *const chr2nd)
void	SetCommonHistsResults4th(AliFlowCommonHistResults *const chr4th)
void	SetCommonHistsResults6th(AliFlowCommonHistResults *const chr6th)
void	SetCommonHistsResults8th(AliFlowCommonHistResults *const chr8th)
void	SetDiffFlow(TH1D *const df, Int_t rp, Int_t pe, Int_t co)
void	SetDiffFlowCumulants(TH1D *const dfc, Int_t rp, Int_t pe, Int_t co)
void	SetDiffFlowFlags(TProfile *const dff)
void	SetDiffFlowGenFun(TProfile3D *const dfgf, Int_t ri, Int_t rp, Int_t pe)
void	SetEtaWeights(TH1D *const histEtaWeights)
void	SetHarmonic(Int_t harmonic)
void	SetHistList(TList *const hl)
void	SetHistListName(const char* hln)
void	SetMaxMult(Double_t maxm)
void	SetMinMult(Double_t minm)
void	SetMultiple(Int_t multiple)
void	SetMultiplicityWeight(const char* multiplicityWeight)
void	SetnBinsMult(Int_t nbm)
void	SetNoOfParticlesInBin(TProfile *const nopib, Int_t rp, Int_t pe)
void	SetPhiWeights(TH1F *const histPhiWeights)
void	SetPrintFinalResults(Bool_t printOrNot, Int_t i)
void	SetPtWeights(TH1D *const histPtWeights)
void	SetQvectorComponents(TProfile *const qvc)
void	SetQvectorComponentsVsM(TProfile2D *const qvcVsM)
void	SetR0(Double_t r0)
void	SetReferenceFlow(TH1D *const rf)
void	SetReferenceFlowCumulants(TH1D *const rfc)
void	SetReferenceFlowCumulantsVsM(TH1D *const rfcVsM, Int_t co)
void	SetReferenceFlowFlags(TProfile *const rff)
void	SetReferenceFlowGenFun(TProfile2D *const rfgf)
void	SetReferenceFlowGenFunVsM(TProfile3D *const rfgfVsM)
void	SetTuneParameters(Bool_t tp)
void	SetTuningAvM(TProfile *const tam)
void	SetTuningCumulants(TH1D *const tc, Int_t r, Int_t pq)
void	SetTuningFlags(TProfile *const tf)
void	SetTuningFlow(TH1D *const tf, Int_t r, Int_t pq)
void	SetTuningGenFun(TProfile2D *const tgf, Int_t r, Int_t pq)
void	SetTuningR0(Double_t tr0, Int_t r)
void	SetUseEtaWeights(Bool_t uEtaW)
void	SetUsePhiWeights(Bool_t uPhiW)
void	SetUsePtWeights(Bool_t uPtW)
void	SetWeightsList(TList *const wlist)
virtual void	ShowMembers(TMemberInspector&)
virtual void	StoreDiffFlowFlags()
virtual void	StoreReferenceFlowFlags()
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual void	WriteHistograms(TString* outputFileName)
virtual void	WriteHistograms(TString outputFileName)
virtual void	WriteHistograms(TDirectoryFile* outputFileName)

private:

	AliFlowAnalysisWithCumulants(const AliFlowAnalysisWithCumulants& afawc)
AliFlowAnalysisWithCumulants&	operator=(const AliFlowAnalysisWithCumulants& afawc)

Data Members

private:

TProfile*	fAnalysisSettings	profile to hold analysis settings
Double_t	fAvM	average multiplicity
TProfile*	fAvMVsM	<M> vs multiplicity bin
TProfile*	fAverageOfSquaredWeight	<<w^2>>, where w = wPhiwPtwEta
TProfile2D*	fAverageOfSquaredWeightVsM	<<w^2>>, where w = wPhiwPtwEta vs multiplicity
Bool_t	fCalculateVsMultiplicity	perform flow analysis independently for each multiplicity bin
TH1D*	fChi	final results for resolution
AliFlowCommonHist*	fCommonHists	common control histograms (filled only with events with 3 or more tracks for 3-p correlators)
AliFlowCommonHistResults*	fCommonHistsResults2nd	common result histograms for 2nd order cumulant
AliFlowCommonHistResults*	fCommonHistsResults4th	common result histograms for 4th order cumulant
AliFlowCommonHistResults*	fCommonHistsResults6th	common result histograms for 6th order cumulant
AliFlowCommonHistResults*	fCommonHistsResults8th	common result histograms for 8th order cumulant
TH1D*	fDiffFlow[2][2][4]	differential flow [0=RP,1=POI][0=pt,1=eta][cumulant order]
TH1D*	fDiffFlowCumulants[2][2][4]	isotropic differential flow cumulants [0=RP,1=POI][0=pt,1=eta][cumulant order]
TProfile*	fDiffFlowFlags	profile to hold all flags for reference flow
TProfile3D*	fDiffFlowGenFun[2][2][2]	all-event avarage of generating function used for differential flow [0=Re,1=Im][0=RP,1=POI][0=pt,1=eta]
TList*	fDiffFlowList	list to hold all histograms and profiles relevant for differential flow
TList*	fDiffFlowProfiles	list to hold all profiles relevant for differential flow
TList*	fDiffFlowResults	list to hold all histograms with final results relevant for differential flow
Double_t	fEtaBinWidth	bin width for eta histograms
Double_t	fEtaMax	maximum eta
Double_t	fEtaMin	minimum eta
TH1D*	fEtaWeights	histogram holding phi weights
TMatrixD*	fGEBE	reference flow generating function only for current event
Int_t	fHarmonic	harmonic
TList*	fHistList	base list to hold all output objects
TString*	fHistListName	name of base list
Double_t	fMaxMult	maximal multiplicity for flow analysis versus multiplicity
Double_t	fMinMult	minimal multiplicity for flow analysis versus multiplicity
Int_t	fMultiple	the multiple m in p=m*n, where n is harmonic (relevant for differential flow)
TString*	fMultiplicityWeight	event-by-event weight for reference flow generating function (can be "unit" or "multiplicity")
TProfile*	fNoOfParticlesInBin[2][2]	number of particles in pt/eta bin for RPs/POIs [0=RP,1=POI][0=pt,1=eta]
Double_t	fPhiBinWidth	bin width for phi histograms
Double_t	fPhiMax	maximum phi
Double_t	fPhiMin	minimum phi
TH1F*	fPhiWeights	histogram holding phi weights
Bool_t	fPrintFinalResults[3]	print on the screen the final results [0=RF,1=RP,2=POI]
Double_t	fPtBinWidth	bin width for pt histograms
Double_t	fPtMax	maximum pt
Double_t	fPtMin	minimum pt
TH1D*	fPtWeights	histogram holding phi weights
TProfile*	fQvectorComponents	averages of Q-vector components (1st bin: <Q_x>, 2nd bin: <Q_y>, 3rd bin: <(Q_x)^2>, 4th bin: <(Q_y)^2>)
TProfile2D*	fQvectorComponentsVsM	averages of Q-vector components (1st bin: <Q_x>, 2nd bin: <Q_y>, 3rd bin: <(Q_x)^2>, 4th bin: <(Q_y)^2>) vs multiplicity
Double_t	fR0	r_{0} parameter
TH1D*	fReferenceFlow	final results for reference flow
TH1D*	fReferenceFlowCumulants	final results for isotropic cumulants for reference flow
TH1D*	fReferenceFlowCumulantsVsM[4]	final results for isotropic cumulants for reference flow versus multiplicity
TProfile*	fReferenceFlowFlags	profile to hold all flags for reference flow
TProfile2D*	fReferenceFlowGenFun	all-event average of the generating function used to calculate reference flow
TProfile3D*	fReferenceFlowGenFunVsM	all-event average of the generating function used to calculate reference flow vs multiplicity
TList*	fReferenceFlowList	list to hold all histograms and profiles relevant for reference flow
TList*	fReferenceFlowProfiles	list to hold all profiles relevant for reference flow
TList*	fReferenceFlowResults	list to hold all histograms with final results relevant for reference flow
Bool_t	fTuneParameters	tune r0 and cut series at different order
TProfile*	fTuningAvM	average multiplicities for events with nRPs >= cuttof
TH1D*	fTuningCumulants[10][5]	isotropic cumulants for reference flow for 10 different r0s and 5 different sets of (pmax,qmax)
TProfile*	fTuningFlags	profile to hold all flags for tuning
TH1D*	fTuningFlow[10][5]	reference flow for 10 different r0s and 5 different sets of (pmax,qmax)
TProfile2D*	fTuningGenFun[10][5]	generating function G evaluated for 10 different r0s and 5 different sets of (pmax,qmax)
TList*	fTuningList	list to hold all histograms and profiles relevant for tuning
TList*	fTuningProfiles	list to hold all profiles relevant for tuning
Double_t	fTuningR0[10]	different r0 values (at maximum 10 different values allowed)
TList*	fTuningResults	list to hold all histograms with final results relevant for tuning
Bool_t	fUseEtaWeights	use eta weights
Bool_t	fUsePhiWeights	use phi weights
Bool_t	fUsePtWeights	use pt weights
TList*	fWeightsList	list to hold all histograms with particle weights: fPhiWeights, fPtWeights and fEtaWeights
Int_t	fnBinsEta	number of eta bins
Int_t	fnBinsMult	number of multiplicity bins for flow analysis versus multiplicity
Int_t	fnBinsPhi	number of phi bins
Int_t	fnBinsPt	number of pt bins
Int_t	fnEvts	number of events

Class Charts

Inheritance Chart:

AliFlowAnalysisWithCumulants

Function documentation

AliFlowAnalysisWithCumulants()

 Constructor.

~AliFlowAnalysisWithCumulants()

 Desctructor.

void Init()

 Initialize and book all objects.

void Make(AliFlowEventSimple* anEvent)

 Running over data only in this method.

void Finish()

 Calculate the final results.

void FinalizeTuning()

 Finalize results with tuned inerpolating parameters.

void FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple* anEvent)

 Fill generating function for reference flow evaluated for different tuning parameters.

void FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple* anEvent)

 Fill generating function for reference flow for current event.

void FillQvectorComponents(AliFlowEventSimple* anEvent)

 Fill components of Q-vector for current event (needed for error calculation).

void FillGeneratingFunctionForDiffFlow(AliFlowEventSimple* anEvent)

 Fill generating function for differential flow for the current event.

void GetOutputHistograms(TList* outputListHistos)

 Get pointers to all objects saved in the output file.

void GetPointersForBaseHistograms()

 Get pointers to base histograms.

void GetPointersForCommonControlHistograms()

 Get pointers for common control histograms.

void GetPointersForCommonResultsHistograms()

 Get pointers for common results histograms.

void GetPointersForTuningObjects()

 Get pointers to all objects used for tuning.

void GetPointersForReferenceFlowObjects()

 Get pointers for all objects relevant for calculation of reference flow.

void GetPointersForDiffFlowObjects()

 Get pointers to all objects relevant for differential flow.

void CalculateIntegratedFlow(TString rpPoi)

 Calculate final results for integrated flow of RPs and POIs.
 (to be improved - this method can be implemented much better)

void FillCommonHistResultsForDifferentialFlow(TString rpPoi)

 Fill common result histograms for differential flow.
 (to be improved - this method can be implemented much better)

void CalculateDifferentialFlow(TString rpPoi, TString ptEta)

 Calculate differential flow for RPs/POIs vs pt/eta from cumulants.

void CalculateDifferentialFlowErrors(TString rpPoi, TString ptEta)

 Calculate errors of differential flow.

void CalculateCumulantsForDiffFlow(TString rpPoi, TString ptEta)

 Calculate cumulants for differential flow.

void PrintFinalResults(TString rpPoi)

 Printing on the screen the final results for reference flow and for integrated flow of RPs and POIs.

void FillCommonHistResultsForReferenceFlow()

 Fill in AliFlowCommonHistResults dedicated histograms for reference flow.

void CalculateReferenceFlowError()

 Calculate error of reference flow harmonics.

void CalculateReferenceFlow()

 Calculate from isotropic cumulants reference flow.

void CalculateCumulantsForReferenceFlow()

 Calculate cumulants for reference flow.

void GetAvMultAndNoOfEvts()

 From relevant common control histogram get average multiplicity of RPs and number of events.

void InitializeArrays()

 Initialize all arrays.

void CrossCheckSettings()

 Cross-check the user settings before starting.

void AccessConstants()

 Access needed common constants from AliFlowCommonConstants.

void BookAndFillWeightsHistograms()

 Book and fill histograms which hold phi, pt and eta weights.

void BookEverythingForCalculationVsMultiplicity()

 Book all objects relevant for flow analysis versus multiplicity.

void BookEverythingForReferenceFlow()

 Book all objects relevant for calculation of reference flow.

void BookEverythingForTuning()

 Book all objects relevant for tuning.

void BookEverythingForDiffFlow()

 Book all objects relevant for calculation of differential flow.

void StoreReferenceFlowFlags()

 Store all flags for reference flow in profile fReferenceFlowFlags.

void StoreDiffFlowFlags()

 Store all flags for differential flow in profile fDiffFlowFlags.

void BookAndNestAllLists()

 Book and nest all list in base list fHistList.

void BookProfileHoldingSettings()

 Book profile to hold all analysis settings.

void BookCommonHistograms()

 Book common control histograms and common histograms for final results.

void CheckPointersUsedInMake()

 Check pointers used in method Make().

void CheckPointersUsedInFinish()

 Check pointers used in method Finish().

void AccessSettings()

 Access the settings for analysis with Generating Function Cumulants.

void WriteHistograms(TString* outputFileName)

 Store the final results in output .root file.

void WriteHistograms(TString outputFileName)

 Store the final results in output .root file.

void WriteHistograms(TDirectoryFile* outputFileName)

 Store the final results in output .root file.

AliFlowAnalysisWithCumulants()

void SetHistList(TList *const hl)

 5.) Other methods:

 6.) Setters and getters:
  6.0.) base:

{this->fHistList = hl;}

TList* GetHistList() const

{return this->fHistList;}

void SetHistListName(const char* hln)

{this->fHistListName->Append(*hln);}

TString * GetHistListName() const

{return this->fHistListName;}

void SetAnalysisSettings(TProfile *const as)

{this->fAnalysisSettings = as;}

TProfile* GetAnalysisSettings() const

  6.1.) common:

{return this->fAnalysisSettings;}

void SetCommonHists(AliFlowCommonHist *const ch)

{this->fCommonHists = ch;}

AliFlowCommonHist* GetCommonHists() const

{return this->fCommonHists;}

void SetCommonHistsResults2nd(AliFlowCommonHistResults *const chr2nd)

{this->fCommonHistsResults2nd = chr2nd;}

AliFlowCommonHistResults* GetCommonHistsResults2nd() const

{return this->fCommonHistsResults2nd;}

void SetCommonHistsResults4th(AliFlowCommonHistResults *const chr4th)

{this->fCommonHistsResults4th = chr4th;}

AliFlowCommonHistResults* GetCommonHistsResults4th() const

{return this->fCommonHistsResults4th;}

void SetCommonHistsResults6th(AliFlowCommonHistResults *const chr6th)

{this->fCommonHistsResults6th = chr6th;}

AliFlowCommonHistResults* GetCommonHistsResults6th() const

{return this->fCommonHistsResults6th;}

void SetCommonHistsResults8th(AliFlowCommonHistResults *const chr8th)

{this->fCommonHistsResults8th = chr8th;}

AliFlowCommonHistResults* GetCommonHistsResults8th() const

{return this->fCommonHistsResults8th;}

void SetHarmonic(Int_t harmonic)

{this->fHarmonic = harmonic;}

Int_t GetHarmonic() const

{return this->fHarmonic;}

void SetMultiple(Int_t multiple)

{this->fMultiple = multiple;}

Int_t GetMultiple() const

{return this->fMultiple;}

void SetR0(Double_t r0)

{this->fR0 = r0;}

Double_t GetR0() const

{return this->fR0;}

void SetPrintFinalResults(Bool_t printOrNot, Int_t i)

{this->fPrintFinalResults[i] = printOrNot;}

Bool_t GetPrintFinalResults(Int_t i) const

  6.2.0.) particle weights:

{return this->fPrintFinalResults[i];}

void SetWeightsList(TList *const wlist)

{this->fWeightsList = (TList*)wlist->Clone();}

TList* GetWeightsList() const

{return this->fWeightsList;}

void SetUsePhiWeights(Bool_t uPhiW)

{this->fUsePhiWeights = uPhiW;}

Bool_t GetUsePhiWeights() const

{return this->fUsePhiWeights;}

void SetUsePtWeights(Bool_t uPtW)

{this->fUsePtWeights = uPtW;}

Bool_t GetUsePtWeights() const

{return this->fUsePtWeights;}

void SetUseEtaWeights(Bool_t uEtaW)

{this->fUseEtaWeights = uEtaW;}

Bool_t GetUseEtaWeights() const

{return this->fUseEtaWeights;}

void SetPhiWeights(TH1F *const histPhiWeights)

{this->fPhiWeights = histPhiWeights;}

TH1F* GetPhiWeights() const

{return this->fPhiWeights;}

void SetPtWeights(TH1D *const histPtWeights)

{this->fPtWeights = histPtWeights;}

TH1D* GetPtWeights() const

{return this->fPtWeights;}

void SetEtaWeights(TH1D *const histEtaWeights)

{this->fEtaWeights = histEtaWeights;}

TH1D* GetEtaWeights() const

  6.2.1.) event weights:

{return this->fEtaWeights;}

void SetMultiplicityWeight(const char* multiplicityWeight)

  6.3.) reference flow:

{*this->fMultiplicityWeight = multiplicityWeight;}

void SetReferenceFlowFlags(TProfile *const rff)

{this->fReferenceFlowFlags = rff;}

TProfile* GetReferenceFlowFlags() const

{return this->fReferenceFlowFlags;}

void SetCalculateVsMultiplicity(Bool_t ecvm)

{this->fCalculateVsMultiplicity = ecvm;}

Bool_t GetCalculateVsMultiplicity() const

{return this->fCalculateVsMultiplicity;}

void SetnBinsMult(Int_t nbm)

{this->fnBinsMult = nbm;}

Int_t GetnBinsMult() const

{return this->fnBinsMult;}

void SetMinMult(Double_t minm)

{this->fMinMult = minm;}

Double_t GetMinMult() const

{return this->fMinMult;}

void SetMaxMult(Double_t maxm)

{this->fMaxMult = maxm;}

Double_t GetMaxMult() const

  6.3.0.) profiles:

{return this->fMaxMult;}

void SetReferenceFlowGenFun(TProfile2D *const rfgf)

{this->fReferenceFlowGenFun = rfgf;}

TProfile2D* GetReferenceFlowGenFun() const

{return this->fReferenceFlowGenFun;}

void SetQvectorComponents(TProfile *const qvc)

{this->fQvectorComponents = qvc;}

TProfile* GetQvectorComponents() const

{return this->fQvectorComponents;}

void SetAverageOfSquaredWeight(TProfile *const aosw)

{this->fAverageOfSquaredWeight = aosw;}

TProfile* GetSumOfSquaredWeight() const

{return this->fAverageOfSquaredWeight;}

void SetReferenceFlowGenFunVsM(TProfile3D *const rfgfVsM)

{this->fReferenceFlowGenFunVsM = rfgfVsM;}

TProfile3D* GetReferenceFlowGenFunVsM() const

{return this->fReferenceFlowGenFunVsM;}

void SetQvectorComponentsVsM(TProfile2D *const qvcVsM)

{this->fQvectorComponentsVsM = qvcVsM;}

TProfile2D* GetQvectorComponentsVsM() const

{return this->fQvectorComponentsVsM;}

void SetAverageOfSquaredWeightVsM(TProfile2D *const aoswVsM)

{this->fAverageOfSquaredWeightVsM = aoswVsM;}

TProfile2D* GetSumOfSquaredWeightVsM() const

{return this->fAverageOfSquaredWeightVsM;}

void SetAvMVsM(TProfile *const amVsM)

{this->fAvMVsM = amVsM;}

TProfile* GetAvMVsM() const

  6.3.1.) results:

{return this->fAvMVsM;}

void SetReferenceFlowCumulants(TH1D *const rfc)

{this->fReferenceFlowCumulants = rfc;}

TH1D* GetReferenceFlowCumulants() const

{return this->fReferenceFlowCumulants;}

void SetReferenceFlow(TH1D *const rf)

{this->fReferenceFlow = rf;}

TH1D* GetReferenceFlow() const

{return this->fReferenceFlow;}

void SetChi(TH1D *const c)

{this->fChi = c;}

TH1D* GetChi() const

{return this->fChi;}

void SetReferenceFlowCumulantsVsM(TH1D *const rfcVsM, Int_t co)

{this->fReferenceFlowCumulantsVsM[co] = rfcVsM;}

TH1D* GetReferenceFlowCumulantsVsM(Int_t co) const

 6.4.) differential flow:

{return this->fReferenceFlowCumulantsVsM[co];}

void SetDiffFlowFlags(TProfile *const dff)

{this->fDiffFlowFlags = dff;}

TProfile* GetDiffFlowFlags() const

  6.4.0.) profiles:

{return this->fDiffFlowFlags;}

void SetDiffFlowGenFun(TProfile3D *const dfgf, Int_t ri, Int_t rp, Int_t pe)

{this->fDiffFlowGenFun[ri][rp][pe] = dfgf;}

TProfile3D* GetDiffFlowGenFun(Int_t ri, Int_t rp, Int_t pe) const

{return this->fDiffFlowGenFun[ri][rp][pe];}

void SetNoOfParticlesInBin(TProfile *const nopib, Int_t rp, Int_t pe)

{this->fNoOfParticlesInBin[rp][pe] = nopib;}

TProfile* GetNoOfParticlesInBin(Int_t rp, Int_t pe) const

  6.4.1.) results:

{return this->fNoOfParticlesInBin[rp][pe];}

void SetDiffFlowCumulants(TH1D *const dfc, Int_t rp, Int_t pe, Int_t co)

{this->fDiffFlowCumulants[rp][pe][co] = dfc;}

TH1D* GetDiffFlowCumulants(Int_t rp, Int_t pe, Int_t co) const

{return this->fDiffFlowCumulants[rp][pe][co];}

void SetDiffFlow(TH1D *const df, Int_t rp, Int_t pe, Int_t co)

{this->fDiffFlow[rp][pe][co] = df;}

TH1D* GetDiffFlow(Int_t rp, Int_t pe, Int_t co) const

 6.x.) Tuning the interpolating parameter r0 and using cutoff at different order in series:

{return this->fDiffFlow[rp][pe][co];}

void SetTuningFlags(TProfile *const tf)

{this->fTuningFlags = tf;}

TProfile* GetTuningFlags() const

{return this->fTuningFlags;}

void SetTuneParameters(Bool_t tp)

{this->fTuneParameters = tp;}

Bool_t GetTuneParameters() const

{return this->fTuneParameters;}

void SetTuningR0(Double_t tr0, Int_t r)

{this->fTuningR0[r] = tr0;}

Double_t GetTuningR0(Int_t r) const

  6.x.0.) profiles:

{return this->fTuningR0[r];}

void SetTuningGenFun(TProfile2D *const tgf, Int_t r, Int_t pq)

{this->fTuningGenFun[r][pq] = tgf;}

TProfile2D* GetTuningGenFun(Int_t r, Int_t pq) const

{return this->fTuningGenFun[r][pq];}

void SetTuningAvM(TProfile *const tam)

{this->fTuningAvM = tam;}

TProfile* GetTuningAvM() const

  6.x.1.) results:

{return this->fTuningAvM;}

void SetTuningCumulants(TH1D *const tc, Int_t r, Int_t pq)

{this->fTuningCumulants[r][pq] = tc;}

TH1D* GetTuningCumulants(Int_t r, Int_t pq) const

{return this->fTuningCumulants[r][pq];}

void SetTuningFlow(TH1D *const tf, Int_t r, Int_t pq)

{this->fTuningFlow[r][pq] = tf;}

TH1D* GetTuningFlow(Int_t r, Int_t pq) const

{return this->fTuningFlow[r][pq];}

AliFlowAnalysisWithCumulants& operator=(const AliFlowAnalysisWithCumulants& afawc)

 0.) Base: