]>
Commit | Line | Data |
---|---|---|
2188af53 | 1 | /* |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. | |
3 | * See cxx source for full Copyright notice | |
4 | * $Id$ | |
5 | */ | |
6 | ||
d6130938 | 7 | /************************************************* |
8 | * Flow analysis with cumulants. In this class * | |
9 | * cumulants are calculated by making use of the * | |
10 | * formalism of generating functions proposed by * | |
11 | * Ollitrault et al. * | |
12 | * * | |
13 | * Author: Ante Bilandzic * | |
14 | * (abilandzic@gmail.com) * | |
15 | *************************************************/ | |
2188af53 | 16 | |
b6cd16a9 | 17 | #ifndef ALIFLOWANALYSISWITHCUMULANTS_H |
18 | #define ALIFLOWANALYSISWITHCUMULANTS_H | |
f1d945a1 | 19 | |
d6130938 | 20 | #include "TMatrixD.h" |
f1d945a1 | 21 | |
2188af53 | 22 | class TList; |
23 | class TFile; | |
aaebd73d | 24 | |
929098e4 | 25 | class TH1D; |
d6130938 | 26 | class TH1F; |
aaebd73d | 27 | class TProfile; |
28 | class TProfile2D; | |
29 | class TProfile3D; | |
929098e4 | 30 | class TDirectoryFile; |
aaebd73d | 31 | |
f1d945a1 | 32 | class AliFlowEventSimple; |
33 | class AliFlowTrackSimple; | |
2701c4bc | 34 | class AliFlowCommonConstants; |
f1d945a1 | 35 | class AliFlowCommonHist; |
36 | class AliFlowCommonHistResults; | |
37 | class AliFlowVector; | |
38 | ||
2188af53 | 39 | //================================================================================================================ |
40 | ||
41 | class AliFlowAnalysisWithCumulants{ | |
f1d945a1 | 42 | public: |
43 | AliFlowAnalysisWithCumulants(); | |
2188af53 | 44 | virtual ~AliFlowAnalysisWithCumulants(); |
d6130938 | 45 | // 0.) Methods called in the constructor: |
46 | virtual void InitializeArrays(); | |
47 | // 1.) Method Init() and methods called within Init(): | |
e5e75b58 | 48 | virtual void Init(); |
d6130938 | 49 | virtual void CrossCheckSettings(); |
50 | virtual void AccessConstants(); | |
51 | virtual void BookAndNestAllLists(); | |
52 | virtual void BookProfileHoldingSettings(); | |
53 | virtual void BookCommonHistograms(); | |
54 | virtual void BookAndFillWeightsHistograms(); | |
55 | virtual void BookEverythingForReferenceFlow(); | |
56 | virtual void BookEverythingForDiffFlow(); | |
57 | virtual void StoreReferenceFlowFlags(); | |
58 | virtual void StoreDiffFlowFlags(); | |
3688e459 | 59 | virtual void BookEverythingForTuning(); |
60 | virtual void BookEverythingForCalculationVsMultiplicity(); | |
d6130938 | 61 | // 2.) Method Make() and methods called within Make(): |
dce74562 | 62 | virtual void Make(AliFlowEventSimple* anEvent); |
d6130938 | 63 | virtual void CheckPointersUsedInMake(); |
64 | virtual void FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple *anEvent); | |
65 | virtual void FillQvectorComponents(AliFlowEventSimple *anEvent); | |
66 | virtual void FillGeneratingFunctionForDiffFlow(AliFlowEventSimple *anEvent); | |
3688e459 | 67 | virtual void FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple *anEvent); |
d6130938 | 68 | // 3.) Method Finish() and methods called within Finish(): |
69 | virtual void Finish(); | |
70 | virtual void CheckPointersUsedInFinish(); | |
71 | virtual void AccessSettings(); | |
72 | virtual void GetAvMultAndNoOfEvts(); | |
73 | virtual void CalculateCumulantsForReferenceFlow(); | |
74 | virtual void CalculateReferenceFlow(); | |
75 | virtual void CalculateReferenceFlowError(); | |
76 | virtual void FillCommonHistResultsForReferenceFlow(); | |
77 | virtual void CalculateCumulantsForDiffFlow(TString rpPoi,TString ptEta); | |
78 | virtual void CalculateDifferentialFlow(TString rpPoi,TString ptEta); | |
79 | virtual void CalculateDifferentialFlowErrors(TString rpPoi,TString ptEta); | |
80 | virtual void FillCommonHistResultsForDifferentialFlow(TString rpPoi); | |
81 | virtual void CalculateIntegratedFlow(TString rpPoi); // to be improved (add also possibility to integrate over eta yield) | |
82 | virtual void PrintFinalResults(TString rpPoi); | |
83 | virtual void FinalizeTuning(); | |
84 | // 4.) Method GetOutputHistograms() and method called within it: | |
85 | virtual void GetOutputHistograms(TList *outputListHistos); | |
86 | virtual void GetPointersForBaseHistograms(); | |
87 | virtual void GetPointersForCommonControlHistograms(); | |
88 | virtual void GetPointersForCommonResultsHistograms(); | |
d6130938 | 89 | virtual void GetPointersForReferenceFlowObjects(); |
90 | virtual void GetPointersForDiffFlowObjects(); | |
3688e459 | 91 | virtual void GetPointersForTuningObjects(); |
d6130938 | 92 | virtual void WriteHistograms(TString *outputFileName); |
b0fda271 | 93 | virtual void WriteHistograms(TString outputFileName); |
ad87ae62 | 94 | virtual void WriteHistograms(TDirectoryFile *outputFileName); |
d6130938 | 95 | // 5.) Other methods: |
96 | // ... | |
97 | // 6.) Setters and getters: | |
98 | // 6.0.) base: | |
99 | void SetHistList(TList* const hl) {this->fHistList = hl;} | |
100 | TList* GetHistList() const {return this->fHistList;} | |
101 | void SetHistListName(const char *hln) {this->fHistListName->Append(*hln);}; | |
102 | TString *GetHistListName() const {return this->fHistListName;}; | |
103 | void SetAnalysisSettings(TProfile* const as) {this->fAnalysisSettings = as;}; | |
104 | TProfile* GetAnalysisSettings() const {return this->fAnalysisSettings;}; | |
105 | // 6.1.) common: | |
106 | void SetCommonHists(AliFlowCommonHist* const ch) {this->fCommonHists = ch;}; | |
107 | AliFlowCommonHist* GetCommonHists() const {return this->fCommonHists;}; | |
108 | void SetCommonHistsResults2nd(AliFlowCommonHistResults* const chr2nd) {this->fCommonHistsResults2nd = chr2nd;}; | |
109 | AliFlowCommonHistResults* GetCommonHistsResults2nd() const {return this->fCommonHistsResults2nd;}; | |
110 | void SetCommonHistsResults4th(AliFlowCommonHistResults* const chr4th) {this->fCommonHistsResults4th = chr4th;}; | |
111 | AliFlowCommonHistResults* GetCommonHistsResults4th() const {return this->fCommonHistsResults4th;}; | |
112 | void SetCommonHistsResults6th(AliFlowCommonHistResults* const chr6th) {this->fCommonHistsResults6th = chr6th;}; | |
113 | AliFlowCommonHistResults* GetCommonHistsResults6th() const {return this->fCommonHistsResults6th;}; | |
114 | void SetCommonHistsResults8th(AliFlowCommonHistResults* const chr8th) {this->fCommonHistsResults8th = chr8th;}; | |
115 | AliFlowCommonHistResults* GetCommonHistsResults8th() const {return this->fCommonHistsResults8th;}; | |
116 | void SetHarmonic(Int_t const harmonic) {this->fHarmonic = harmonic;}; | |
117 | Int_t GetHarmonic() const {return this->fHarmonic;}; | |
118 | void SetMultiple(Int_t const multiple) {this->fMultiple = multiple;}; | |
119 | Int_t GetMultiple() const {return this->fMultiple;}; | |
120 | void SetR0(Double_t const r0) {this->fR0 = r0;}; | |
121 | Double_t GetR0() const {return this->fR0;}; | |
122 | void SetPrintFinalResults(Bool_t const printOrNot, Int_t const i) {this->fPrintFinalResults[i] = printOrNot;}; | |
123 | Bool_t GetPrintFinalResults(Int_t i) const {return this->fPrintFinalResults[i];}; | |
124 | // 6.2.0.) particle weights: | |
125 | void SetWeightsList(TList* const wlist) {this->fWeightsList = (TList*)wlist->Clone();} | |
126 | TList* GetWeightsList() const {return this->fWeightsList;} | |
e5e75b58 | 127 | void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;}; |
128 | Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;}; | |
e5e75b58 | 129 | void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;}; |
130 | Bool_t GetUsePtWeights() const {return this->fUsePtWeights;}; | |
e5e75b58 | 131 | void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;}; |
132 | Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;}; | |
d6130938 | 133 | void SetPhiWeights(TH1F* const histPhiWeights) {this->fPhiWeights = histPhiWeights;}; |
134 | TH1F* GetPhiWeights() const {return this->fPhiWeights;}; | |
135 | void SetPtWeights(TH1D* const histPtWeights) {this->fPtWeights = histPtWeights;}; | |
136 | TH1D* GetPtWeights() const {return this->fPtWeights;}; | |
137 | void SetEtaWeights(TH1D* const histEtaWeights) {this->fEtaWeights = histEtaWeights;}; | |
138 | TH1D* GetEtaWeights() const {return this->fEtaWeights;}; | |
139 | // 6.2.1.) event weights: | |
140 | void SetMultiplicityWeight(const char *multiplicityWeight) {*this->fMultiplicityWeight = multiplicityWeight;}; | |
141 | // 6.3.) reference flow: | |
142 | void SetReferenceFlowFlags(TProfile* const rff) {this->fReferenceFlowFlags = rff;}; | |
3688e459 | 143 | TProfile* GetReferenceFlowFlags() const {return this->fReferenceFlowFlags;}; |
144 | void SetCalculateVsMultiplicity(Bool_t const ecvm) {this->fCalculateVsMultiplicity = ecvm;}; | |
145 | Bool_t GetCalculateVsMultiplicity() const {return this->fCalculateVsMultiplicity;}; | |
d6130938 | 146 | void SetnBinsMult(Int_t const nbm) {this->fnBinsMult = nbm;}; |
147 | Int_t GetnBinsMult() const {return this->fnBinsMult;}; | |
148 | void SetMinMult(Double_t const minm) {this->fMinMult = minm;}; | |
149 | Double_t GetMinMult() const {return this->fMinMult;}; | |
150 | void SetMaxMult(Double_t const maxm) {this->fMaxMult = maxm;}; | |
151 | Double_t GetMaxMult() const {return this->fMaxMult;}; | |
152 | // 6.3.0.) profiles: | |
153 | void SetReferenceFlowGenFun(TProfile2D* const rfgf) {this->fReferenceFlowGenFun = rfgf;}; | |
154 | TProfile2D* GetReferenceFlowGenFun() const {return this->fReferenceFlowGenFun;}; | |
155 | void SetQvectorComponents(TProfile* const qvc) {this->fQvectorComponents = qvc;}; | |
156 | TProfile* GetQvectorComponents() const {return this->fQvectorComponents;}; | |
9dd53ff2 | 157 | void SetAverageOfSquaredWeight(TProfile* const aosw) {this->fAverageOfSquaredWeight = aosw;}; |
158 | TProfile* GetSumOfSquaredWeight() const {return this->fAverageOfSquaredWeight;}; | |
3688e459 | 159 | void SetReferenceFlowGenFunVsM(TProfile3D* const rfgfVsM) {this->fReferenceFlowGenFunVsM = rfgfVsM;}; |
160 | TProfile3D* GetReferenceFlowGenFunVsM() const {return this->fReferenceFlowGenFunVsM;}; | |
161 | void SetQvectorComponentsVsM(TProfile2D* const qvcVsM) {this->fQvectorComponentsVsM = qvcVsM;}; | |
162 | TProfile2D* GetQvectorComponentsVsM() const {return this->fQvectorComponentsVsM;}; | |
163 | void SetAverageOfSquaredWeightVsM(TProfile2D* const aoswVsM) {this->fAverageOfSquaredWeightVsM = aoswVsM;}; | |
164 | TProfile2D* GetSumOfSquaredWeightVsM() const {return this->fAverageOfSquaredWeightVsM;}; | |
165 | void SetAvMVsM(TProfile* const amVsM) {this->fAvMVsM = amVsM;}; | |
166 | TProfile* GetAvMVsM() const {return this->fAvMVsM;}; | |
d6130938 | 167 | // 6.3.1.) results: |
168 | void SetReferenceFlowCumulants(TH1D* const rfc) {this->fReferenceFlowCumulants = rfc;}; | |
169 | TH1D* GetReferenceFlowCumulants() const {return this->fReferenceFlowCumulants;}; | |
170 | void SetReferenceFlow(TH1D* const rf) {this->fReferenceFlow = rf;}; | |
171 | TH1D* GetReferenceFlow() const {return this->fReferenceFlow;}; | |
172 | void SetChi(TH1D* const c) {this->fChi = c;}; | |
173 | TH1D* GetChi() const {return this->fChi;}; | |
3688e459 | 174 | void SetReferenceFlowCumulantsVsM(TH1D* const rfcVsM, Int_t co) {this->fReferenceFlowCumulantsVsM[co] = rfcVsM;}; |
175 | TH1D* GetReferenceFlowCumulantsVsM(Int_t co) const {return this->fReferenceFlowCumulantsVsM[co];}; | |
d6130938 | 176 | // 6.4.) differential flow: |
177 | void SetDiffFlowFlags(TProfile* const dff) {this->fDiffFlowFlags = dff;}; | |
178 | TProfile* GetDiffFlowFlags() const {return this->fDiffFlowFlags;}; | |
179 | // 6.4.0.) profiles: | |
180 | void SetDiffFlowGenFun(TProfile3D* const dfgf, Int_t const ri, Int_t const rp, Int_t const pe) {this->fDiffFlowGenFun[ri][rp][pe] = dfgf;}; | |
181 | TProfile3D* GetDiffFlowGenFun(Int_t const ri, Int_t const rp, Int_t const pe) const {return this->fDiffFlowGenFun[ri][rp][pe];}; | |
182 | void SetNoOfParticlesInBin(TProfile* const nopib, Int_t const rp, Int_t const pe) {this->fNoOfParticlesInBin[rp][pe] = nopib;}; | |
183 | TProfile* GetNoOfParticlesInBin(Int_t const rp, Int_t const pe) const {return this->fNoOfParticlesInBin[rp][pe];}; | |
184 | // 6.4.1.) results: | |
185 | void SetDiffFlowCumulants(TH1D* const dfc, Int_t const rp, Int_t const pe, Int_t const co) {this->fDiffFlowCumulants[rp][pe][co] = dfc;}; | |
186 | TH1D* GetDiffFlowCumulants(Int_t const rp, Int_t const pe, Int_t const co) const {return this->fDiffFlowCumulants[rp][pe][co];}; | |
187 | void SetDiffFlow(TH1D* const df, Int_t const rp, Int_t const pe, Int_t const co) {this->fDiffFlow[rp][pe][co] = df;}; | |
188 | TH1D* GetDiffFlow(Int_t const rp, Int_t const pe, Int_t const co) const {return this->fDiffFlow[rp][pe][co];}; | |
189 | // 6.x.) Tuning the interpolating parameter r0 and using cutoff at different order in series: | |
190 | void SetTuningFlags(TProfile* const tf) {this->fTuningFlags = tf;}; | |
191 | TProfile* GetTuningFlags() const {return this->fTuningFlags;}; | |
192 | void SetTuneParameters(Bool_t const tp) {this->fTuneParameters = tp;}; | |
193 | Bool_t GetTuneParameters() const {return this->fTuneParameters;}; | |
194 | void SetTuningR0(Double_t const tr0, Int_t const r) {this->fTuningR0[r] = tr0;}; | |
195 | Double_t GetTuningR0(Int_t const r) const {return this->fTuningR0[r];}; | |
196 | // 6.x.0.) profiles: | |
197 | void SetTuningGenFun(TProfile2D* const tgf, Int_t const r, Int_t const pq) {this->fTuningGenFun[r][pq] = tgf;}; | |
198 | TProfile2D* GetTuningGenFun(Int_t const r, Int_t const pq) const {return this->fTuningGenFun[r][pq];}; | |
3688e459 | 199 | void SetTuningAvM(TProfile* const tam) {this->fTuningAvM = tam;}; |
200 | TProfile* GetTuningAvM() const {return this->fTuningAvM;}; | |
d6130938 | 201 | // 6.x.1.) results: |
202 | void SetTuningCumulants(TH1D* const tc, Int_t const r, Int_t const pq) {this->fTuningCumulants[r][pq] = tc;}; | |
203 | TH1D* GetTuningCumulants(Int_t const r, Int_t const pq) const {return this->fTuningCumulants[r][pq];}; | |
204 | void SetTuningFlow(TH1D* const tf, Int_t const r, Int_t const pq) {this->fTuningFlow[r][pq] = tf;}; | |
205 | TH1D* GetTuningFlow(Int_t const r, Int_t const pq) const {return this->fTuningFlow[r][pq];}; | |
206 | ||
2188af53 | 207 | private: |
208 | AliFlowAnalysisWithCumulants(const AliFlowAnalysisWithCumulants& afawc); | |
d6130938 | 209 | AliFlowAnalysisWithCumulants& operator=(const AliFlowAnalysisWithCumulants& afawc); |
210 | // 0.) Base: | |
211 | TList *fHistList; // base list to hold all output objects | |
212 | TString *fHistListName; // name of base list | |
213 | TProfile *fAnalysisSettings; // profile to hold analysis settings | |
214 | // 1.) Common: | |
215 | AliFlowCommonHist *fCommonHists; // common control histograms (filled only with events with 3 or more tracks for 3-p correlators) | |
216 | AliFlowCommonHistResults *fCommonHistsResults2nd; // common result histograms for 2nd order cumulant | |
217 | AliFlowCommonHistResults *fCommonHistsResults4th; // common result histograms for 4th order cumulant | |
218 | AliFlowCommonHistResults *fCommonHistsResults6th; // common result histograms for 6th order cumulant | |
219 | AliFlowCommonHistResults *fCommonHistsResults8th; // common result histograms for 8th order cumulant | |
220 | Int_t fnBinsPhi; // number of phi bins | |
221 | Double_t fPhiMin; // minimum phi | |
222 | Double_t fPhiMax; // maximum phi | |
223 | Double_t fPhiBinWidth; // bin width for phi histograms | |
224 | Int_t fnBinsPt; // number of pt bins | |
225 | Double_t fPtMin; // minimum pt | |
226 | Double_t fPtMax; // maximum pt | |
227 | Double_t fPtBinWidth; // bin width for pt histograms | |
228 | Int_t fnBinsEta; // number of eta bins | |
229 | Double_t fEtaMin; // minimum eta | |
230 | Double_t fEtaMax; // maximum eta | |
231 | Double_t fEtaBinWidth; // bin width for eta histograms | |
232 | Int_t fHarmonic; // harmonic | |
233 | Int_t fMultiple; // the multiple m in p=m*n, where n is harmonic (relevant for differential flow) | |
234 | Double_t fR0; // r_{0} parameter | |
235 | Bool_t fPrintFinalResults[3]; // print on the screen the final results [0=RF,1=RP,2=POI] | |
236 | // 2a.) Particle weights: | |
3688e459 | 237 | TList *fWeightsList; // list to hold all histograms with particle weights: fPhiWeights, fPtWeights and fEtaWeights |
d6130938 | 238 | Bool_t fUsePhiWeights; // use phi weights |
239 | Bool_t fUsePtWeights; // use pt weights | |
240 | Bool_t fUseEtaWeights; // use eta weights | |
d6130938 | 241 | TH1F *fPhiWeights; // histogram holding phi weights |
242 | TH1D *fPtWeights; // histogram holding phi weights | |
243 | TH1D *fEtaWeights; // histogram holding phi weights | |
244 | // 2b.) Event weights: | |
245 | TString *fMultiplicityWeight; // event-by-event weight for reference flow generating function (can be "unit" or "multiplicity") | |
246 | // 3.) Reference flow: | |
247 | // 3a.) lists: | |
248 | TList *fReferenceFlowList; // list to hold all histograms and profiles relevant for reference flow | |
249 | TList *fReferenceFlowProfiles; // list to hold all profiles relevant for reference flow | |
250 | TList *fReferenceFlowResults; // list to hold all histograms with final results relevant for reference flow | |
251 | // 3b.) flags: | |
252 | TProfile *fReferenceFlowFlags; // profile to hold all flags for reference flow | |
3688e459 | 253 | Bool_t fCalculateVsMultiplicity; // perform flow analysis independently for each multiplicity bin |
d6130938 | 254 | Int_t fnBinsMult; // number of multiplicity bins for flow analysis versus multiplicity |
255 | Double_t fMinMult; // minimal multiplicity for flow analysis versus multiplicity | |
256 | Double_t fMaxMult; // maximal multiplicity for flow analysis versus multiplicity | |
257 | // 3c.) event-by-event quantities: | |
a663ab5a | 258 | TMatrixD *fGEBE; // reference flow generating function only for current event |
d6130938 | 259 | // 3d.) profiles: |
260 | TProfile2D *fReferenceFlowGenFun; // all-event average of the generating function used to calculate reference flow | |
261 | 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>) | |
262 | TProfile *fAverageOfSquaredWeight; // <<w^2>>, where w = wPhi*wPt*wEta | |
3688e459 | 263 | TProfile3D *fReferenceFlowGenFunVsM; // all-event average of the generating function used to calculate reference flow vs multiplicity |
264 | 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 | |
265 | TProfile2D *fAverageOfSquaredWeightVsM; // <<w^2>>, where w = wPhi*wPt*wEta vs multiplicity | |
266 | TProfile *fAvMVsM; // <M> vs multiplicity bin | |
d6130938 | 267 | // 3e.) results: |
268 | Double_t fAvM; // average multiplicity | |
269 | Int_t fnEvts; // number of events | |
270 | TH1D *fReferenceFlowCumulants; // final results for isotropic cumulants for reference flow | |
271 | TH1D *fReferenceFlow; // final results for reference flow | |
272 | TH1D *fChi; // final results for resolution | |
3688e459 | 273 | TH1D *fReferenceFlowCumulantsVsM[4]; // final results for isotropic cumulants for reference flow versus multiplicity |
d6130938 | 274 | // 4.) Differential flow: |
275 | // 4a.) lists: | |
276 | TList *fDiffFlowList; // list to hold all histograms and profiles relevant for differential flow | |
277 | TList *fDiffFlowProfiles; // list to hold all profiles relevant for differential flow | |
278 | TList *fDiffFlowResults; // list to hold all histograms with final results relevant for differential flow | |
279 | // 4b.) flags: | |
280 | TProfile *fDiffFlowFlags; // profile to hold all flags for reference flow | |
281 | // 4c.) profiles: | |
282 | 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] | |
283 | TProfile *fNoOfParticlesInBin[2][2]; // number of particles in pt/eta bin for RPs/POIs [0=RP,1=POI][0=pt,1=eta] | |
284 | // 4d.) results: | |
285 | TH1D *fDiffFlowCumulants[2][2][4]; // isotropic differential flow cumulants [0=RP,1=POI][0=pt,1=eta][cumulant order] | |
286 | TH1D *fDiffFlow[2][2][4]; // differential flow [0=RP,1=POI][0=pt,1=eta][cumulant order] | |
287 | // x.) Tuning the interpolating parameter r0 and using cutoff at different order in series: | |
288 | // xa.) lists: | |
289 | TList *fTuningList; // list to hold all histograms and profiles relevant for tuning | |
290 | TList *fTuningProfiles; // list to hold all profiles relevant for tuning | |
291 | TList *fTuningResults; // list to hold all histograms with final results relevant for tuning | |
292 | // xb.) flags: | |
293 | TProfile *fTuningFlags; // profile to hold all flags for tuning | |
294 | Bool_t fTuneParameters; // tune r0 and cut series at different order | |
295 | Double_t fTuningR0[10]; // different r0 values (at maximum 10 different values allowed) | |
296 | // xc.) profiles: | |
297 | TProfile2D *fTuningGenFun[10][5]; // generating function G evaluated for 10 different r0s and 5 different sets of (pmax,qmax) | |
3688e459 | 298 | TProfile *fTuningAvM; // average multiplicities for events with nRPs >= cuttof |
d6130938 | 299 | // xd.) results: |
300 | TH1D *fTuningCumulants[10][5]; // isotropic cumulants for reference flow for 10 different r0s and 5 different sets of (pmax,qmax) | |
301 | TH1D *fTuningFlow[10][5]; // reference flow for 10 different r0s and 5 different sets of (pmax,qmax) | |
2188af53 | 302 | |
f1d945a1 | 303 | ClassDef(AliFlowAnalysisWithCumulants, 0); |
d6130938 | 304 | |
f1d945a1 | 305 | }; |
2188af53 | 306 | |
307 | //================================================================================================================ | |
308 | ||
f1d945a1 | 309 | #endif |
310 | ||
311 | ||
aaebd73d | 312 | |
313 | ||
314 |