]>
Commit | Line | Data |
---|---|---|
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 | |
22 | class TObjArray; | |
23 | class TList; | |
24 | class TFile; | |
e085f1a9 | 25 | class TGraph; |
bc92c0cb | 26 | |
27 | class TH1; | |
28 | class TProfile; | |
9c1a9547 | 29 | class TProfile2D; |
bc92c0cb | 30 | |
31 | class AliFlowEventSimple; | |
32 | class AliFlowTrackSimple; | |
52021ae2 | 33 | class AliFlowVector; |
34 | ||
bc92c0cb | 35 | class AliFlowCommonHist; |
36 | class AliFlowCommonHistResults; | |
bc92c0cb | 37 | |
38 | //================================================================================================================ | |
39 | ||
40 | class 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 |