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 » AliFlowAnalysisWithFittingQDistribution

class AliFlowAnalysisWithFittingQDistribution

Function Members (Methods)

public:

	AliFlowAnalysisWithFittingQDistribution()
virtual	~AliFlowAnalysisWithFittingQDistribution()
virtual void	AccessConstants()
virtual void	AccessFittingParameters()
virtual void	BookAndFillWeightsHistograms()
virtual void	BookCommonHistograms()
virtual void	BookEverythingForDistributions()
virtual void	CheckPointersUsedInFinish()
virtual void	CheckPointersUsedInMake()
static TClass*	Class()
virtual void	DoFit(Bool_t sigma2Fitted)
virtual void	FillCommonHistResults(Bool_t sigma2Fitted)
virtual void	Finish(Bool_t doFit = kTRUE)
TString*	GetAnalysisLabel() const
Bool_t	GetBookOnlyBasicCCH() const
TH1D*	GetChi2(Int_t sigmaFitted) const
AliFlowCommonHist*	GetCommonHists() const
AliFlowCommonHistResults*	GetCommonHistsResults() const
Bool_t	GetDoFit() const
TH1D*	GetEtaWeights() const
Int_t	GetExactNoRPs() const
Bool_t	GetFinalResultIsFromSigma2Fitted() const
TF1*	GetFittingFunction(Int_t sigmaFitted) const
TProfile*	GetFittingParameters() const
Int_t	GetHarmonic() const
TList*	GetHistList() const
TH1D*	GetIntFlow(Int_t sigmaFitted) const
Double_t	GetMaxMult() const
Double_t	GetMinMult() const
Int_t	GetnBinsMult() const
virtual void	GetOutputHistograms(TList* outputListHistos)
TH1F*	GetPhiWeights() const
Bool_t	GetPrintOnTheScreen() const
TH1D*	GetPtWeights() const
TH1D*	GetqDistribution() const
TH2D*	GetqDistributionVsMult() const
Double_t	GetqMax() const
Double_t	GetqMin() const
Int_t	GetqNbins() const
TH1D*	GetSigma2(Int_t sigmaFitted) const
Double_t	GetSigma2Max() const
Double_t	GetSigma2Min() const
Double_t	GetSigma2Start() const
Bool_t	GetStoreqDistributionVsMult() const
TH1D*	GetSumOfParticleWeights() const
Double_t	GetTreshold() const
Bool_t	GetUseEtaWeights() const
TProfile*	GetUseParticleWeights() const
Bool_t	GetUsePhiWeights() const
Bool_t	GetUsePtWeights() const
Double_t	GetvMax() const
Double_t	GetvMin() const
Double_t	GetvStart() const
TList*	GetWeightsList() const
virtual void	Init()
virtual void	InitializeArrays()
virtual TClass*	IsA() const
virtual void	Make(AliFlowEventSimple* anEvent)
virtual void	PrintOnTheScreen()
void	SetAnalysisLabel(const char* aLabel)
void	SetBookOnlyBasicCCH(Bool_t bobcch)
void	SetChi2(TH1D *const chi2, Int_t sigmaFitted)
void	SetCommonHists(AliFlowCommonHist *const ch)
void	SetCommonHistsResults(AliFlowCommonHistResults *const chr)
void	SetDoFit(Bool_t df)
void	SetEtaWeights(TH1D *const histEtaWeights)
void	SetExactNoRPs(Int_t enr)
void	SetFinalResultIsFromSigma2Fitted(Bool_t frifs2f)
void	SetFittingFunction(TF1 *const ff, Int_t sigmaFitted)
void	SetFittingParameters(TProfile *const fp)
void	SetHarmonic(Int_t harmonic)
void	SetIntFlow(TH1D *const intFlow, Int_t sigmaFitted)
void	SetMaxMult(Double_t maxm)
void	SetMinMult(Double_t minm)
void	SetMultiplicityIs(AliFlowCommonConstants::ERefMultSource mi)
void	SetnBinsMult(Int_t nbm)
void	SetPhiWeights(TH1F *const histPhiWeights)
void	SetPrintOnTheScreen(Bool_t pots)
void	SetPtWeights(TH1D *const histPtWeights)
void	SetqDistribution(TH1D *const qd)
void	SetqDistributionVsMult(TH2D *const qdvm)
void	SetqMax(Double_t qmax)
void	SetqMin(Double_t qmin)
void	SetqNbins(Int_t qNbins)
void	SetSigma2(TH1D *const sigma2, Int_t sigmaFitted)
void	SetSigma2Max(Double_t Sigma2Max)
void	SetSigma2Min(Double_t Sigma2Min)
void	SetSigma2Start(Double_t Sigma2Start)
void	SetStoreqDistributionVsMult(Bool_t sqdvm)
void	SetSumOfParticleWeights(TH1D *const sopW)
void	SetTreshold(Double_t treshold)
void	SetUseEtaWeights(Bool_t uEtaW)
void	SetUseParticleWeights(TProfile *const uPW)
void	SetUsePhiWeights(Bool_t uPhiW)
void	SetUsePtWeights(Bool_t uPtW)
void	SetvMax(Double_t vMax)
void	SetvMin(Double_t vMin)
void	SetvStart(Double_t vStart)
void	SetWeightsList(TList* wlist)
virtual void	ShowMembers(TMemberInspector&)
virtual void	StoreFittingParameters()
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:

	AliFlowAnalysisWithFittingQDistribution(const AliFlowAnalysisWithFittingQDistribution& afawfqd)
AliFlowAnalysisWithFittingQDistribution&	operator=(const AliFlowAnalysisWithFittingQDistribution& afawfqd)

Data Members

private:

TString*	fAnalysisLabel	analysis label (all histograms and output file will have this label)
Bool_t	fBookOnlyBasicCCH	book only basis common control histrograms (TRUE by default)
TH1D*	fChi2[2]	final results for chi^2 from Minuit [0=sigma^2 not fitted, 1=sigma^2 fitted]
AliFlowCommonHist*	fCommonHists	common control histograms
AliFlowCommonHistResults*	fCommonHistsResults	final results in common histograms
Bool_t	fDoFit	do the final fit
Double_t	fEtaBinWidth	bin width for eta histograms
Double_t	fEtaMax	maximum eta
Double_t	fEtaMin	minimum eta
TH1D*	fEtaWeights	histogram holding eta weights
Int_t	fExactNoRPs	when shuffled, select only this number of RPs for the analysis
Bool_t	fFinalResultIsFromSigma2Fitted	the result obtained with sigma^2 fitted or sigma^2 fixed is being stored
TF1*	fFittingFunction[2]	resulting fitting function of q-distribution [0=sigma^2 not fitted, 1=sigma^2 fitted]
TProfile*	fFittingParameters	profile to hold all fitting parameters
Int_t	fHarmonic	harmonic
TList*	fHistList	base list to hold all output object
TH1D*	fIntFlow[2]	final result for integrated flow [0=sigma^2 not fitted, 1=sigma^2 fitted]
Double_t	fMaxMult	maximum multiplicity
Double_t	fMinMult	minimum multiplicity
AliFlowCommonConstants::ERefMultSource	fMultiplicityIs	by default "kRP", see AliFlowCommonConstants to see the other options
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	fPrintOnTheScreen	print or not the final results on the screen
Double_t	fPtBinWidth	bin width for pt histograms
Double_t	fPtMax	maximum pt
Double_t	fPtMin	minimum pt
TH1D*	fPtWeights	histogram holding pt weights
TH1D*	fSigma2[2]	final results for sigma^2 [0=sigma^2 not fitted, 1=sigma^2 fitted]
Double_t	fSigma2Max	sigma2 range, upper boundary
Double_t	fSigma2Min	sigma2 range, lower boundary (this should be kept above 0.5 according to theorists...)
Double_t	fSigma2Start	fitting of sigma2 will start from this point
Bool_t	fStoreqDistributionVsMult	store q-distributions vs M
TH1D*	fSumOfParticleWeights	distribution of sum of particle weights (for unit weights this equals to multiplicity)
Double_t	fTreshold	the first bin taken for the fitting is the first bin with nEntries >= fTreshold (analogously for the last bin)
Bool_t	fUseEtaWeights	use eta weights
TProfile*	fUseParticleWeights	profile with three bins to hold values of fUsePhiWeights, fUsePtWeights and fUseEtaWeights
Bool_t	fUsePhiWeights	use phi weights
Bool_t	fUsePtWeights	use pt weights
TList*	fWeightsList	list to hold all histograms with particle weights: fUseParticleWeights, fPhiWeights, fPtWeights and fEtaWeights
Int_t	fnBinsEta	number of eta bins
Int_t	fnBinsMult	number of multiplicity bins
Int_t	fnBinsPhi	number of phi bins
Int_t	fnBinsPt	number of pt bins
TH1D*	fqDistribution	distribution of Q/sqrt{M}
TH2D*	fqDistributionVsMult	distribution of Q/sqrt{M} vs multiplicity
Double_t	fqMax	upper boundary of TH1D *fqDistribution
Double_t	fqMin	lower boundary of TH1D *fqDistribution
Int_t	fqNbins	number of bins of TH1D *fqDistribution
Double_t	fvMax	v range, upper boundary
Double_t	fvMin	v range, lower boundary
Double_t	fvStart	fitting of v will start from this point

Class Charts

Inheritance Chart:

AliFlowAnalysisWithFittingQDistribution

Function documentation

AliFlowAnalysisWithFittingQDistribution()

 constructor

~AliFlowAnalysisWithFittingQDistribution()

 destructor

void Init()

 Access constants and book everything.

void Make(AliFlowEventSimple* anEvent)

 Loop over data only in this method.

void Finish(Bool_t doFit = kTRUE)

 Calculate the final results.

void CheckPointersUsedInMake()

 Check all pointers used in method Make().

void CheckPointersUsedInFinish()

 Check all pointers used in method Finish().

void GetOutputHistograms(TList* outputListHistos)

 Get pointers to all output histograms (called before Finish()).

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

void InitializeArrays()

 Initialize all arrays.

void BookCommonHistograms()

 Book common histograms.

void BookAndFillWeightsHistograms()

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

void AccessConstants()

 access needed common constants from AliFlowCommonConstants

void BookEverythingForDistributions()

 Book all objects relevant for fitting of q-distributions.

void DoFit(Bool_t sigma2Fitted)

 Do the final fit of q-distribution.

void FillCommonHistResults(Bool_t sigma2Fitted)

 Fill common result histogram for reference flow and resolution.

void PrintOnTheScreen()

 Print the final results on the screen.

void StoreFittingParameters()

 Store fitting parameters for the fit of q-distribution in profile fFittingParameters.

void AccessFittingParameters()

 Access fitting parameters for the fit of q-distribution.

AliFlowAnalysisWithFittingQDistribution()

TList* GetHistList() const

 **** SETTERS and GETTERS ****
 0.) base:

{return this->fHistList;}

void SetBookOnlyBasicCCH(Bool_t bobcch)

 1.) common:

{this->fBookOnlyBasicCCH = bobcch;}

Bool_t GetBookOnlyBasicCCH() const

{return this->fBookOnlyBasicCCH;}

void SetCommonHists(AliFlowCommonHist *const ch)

{this->fCommonHists = ch;}

AliFlowCommonHist* GetCommonHists() const

{return this->fCommonHists;}

void SetCommonHistsResults(AliFlowCommonHistResults *const chr)

{this->fCommonHistsResults = chr;}

AliFlowCommonHistResults* GetCommonHistsResults() const

{return this->fCommonHistsResults;}

void SetHarmonic(Int_t harmonic)

{this->fHarmonic = harmonic;}

Int_t GetHarmonic() const

{return this->fHarmonic;}

void SetAnalysisLabel(const char* aLabel)

{this->fAnalysisLabel->Append(*aLabel);}

TString * GetAnalysisLabel() const

{return this->fAnalysisLabel;}

void SetMultiplicityIs(AliFlowCommonConstants::ERefMultSource mi)

 2.) weights:

{this->fMultiplicityIs = mi;}

void SetWeightsList(TList* 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 SetUseParticleWeights(TProfile *const uPW)

{this->fUseParticleWeights = uPW;}

TProfile* GetUseParticleWeights() const

{return this->fUseParticleWeights;}

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

 3.) distributions:

{return this->fEtaWeights;}

void SetSumOfParticleWeights(TH1D *const sopW)

{this->fSumOfParticleWeights = sopW;}

TH1D* GetSumOfParticleWeights() const

{return this->fSumOfParticleWeights;}

void SetqDistribution(TH1D *const qd)

{this->fqDistribution = qd;}

TH1D* GetqDistribution() const

{return this->fqDistribution;}

void SetqMin(Double_t qmin)

{this->fqMin = qmin;}

Double_t GetqMin() const

{return this->fqMin;}

void SetqMax(Double_t qmax)

{this->fqMax = qmax;}

Double_t GetqMax() const

{return this->fqMax;}

void SetqNbins(Int_t qNbins)

{this->fqNbins = qNbins;}

Int_t GetqNbins() const

{return this->fqNbins;}

void SetStoreqDistributionVsMult(Bool_t sqdvm)

{this->fStoreqDistributionVsMult = sqdvm;}

Bool_t GetStoreqDistributionVsMult() const

{return this->fStoreqDistributionVsMult;}

void SetqDistributionVsMult(TH2D *const qdvm)

{this->fqDistributionVsMult = qdvm;}

TH2D* GetqDistributionVsMult() const

{return this->fqDistributionVsMult;}

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

{return this->fMaxMult;}

void SetnBinsMult(Int_t nbm)

{this->fnBinsMult = nbm;}

Int_t GetnBinsMult() const

 4.) final results of fitting:

{return this->fnBinsMult;}

void SetIntFlow(TH1D *const intFlow, Int_t sigmaFitted)

{this->fIntFlow[sigmaFitted] = intFlow;}

TH1D* GetIntFlow(Int_t sigmaFitted) const

{return this->fIntFlow[sigmaFitted];}

void SetSigma2(TH1D *const sigma2, Int_t sigmaFitted)

{this->fSigma2[sigmaFitted] = sigma2;}

TH1D* GetSigma2(Int_t sigmaFitted) const

{return this->fSigma2[sigmaFitted];}

void SetChi2(TH1D *const chi2, Int_t sigmaFitted)

{this->fChi2[sigmaFitted] = chi2;}

TH1D* GetChi2(Int_t sigmaFitted) const

{return this->fChi2[sigmaFitted];}

void SetFittingFunction(TF1 *const ff, Int_t sigmaFitted)

{this->fFittingFunction[sigmaFitted] = ff;}

TF1* GetFittingFunction(Int_t sigmaFitted) const

 5.) fitting parameters:

{return this->fFittingFunction[sigmaFitted];}

void SetFittingParameters(TProfile *const fp)

{this->fFittingParameters = fp;}

TProfile* GetFittingParameters() const

{return this->fFittingParameters;}

void SetTreshold(Double_t treshold)

{this->fTreshold = treshold;}

Double_t GetTreshold() const

{return this->fTreshold;}

void SetvStart(Double_t vStart)

{this->fvStart = vStart;}

Double_t GetvStart() const

{return this->fvStart;}

void SetvMin(Double_t vMin)

{this->fvMin = vMin;}

Double_t GetvMin() const

{return this->fvMin;}

void SetvMax(Double_t vMax)

{this->fvMax = vMax;}

Double_t GetvMax() const

{return this->fvMax;}

void SetSigma2Start(Double_t Sigma2Start)

{this->fSigma2Start = Sigma2Start;}

Double_t GetSigma2Start() const

{return this->fSigma2Start;}

void SetSigma2Min(Double_t Sigma2Min)

{this->fSigma2Min = Sigma2Min;}

Double_t GetSigma2Min() const

{return this->fSigma2Min;}

void SetSigma2Max(Double_t Sigma2Max)

{this->fSigma2Max = Sigma2Max;}

Double_t GetSigma2Max() const

{return this->fSigma2Max;}

void SetFinalResultIsFromSigma2Fitted(Bool_t frifs2f)

{this->fFinalResultIsFromSigma2Fitted = frifs2f;}

Bool_t GetFinalResultIsFromSigma2Fitted() const

{return this->fFinalResultIsFromSigma2Fitted;}

void SetPrintOnTheScreen(Bool_t pots)

{this->fPrintOnTheScreen = pots;}

Bool_t GetPrintOnTheScreen() const

{return this->fPrintOnTheScreen;}

void SetDoFit(Bool_t df)

{this->fDoFit = df;}

Bool_t GetDoFit() const

{return this->fDoFit;}

void SetExactNoRPs(Int_t enr)

{this->fExactNoRPs = enr;}

Int_t GetExactNoRPs() const

{return this->fExactNoRPs;}

AliFlowAnalysisWithFittingQDistribution& operator=(const AliFlowAnalysisWithFittingQDistribution& afawfqd)

 0.) base: