Adding "+" after the definition of the AliTOFRecoParam class.
[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommon / AliFlowAnalysisWithQCumulants.h
CommitLineData
bc92c0cb 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
7/**********************************
8 * flow analysis with Q-cumulants *
9 * *
10 * author: Ante Bilandzic *
11 * (anteb@nikhef.nl) *
12 *********************************/
13
52021ae2 14#ifndef ALIFLOWANALYSISWITHQCUMULANTS_H
15#define ALIFLOWANALYSISWITHQCUMULANTS_H
bc92c0cb 16
9c1a9547 17#include "AliFlowCommonConstants.h" // needed as include
18#include "TMatrixD.h"
19#include "TH2D.h"
20#include "TBits.h"
bc92c0cb 21
22class TObjArray;
23class TList;
24class TFile;
e085f1a9 25class TGraph;
bc92c0cb 26
27class TH1;
28class TProfile;
9c1a9547 29class TProfile2D;
bc92c0cb 30
31class AliFlowEventSimple;
32class AliFlowTrackSimple;
52021ae2 33class AliFlowVector;
34
bc92c0cb 35class AliFlowCommonHist;
36class AliFlowCommonHistResults;
bc92c0cb 37
38//================================================================================================================
39
40class AliFlowAnalysisWithQCumulants{
41 public:
42 AliFlowAnalysisWithQCumulants();
43 virtual ~AliFlowAnalysisWithQCumulants();
44
e085f1a9 45 virtual void Init();
bc92c0cb 46 virtual void Make(AliFlowEventSimple* anEvent);
9c1a9547 47
48 virtual void CalculateCorrelationsForIntegratedFlow(); // everything cross-checked (2-8)
49 virtual void CalculateWeightedCorrelationsForIntegratedFlow();
50 virtual void CalculateCorrelationsForDifferentialFlow(TString type="POI");
51 virtual void CalculateWeightedCorrelationsForDifferentialFlow(TString type="POI");
c365fe76 52
2bdc5281 53 virtual void CalculateCorrectionsForNonUniformAcceptanceForNoNameIntegratedFlowCosTerms();
54 virtual void CalculateCorrectionsForNonUniformAcceptanceForNoNameIntegratedFlowSinTerms();
55 virtual void CalculateCorrectionsForNonUniformAcceptanceForDifferentialFlowCosTerms(TString type="POI");
56 virtual void CalculateCorrectionsForNonUniformAcceptanceForDifferentialFlowSinTerms(TString type="POI");
c365fe76 57
9c1a9547 58 virtual void EvaluateNestedLoopsForIntegratedFlow(AliFlowEventSimple* anEvent);
59 virtual void EvaluateNestedLoopsForDifferentialFlow(AliFlowEventSimple* anEvent);
60
fd46c3dd 61 virtual void GetOutputHistograms(TList *outputListHistos); // get pointers to all output histograms (called before Finish())
bc92c0cb 62 virtual void Finish();
9c1a9547 63
64 TProfile* MakePtProjection(TProfile2D *profilePtEta) const;
65 TProfile* MakeEtaProjection(TProfile2D *profilePtEta) const;
66
2bdc5281 67 virtual void CalculateFinalCorrectionsForNonUniformAcceptanceForNoNameIntegratedFlow(Bool_t useWeights=kFALSE);
68 virtual void CalculateFinalCorrectionsForNonUniformAcceptanceForDifferentialFlow(Bool_t useWeights=kFALSE,TString type="POI");
c365fe76 69
9c1a9547 70 virtual void CalculateFinalResultsForNoNameIntegratedFlow(Bool_t useWeights=kFALSE);
71 virtual void CalculateFinalResultsForRPandPOIIntegratedFlow(Bool_t useWeights, TString type);
3c16adde 72 virtual void CalculateFinalResultsForDifferentialFlow(TH2D *flowPtEta, TH1D *flowPt, TH1D *flowEta,
73 TProfile2D *profile2ndPtEta, TProfile2D *profile4thPtEta = NULL,
74 TProfile2D *profile6thPtEta = NULL, TProfile2D *profile8thPtEta = NULL);
9c1a9547 75
76 virtual void PrintFinalResultsForIntegratedFlow(Bool_t useWeights=kTRUE, TString type="NONAME");
77
78 virtual void CompareDirectAndQCorrelationsForIntegratedFlow(Bool_t useWeights);
79 virtual void CompareDirectAndQCorrelationsForDifferentialFlow(Bool_t useWeights);
80
4057ba99 81 virtual void WriteHistograms(TString outputFileName);
9c1a9547 82
83 virtual void TempDeleteMe();
8842fb2b 84
85//----------------------------------------------------------------------------------------------------------------
86// setters and getters
87//----------------------------------------------------------------------------------------------------------------
03a02aca 88 TList* GetHistList() const {return this->fHistList;}
89
90 void SetWeightsList(TList* wlist) {this->fWeightsList = wlist;}
9c1a9547 91 TList* GetWeightsList() const {return this->fWeightsList;}
92
93 void SetResultsList(TList* rlist) {this->fResultsList = rlist;}
94 TList* GetResultsList() const {return this->fResultsList;}
c365fe76 95
96 void SetFinalCorrectionsForNUA(TH1D* const fcfnua) {this->fFinalCorrectionsForNUA = fcfnua;}; // NUA = non-uniform acceptance
97 TH1D* GetFinalCorrectionsForNUA() const {return this->fFinalCorrectionsForNUA;};
bc92c0cb 98
52021ae2 99 void SetIntFlowResults(TH1D* const ifr) {this->fIntFlowResultsQC = ifr;};
100 TH1D* GetIntFlowResults() const {return this->fIntFlowResultsQC;};
8842fb2b 101
9c1a9547 102 void SetIntFlowResultsW(TH1D* const ifrw) {this->fIntFlowResultsQCW = ifrw;};
103 TH1D* GetIntFlowResultsW() const {return this->fIntFlowResultsQCW;};
104
105 void SetIntFlowResultsPOI(TH1D* const ifrp) {this->fIntFlowResultsPOIQC = ifrp;};
106 TH1D* GetIntFlowResultsPOI() const {return this->fIntFlowResultsPOIQC;};
107
108 void SetIntFlowResultsPOIW(TH1D* const ifrpw) {this->fIntFlowResultsPOIQCW = ifrpw;};
109 TH1D* GetIntFlowResultsPOIW() const {return this->fIntFlowResultsPOIQCW;};
110
111 void SetIntFlowResultsRP(TH1D* const ifrr) {this->fIntFlowResultsRPQC = ifrr;};
112 TH1D* GetIntFlowResultsRP() const {return this->fIntFlowResultsRPQC;};
113
114 void SetIntFlowResultsRPW(TH1D* const ifrrw) {this->fIntFlowResultsRPQCW = ifrrw;};
115 TH1D* GetIntFlowResultsRPW() const {return this->fIntFlowResultsRPQCW;};
116
117
118
119
120
52021ae2 121 void SetDiffFlowResults2nd(TH1D* const diff2nd) {this->fDiffFlowResults2ndOrderQC = diff2nd;};
122 TH1D* GetDiffFlowResults2nd() const {return this->fDiffFlowResults2ndOrderQC;};
8842fb2b 123
52021ae2 124 void SetDiffFlowResults4th(TH1D* const diff4th) {this->fDiffFlowResults4thOrderQC = diff4th;};
125 TH1D* GetDiffFlowResults4th() const {return this->fDiffFlowResults4thOrderQC;};
8842fb2b 126
52021ae2 127 void SetCovariances(TH1D* const cov) {this->fCovariances = cov;};
128 TH1D* GetCovariances() const {return this->fCovariances;};
8842fb2b 129
7e58a232 130 void SetCommonHists2nd(AliFlowCommonHist* const ch2nd) {this->fCommonHists2nd = ch2nd;};
131 AliFlowCommonHist* GetCommonHists2nd() const {return this->fCommonHists2nd;};
132
133 void SetCommonHists4th(AliFlowCommonHist* const ch4th) {this->fCommonHists4th = ch4th;};
134 AliFlowCommonHist* GetCommonHists4th() const {return this->fCommonHists4th;};
135
136 void SetCommonHists6th(AliFlowCommonHist* const ch6th) {this->fCommonHists6th = ch6th;};
137 AliFlowCommonHist* GetCommonHists6th() const {return this->fCommonHists6th;};
138
139 void SetCommonHists8th(AliFlowCommonHist* const ch8th) {this->fCommonHists8th = ch8th;};
140 AliFlowCommonHist* GetCommonHists8th() const {return this->fCommonHists8th;};
141
52021ae2 142 void SetCommonHistsResults2nd(AliFlowCommonHistResults* const chr2nd) {this->fCommonHistsResults2nd = chr2nd;};
143 AliFlowCommonHistResults* GetCommonHistsResults2nd() const {return this->fCommonHistsResults2nd;};
8842fb2b 144
52021ae2 145 void SetCommonHistsResults4th(AliFlowCommonHistResults* const chr4th) {this->fCommonHistsResults4th = chr4th;};
146 AliFlowCommonHistResults* GetCommonHistsResults4th() const {return this->fCommonHistsResults4th;};
8842fb2b 147
52021ae2 148 void SetCommonHistsResults6th(AliFlowCommonHistResults* const chr6th) {this->fCommonHistsResults6th = chr6th;};
149 AliFlowCommonHistResults* GetCommonHistsResults6th() const {return this->fCommonHistsResults6th;};
8842fb2b 150
52021ae2 151 void SetCommonHistsResults8th(AliFlowCommonHistResults* const chr8th) {this->fCommonHistsResults8th = chr8th;};
152 AliFlowCommonHistResults* GetCommonHistsResults8th() const {return this->fCommonHistsResults8th;};
8842fb2b 153
52021ae2 154 void SetAverageMultiplicity(TProfile* const am) {this->fAvMultIntFlowQC = am;};
155 TProfile* GetAverageMultiplicity() const {return this->fAvMultIntFlowQC;};
8842fb2b 156
e085f1a9 157 void SetQvectorForEachEventX(TProfile* const qvfeex) {this->fQvectorForEachEventX = qvfeex;};
158 TProfile* GetQvectorForEachEventX() const {return this->fQvectorForEachEventX;};
159
160 void SetQvectorForEachEventY(TProfile* const qvfeey) {this->fQvectorForEachEventY = qvfeey;};
161 TProfile* GetQvectorForEachEventY() const {return this->fQvectorForEachEventY;};
162
52021ae2 163 void SetQCorrelations(TProfile* const QCorr) {this->fQCorrelations = QCorr;};
164 TProfile* GetQCorrelations() const {return this->fQCorrelations;};
8842fb2b 165
9c1a9547 166 void SetQCorrelationsW(TProfile* const QCorrW) {this->fQCorrelationsW = QCorrW;};
167 TProfile* GetQCorrelationsW() const {return this->fQCorrelationsW;};
3d824203 168
c365fe76 169 void SetQCorrectionsCos(TProfile* const QCorrectCos) {this->fQCorrectionsCos = QCorrectCos;};
170 TProfile* GetQCorrectionsCos() const {return this->fQCorrectionsCos;};
171
172 void SetQCorrectionsSin(TProfile* const QCorrectSin) {this->fQCorrectionsSin = QCorrectSin;};
173 TProfile* GetQCorrectionsSin() const {return this->fQCorrectionsSin;};
174
52021ae2 175 void SetQProduct(TProfile* const qp) {this->fQProduct = qp;};
176 TProfile* GetQProduct() const {return this->fQProduct;};
8842fb2b 177
52021ae2 178 void SetQVectorComponents(TProfile* const qvc) {this->fQvectorComponents = qvc;};
179 TProfile* GetQVectorComponents() const {return this->fQvectorComponents;};
8842fb2b 180
1dfa3c16 181 void SetTwo1n1nPerPtBinRP(TProfile* const pb2PerPtBin1n1nRP) {this->f2PerPtBin1n1nRP = pb2PerPtBin1n1nRP;};
182 TProfile* GetTwo1n1nPerPtBinRP() const {return this->f2PerPtBin1n1nRP;};
8842fb2b 183
1dfa3c16 184 void SetFour1n1n1n1nPerPtBinRP(TProfile* const pb4PerPtBin1n1n1n1nRP) {this->f4PerPtBin1n1n1n1nRP = pb4PerPtBin1n1n1n1nRP;};
185 TProfile* GetFour1n1n1n1nPerPtBinRP() const {return this->f4PerPtBin1n1n1n1nRP;};
03a02aca 186
1dfa3c16 187 void SetTwo1n1nPerEtaBinRP(TProfile* const pb2PerEtaBin1n1nRP) {this->f2PerEtaBin1n1nRP = pb2PerEtaBin1n1nRP;};
188 TProfile* GetTwo1n1nPerEtaBinRP() const {return this->f2PerEtaBin1n1nRP;};
189
1dfa3c16 190 void SetFour1n1n1n1nPerEtaBinRP(TProfile* const pb4PerEtaBin1n1n1n1nRP) {this->f4PerEtaBin1n1n1n1nRP = pb4PerEtaBin1n1n1n1nRP;};
191 TProfile* GetFour1n1n1n1nPerEtaBinRP() const {return this->f4PerEtaBin1n1n1n1nRP;};
192
193 void SetTwo1n1nPerPtBinPOI(TProfile* const pb2PerPtBin1n1nPOI) {this->f2PerPtBin1n1nPOI = pb2PerPtBin1n1nPOI;};
194 TProfile* GetTwo1n1nPerPtBinPOI() const {return this->f2PerPtBin1n1nPOI;};
195
1dfa3c16 196 void SetFour1n1n1n1nPerPtBinPOI(TProfile* const pb4PerPtBin1n1n1n1nPOI) {this->f4PerPtBin1n1n1n1nPOI = pb4PerPtBin1n1n1n1nPOI;};
197 TProfile* GetFour1n1n1n1nPerPtBinPOI() const {return this->f4PerPtBin1n1n1n1nPOI;};
198
199 void SetTwo1n1nPerEtaBinPOI(TProfile* const pb2PerEtaBin1n1nPOI) {this->f2PerEtaBin1n1nPOI = pb2PerEtaBin1n1nPOI;};
200 TProfile* GetTwo1n1nPerEtaBinPOI() const {return this->f2PerEtaBin1n1nPOI;};
201
1dfa3c16 202 void SetFour1n1n1n1nPerEtaBinPOI(TProfile* const pb4PerEtaBin1n1n1n1nPOI) {this->f4PerEtaBin1n1n1n1nPOI = pb4PerEtaBin1n1n1n1nPOI;};
203 TProfile* GetFour1n1n1n1nPerEtaBinPOI() const {return this->f4PerEtaBin1n1n1n1nPOI;};
8842fb2b 204
3d824203 205 void SetTwo1n1nWPerPtBinPOI(TProfile* const pb2WPerPtBin1n1nPOI) {this->f2WPerPtBin1n1nPOI = pb2WPerPtBin1n1nPOI;};
206 TProfile* GetTwo1n1nWPerPtBinPOI() const {return this->f2WPerPtBin1n1nPOI;};
207
3d824203 208 void SetFour1n1n1n1nWPerPtBinPOI(TProfile* const pb4WPerPtBin1n1n1n1nPOI) {this->f4WPerPtBin1n1n1n1nPOI = pb4WPerPtBin1n1n1n1nPOI;};
209 TProfile* GetFour1n1n1n1nWPerPtBinPOI() const {return this->f4WPerPtBin1n1n1n1nPOI;}
210
3d824203 211 void SetTwo1n1nWPerEtaBinPOI(TProfile* const pb2WPerEtaBin1n1nPOI) {this->f2WPerEtaBin1n1nPOI = pb2WPerEtaBin1n1nPOI;};
212 TProfile* GetTwo1n1nWPerEtaBinPOI() const {return this->f2WPerEtaBin1n1nPOI;};
213
214 void SetFour1n1n1n1nWPerEtaBinPOI(TProfile* const pb4WPerEtaBin1n1n1n1nPOI) {this->f4WPerEtaBin1n1n1n1nPOI = pb4WPerEtaBin1n1n1n1nPOI;};
215 TProfile* GetFour1n1n1n1nWPerEtaBinPOI() const {return this->f4WPerEtaBin1n1n1n1nPOI;}
216
217 void SetTwo1n1nWPerPtBinRP(TProfile* const pb2WPerPtBin1n1nRP) {this->f2WPerPtBin1n1nRP = pb2WPerPtBin1n1nRP;};
218 TProfile* GetTwo1n1nWPerPtBinRP() const {return this->f2WPerPtBin1n1nRP;};
219
220 void SetFour1n1n1n1nWPerPtBinRP(TProfile* const pb4WPerPtBin1n1n1n1nRP) {this->f4WPerPtBin1n1n1n1nRP = pb4WPerPtBin1n1n1n1nRP;};
221 TProfile* GetFour1n1n1n1nWPerPtBinRP() const {return this->f4WPerPtBin1n1n1n1nRP;}
222
223 void SetTwo1n1nWPerEtaBinRP(TProfile* const pb2WPerEtaBin1n1nRP) {this->f2WPerEtaBin1n1nRP = pb2WPerEtaBin1n1nRP;};
224 TProfile* GetTwo1n1nWPerEtaBinRP() const {return this->f2WPerEtaBin1n1nRP;};
225
226 void SetFour1n1n1n1nWPerEtaBinRP(TProfile* const pb4WPerEtaBin1n1n1n1nRP) {this->f4WPerEtaBin1n1n1n1nRP = pb4WPerEtaBin1n1n1n1nRP;};
227 TProfile* GetFour1n1n1n1nWPerEtaBinRP() const {return this->f4WPerEtaBin1n1n1n1nRP;}
228
52021ae2 229 void SetDirectCorrelations(TProfile* const dc) {this->fDirectCorrelations = dc;};
230 TProfile* GetDirectCorrelations() const {return this->fDirectCorrelations;};
e085f1a9 231
9c1a9547 232 void SetDirectCorrelationsW(TProfile* const dcw) {this->fDirectCorrelationsW = dcw;};
233 TProfile* GetDirectCorrelationsW() const {return this->fDirectCorrelationsW;};
234
235 void SetDirectCorrelationsDiffFlow(TProfile* const dcdf) {this->fDirectCorrelationsDiffFlow = dcdf;};
236 TProfile* GetDirectCorrelationsDiffFlow() const {return this->fDirectCorrelationsDiffFlow;};
237
238 void SetDirectCorrelationsDiffFlowW(TProfile* const dcdfw) {this->fDirectCorrelationsDiffFlowW = dcdfw;};
239 TProfile* GetDirectCorrelationsDiffFlowW() const {return this->fDirectCorrelationsDiffFlowW;};
240
c365fe76 241 void SetDirectCorrectionsCos(TProfile* const dCorrectCos) {this->fDirectCorrectionsCos = dCorrectCos;};
242 TProfile* GetDirectCorrectionsCos() const {return this->fDirectCorrectionsCos;};
243
244 void SetDirectCorrectionsSin(TProfile* const dCorrectSin) {this->fDirectCorrectionsSin = dCorrectSin;};
245 TProfile* GetDirectCorrectionsSin() const {return this->fDirectCorrectionsSin;};
2bdc5281 246
247 void SetDirectCorrectionsDiffFlowCos(TProfile* const dcdfCos) {this->fDirectCorrectionsDiffFlowCos = dcdfCos;};
248 TProfile* GetDirectCorrectionsDiffFlowCos() const {return this->fDirectCorrectionsDiffFlowCos;};
249
250 void SetDirectCorrectionsDiffFlowSin(TProfile* const dcdfSin) {this->fDirectCorrectionsDiffFlowSin = dcdfSin;};
251 TProfile* GetDirectCorrectionsDiffFlowSin() const {return this->fDirectCorrectionsDiffFlowSin;};
c365fe76 252
e04e4ec5 253 void SetUsePhiWeights(Bool_t const uPhiW) {this->fUsePhiWeights = uPhiW;};
03a02aca 254 Bool_t GetUsePhiWeights() const {return this->fUsePhiWeights;};
e085f1a9 255
e04e4ec5 256 void SetUsePtWeights(Bool_t const uPtW) {this->fUsePtWeights = uPtW;};
03a02aca 257 Bool_t GetUsePtWeights() const {return this->fUsePtWeights;};
e085f1a9 258
e04e4ec5 259 void SetUseEtaWeights(Bool_t const uEtaW) {this->fUseEtaWeights = uEtaW;};
03a02aca 260 Bool_t GetUseEtaWeights() const {return this->fUseEtaWeights;};
9c1a9547 261
262 void SetUseWeights(Bool_t const uw) {this->fUseWeights = uw;};
263 Bool_t GetUseWeights() const {return this->fUseWeights;};
264
265 void SetUseWeightsBits(TBits* const uwb) {this->fUseWeightsBits = uwb;};
266 TBits* GetUseWeightsBits() const {return this->fUseWeightsBits;};
2bdc5281 267
268 // .................................................................................................
269 // POI:
270 // corrections for non-uniform acceptance for differential flow (cos terms):
271 void SetCorrectionsCosP1nPsiPtEtaPOI(TProfile2D* const cCosP1nPsiPtEtaPOI) {this->fCorrectionsCosP1nPsiPtEtaPOI = cCosP1nPsiPtEtaPOI;};
272 TProfile2D* GetCorrectionsCosP1nPsiPtEtaPOI() const {return this->fCorrectionsCosP1nPsiPtEtaPOI;};
273
274 // ...
9c1a9547 275
2bdc5281 276 // corrections for non-uniform acceptance for differential flow (sin terms):
277 void SetCorrectionsSinP1nPsiPtEtaPOI(TProfile2D* const cSinP1nPsiPtEtaPOI) {this->fCorrectionsSinP1nPsiPtEtaPOI = cSinP1nPsiPtEtaPOI;};
278 TProfile2D* GetCorrectionsSinP1nPsiPtEtaPOI() const {return this->fCorrectionsSinP1nPsiPtEtaPOI;};
279
280 // ...
281
282 // RP:
283 // corrections for non-uniform acceptance for differential flow (cos terms):
284 void SetCorrectionsCosP1nPsiPtEtaRP(TProfile2D* const cCosP1nPsiPtEtaRP) {this->fCorrectionsCosP1nPsiPtEtaRP = cCosP1nPsiPtEtaRP;};
285 TProfile2D* GetCorrectionsCosP1nPsiPtEtaRP() const {return this->fCorrectionsCosP1nPsiPtEtaRP;};
9c1a9547 286
2bdc5281 287 // ...
9c1a9547 288
2bdc5281 289 // corrections for non-uniform acceptance for differential flow (sin terms):
290 void SetCorrectionsSinP1nPsiPtEtaRP(TProfile2D* const cSinP1nPsiPtEtaRP) {this->fCorrectionsSinP1nPsiPtEtaRP = cSinP1nPsiPtEtaRP;};
291 TProfile2D* GetCorrectionsSinP1nPsiPtEtaRP() const {return this->fCorrectionsSinP1nPsiPtEtaRP;};
9c1a9547 292
2bdc5281 293 // ...
9c1a9547 294
2bdc5281 295 // .................................................................................................
9c1a9547 296
297 // .................................................................................................
298 // non-weighted correlations for differential flow of POIs:
299 void Set2pPtEtaPOI(TProfile2D* const tppep) {this->f2pPtEtaPOI = tppep;};
300 TProfile2D* Get2pPtEtaPOI() const {return this->f2pPtEtaPOI;};
301 void Set4pPtEtaPOI(TProfile2D* const fppep) {this->f4pPtEtaPOI = fppep;};
302 TProfile2D* Get4pPtEtaPOI() const {return this->f4pPtEtaPOI;};
303 void Set6pPtEtaPOI(TProfile2D* const sppep) {this->f6pPtEtaPOI = sppep;};
304 TProfile2D* Get6pPtEtaPOI() const {return this->f6pPtEtaPOI;};
305 void Set8pPtEtaPOI(TProfile2D* const eppep) {this->f8pPtEtaPOI = eppep;};
306 TProfile2D* Get8pPtEtaPOI() const {return this->f8pPtEtaPOI;};
307
2bdc5281 308 // corrections for non-uniform acceptance to non-weighted correlations for differential flow of POIs:
309 void Set2pFinalCorrectionsForNUAPtEtaPOI(TH2D* const tpfcfnuapePOI) {this->f2pFinalCorrectionsForNUAPtEtaPOI = tpfcfnuapePOI;};
310 TH2D* Get2pFinalCorrectionsForNUAPtEtaPOI() const {return this->f2pFinalCorrectionsForNUAPtEtaPOI;};
311 void Set4pFinalCorrectionsForNUAPtEtaPOI(TH2D* const fpfcfnuapePOI) {this->f4pFinalCorrectionsForNUAPtEtaPOI = fpfcfnuapePOI;};
312 TH2D* Get4pFinalCorrectionsForNUAPtEtaPOI() const {return this->f4pFinalCorrectionsForNUAPtEtaPOI;};
313 void Set6pFinalCorrectionsForNUAPtEtaPOI(TH2D* const spfcfnuapePOI) {this->f6pFinalCorrectionsForNUAPtEtaPOI = spfcfnuapePOI;};
314 TH2D* Get6pFinalCorrectionsForNUAPtEtaPOI() const {return this->f6pFinalCorrectionsForNUAPtEtaPOI;};
315 void Set8pFinalCorrectionsForNUAPtEtaPOI(TH2D* const epfcfnuapePOI) {this->f8pFinalCorrectionsForNUAPtEtaPOI = epfcfnuapePOI;};
316 TH2D* Get8pFinalCorrectionsForNUAPtEtaPOI() const {return this->f8pFinalCorrectionsForNUAPtEtaPOI;};
317
318 // corrections for non-uniform acceptance to non-weighted correlations for each (pt) bin for differential flow of POIs:
319 void Set2pFinalCorrectionsForNUAPtPOI(TH1D* const tpfcfnuapPOI) {this->f2pFinalCorrectionsForNUAPtPOI = tpfcfnuapPOI;};
320 TH1D* Get2pFinalCorrectionsForNUAPtPOI() const {return this->f2pFinalCorrectionsForNUAPtPOI;};
321 void Set4pFinalCorrectionsForNUAPtPOI(TH1D* const fpfcfnuapPOI) {this->f4pFinalCorrectionsForNUAPtPOI = fpfcfnuapPOI;};
322 TH1D* Get4pFinalCorrectionsForNUAPtPOI() const {return this->f4pFinalCorrectionsForNUAPtPOI;};
323 void Set6pFinalCorrectionsForNUAPtPOI(TH1D* const spfcfnuapPOI) {this->f6pFinalCorrectionsForNUAPtPOI = spfcfnuapPOI;};
324 TH1D* Get6pFinalCorrectionsForNUAPtPOI() const {return this->f6pFinalCorrectionsForNUAPtPOI;};
325 void Set8pFinalCorrectionsForNUAPtPOI(TH1D* const epfcfnuapPOI) {this->f8pFinalCorrectionsForNUAPtPOI = epfcfnuapPOI;};
326 TH1D* Get8pFinalCorrectionsForNUAPtPOI() const {return this->f8pFinalCorrectionsForNUAPtPOI;};
327
328 // corrections for non-uniform acceptance to non-weighted correlations for each (eta) bin for differential flow of POIs:
329 void Set2pFinalCorrectionsForNUAEtaPOI(TH1D* const tpfcfnuaePOI) {this->f2pFinalCorrectionsForNUAEtaPOI = tpfcfnuaePOI;};
330 TH1D* Get2pFinalCorrectionsForNUAEtaPOI() const {return this->f2pFinalCorrectionsForNUAEtaPOI;};
331 void Set4pFinalCorrectionsForNUAEtaPOI(TH1D* const fpfcfnuaePOI) {this->f4pFinalCorrectionsForNUAEtaPOI = fpfcfnuaePOI;};
332 TH1D* Get4pFinalCorrectionsForNUAEtaPOI() const {return this->f4pFinalCorrectionsForNUAEtaPOI;};
333 void Set6pFinalCorrectionsForNUAEtaPOI(TH1D* const spfcfnuaePOI) {this->f6pFinalCorrectionsForNUAEtaPOI = spfcfnuaePOI;};
334 TH1D* Get6pFinalCorrectionsForNUAEtaPOI() const {return this->f6pFinalCorrectionsForNUAEtaPOI;};
335 void Set8pFinalCorrectionsForNUAEtaPOI(TH1D* const epfcfnuaePOI) {this->f8pFinalCorrectionsForNUAEtaPOI = epfcfnuaePOI;};
336 TH1D* Get8pFinalCorrectionsForNUAEtaPOI() const {return this->f8pFinalCorrectionsForNUAEtaPOI;};
337
9c1a9547 338 // non-weighted final results for differential flow of POIs:
339 // 3D (pt,eta):
340 void Setvn2ndPtEtaPOI(TH2D* const v2pep) {this->fvn2ndPtEtaPOI = v2pep;};
341 TH2D* Getvn2ndPtEtaPOI() const {return this->fvn2ndPtEtaPOI;};
342 void Setvn4thPtEtaPOI(TH2D* const v4pep) {this->fvn4thPtEtaPOI = v4pep;};
343 TH2D* Getvn4thPtEtaPOI() const {return this->fvn4thPtEtaPOI;};
344 void Setvn6thPtEtaPOI(TH2D* const v6pep) {this->fvn6thPtEtaPOI = v6pep;};
345 TH2D* Getvn6thPtEtaPOI() const {return this->fvn6thPtEtaPOI;};
346 void Setvn8thPtEtaPOI(TH2D* const v8pep) {this->fvn8thPtEtaPOI = v8pep;};
347 TH2D* Getvn8thPtEtaPOI() const {return this->fvn8thPtEtaPOI;};
348 // 2D (pt):
349 void Setvn2ndPtPOI(TH1D* const v2pp) {this->fvn2ndPtPOI = v2pp;};
350 TH1D* Getvn2ndPtPOI() const {return this->fvn2ndPtPOI;};
351 void Setvn4thPtPOI(TH1D* const v4pp) {this->fvn4thPtPOI = v4pp;};
352 TH1D* Getvn4thPtPOI() const {return this->fvn4thPtPOI;};
353 void Setvn6thPtPOI(TH1D* const v6pp) {this->fvn6thPtPOI = v6pp;};
354 TH1D* Getvn6thPtPOI() const {return this->fvn6thPtPOI;};
355 void Setvn8thPtPOI(TH1D* const v8pp) {this->fvn8thPtPOI = v8pp;};
356 TH1D* Getvn8thPtPOI() const {return this->fvn8thPtPOI;};
357 // 2D (eta):
358 void Setvn2ndEtaPOI(TH1D* const v2ep) {this->fvn2ndEtaPOI = v2ep;};
359 TH1D* Getvn2ndEtaPOI() const {return this->fvn2ndEtaPOI;};
360 void Setvn4thEtaPOI(TH1D* const v4ep) {this->fvn4thEtaPOI = v4ep;};
361 TH1D* Getvn4thEtaPOI() const {return this->fvn4thEtaPOI;};
362 void Setvn6thEtaPOI(TH1D* const v6ep) {this->fvn6thEtaPOI = v6ep;};
363 TH1D* Getvn6thEtaPOI() const {return this->fvn6thEtaPOI;};
364 void Setvn8thEtaPOI(TH1D* const v8ep) {this->fvn8thEtaPOI = v8ep;};
365 TH1D* Getvn8thEtaPOI() const {return this->fvn8thEtaPOI;};
366
367 // weighted correlations for differential flow of POIs:
368 void Set2pPtEtaPOIW(TProfile2D* const tppepw) {this->f2pPtEtaPOIW = tppepw;};
369 TProfile2D* Get2pPtEtaPOIW() const {return this->f2pPtEtaPOIW;};
370 void Set4pPtEtaPOIW(TProfile2D* const fppepw) {this->f4pPtEtaPOIW = fppepw;};
371 TProfile2D* Get4pPtEtaPOIW() const {return this->f4pPtEtaPOIW;};
372 void Set6pPtEtaPOIW(TProfile2D* const sppepw) {this->f6pPtEtaPOIW = sppepw;};
373 TProfile2D* Get6pPtEtaPOIW() const {return this->f6pPtEtaPOIW;};
374 void Set8pPtEtaPOIW(TProfile2D* const eppepw) {this->f8pPtEtaPOIW = eppepw;};
375 TProfile2D* Get8pPtEtaPOIW() const {return this->f8pPtEtaPOIW;};
376
377 // weighted final results for differential flow of POIs:
378 // 3D (pt,eta):
379 void Setvn2ndPtEtaPOIW(TH2D* const v2pepw) {this->fvn2ndPtEtaPOIW = v2pepw;};
380 TH2D* Getvn2ndPtEtaPOIW() const {return this->fvn2ndPtEtaPOIW;};
381 void Setvn4thPtEtaPOIW(TH2D* const v4pepw) {this->fvn4thPtEtaPOIW = v4pepw;};
382 TH2D* Getvn4thPtEtaPOIW() const {return this->fvn4thPtEtaPOIW;};
383 void Setvn6thPtEtaPOIW(TH2D* const v6pepw) {this->fvn6thPtEtaPOIW = v6pepw;};
384 TH2D* Getvn6thPtEtaPOIW() const {return this->fvn6thPtEtaPOIW;};
385 void Setvn8thPtEtaPOIW(TH2D* const v8pepw) {this->fvn8thPtEtaPOIW = v8pepw;};
386 TH2D* Getvn8thPtEtaPOIW() const {return this->fvn8thPtEtaPOIW;};
387 // 2D (pt):
388 void Setvn2ndPtPOIW(TH1D* const v2ppw) {this->fvn2ndPtPOIW = v2ppw;};
389 TH1D* Getvn2ndPtPOIW() const {return this->fvn2ndPtPOIW;};
390 void Setvn4thPtPOIW(TH1D* const v4ppw) {this->fvn4thPtPOIW = v4ppw;};
391 TH1D* Getvn4thPtPOIW() const {return this->fvn4thPtPOIW;};
392 void Setvn6thPtPOIW(TH1D* const v6ppw) {this->fvn6thPtPOIW = v6ppw;};
393 TH1D* Getvn6thPtPOIW() const {return this->fvn6thPtPOIW;};
394 void Setvn8thPtPOIW(TH1D* const v8ppw) {this->fvn8thPtPOIW = v8ppw;};
395 TH1D* Getvn8thPtPOIW() const {return this->fvn8thPtPOIW;};
396 // 2D (eta):
397 void Setvn2ndEtaPOIW(TH1D* const v2epw) {this->fvn2ndEtaPOIW = v2epw;};
398 TH1D* Getvn2ndEtaPOIW() const {return this->fvn2ndEtaPOIW;};
399 void Setvn4thEtaPOIW(TH1D* const v4epw) {this->fvn4thEtaPOIW = v4epw;};
400 TH1D* Getvn4thEtaPOIW() const {return this->fvn4thEtaPOIW;};
401 void Setvn6thEtaPOIW(TH1D* const v6epw) {this->fvn6thEtaPOIW = v6epw;};
402 TH1D* Getvn6thEtaPOIW() const {return this->fvn6thEtaPOIW;};
403 void Setvn8thEtaPOIW(TH1D* const v8epw) {this->fvn8thEtaPOIW = v8epw;};
404 TH1D* Getvn8thEtaPOIW() const {return this->fvn8thEtaPOIW;};
405
406 // non-weighted correlations for differential flow of RPs:
407 void Set2pPtEtaRP(TProfile2D* const tpper) {this->f2pPtEtaRP = tpper;};
408 TProfile2D* Get2pPtEtaRP() const {return this->f2pPtEtaRP;};
409 void Set4pPtEtaRP(TProfile2D* const fpper) {this->f4pPtEtaRP = fpper;};
410 TProfile2D* Get4pPtEtaRP() const {return this->f4pPtEtaRP;};
411 void Set6pPtEtaRP(TProfile2D* const spper) {this->f6pPtEtaRP = spper;};
412 TProfile2D* Get6pPtEtaRP() const {return this->f6pPtEtaRP;};
413 void Set8pPtEtaRP(TProfile2D* const epper) {this->f8pPtEtaRP = epper;};
414 TProfile2D* Get8pPtEtaRP() const {return this->f8pPtEtaRP;};
415
2bdc5281 416 // corrections for non-uniform acceptance to non-weighted correlations for each (pt,eta) bin for differential flow of RPs:
417 void Set2pFinalCorrectionsForNUAPtEtaRP(TH2D* const tpfcfnuapeRP) {this->f2pFinalCorrectionsForNUAPtEtaRP = tpfcfnuapeRP;};
418 TH2D* Get2pFinalCorrectionsForNUAPtEtaRP() const {return this->f2pFinalCorrectionsForNUAPtEtaRP;};
419 void Set4pFinalCorrectionsForNUAPtEtaRP(TH2D* const fpfcfnuapeRP) {this->f4pFinalCorrectionsForNUAPtEtaRP = fpfcfnuapeRP;};
420 TH2D* Get4pFinalCorrectionsForNUAPtEtaRP() const {return this->f4pFinalCorrectionsForNUAPtEtaRP;};
421 void Set6pFinalCorrectionsForNUAPtEtaRP(TH2D* const spfcfnuapeRP) {this->f6pFinalCorrectionsForNUAPtEtaRP = spfcfnuapeRP;};
422 TH2D* Get6pFinalCorrectionsForNUAPtEtaRP() const {return this->f6pFinalCorrectionsForNUAPtEtaRP;};
423 void Set8pFinalCorrectionsForNUAPtEtaRP(TH2D* const epfcfnuapeRP) {this->f8pFinalCorrectionsForNUAPtEtaRP = epfcfnuapeRP;};
424 TH2D* Get8pFinalCorrectionsForNUAPtEtaRP() const {return this->f8pFinalCorrectionsForNUAPtEtaRP;};
425
426 // corrections for non-uniform acceptance to non-weighted correlations for each (pt) bin for differential flow of RPs:
427 void Set2pFinalCorrectionsForNUAPtRP(TH1D* const tpfcfnuapRP) {this->f2pFinalCorrectionsForNUAPtRP = tpfcfnuapRP;};
428 TH1D* Get2pFinalCorrectionsForNUAPtRP() const {return this->f2pFinalCorrectionsForNUAPtRP;};
429 void Set4pFinalCorrectionsForNUAPtRP(TH1D* const fpfcfnuapRP) {this->f4pFinalCorrectionsForNUAPtRP = fpfcfnuapRP;};
430 TH1D* Get4pFinalCorrectionsForNUAPtRP() const {return this->f4pFinalCorrectionsForNUAPtRP;};
431 void Set6pFinalCorrectionsForNUAPtRP(TH1D* const spfcfnuapRP) {this->f6pFinalCorrectionsForNUAPtRP = spfcfnuapRP;};
432 TH1D* Get6pFinalCorrectionsForNUAPtRP() const {return this->f6pFinalCorrectionsForNUAPtRP;};
433 void Set8pFinalCorrectionsForNUAPtRP(TH1D* const epfcfnuapRP) {this->f8pFinalCorrectionsForNUAPtRP = epfcfnuapRP;};
434 TH1D* Get8pFinalCorrectionsForNUAPtRP() const {return this->f8pFinalCorrectionsForNUAPtRP;};
435
436 // corrections for non-uniform acceptance to non-weighted correlations for each (eta) bin for differential flow of RPs:
437 void Set2pFinalCorrectionsForNUAEtaRP(TH1D* const tpfcfnuaeRP) {this->f2pFinalCorrectionsForNUAEtaRP = tpfcfnuaeRP;};
438 TH1D* Get2pFinalCorrectionsForNUAEtaRP() const {return this->f2pFinalCorrectionsForNUAEtaRP;};
439 void Set4pFinalCorrectionsForNUAEtaRP(TH1D* const fpfcfnuaeRP) {this->f4pFinalCorrectionsForNUAEtaRP = fpfcfnuaeRP;};
440 TH1D* Get4pFinalCorrectionsForNUAEtaRP() const {return this->f4pFinalCorrectionsForNUAEtaRP;};
441 void Set6pFinalCorrectionsForNUAEtaRP(TH1D* const spfcfnuaeRP) {this->f6pFinalCorrectionsForNUAEtaRP = spfcfnuaeRP;};
442 TH1D* Get6pFinalCorrectionsForNUAEtaRP() const {return this->f6pFinalCorrectionsForNUAEtaRP;};
443 void Set8pFinalCorrectionsForNUAEtaRP(TH1D* const epfcfnuaeRP) {this->f8pFinalCorrectionsForNUAEtaRP = epfcfnuaeRP;};
444 TH1D* Get8pFinalCorrectionsForNUAEtaRP() const {return this->f8pFinalCorrectionsForNUAEtaRP;};
445
9c1a9547 446 // non-weighted final results for differential flow of RPs:
447 // 3D (pt,eta):
448 void Setvn2ndPtEtaRP(TH2D* const v2per) {this->fvn2ndPtEtaRP = v2per;};
449 TH2D* Getvn2ndPtEtaRP() const {return this->fvn2ndPtEtaRP;};
450 void Setvn4thPtEtaRP(TH2D* const v4per) {this->fvn4thPtEtaRP = v4per;};
451 TH2D* Getvn4thPtEtaRP() const {return this->fvn4thPtEtaRP;};
452 void Setvn6thPtEtaRP(TH2D* const v6per) {this->fvn6thPtEtaRP = v6per;};
453 TH2D* Getvn6thPtEtaRP() const {return this->fvn6thPtEtaRP;};
454 void Setvn8thPtEtaRP(TH2D* const v8per) {this->fvn4thPtEtaRP = v8per;};
455 TH2D* Getvn8thPtEtaRP() const {return this->fvn8thPtEtaRP;};
456 // 2D (pt):
457 void Setvn2ndPtRP(TH1D* const v2pp) {this->fvn2ndPtRP = v2pp;};
458 TH1D* Getvn2ndPtRP() const {return this->fvn2ndPtRP;};
459 void Setvn4thPtRP(TH1D* const v4pp) {this->fvn4thPtRP = v4pp;};
460 TH1D* Getvn4thPtRP() const {return this->fvn4thPtRP;};
461 void Setvn6thPtRP(TH1D* const v6pp) {this->fvn6thPtRP = v6pp;};
462 TH1D* Getvn6thPtRP() const {return this->fvn6thPtRP;};
463 void Setvn8thPtRP(TH1D* const v8pp) {this->fvn8thPtRP = v8pp;};
464 TH1D* Getvn8thPtRP() const {return this->fvn8thPtRP;};
465 // 2D (eta):
466 void Setvn2ndEtaRP(TH1D* const v2ep) {this->fvn2ndEtaRP = v2ep;};
467 TH1D* Getvn2ndEtaRP() const {return this->fvn2ndEtaRP;};
468 void Setvn4thEtaRP(TH1D* const v4ep) {this->fvn4thEtaRP = v4ep;};
469 TH1D* Getvn4thEtaRP() const {return this->fvn4thEtaRP;};
470 void Setvn6thEtaRP(TH1D* const v6ep) {this->fvn6thEtaRP = v6ep;};
471 TH1D* Getvn6thEtaRP() const {return this->fvn6thEtaRP;};
472 void Setvn8thEtaRP(TH1D* const v8ep) {this->fvn8thEtaRP = v8ep;};
473 TH1D* Getvn8thEtaRP() const {return this->fvn8thEtaRP;};
474
475 // weighted correlations for differential flow of RPs:
476 void Set2pPtEtaRPW(TProfile2D* const tpperw) {this->f2pPtEtaRPW = tpperw;};
477 TProfile2D* Get2pPtEtaRPW() const {return this->f2pPtEtaRPW;};
478 void Set4pPtEtaRPW(TProfile2D* const fpperw) {this->f4pPtEtaRPW = fpperw;};
479 TProfile2D* Get4pPtEtaRPW() const {return this->f4pPtEtaRPW;};
480 void Set6pPtEtaRPW(TProfile2D* const spperw) {this->f6pPtEtaRPW = spperw;};
481 TProfile2D* Get6pPtEtaRPW() const {return this->f6pPtEtaRPW;};
482 void Set8pPtEtaRPW(TProfile2D* const epperw) {this->f8pPtEtaRPW = epperw;};
483 TProfile2D* Get8pPtEtaRPW() const {return this->f8pPtEtaRPW;};
484
485 // weighted final results for differential flow of RPs:
486 // 3D (pt,eta):
487 void Setvn2ndPtEtaRPW(TH2D* const v2perw) {this->fvn2ndPtEtaRPW = v2perw;};
488 TH2D* Getvn2ndPtEtaRPW() const {return this->fvn2ndPtEtaRPW;};
489 void Setvn4thPtEtaRPW(TH2D* const v4perw) {this->fvn4thPtEtaRPW = v4perw;};
490 TH2D* Getvn4thPtEtaRPW() const {return this->fvn4thPtEtaRPW;};
491 void Setvn6thPtEtaRPW(TH2D* const v6perw) {this->fvn6thPtEtaRPW = v6perw;};
492 TH2D* Getvn6thPtEtaRPW() const {return this->fvn6thPtEtaRPW;};
493 void Setvn8thPtEtaRPW(TH2D* const v8perw) {this->fvn4thPtEtaRPW = v8perw;};
494 TH2D* Getvn8thPtEtaRPW() const {return this->fvn8thPtEtaRPW;};
495 // 2D (pt):
496 void Setvn2ndPtRPW(TH1D* const v2ppw) {this->fvn2ndPtRPW = v2ppw;};
497 TH1D* Getvn2ndPtRPW() const {return this->fvn2ndPtRPW;};
498 void Setvn4thPtRPW(TH1D* const v4ppw) {this->fvn4thPtRPW = v4ppw;};
499 TH1D* Getvn4thPtRPW() const {return this->fvn4thPtRPW;};
500 void Setvn6thPtRPW(TH1D* const v6ppw) {this->fvn6thPtRPW = v6ppw;};
501 TH1D* Getvn6thPtRPW() const {return this->fvn6thPtRPW;};
502 void Setvn8thPtRPW(TH1D* const v8ppw) {this->fvn8thPtRPW = v8ppw;};
503 TH1D* Getvn8thPtRPW() const {return this->fvn8thPtRPW;};
504 // 2D (eta):
505 void Setvn2ndEtaRPW(TH1D* const v2epw) {this->fvn2ndEtaRPW = v2epw;};
506 TH1D* Getvn2ndEtaRPW() const {return this->fvn2ndEtaRPW;};
507 void Setvn4thEtaRPW(TH1D* const v4epw) {this->fvn4thEtaRPW = v4epw;};
508 TH1D* Getvn4thEtaRPW() const {return this->fvn4thEtaRPW;};
509 void Setvn6thEtaRPW(TH1D* const v6epw) {this->fvn6thEtaRPW = v6epw;};
510 TH1D* Getvn6thEtaRPW() const {return this->fvn6thEtaRPW;};
511 void Setvn8thEtaRPW(TH1D* const v8epw) {this->fvn8thEtaRPW = v8epw;};
512 TH1D* Getvn8thEtaRPW() const {return this->fvn8thEtaRPW;};
513 // .................................................................................................
514
515
516
517
8842fb2b 518//----------------------------------------------------------------------------------------------------------------
519
bc92c0cb 520 private:
521 AliFlowAnalysisWithQCumulants(const AliFlowAnalysisWithQCumulants& afawQc);
522 AliFlowAnalysisWithQCumulants& operator=(const AliFlowAnalysisWithQCumulants& afawQc);
8842fb2b 523
524 AliFlowTrackSimple* fTrack; //track
525 TList* fHistList; //list to hold all output histograms
ae733b3b 526 TList* fDiffFlowList; //list to hold all histograms and profiles needed for differential flow
03a02aca 527 TList* fWeightsList; //list to hold all histograms with weights
9c1a9547 528 TList* fResultsList; // list to hold all histograms with results
03a02aca 529
8842fb2b 530 TProfile* fAvMultIntFlowQC; //average selected multiplicity (for int. flow)
bc92c0cb 531
8842fb2b 532 TProfile* fQvectorComponents; //averages of Q-vector components (1st bin: <Q_x>, 2nd bin: <Q_y>, ...)
bc92c0cb 533
8842fb2b 534 TH1D* fDiffFlowResults2ndOrderQC; //differential flow results from 2nd order Q-cumulant
535 TH1D* fDiffFlowResults4thOrderQC; //differential flow results from 4th order Q-cumulant
536 TH1D* fCovariances; //final results for covariances: 1st bin: <2*4>-<2>*<4>, 2nd bin: <2*6>-<2>*<6>, ...
537
e085f1a9 538 TProfile* fQvectorForEachEventX; //profile containing the x-components of Q-vectors from all events (to be removed)
539 TProfile* fQvectorForEachEventY; //profile containing the y-components of Q-vectors from all events (to be removed)
8842fb2b 540 TProfile* fQCorrelations; //multi-particle correlations calculated from Q-vectors
9c1a9547 541 TProfile* fQCorrelationsW; //weighted multi-particle correlations calculated from Q-vectors
c365fe76 542 TProfile* fQCorrectionsCos; // corrections for non-uniform acceptance (cos terms) calculated from Q-vectors
543 TProfile* fQCorrectionsSin; // corrections for non-uniform acceptance (sin terms) calculated from Q-vectors
8842fb2b 544 TProfile* fQProduct; //average of products: 1st bin: <2*4>, 2nd bin: <2*6>, ...
545
9c1a9547 546 TProfile* fDirectCorrelations; // multi-particle correlations calculated with nested loop needed for int. flow
547 TProfile* fDirectCorrelationsW; // multi-particle correlations calculated with nested loop needed for weighted int. flow
548 TProfile* fDirectCorrelationsDiffFlow; // multi-particle correlations calculated with nested loop needed for diff. flow
549 TProfile* fDirectCorrelationsDiffFlowW; // multi-particle correlations calculated with nested loop needed for weighted int. flow
c365fe76 550
551 TProfile* fDirectCorrectionsCos; // corrections for non-uniform acceptance (cos terms) calculated with nested loops
552 TProfile* fDirectCorrectionsSin; // corrections for non-uniform acceptance (sin terms) calculated with nested loops
1dfa3c16 553
2bdc5281 554 TProfile* fDirectCorrectionsDiffFlowCos; // corrections for non-uniform acceptance (cos terms) calculated with nested loops (diff)
555 TProfile* fDirectCorrectionsDiffFlowSin; // corrections for non-uniform acceptance (sin terms) calculated with nested loops (diff)
556
77515452 557 // POI (Particles Of Interest):
558 // non-weighted correlations
1dfa3c16 559 TProfile* f2PerPtBin1n1nPOI; //<<2'>>_{n|n} per pt-bin
1dfa3c16 560 TProfile* f4PerPtBin1n1n1n1nPOI; //<<4'>>_{n,n|n,n} per pt-bin
1dfa3c16 561
562 TProfile* f2PerEtaBin1n1nPOI; //<<2'>>_{n|n} per eta-bin
1dfa3c16 563 TProfile* f4PerEtaBin1n1n1n1nPOI; //<<4'>>_{n,n|n,n} per eta-bin
77515452 564 // weighted correlations
3d824203 565 TProfile* f2WPerPtBin1n1nPOI; //<<2'>>_{n|n} per eta-bin
3d824203 566 TProfile* f4WPerPtBin1n1n1n1nPOI; //<<4'>>_{n,n|n,n} per eta-bin
567
77515452 568 TProfile* f2WPerEtaBin1n1nPOI; //<<2'>>_{n|n} per eta-bin
569 TProfile* f4WPerEtaBin1n1n1n1nPOI; //<<4'>>_{n,n|n,n} per eta-bin
3d824203 570
77515452 571 // RP (Reaction Plane particles)
572 // non-weighted correlations
573 TProfile* f2PerPtBin1n1nRP; //<<2'>>_{n|n} per pt-bin
574 TProfile* f4PerPtBin1n1n1n1nRP; //<<4'>>_{n,n|n,n} per pt-bin
575
576 TProfile* f2PerEtaBin1n1nRP; //<<2'>>_{n|n} per eta-bin
577 TProfile* f4PerEtaBin1n1n1n1nRP; //<<4'>>_{n,n|n,n} per eta-bin
578 // weighted correlations
579 TProfile* f2WPerPtBin1n1nRP; //<<2'>>_{n|n} per eta-bin
580 TProfile* f4WPerPtBin1n1n1n1nRP; //<<4'>>_{n,n|n,n} per eta-bin
3d824203 581
582 TProfile* f2WPerEtaBin1n1nRP; //<<2'>>_{n|n} per eta-bin
583 TProfile* f4WPerEtaBin1n1n1n1nRP; //<<4'>>_{n,n|n,n} per eta-bin
584
7e58a232 585 AliFlowCommonHist* fCommonHists2nd; //common control histograms (taking into account only the events with 2 and more particles)
586 AliFlowCommonHist* fCommonHists4th; //common control histograms (taking into account only the events with 4 and more particles)
587 AliFlowCommonHist* fCommonHists6th; //common control histograms (taking into account only the events with 6 and more particles)
588 AliFlowCommonHist* fCommonHists8th; //common control histograms (taking into account only the events with 8 and more particles)
bc92c0cb 589
1315fe58 590 AliFlowCommonHistResults* fCommonHistsResults2nd; //final results for 2nd order int. and diff. flow stored in the common histograms
591 AliFlowCommonHistResults* fCommonHistsResults4th; //final results for 4th order int. and diff. flow stored in the common histograms
592 AliFlowCommonHistResults* fCommonHistsResults6th; //final results for 6th order int. and diff. flow stored in the common histograms
593 AliFlowCommonHistResults* fCommonHistsResults8th; //final results for 8th order int. and diff. flow stored in the common histograms
1315fe58 594
5e838eeb 595 TH1D* f2pDistribution; //distribution of <2>_{n|n}
596 TH1D* f4pDistribution; //distribution of <4>_{n,n|n,n}
597 TH1D* f6pDistribution; //distribution of <6>_{n,n,n|n,n,n}
598 TH1D* f8pDistribution; //distribution of <8>_{n,n,n,n|n,n,n,n}
dee1e0e0 599
8842fb2b 600 Int_t fnBinsPt; //number of pt bins
52021ae2 601 Double_t fPtMin; //minimum pt
1dfa3c16 602 Double_t fPtMax; //maximum pt
603
604 Int_t fnBinsEta; //number of eta bins
605 Double_t fEtaMin; //minimum eta
e085f1a9 606 Double_t fEtaMax; //maximum eta
607 Int_t fEventCounter; //counting the number of events
608
9c1a9547 609 Bool_t fUsePhiWeights; // phi weights
610 Bool_t fUsePtWeights; // pt weights
611 Bool_t fUseEtaWeights; // eta weights
612 Bool_t fUseWeights; // use phi || pt || eta weights
613 TBits* fUseWeightsBits; // use phi || pt || eta weights
9c1a9547 614
2bdc5281 615 // ...................................................................................................................
616 // POI:
617 // corrections for non-uniform acceptance for differential flow (cos terms):
618 TProfile2D *fCorrectionsCosP1nPsiPtEtaPOI; // <<cos(n*psi)>>
619
620 // ...
621
622 // corrections for non-uniform acceptance for differential flow (sin terms):
623 TProfile2D *fCorrectionsSinP1nPsiPtEtaPOI; // <<sin(n*psi)>>
624
625 // ...
626
627 // RP:
628 // corrections for non-uniform acceptance for differential flow (cos terms):
629 TProfile2D *fCorrectionsCosP1nPsiPtEtaRP; // <<cos(n*psi)>>
630
631 // ...
632
633 // corrections for non-uniform acceptance for differential flow (sin terms):
634 TProfile2D *fCorrectionsSinP1nPsiPtEtaRP; // <<sin(n*psi)>>
635
636 // ...
637
638 // ...................................................................................................................
639
9c1a9547 640 // ...................................................................................................................
641 // Q_{n,k} and S^M_{n,k}:
642 TMatrixD *fReQ; // real part of the Q-vectors stored in matrix fReQ[n][k] = sum_{i=1}^{M} w_{i}^{k} cos(n phi_{i})
643 TMatrixD *fImQ; // imaginary part of the Q-vectors stored in matrix fImQ[n][k] = sum_{i=1}^{M} w_{i}^{k} sin(n phi_{i})
644 TMatrixD *fSMpk; // fSM[p][k] = (sum_{i=1}^{M} w_{i}^{k})^{p}
645
646 // q_{n} (POIs):
647 TH2D *fReqnPtEta; // real part of q_n (q_n is a Q-vector evaluated only for POIs in harmonic n for each (pt,eta) bin)
648 TH2D *fImqnPtEta; // imaginary part of q_n (q_n is a Q-vector evaluated only for POIs in harmonic n for each (pt,eta) bin)
649 TH2D *fmPtEta; // # of POIs (m) for each (pt,eta) bin
650
651 // non-weighted q''_{n} and q''_{2n} (both POIs and RPs)
652 TH2D *fReqPrimePrime1nPtEta; // real part of q''_{n} for each (pt,eta) bin
653 TH2D *fImqPrimePrime1nPtEta; // imaginary part of q''_{n} for each (pt,eta) bin
654 TH2D *fReqPrimePrime2nPtEta; // real part of q''_{2n} for each (pt,eta) bin
655 TH2D *fImqPrimePrime2nPtEta; // imaginary part of q''_{2n} for each (pt,eta) bin
656
657 // weighted q''_{n,2k} and q''_{2n,k} (both POIs and RPs)
658 TH2D *fReqPrimePrime1n2kPtEta; // real part of q''_{n,2k} for each (pt,eta) bin
659 TH2D *fImqPrimePrime1n2kPtEta; // imaginary part of q''_{n,2k} for each (pt,eta) bin
660 TH2D *fReqPrimePrime2n1kPtEta; // real part of q''_{2n,k} for each (pt,eta) bin
661 TH2D *fImqPrimePrime2n1kPtEta; // imaginary part of q''_{2n,k} for each (pt,eta) bin
662
663 // m'' (both POIs and RPs) :
664 TH2D *fmPrimePrimePtEta; // # of particles which are both POIs and RPs for each (pt,eta) bin
665
666 // S^{m''}_{p,k} (both POIs and RPs):
667 TH2D *fSmPrimePrime1p1kPtEta; // pow(sum_{i=1}^{m''} w_{i} cos(n phi_{i}), 1)
668 TH2D *fSmPrimePrime1p2kPtEta; // pow(sum_{i=1}^{m''} w_{i}^{2} cos(n phi_{i}), 1)
669 TH2D *fSmPrimePrime1p3kPtEta; // pow(sum_{i=1}^{m''} w_{i}^{3} cos(n phi_{i}), 1)
670
671 // non-weighted q_RP{n} and q_RP{2n} (for each (pt,eta) bin for RPs)
672 TH2D *fReqRP1nPtEta; // real part of q_RP{n} (q_RP{n} is a Q-vector evaluated only for RPs in harmonic n for each (pt,eta) bin)
673 TH2D *fImqRP1nPtEta; // imaginary part of q_RP{n} (q_RP{n} is a Q-vector evaluated only for RPs in harmonic n for each (pt,eta) bin)
674 TH2D *fReqRP2nPtEta; // real part of q_RP{2n} (q_RP{2n} is a Q-vector evaluated only for RPs in harmonic 2n for each (pt,eta) bin)
675 TH2D *fImqRP2nPtEta; // imaginary part of q_RP{2n} (q_RP{2n} is a Q-vector evaluated only for RPs in harmonic 2n for each (pt,eta) bin)
676
677 // weighted q_RP{n,2k} and q_RP{2n,k} (for each (pt,eta) bin for RPs)
678 TH2D *fReqRP1n2kPtEta; // real part of q_RP{n,2k} for each (pt,eta) bin
679 TH2D *fImqRP1n2kPtEta; // imaginary part of q_RP{n,2k} for each (pt,eta) bin
680 TH2D *fReqRP2n1kPtEta; // real part of q_RP{2n,k} for each (pt,eta) bin
681 TH2D *fImqRP2n1kPtEta; // imaginary part of q_RP{2n,k} for each (pt,eta) bin
682
683 // m_RP:
684 TH2D *fmRPPtEta; // # of particles which are RPs for each (pt,eta) bin
685
686 // S^{m_RP}_{p,k} (for each (pt,eta) bin for RPs):
687 TH2D *fSmRP1p1kPtEta; // pow(sum_{i=1}^{m_RP} w_{i} cos(n phi_{i}), 1)
688 TH2D *fSmRP1p2kPtEta; // pow(sum_{i=1}^{m_RP} w_{i}^{2} cos(n phi_{i}), 1)
689 TH2D *fSmRP1p3kPtEta; // pow(sum_{i=1}^{m_RP} w_{i}^{3} cos(n phi_{i}), 1)
690
691 // ----- RESULTS ----
c365fe76 692
693 TH1D *fFinalCorrectionsForNUA; // final corrections for non-uniform acceptance for QC{2}, QC{4}, QC{6} and QC{8}
694
9c1a9547 695 // non-weighted integrated flow:
696 TH1D *fIntFlowResultsQC; // final results for non-weighted no-name integrated flow
697 TH1D *fIntFlowResultsPOIQC; // final results for non-weighted POIs integrated flow
698 TH1D *fIntFlowResultsRPQC; // final results for non-weighted RPs integrated flow
699
700 // weighted integrated flow:
701 TH1D *fIntFlowResultsQCW; // final results for weighted no-name integrated flow
702 TH1D *fIntFlowResultsPOIQCW; // final results for weighted POIs integrated flow
703 TH1D *fIntFlowResultsRPQCW; // final results for weighted RPs integrated flow
704
705 // non-weighted correlations for each (pt,eta) bin for POIs:
2bdc5281 706 TProfile2D *f2pPtEtaPOI; // <<cos n(psi1-phi2)>> for POIs
707 TProfile2D *f4pPtEtaPOI; // <<cos n(psi1+phi2-phi3-phi4)>> for POIs
708 TProfile2D *f6pPtEtaPOI; // <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for POIs
709 TProfile2D *f8pPtEtaPOI; // <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for POIs
710
711 // corrections for non-uniform acceptance to non-weighted correlations for each (pt,eta) bin for POIs:
712 TH2D *f2pFinalCorrectionsForNUAPtEtaPOI; // correction to <<cos n(psi1-phi2)>> for POIs
713 TH2D *f4pFinalCorrectionsForNUAPtEtaPOI; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for POIs
714 TH2D *f6pFinalCorrectionsForNUAPtEtaPOI; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for POIs
715 TH2D *f8pFinalCorrectionsForNUAPtEtaPOI; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for POIs
716
717 // corrections for non-uniform acceptance to non-weighted correlations for each (pt) bin for POIs:
718 TH1D *f2pFinalCorrectionsForNUAPtPOI; // correction to <<cos n(psi1-phi2)>> for POIs
719 TH1D *f4pFinalCorrectionsForNUAPtPOI; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for POIs
720 TH1D *f6pFinalCorrectionsForNUAPtPOI; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for POIs
721 TH1D *f8pFinalCorrectionsForNUAPtPOI; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for POIs
722
723 // corrections for non-uniform acceptance to non-weighted correlations for each (eta) bin for POIs:
724 TH1D *f2pFinalCorrectionsForNUAEtaPOI; // correction to <<cos n(psi1-phi2)>> for POIs
725 TH1D *f4pFinalCorrectionsForNUAEtaPOI; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for POIs
726 TH1D *f6pFinalCorrectionsForNUAEtaPOI; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for POIs
727 TH1D *f8pFinalCorrectionsForNUAEtaPOI; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for POIs
9c1a9547 728
729 // non-weighted final results for differential flow for POIs:
730 // 3D (pt,eta):
731 TH2D *fvn2ndPtEtaPOI; // v'_{n}{2,QC} (pt,eta) for POIs
732 TH2D *fvn4thPtEtaPOI; // v'_{n}{4,QC} (pt,eta) for POIs
733 TH2D *fvn6thPtEtaPOI; // v'_{n}{6,QC} (pt,eta) for POIs
734 TH2D *fvn8thPtEtaPOI; // v'_{n}{8,QC} (pt,eta) for POIs
735 // 2D (pt):
736 TH1D *fvn2ndPtPOI; // v'_{n}{2,QC} (pt) for POIs
737 TH1D *fvn4thPtPOI; // v'_{n}{4,QC} (pt) for POIs
738 TH1D *fvn6thPtPOI; // v'_{n}{6,QC} (pt) for POIs
739 TH1D *fvn8thPtPOI; // v'_{n}{8,QC} (pt) for POIs
740 // 2D (eta):
741 TH1D *fvn2ndEtaPOI; // v'_{n}{2,QC} (eta) for POIs
742 TH1D *fvn4thEtaPOI; // v'_{n}{4,QC} (eta) for POIs
743 TH1D *fvn6thEtaPOI; // v'_{n}{6,QC} (eta) for POIs
744 TH1D *fvn8thEtaPOI; // v'_{n}{8,QC} (eta) for POIs
745
746 // weighted correlations for each (pt,eta) bin for POIs:
747 TProfile2D *f2pPtEtaPOIW; // <w2 cos n(psi1-phi2)> for POIs
748 TProfile2D *f4pPtEtaPOIW; // <w2 w3 w4 cos n(psi1+phi2-phi3-phi4)> for POIs
749 TProfile2D *f6pPtEtaPOIW; // <w2 w3 w4 w5 w6 cos n(psi1+phi2+phi3-phi4-phi5-phi6)> for POIs
750 TProfile2D *f8pPtEtaPOIW; // <w2 w3 w4 w5 w6 w7 w8 cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)> for POIs
751
752 // weighted final results for differential flow for POIs:
753 // 3D (pt,eta):
754 TH2D *fvn2ndPtEtaPOIW; // v'_{n}{2,QC} (pt,eta) for POIs
755 TH2D *fvn4thPtEtaPOIW; // v'_{n}{4,QC} (pt,eta) for POIs
756 TH2D *fvn6thPtEtaPOIW; // v'_{n}{6,QC} (pt,eta) for POIs
757 TH2D *fvn8thPtEtaPOIW; // v'_{n}{8,QC} (pt,eta) for POIs
758 // 2D (pt):
759 TH1D *fvn2ndPtPOIW; // v'_{n}{2,QC} (pt) for POIs
760 TH1D *fvn4thPtPOIW; // v'_{n}{4,QC} (pt) for POIs
761 TH1D *fvn6thPtPOIW; // v'_{n}{6,QC} (pt) for POIs
762 TH1D *fvn8thPtPOIW; // v'_{n}{8,QC} (pt) for POIs
763 // 2D (eta):
764 TH1D *fvn2ndEtaPOIW; // v'_{n}{2,QC} (eta) for POIs
765 TH1D *fvn4thEtaPOIW; // v'_{n}{4,QC} (eta) for POIs
766 TH1D *fvn6thEtaPOIW; // v'_{n}{6,QC} (eta) for POIs
767 TH1D *fvn8thEtaPOIW; // v'_{n}{8,QC} (eta) for POIs
768
769 // non-weighted correlations for each (pt,eta) bin for RPs:
770 TProfile2D *f2pPtEtaRP; // <cos n(psi1-phi2)> for RPs
771 TProfile2D *f4pPtEtaRP; // <cos n(psi1+phi2-phi3-phi4)> for RPs
772 TProfile2D *f6pPtEtaRP; // <cos n(psi1+phi2+phi3-phi4-phi5-phi6)> for RPs
773 TProfile2D *f8pPtEtaRP; // <cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)> for RPs
774
2bdc5281 775 // corrections for non-uniform acceptance to non-weighted correlations for each (pt,eta) bin for RPs:
776 TH2D *f2pFinalCorrectionsForNUAPtEtaRP; // correction to <<cos n(psi1-phi2)>> for RPs
777 TH2D *f4pFinalCorrectionsForNUAPtEtaRP; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for RPs
778 TH2D *f6pFinalCorrectionsForNUAPtEtaRP; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for RPs
779 TH2D *f8pFinalCorrectionsForNUAPtEtaRP; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for RPs
780
781 // corrections for non-uniform acceptance to non-weighted correlations for each (pt) bin for RPs:
782 TH1D *f2pFinalCorrectionsForNUAPtRP; // correction to <<cos n(psi1-phi2)>> for RPs
783 TH1D *f4pFinalCorrectionsForNUAPtRP; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for RPs
784 TH1D *f6pFinalCorrectionsForNUAPtRP; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for RPs
785 TH1D *f8pFinalCorrectionsForNUAPtRP; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for RPs
786
787 // corrections for non-uniform acceptance to non-weighted correlations for each (eta) bin for RPs:
788 TH1D *f2pFinalCorrectionsForNUAEtaRP; // correction to <<cos n(psi1-phi2)>> for RPs
789 TH1D *f4pFinalCorrectionsForNUAEtaRP; // correction to <<cos n(psi1+phi2-phi3-phi4)>> for RPs
790 TH1D *f6pFinalCorrectionsForNUAEtaRP; // correction to <<cos n(psi1+phi2+phi3-phi4-phi5-phi6)>> for RPs
791 TH1D *f8pFinalCorrectionsForNUAEtaRP; // correction to <<cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)>> for RPs
792
9c1a9547 793 // non-weighted final results for differential flow for RPs:
794 // 3D (pt,eta):
795 TH2D *fvn2ndPtEtaRP; // v'_{n}{2,QC} (pt,eta) for RPs
796 TH2D *fvn4thPtEtaRP; // v'_{n}{4,QC} (pt,eta) for RPs
797 TH2D *fvn6thPtEtaRP; // v'_{n}{6,QC} (pt,eta) for RPs
798 TH2D *fvn8thPtEtaRP; // v'_{n}{8,QC} (pt,eta) for RPs
799 // 2D (pt):
800 TH1D *fvn2ndPtRP; // v'_{n}{2,QC} (pt) for RPs
801 TH1D *fvn4thPtRP; // v'_{n}{4,QC} (pt) for RPs
802 TH1D *fvn6thPtRP; // v'_{n}{6,QC} (pt) for RPs
803 TH1D *fvn8thPtRP; // v'_{n}{8,QC} (pt) for RPs
804 // 2D (eta):
805 TH1D *fvn2ndEtaRP; // v'_{n}{2,QC} (eta) for RPs
806 TH1D *fvn4thEtaRP; // v'_{n}{4,QC} (eta) for RPs
807 TH1D *fvn6thEtaRP; // v'_{n}{6,QC} (eta) for RPs
808 TH1D *fvn8thEtaRP; // v'_{n}{8,QC} (eta) for RPs
809
810 // weighted correlations for each (pt,eta) bin for RPs:
811 TProfile2D *f2pPtEtaRPW; // <w2 cos n(psi1-phi2)> for RPs
812 TProfile2D *f4pPtEtaRPW; // <w2 w3 w4 cos n(psi1+phi2-phi3-phi4)> for RPs
813 TProfile2D *f6pPtEtaRPW; // <w2 w3 w4 w5 w6 cos n(psi1+phi2+phi3-phi4-phi5-phi6)> for RPs
814 TProfile2D *f8pPtEtaRPW; // <w2 w3 w4 w5 w6 w7 w8 cos n(psi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8)> for RPs
815
816 // weighted final results for differential flow for RPs:
817 // 3D (pt,eta):
818 TH2D *fvn2ndPtEtaRPW; // v'_{n}{2,QC} (pt,eta) for RPs
819 TH2D *fvn4thPtEtaRPW; // v'_{n}{4,QC} (pt,eta) for RPs
820 TH2D *fvn6thPtEtaRPW; // v'_{n}{6,QC} (pt,eta) for RPs
821 TH2D *fvn8thPtEtaRPW; // v'_{n}{8,QC} (pt,eta) for RPs
822 // 2D (pt):
823 TH1D *fvn2ndPtRPW; // v'_{n}{2,QC} (pt) for RPs
824 TH1D *fvn4thPtRPW; // v'_{n}{4,QC} (pt) for RPs
825 TH1D *fvn6thPtRPW; // v'_{n}{6,QC} (pt) for RPs
826 TH1D *fvn8thPtRPW; // v'_{n}{8,QC} (pt) for RPs
827 // 2D (eta):
828 TH1D *fvn2ndEtaRPW; // v'_{n}{2,QC} (eta) for RPs
829 TH1D *fvn4thEtaRPW; // v'_{n}{4,QC} (eta) for RPs
830 TH1D *fvn6thEtaRPW; // v'_{n}{6,QC} (eta) for RPs
831 TH1D *fvn8thEtaRPW; // v'_{n}{8,QC} (eta) for RPs
832 // ...................................................................................................................
833
834
835
ae733b3b 836
bc92c0cb 837 ClassDef(AliFlowAnalysisWithQCumulants, 0);
838};
839
840//================================================================================================================
841
842#endif
843
844
845
846
847