]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG2/FLOW/AliFlowCommon/AliFlowAnalysisWithQCumulants.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
typo in log message
[u/mrichter/AliRoot.git] / PWG2 / FLOW / AliFlowCommon / AliFlowAnalysisWithQCumulants.cxx
CommitLineData
a5b7efd0 1/*************************************************************************\r
2* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *\r
3* *\r
4* Author: The ALICE Off-line Project. *\r
5* Contributors are mentioned in the code where appropriate. *\r
6* *\r
7* Permission to use, copy, modify and distribute this software and its *\r
8* documentation strictly for non-commercial purposes is hereby granted *\r
9* without fee, provided that the above copyright notice appears in all *\r
10* copies and that both the copyright notice and this permission notice *\r
11* appear in the supporting documentation. The authors make no claims *\r
12* about the suitability of this software for any purpose. It is *\r
13* provided "as is" without express or implied warranty. * \r
14**************************************************************************/\r
15\r
16/********************************** \r
17 * flow analysis with Q-cumulants * \r
18 * * \r
19 * author: Ante Bilandzic * \r
20 * (anteb@nikhef.nl) *\r
21 *********************************/ \r
22\r
23#define AliFlowAnalysisWithQCumulants_cxx\r
24\r
25#include "Riostream.h"\r
26#include "AliFlowCommonConstants.h"\r
27#include "AliFlowCommonHist.h"\r
28#include "AliFlowCommonHistResults.h"\r
29#include "TChain.h"\r
30\r
31#include "TFile.h"\r
32#include "TList.h"\r
33#include "TGraph.h"\r
34#include "TParticle.h"\r
35#include "TRandom3.h"\r
36#include "TStyle.h"\r
37#include "TProfile.h"\r
38#include "TProfile2D.h" \r
39#include "TProfile3D.h"\r
40#include "TMath.h"\r
41#include "TArrow.h"\r
42#include "TPaveLabel.h"\r
43#include "TCanvas.h"\r
44#include "AliFlowEventSimple.h"\r
45#include "AliFlowTrackSimple.h"\r
46#include "AliFlowAnalysisWithQCumulants.h"\r
47#include "TArrayD.h"\r
48#include "TRandom.h"\r
49#include "TF1.h"\r
50\r
51class TH1;\r
52class TH2;\r
53class TGraph;\r
54class TPave;\r
55class TLatex;\r
56class TMarker;\r
57class TRandom3;\r
58class TObjArray;\r
59class TList;\r
60class TCanvas;\r
61class TSystem;\r
62class TROOT;\r
63class AliFlowVector;\r
64class TVector;\r
65\r
66\r
67//================================================================================================================\r
68\r
69\r
70ClassImp(AliFlowAnalysisWithQCumulants)\r
71\r
72AliFlowAnalysisWithQCumulants::AliFlowAnalysisWithQCumulants(): \r
73 // 0.) base:\r
74 fHistList(NULL),\r
75 // 1.) common:\r
76 fCommonHists(NULL),\r
77 fCommonHists2nd(NULL), \r
78 fCommonHists4th(NULL),\r
79 fCommonHists6th(NULL),\r
80 fCommonHists8th(NULL),\r
81 fCommonHistsResults2nd(NULL),\r
82 fCommonHistsResults4th(NULL),\r
83 fCommonHistsResults6th(NULL),\r
84 fCommonHistsResults8th(NULL),\r
85 fnBinsPhi(0),\r
86 fPhiMin(0),\r
87 fPhiMax(0),\r
88 fPhiBinWidth(0),\r
89 fnBinsPt(0),\r
90 fPtMin(0),\r
91 fPtMax(0),\r
92 fPtBinWidth(0),\r
93 fnBinsEta(0),\r
94 fEtaMin(0),\r
95 fEtaMax(0),\r
96 fEtaBinWidth(0),\r
97 fHarmonic(2),\r
98 fAnalysisLabel(NULL),\r
99 // 2a.) particle weights:\r
100 fWeightsList(NULL),\r
101 fUsePhiWeights(kFALSE),\r
102 fUsePtWeights(kFALSE),\r
103 fUseEtaWeights(kFALSE),\r
104 fUseParticleWeights(NULL),\r
105 fPhiWeights(NULL),\r
106 fPtWeights(NULL),\r
107 fEtaWeights(NULL),\r
108 // 2b.) event weights:\r
109 fMultiplicityWeight(NULL),\r
110 // 3.) integrated flow:\r
111 fIntFlowList(NULL), \r
112 fIntFlowProfiles(NULL),\r
113 fIntFlowResults(NULL),\r
114 fIntFlowFlags(NULL),\r
115 fApplyCorrectionForNUA(kTRUE), \r
116 fReQ(NULL),\r
117 fImQ(NULL),\r
118 fSMpk(NULL),\r
119 fIntFlowCorrelationsEBE(NULL),\r
120 fIntFlowEventWeightsForCorrelationsEBE(NULL),\r
121 fIntFlowCorrelationsAllEBE(NULL),\r
122 fAvMultiplicity(NULL),\r
123 fIntFlowCorrelationsPro(NULL),\r
124 fIntFlowCorrelationsAllPro(NULL),\r
125 fIntFlowExtraCorrelationsPro(NULL),\r
126 fIntFlowProductOfCorrelationsPro(NULL),\r
127 fIntFlowCorrelationsHist(NULL),\r
128 fIntFlowCorrelationsAllHist(NULL),\r
129 fIntFlowCovariances(NULL),\r
130 fIntFlowSumOfProductOfEventWeights(NULL),\r
131 fIntFlowQcumulants(NULL),\r
132 fIntFlow(NULL),\r
133 // 4.) differential flow:\r
134 fDiffFlowList(NULL),\r
135 fDiffFlowProfiles(NULL),\r
136 fDiffFlowResults(NULL),\r
137 fDiffFlowFlags(NULL),\r
138 fCalculate2DFlow(kFALSE),\r
139 // 5.) distributions:\r
140 fDistributionsList(NULL),\r
141 // x.) debugging and cross-checking:\r
142 fNestedLoopsList(NULL),\r
143 fEvaluateIntFlowNestedLoops(kFALSE),\r
144 fEvaluateDiffFlowNestedLoops(kFALSE),\r
145 fMaxAllowedMultiplicity(10),\r
146 fEvaluateNestedLoops(NULL),\r
147 fIntFlowDirectCorrelations(NULL),\r
148 fIntFlowExtraDirectCorrelations(NULL),\r
149 fCrossCheckInPtBinNo(10),\r
150 fCrossCheckInEtaBinNo(20)\r
151 {\r
152 // constructor \r
153 \r
154 // base list to hold all output objects:\r
155 fHistList = new TList();\r
156 fHistList->SetName("cobjQC");\r
157 fHistList->SetOwner(kTRUE);\r
158 \r
159 // list to hold histograms with phi, pt and eta weights: \r
160 fWeightsList = new TList();\r
161 \r
162 // multiplicity weight:\r
163 fMultiplicityWeight = new TString("combinations");\r
164 \r
165 // analysis label;\r
166 fAnalysisLabel = new TString();\r
167 \r
168 // initialize all arrays: \r
169 this->InitializeArraysForIntFlow();\r
170 this->InitializeArraysForDiffFlow();\r
171 this->InitializeArraysForDistributions();\r
172 this->InitializeArraysForNestedLoops();\r
173 \r
174 } // end of constructor\r
175 \r
176\r
177//================================================================================================================ \r
178\r
179\r
180AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()\r
181{\r
182 // destructor\r
183 \r
184 delete fHistList;\r
185\r
186} // end of AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()\r
187\r
188\r
189//================================================================================================================\r
190\r
191\r
192void AliFlowAnalysisWithQCumulants::Init()\r
193{\r
194 // a) Access all common constants;\r
195 // b) Book all objects;\r
196 // c) Store flags for integrated and differential flow;\r
197 // d) Store harmonic which will be estimated.\r
198 \r
199 // a) Access all common constants:\r
200 this->AccessConstants();\r
201 \r
202 // b) Book all objects:\r
203 this->BookAndFillWeightsHistograms();\r
204 this->BookAndNestAllLists();\r
205 this->BookCommonHistograms();\r
206 this->BookEverythingForIntegratedFlow(); \r
207 this->BookEverythingForDifferentialFlow(); \r
208 this->BookEverythingForDistributions();\r
209 this->BookEverythingForNestedLoops();\r
210 \r
211 // c) Store flags for integrated and differential flow:\r
212 this->StoreIntFlowFlags();\r
213 this->StoreDiffFlowFlags();\r
214\r
215 // d) Store harmonic which will be estimated:\r
216 this->StoreHarmonic();\r
217 \r
218} // end of void AliFlowAnalysisWithQCumulants::Init()\r
219\r
220\r
221//================================================================================================================\r
222\r
223\r
224void AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)\r
225{\r
226 // Running over data only in this method.\r
227 \r
228 // a) Fill the common control histograms and call the method to fill fAvMultiplicity;\r
229 // b) Loop over data and calculate e-b-e quantities;\r
230 // c) call the methods;\r
231 // d) Debugging and cross-checking (evaluate nested loops);\r
232 // e) Reset all event by event quantities. \r
233 \r
234 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame\r
235 Double_t dPt = 0.; // transverse momentum\r
236 Double_t dEta = 0.; // pseudorapidity\r
237\r
238 Double_t wPhi = 1.; // phi weight\r
239 Double_t wPt = 1.; // pt weight\r
240 Double_t wEta = 1.; // eta weight\r
241 \r
242 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)\r
243 \r
244 // a) Fill the common control histograms and call the method to fill fAvMultiplicity:\r
245 this->FillCommonControlHistograms(anEvent); \r
246 this->FillAverageMultiplicities(nRP); \r
247 \r
248 // b) Loop over data and calculate e-b-e quantities:\r
249 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI + rest, where:\r
250 // nRP = # of particles used to determine the reaction plane;\r
251 // nPOI = # of particles of interest for a detailed flow analysis;\r
252 // rest = # of particles which are not niether RPs nor POIs. \r
253 \r
254 AliFlowTrackSimple *aftsTrack = NULL;\r
255 \r
256 for(Int_t i=0;i<nPrim;i++) \r
257 { \r
258 aftsTrack=anEvent->GetTrack(i);\r
259 if(aftsTrack)\r
260 {\r
261 if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())) continue; // consider only tracks which are RPs or POIs\r
262 Int_t n = fHarmonic; // shortcut for the harmonic\r
263 if(aftsTrack->InRPSelection()) // RP condition:\r
264 { \r
265 dPhi = aftsTrack->Phi();\r
266 dPt = aftsTrack->Pt();\r
267 dEta = aftsTrack->Eta();\r
268 if(fUsePhiWeights && fPhiWeights && fnBinsPhi) // determine phi weight for this particle:\r
269 {\r
270 wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));\r
271 }\r
272 if(fUsePtWeights && fPtWeights && fnBinsPt) // determine pt weight for this particle:\r
273 {\r
274 wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); \r
275 } \r
276 if(fUseEtaWeights && fEtaWeights && fEtaBinWidth) // determine eta weight for this particle: \r
277 {\r
278 wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); \r
279 } \r
280 \r
281 // integrated flow: \r
282 // calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}], m = 1,2,3,4, for this event:\r
283 for(Int_t m=0;m<4;m++)\r
284 {\r
285 for(Int_t k=0;k<9;k++)\r
286 {\r
287 (*fReQ)(m,k)+=pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1)*n*dPhi); \r
288 (*fImQ)(m,k)+=pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1)*n*dPhi); \r
289 } \r
290 }\r
291 // calculate S^{M}_{p,k} for this event \r
292 // Remark: final calculation of S^{M}_{p,k} follows after the loop over data bellow:\r
293 for(Int_t p=0;p<8;p++)\r
294 {\r
295 for(Int_t k=0;k<9;k++)\r
296 { \r
297 (*fSMpk)(p,k)+=pow(wPhi*wPt*wEta,k);\r
298 }\r
299 } \r
300 \r
301 // differential flow:\r
302 // 1D (pt):\r
303 // (r_{m*m,k}(pt)): \r
304 for(Int_t m=0;m<4;m++)\r
305 {\r
306 for(Int_t k=0;k<9;k++)\r
307 {\r
308 fReRPQ1dEBE[0][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
309 fImRPQ1dEBE[0][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
310 }\r
311 }\r
312 \r
313 // s_{k}(pt) for RPs // to be improved (clarified)\r
314 // Remark: final calculation of s_{p,k}(pt) follows after the loop over data bellow:\r
315 for(Int_t k=0;k<9;k++)\r
316 {\r
317 fs1dEBE[0][0][k]->Fill(dPt,pow(wPhi*wPt*wEta,k),1.);\r
318 }\r
319 // 1D (eta):\r
320 // (r_{m*m,k}(eta)): \r
321 for(Int_t m=0;m<4;m++)\r
322 {\r
323 for(Int_t k=0;k<9;k++)\r
324 {\r
325 fReRPQ1dEBE[0][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
326 fImRPQ1dEBE[0][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
327 }\r
328 } \r
329 // s_{k}(eta) for RPs // to be improved (clarified)\r
330 // Remark: final calculation of s_{p,k}(eta) follows after the loop over data bellow:\r
331 for(Int_t k=0;k<9;k++)\r
332 {\r
333 fs1dEBE[0][1][k]->Fill(dEta,pow(wPhi*wPt*wEta,k),1.);\r
334 }\r
335 \r
336 \r
337 \r
338 /*\r
339 // 2D (pt,eta):\r
340 if(fCalculate2DFlow)\r
341 {\r
342 // (r_{m*m,k}(pt,eta)): \r
343 for(Int_t m=0;m<4;m++)\r
344 {\r
345 for(Int_t k=0;k<9;k++)\r
346 {\r
347 fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
348 fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
349 }\r
350 } \r
351 // s_{k}(pt,eta) for RPs // to be improved (clarified)\r
352 // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
353 for(Int_t k=0;k<9;k++)\r
354 {\r
355 fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k),1.);\r
356 }\r
357 } // end of if(fCalculate2DFlow) \r
358 */ \r
359 \r
360 \r
361 \r
362 if(aftsTrack->InPOISelection())\r
363 {\r
364 // 1D (pt): \r
365 // (q_{m*m,k}(pt)): \r
366 for(Int_t m=0;m<4;m++)\r
367 {\r
368 for(Int_t k=0;k<9;k++)\r
369 {\r
370 fReRPQ1dEBE[2][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
371 fImRPQ1dEBE[2][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
372 }\r
373 } \r
374 // s_{k}(pt) for RP&&POIs // to be improved (clarified)\r
375 // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
376 for(Int_t k=0;k<9;k++)\r
377 {\r
378 fs1dEBE[2][0][k]->Fill(dPt,pow(wPhi*wPt*wEta,k),1.);\r
379 }\r
380 // 1D (eta): \r
381 // (q_{m*m,k}(eta)): \r
382 for(Int_t m=0;m<4;m++)\r
383 {\r
384 for(Int_t k=0;k<9;k++)\r
385 {\r
386 fReRPQ1dEBE[2][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
387 fImRPQ1dEBE[2][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
388 }\r
389 } \r
390 // s_{k}(eta) for RP&&POIs // to be improved (clarified)\r
391 // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
392 for(Int_t k=0;k<9;k++)\r
393 {\r
394 fs1dEBE[2][1][k]->Fill(dEta,pow(wPhi*wPt*wEta,k),1.);\r
395 }\r
396 \r
397 /*\r
398 // 2D (pt,eta) \r
399 if(fCalculate2DFlow)\r
400 {\r
401 // (q_{m*m,k}(pt,eta)): \r
402 for(Int_t m=0;m<4;m++)\r
403 {\r
404 for(Int_t k=0;k<9;k++)\r
405 {\r
406 fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
407 fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
408 }\r
409 } \r
410 // s_{k}(pt,eta) for RP&&POIs // to be improved (clarified)\r
411 // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
412 for(Int_t k=0;k<9;k++)\r
413 {\r
414 fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k),1.);\r
415 }\r
416 } // end of if(fCalculate2DFlow) \r
417 */\r
418 \r
419 } // end of if(aftsTrack->InPOISelection())\r
420 \r
421\r
422 \r
423 } // end of if(pTrack->InRPSelection())\r
424\r
425 \r
426 \r
427 if(aftsTrack->InPOISelection())\r
428 {\r
429 dPhi = aftsTrack->Phi();\r
430 dPt = aftsTrack->Pt();\r
431 dEta = aftsTrack->Eta();\r
432 \r
433 // 1D (pt)\r
434 // p_n(m*n,0): \r
435 for(Int_t m=0;m<4;m++)\r
436 {\r
437 fReRPQ1dEBE[1][0][m][0]->Fill(dPt,TMath::Cos((m+1.)*n*dPhi),1.);\r
438 fImRPQ1dEBE[1][0][m][0]->Fill(dPt,TMath::Sin((m+1.)*n*dPhi),1.);\r
439 }\r
440 // 1D (eta)\r
441 // p_n(m*n,0): \r
442 for(Int_t m=0;m<4;m++)\r
443 {\r
444 fReRPQ1dEBE[1][1][m][0]->Fill(dEta,TMath::Cos((m+1.)*n*dPhi),1.);\r
445 fImRPQ1dEBE[1][1][m][0]->Fill(dEta,TMath::Sin((m+1.)*n*dPhi),1.);\r
446 }\r
447 \r
448 \r
449 /*\r
450 // 2D (pt,eta):\r
451 if(fCalculate2DFlow)\r
452 { \r
453 // p_n(m*n,0): \r
454 for(Int_t m=0;m<4;m++)\r
455 {\r
456 fReRPQ2dEBE[1][m][0]->Fill(dPt,dEta,TMath::Cos((m+1.)*n*dPhi),1.);\r
457 fImRPQ2dEBE[1][m][0]->Fill(dPt,dEta,TMath::Sin((m+1.)*n*dPhi),1.);\r
458 }\r
459 } // end of if(fCalculate2DFlow) \r
460 */\r
461 \r
462 \r
463 } // end of if(pTrack->InPOISelection() ) \r
464 \r
465 \r
466 } else // to if(aftsTrack)\r
467 {\r
468 cout<<endl;\r
469 cout<<" WARNING: no particle! (i.e. aftsTrack is a NULL pointer in AFAWQC::Make().)"<<endl;\r
470 cout<<endl; \r
471 }\r
472 } // end of for(Int_t i=0;i<nPrim;i++) \r
473\r
474 // calculate the final expressions for S^{M}_{p,k}:\r
475 for(Int_t p=0;p<8;p++)\r
476 {\r
477 for(Int_t k=0;k<9;k++)\r
478 {\r
479 (*fSMpk)(p,k)=pow((*fSMpk)(p,k),p+1);\r
480 } \r
481 } \r
482 \r
483 // *****************************\r
484 // **** CALL THE METHODS *******\r
485 // *****************************\r
486 // integrated flow:\r
487 if(!fEvaluateIntFlowNestedLoops)\r
488 {\r
489 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
490 {\r
491 if(nRP>1) this->CalculateIntFlowCorrelations(); // without using particle weights\r
492 } else \r
493 {\r
494 if(nRP>1) this->CalculateIntFlowCorrelationsUsingParticleWeights(); // with using particle weights \r
495 } \r
496 \r
497 if(nRP>3) this->CalculateIntFlowProductOfCorrelations();\r
498 if(nRP>1) this->CalculateIntFlowSumOfEventWeights();\r
499 if(nRP>1) this->CalculateIntFlowSumOfProductOfEventWeights();\r
500 if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (enable correction for NUA also when particle weights are used?)\r
501 {\r
502 if(nRP>0) this->CalculateIntFlowCorrectionsForNUASinTerms();\r
503 if(nRP>0) this->CalculateIntFlowCorrectionsForNUACosTerms();\r
504 }\r
505 } // end of if(!fEvaluateIntFlowNestedLoops)\r
506\r
507 // differential flow:\r
508 if(!fEvaluateDiffFlowNestedLoops)\r
509 {\r
510 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
511 {\r
512 if(nRP>1) // to be improved (move this if somewhere else)\r
513 {\r
514 // without using particle weights:\r
515 this->CalculateDiffFlowCorrelations("RP","Pt"); \r
516 this->CalculateDiffFlowCorrelations("RP","Eta");\r
517 this->CalculateDiffFlowCorrelations("POI","Pt");\r
518 this->CalculateDiffFlowCorrelations("POI","Eta");\r
519 } \r
520 } else\r
521 {\r
522 // with using particle weights: \r
523 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt"); \r
524 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta"); \r
525 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt"); \r
526 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta"); \r
527 } \r
528 \r
529 this->CalculateDiffFlowProductOfCorrelations("RP","Pt");\r
530 this->CalculateDiffFlowProductOfCorrelations("RP","Eta");\r
531 this->CalculateDiffFlowProductOfCorrelations("POI","Pt");\r
532 this->CalculateDiffFlowProductOfCorrelations("POI","Eta");\r
533 this->CalculateDiffFlowSumOfEventWeights("RP","Pt");\r
534 this->CalculateDiffFlowSumOfEventWeights("RP","Eta");\r
535 this->CalculateDiffFlowSumOfEventWeights("POI","Pt");\r
536 this->CalculateDiffFlowSumOfEventWeights("POI","Eta");\r
537 this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Pt");\r
538 this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Eta");\r
539 this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Pt");\r
540 this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Eta");\r
541 if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (enable correction for NUA also when particle weights are used?)\r
542 {\r
543 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");\r
544 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");\r
545 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");\r
546 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");\r
547 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");\r
548 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");\r
549 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");\r
550 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");\r
551 }\r
552 \r
553 } // end of if(!fEvaluateDiffFlowNestedLoops)\r
554\r
555\r
556 \r
557 // with weights:\r
558 // ... \r
559 \r
560 /*\r
561 // 2D differential flow\r
562 if(fCalculate2DFlow)\r
563 {\r
564 // without weights:\r
565 if(nRP>1) this->CalculateCorrelationsForDifferentialFlow2D("RP");\r
566 if(nRP>1) this->CalculateCorrelationsForDifferentialFlow2D("POI");\r
567 \r
568 // with weights:\r
569 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
570 {\r
571 if(nRP>1) this->CalculateWeightedCorrelationsForDifferentialFlow2D("RP");\r
572 if(nRP>1) this->CalculateWeightedCorrelationsForDifferentialFlow2D("POI");\r
573 } \r
574 } // end of if(fCalculate2DFlow)\r
575 */\r
576 \r
577 \r
578 // d) Debugging and cross-checking (evaluate nested loops):\r
579 // d1) cross-checking results for integrated flow:\r
580 if(fEvaluateIntFlowNestedLoops)\r
581 {\r
582 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10 \r
583 {\r
584 // without using particle weights:\r
585 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
586 {\r
587 // correlations:\r
588 this->CalculateIntFlowCorrelations(); // from Q-vectors\r
589 this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)\r
590 // correction for non-uniform acceptance:\r
591 this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)\r
592 this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)\r
593 this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)\r
594 }\r
595 // using particle weights:\r
596 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
597 {\r
598 // correlations:\r
599 this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors\r
600 this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)\r
601 }\r
602 } else if (nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)\r
603 {\r
604 cout<<endl;\r
605 cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;\r
606 } else\r
607 {\r
608 cout<<endl;\r
609 cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl; \r
610 } \r
611 } // end of if(fEvaluateIntFlowNestedLoops) \r
612 \r
613 // d2) cross-checking results for differential flow:\r
614 if(fEvaluateDiffFlowNestedLoops)\r
615 {\r
616 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10\r
617 {\r
618 // without using particle weights:\r
619 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
620 {\r
621 // reduced correlations:\r
622 // Q-vectors:\r
623 this->CalculateDiffFlowCorrelations("RP","Pt");\r
624 this->CalculateDiffFlowCorrelations("RP","Eta");\r
625 this->CalculateDiffFlowCorrelations("POI","Pt");\r
626 this->CalculateDiffFlowCorrelations("POI","Eta");\r
627 // nested loops:\r
628 //this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
629 //this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
630 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
631 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
632 // reduced corrections for non-uniform acceptance:\r
633 // Q-vectors:\r
634 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");\r
635 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");\r
636 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");\r
637 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");\r
638 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");\r
639 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");\r
640 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");\r
641 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");\r
642 // nested loops:\r
643 //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
644 //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
645 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
646 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
647 } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
648 // using particle weights:\r
649 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
650 {\r
651 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt"); \r
652 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta"); \r
653 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt"); \r
654 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta"); \r
655 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
656 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
657 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
658 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
659 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
660 } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10\r
661 } // end of if(fEvaluateDiffFlowNestedLoops) \r
662 \r
663 // e) Reset all event by event quantities: \r
664 this->ResetEventByEventQuantities();\r
665 \r
666} // end of AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)\r
667\r
668\r
669//================================================================================================================================\r
670\r
671\r
672void AliFlowAnalysisWithQCumulants::Finish()\r
673{\r
674 // Calculate the final results.\r
675 // a) acces the constants;\r
676 // b) access the flags;\r
677 // c) calculate the final results for integrated flow (without and with weights);\r
678 // d) store in AliFlowCommonHistResults and print the final results for integrated flow;\r
679 // e) calculate the final results for differential flow (without and with weights);\r
680 // f) print the final results for integrated flow obtained from differential flow (to be improved (terminology));\r
681 // g) cross-check the results: results from Q-vectors vs results from nested loops\r
682 \r
683 // ******************************\r
684 // **** ACCESS THE CONSTANTS ****\r
685 // ******************************\r
686 \r
687 this->AccessConstants(); \r
688 \r
689 if(fCommonHists && fCommonHists->GetHarmonic())\r
690 {\r
691 fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1); // to be improved (moved somewhere else)\r
692 } \r
693\r
694 // **************************\r
695 // **** ACCESS THE FLAGS ****\r
696 // ************************** \r
697 fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1); \r
698 fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2); \r
699 fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3); \r
700 fApplyCorrectionForNUA = (Int_t)fIntFlowFlags->GetBinContent(3); \r
701 fEvaluateIntFlowNestedLoops = (Int_t)fEvaluateNestedLoops->GetBinContent(1);\r
702 fEvaluateDiffFlowNestedLoops = (Int_t)fEvaluateNestedLoops->GetBinContent(2); \r
703 fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);\r
704 fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4); \r
705 \r
706 // *********************************************************\r
707 // **** CALCULATE THE FINAL RESULTS FOR INTEGRATED FLOW ****\r
708 // ********************************************************* \r
709 \r
710 this->FinalizeCorrelationsIntFlow();\r
711 this->CalculateCovariancesIntFlow();\r
712 this->CalculateCumulantsIntFlow();\r
713 this->CalculateIntFlow(); \r
714\r
715 if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (reorganized, etc)\r
716 {\r
717 this->FinalizeCorrectionTermsForNUAIntFlow();\r
718 this->CalculateQcumulantsCorrectedForNUAIntFlow(); \r
719 this->CalculateIntFlowCorrectedForNUA(); \r
720 }\r
721 \r
722 // ***************************************************************\r
723 // **** STORE AND PRINT THE FINAL RESULTS FOR INTEGRATED FLOW ****\r
724 // ***************************************************************\r
725 \r
726 this->FillCommonHistResultsIntFlow(); \r
727 \r
728 this->PrintFinalResultsForIntegratedFlow("NONAME"); // to be improved (name)\r
729 \r
730 // ***********************************************************\r
731 // **** CALCULATE THE FINAL RESULTS FOR DIFFERENTIAL FLOW ****\r
732 // *********************************************************** \r
733 \r
734 this->FinalizeReducedCorrelations("RP","Pt"); \r
735 this->FinalizeReducedCorrelations("RP","Eta"); \r
736 this->FinalizeReducedCorrelations("POI","Pt"); \r
737 this->FinalizeReducedCorrelations("POI","Eta");\r
738 this->CalculateDiffFlowCovariances("RP","Pt");\r
739 this->CalculateDiffFlowCovariances("RP","Eta");\r
740 this->CalculateDiffFlowCovariances("POI","Pt");\r
741 this->CalculateDiffFlowCovariances("POI","Eta");\r
742 this->CalculateDiffFlowCumulants("RP","Pt");\r
743 this->CalculateDiffFlowCumulants("RP","Eta");\r
744 this->CalculateDiffFlowCumulants("POI","Pt");\r
745 this->CalculateDiffFlowCumulants("POI","Eta");\r
746 this->CalculateDiffFlow("RP","Pt");\r
747 this->CalculateDiffFlow("RP","Eta");\r
748 this->CalculateDiffFlow("POI","Pt");\r
749 this->CalculateDiffFlow("POI","Eta");\r
750 \r
751 if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (reorganized, etc)\r
752 {\r
753 this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");\r
754 this->FinalizeCorrectionTermsForNUADiffFlow("RP","Eta");\r
755 this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");\r
756 this->FinalizeCorrectionTermsForNUADiffFlow("POI","Eta"); \r
757 this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Pt"); \r
758 this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Eta"); \r
759 this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Pt"); \r
760 this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Eta"); \r
761 this->CalculateDiffFlowCorrectedForNUA("RP","Pt"); \r
762 this->CalculateDiffFlowCorrectedForNUA("RP","Eta"); \r
763 this->CalculateDiffFlowCorrectedForNUA("POI","Pt"); \r
764 this->CalculateDiffFlowCorrectedForNUA("POI","Eta"); \r
765 }\r
766 \r
767 this->CalculateFinalResultsForRPandPOIIntegratedFlow("RP");\r
768 this->CalculateFinalResultsForRPandPOIIntegratedFlow("POI");\r
769\r
770 // *****************************************************************\r
771 // **** STORE AND PRINT THE FINAL RESULTS FOR DIFFERENTIAL FLOW ****\r
772 // *****************************************************************\r
773 this->FillCommonHistResultsDiffFlow("RP");\r
774 this->FillCommonHistResultsDiffFlow("POI");\r
775\r
776 this->PrintFinalResultsForIntegratedFlow("RP"); \r
777 this->PrintFinalResultsForIntegratedFlow("POI"); \r
778 \r
779 // g) cross-check the results: results from Q-vectors vs results from nested loops\r
780 // g1) integrated flow:\r
781 if(fEvaluateIntFlowNestedLoops)\r
782 {\r
783 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) \r
784 {\r
785 this->CrossCheckIntFlowCorrelations();\r
786 this->CrossCheckIntFlowCorrectionTermsForNUA(); \r
787 } else\r
788 {\r
789 this->CrossCheckIntFlowCorrelations(); \r
790 this->CrossCheckIntFlowExtraCorrelations(); \r
791 }\r
792 } // end of if(fEvaluateIntFlowNestedLoops) \r
793 // g2) differential flow: \r
794 if(fEvaluateDiffFlowNestedLoops) \r
795 {\r
796 // correlations:\r
797 //this->CrossCheckDiffFlowCorrelations("RP","Pt"); // to be improved (enabled eventually) \r
798 //this->CrossCheckDiffFlowCorrelations("RP","Eta"); // to be improved (enabled eventually) \r
799 this->CrossCheckDiffFlowCorrelations("POI","Pt"); \r
800 this->CrossCheckDiffFlowCorrelations("POI","Eta");\r
801 // correction terms for non-uniform acceptance:\r
802 //this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt"); // to be improved (enabled eventually) \r
803 //this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Eta"); // to be improved (enabled eventually) \r
804 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) \r
805 {\r
806 this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt"); \r
807 this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Eta"); \r
808 } \r
809 } // end of if(fEvaluateDiffFlowNestedLoops)\r
810 \r
811} // end of AliFlowAnalysisWithQCumulants::Finish()\r
812\r
813\r
814//================================================================================================================================\r
815\r
816\r
817void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()\r
818{\r
819 // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (cos terms)\r
820 \r
821 // multiplicity:\r
822 Double_t dMult = (*fSMpk)(0,0);\r
823 \r
824 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
825 Double_t dReQ1n = (*fReQ)(0,0);\r
826 Double_t dReQ2n = (*fReQ)(1,0);\r
827 //Double_t dReQ3n = (*fReQ)(2,0);\r
828 //Double_t dReQ4n = (*fReQ)(3,0);\r
829 Double_t dImQ1n = (*fImQ)(0,0);\r
830 Double_t dImQ2n = (*fImQ)(1,0);\r
831 //Double_t dImQ3n = (*fImQ)(2,0);\r
832 //Double_t dImQ4n = (*fImQ)(3,0);\r
833 \r
834 // *************************************************************\r
835 // **** corrections for non-uniform acceptance (cos terms): ****\r
836 // *************************************************************\r
837 //\r
838 // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors \r
839 // are stored in 1D profile fQCorrectionsCos.\r
840 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:\r
841 // --------------------------------------------------------------------------------------------------------------------\r
842 // 1st bin: <<cos(n*(phi1))>> = cosP1n\r
843 // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n\r
844 // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n\r
845 // ...\r
846 // --------------------------------------------------------------------------------------------------------------------\r
847 \r
848 // 1-particle:\r
849 Double_t cosP1n = 0.; // <<cos(n*(phi1))>>\r
850 \r
851 if(dMult>0)\r
852 {\r
853 cosP1n = dReQ1n/dMult; \r
854 \r
855 // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:\r
856 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);\r
857 \r
858 // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:\r
859 fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult); \r
860 } \r
861 \r
862 // 2-particle:\r
863 Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>\r
864 \r
865 if(dMult>1)\r
866 {\r
867 cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1)); \r
868 \r
869 // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:\r
870 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);\r
871 \r
872 // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:\r
873 fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1)); \r
874 } \r
875 \r
876 // 3-particle:\r
877 Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>\r
878 \r
879 if(dMult>2)\r
880 {\r
881 cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)\r
882 / (dMult*(dMult-1)*(dMult-2)); \r
883 \r
884 // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:\r
885 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);\r
886 \r
887 // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:\r
888 fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2)); \r
889 } \r
890 \r
891} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()\r
892\r
893\r
894//================================================================================================================================\r
895\r
896\r
897void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()\r
898{\r
899 // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)\r
900 \r
901 // multiplicity:\r
902 Double_t dMult = (*fSMpk)(0,0);\r
903 \r
904 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
905 Double_t dReQ1n = (*fReQ)(0,0);\r
906 Double_t dReQ2n = (*fReQ)(1,0);\r
907 //Double_t dReQ3n = (*fReQ)(2,0);\r
908 //Double_t dReQ4n = (*fReQ)(3,0);\r
909 Double_t dImQ1n = (*fImQ)(0,0);\r
910 Double_t dImQ2n = (*fImQ)(1,0);\r
911 //Double_t dImQ3n = (*fImQ)(2,0);\r
912 //Double_t dImQ4n = (*fImQ)(3,0);\r
913 \r
914 // *************************************************************\r
915 // **** corrections for non-uniform acceptance (sin terms): ****\r
916 // *************************************************************\r
917 //\r
918 // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors \r
919 // are stored in 1D profile fQCorrectionsSin.\r
920 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:\r
921 // --------------------------------------------------------------------------------------------------------------------\r
922 // 1st bin: <<sin(n*(phi1))>> = sinP1n\r
923 // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n\r
924 // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n\r
925 // ...\r
926 // --------------------------------------------------------------------------------------------------------------------\r
927 \r
928 // 1-particle:\r
929 Double_t sinP1n = 0.; // <sin(n*(phi1))>\r
930 \r
931 if(dMult>0)\r
932 {\r
933 sinP1n = dImQ1n/dMult; \r
934 \r
935 // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:\r
936 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);\r
937 \r
938 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events: \r
939 fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult); \r
940 } \r
941 \r
942 // 2-particle:\r
943 Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>\r
944 \r
945 if(dMult>1)\r
946 {\r
947 sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1)); \r
948 \r
949 // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:\r
950 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);\r
951 \r
952 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events: \r
953 fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1)); \r
954 } \r
955 \r
956 // 3-particle:\r
957 Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>\r
958 \r
959 if(dMult>2)\r
960 {\r
961 sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)\r
962 / (dMult*(dMult-1)*(dMult-2)); \r
963 \r
964 // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:\r
965 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);\r
966 \r
967 // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events: \r
968 fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2)); \r
969 } \r
970 \r
971} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()\r
972\r
973\r
974//================================================================================================================================\r
975\r
976\r
977void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)\r
978{\r
979 // a) Get pointers for common control and common result histograms and profiles.\r
980 // b) Get pointers for histograms with particle weights.\r
981 // c) Get pointers for histograms and profiles relevant for integrated flow.\r
982 // d) Get pointers for histograms and profiles relevant for differental flow.\r
983 // e) Get pointers for histograms and profiles holding results obtained with nested loops.\r
984 \r
985 if(outputListHistos)\r
986 { \r
987 this->GetPointersForCommonHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
988 this->GetPointersForParticleWeightsHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
989 this->GetPointersForIntFlowHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
990 this->GetPointersForDiffFlowHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
991 this->GetPointersForNestedLoopsHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
992 }\r
993 \r
994} // end of void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)\r
995\r
996\r
997//================================================================================================================================\r
998\r
999\r
1000TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta) const\r
1001{\r
1002 // project 2D profile onto pt axis to get 1D profile\r
1003 \r
1004 Int_t nBinsPt = profilePtEta->GetNbinsX();\r
1005 Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();\r
1006 Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();\r
1007 \r
1008 Int_t nBinsEta = profilePtEta->GetNbinsY();\r
1009 \r
1010 TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax); \r
1011 \r
1012 for(Int_t p=1;p<=nBinsPt;p++)\r
1013 {\r
1014 Double_t contentPt = 0.;\r
1015 Double_t entryPt = 0.;\r
1016 Double_t spreadPt = 0.;\r
1017 Double_t sum1 = 0.;\r
1018 Double_t sum2 = 0.;\r
1019 Double_t sum3 = 0.;\r
1020 for(Int_t e=1;e<=nBinsEta;e++)\r
1021 {\r
1022 contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))\r
1023 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1024 entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1025 \r
1026 sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))\r
1027 * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)\r
1028 + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.)); \r
1029 sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1030 sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))\r
1031 * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e))); \r
1032 }\r
1033 if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)\r
1034 {\r
1035 spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);\r
1036 }\r
1037 profilePt->SetBinContent(p,contentPt);\r
1038 profilePt->SetBinEntries(p,entryPt);\r
1039 {\r
1040 profilePt->SetBinError(p,spreadPt);\r
1041 }\r
1042 \r
1043 }\r
1044 \r
1045 return profilePt;\r
1046 \r
1047} // end of TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta)\r
1048\r
1049\r
1050//================================================================================================================================\r
1051\r
1052\r
1053TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta) const\r
1054{\r
1055 // project 2D profile onto eta axis to get 1D profile\r
1056 \r
1057 Int_t nBinsEta = profilePtEta->GetNbinsY();\r
1058 Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();\r
1059 Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();\r
1060 \r
1061 Int_t nBinsPt = profilePtEta->GetNbinsX();\r
1062 \r
1063 TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax); \r
1064 \r
1065 for(Int_t e=1;e<=nBinsEta;e++)\r
1066 {\r
1067 Double_t contentEta = 0.;\r
1068 Double_t entryEta = 0.;\r
1069 for(Int_t p=1;p<=nBinsPt;p++)\r
1070 {\r
1071 contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))\r
1072 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1073 entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1074 }\r
1075 profileEta->SetBinContent(e,contentEta);\r
1076 profileEta->SetBinEntries(e,entryEta);\r
1077 }\r
1078 \r
1079 return profileEta;\r
1080 \r
1081} // end of TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta)\r
1082\r
1083\r
1084//================================================================================================================================\r
1085\r
1086\r
1087void AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type)\r
1088{\r
1089 // printing on the screen the final results for integrated flow (NONAME, POI and RP) // to be improved (NONAME) \r
1090 \r
1091 Int_t n = fHarmonic; \r
1092 \r
1093 if(type == "NONAME" || type == "RP" || type == "POI")\r
1094 {\r
1095 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
1096 {\r
1097 cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl;\r
1098 cout<<" is NULL in AFAWQC::PFRFIF() !!!!"<<endl;\r
1099 }\r
1100 } else\r
1101 {\r
1102 cout<<"WARNING: type in not from {NONAME, RP, POI} in AFAWQC::PFRFIF() !!!!"<<endl;\r
1103 exit(0);\r
1104 }\r
1105 \r
1106 Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8} \r
1107 Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8} \r
1108 \r
1109 if(type == "NONAME")\r
1110 {\r
1111 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1); \r
1112 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1); \r
1113 dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1); \r
1114 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1); \r
1115 dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1); \r
1116 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1); \r
1117 dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1); \r
1118 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1); \r
1119 } else if(type == "RP")\r
1120 {\r
1121 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1); \r
1122 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1); \r
1123 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1); \r
1124 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1); \r
1125 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1); \r
1126 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1); \r
1127 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1); \r
1128 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1); \r
1129 } else if(type == "POI")\r
1130 {\r
1131 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1); \r
1132 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1); \r
1133 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1); \r
1134 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1); \r
1135 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1); \r
1136 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1); \r
1137 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1); \r
1138 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1); \r
1139 }\r
1140 \r
1141 TString title = " flow estimates from Q-cumulants"; \r
1142 TString subtitle = " ("; \r
1143 \r
1144 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
1145 {\r
1146 subtitle.Append(type);\r
1147 subtitle.Append(", without weights)");\r
1148 } else \r
1149 {\r
1150 subtitle.Append(type);\r
1151 subtitle.Append(", with weights)");\r
1152 }\r
1153 \r
1154 cout<<endl;\r
1155 cout<<"*************************************"<<endl;\r
1156 cout<<"*************************************"<<endl;\r
1157 cout<<title.Data()<<endl; \r
1158 cout<<subtitle.Data()<<endl; \r
1159 cout<<endl;\r
1160 \r
1161 for(Int_t i=0;i<4;i++)\r
1162 {\r
1163 if(dVn[i]>=0.)\r
1164 {\r
1165 cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;\r
1166 }\r
1167 else\r
1168 {\r
1169 cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = Im"<<endl;\r
1170 } \r
1171 }\r
1172\r
1173 cout<<endl;\r
1174 /*\r
1175 if(type == "NONAME")\r
1176 {\r
1177 cout<<" nEvts = "<<nEvtsNoName<<", AvM = "<<dMultNoName<<endl; // to be improved\r
1178 }\r
1179 else if (type == "RP")\r
1180 {\r
1181 cout<<" nEvts = "<<nEvtsRP<<", AvM = "<<dMultRP<<endl; // to be improved \r
1182 } \r
1183 else if (type == "POI")\r
1184 {\r
1185 cout<<" nEvts = "<<nEvtsPOI<<", AvM = "<<dMultPOI<<endl; // to be improved \r
1186 } \r
1187 */\r
1188 cout<<"*************************************"<<endl;\r
1189 cout<<"*************************************"<<endl;\r
1190 cout<<endl; \r
1191 \r
1192}// end of AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type="NONAME");\r
1193\r
1194\r
1195//================================================================================================================================\r
1196\r
1197\r
1198void AliFlowAnalysisWithQCumulants::WriteHistograms(TString outputFileName)\r
1199{\r
1200 //store the final results in output .root file\r
1201 TFile *output = new TFile(outputFileName.Data(),"RECREATE");\r
1202 //output->WriteObject(fHistList, "cobjQC","SingleKey");\r
1203 fHistList->Write(fHistList->GetName(), TObject::kSingleKey);\r
1204 delete output;\r
1205}\r
1206\r
1207\r
1208//================================================================================================================================\r
1209\r
1210\r
1211void AliFlowAnalysisWithQCumulants::BookCommonHistograms()\r
1212{\r
1213 // Book common control histograms and common histograms for final results.\r
1214 // common control histogram (ALL events)\r
1215 TString commonHistsName = "AliFlowCommonHistQC";\r
1216 commonHistsName += fAnalysisLabel->Data();\r
1217 fCommonHists = new AliFlowCommonHist(commonHistsName.Data());\r
1218 fHistList->Add(fCommonHists); \r
1219 // common control histogram (for events with 2 and more particles)\r
1220 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";\r
1221 commonHists2ndOrderName += fAnalysisLabel->Data();\r
1222 fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data());\r
1223 fHistList->Add(fCommonHists2nd); \r
1224 // common control histogram (for events with 4 and more particles)\r
1225 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";\r
1226 commonHists4thOrderName += fAnalysisLabel->Data();\r
1227 fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data());\r
1228 fHistList->Add(fCommonHists4th); \r
1229 // common control histogram (for events with 6 and more particles)\r
1230 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";\r
1231 commonHists6thOrderName += fAnalysisLabel->Data();\r
1232 fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data());\r
1233 fHistList->Add(fCommonHists6th); \r
1234 // common control histogram (for events with 8 and more particles)\r
1235 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";\r
1236 commonHists8thOrderName += fAnalysisLabel->Data();\r
1237 fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data());\r
1238 fHistList->Add(fCommonHists8th); \r
1239 // common histograms for final results (calculated for events with 2 and more particles)\r
1240 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";\r
1241 commonHistResults2ndOrderName += fAnalysisLabel->Data();\r
1242 fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data());\r
1243 fHistList->Add(fCommonHistsResults2nd); \r
1244 // common histograms for final results (calculated for events with 4 and more particles)\r
1245 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";\r
1246 commonHistResults4thOrderName += fAnalysisLabel->Data();\r
1247 fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data());\r
1248 fHistList->Add(fCommonHistsResults4th); \r
1249 // common histograms for final results (calculated for events with 6 and more particles)\r
1250 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";\r
1251 commonHistResults6thOrderName += fAnalysisLabel->Data();\r
1252 fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data());\r
1253 fHistList->Add(fCommonHistsResults6th); \r
1254 // common histograms for final results (calculated for events with 8 and more particles)\r
1255 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";\r
1256 commonHistResults8thOrderName += fAnalysisLabel->Data();\r
1257 fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data());\r
1258 fHistList->Add(fCommonHistsResults8th); \r
1259 \r
1260} // end of void AliFlowAnalysisWithQCumulants::BookCommonHistograms()\r
1261\r
1262\r
1263//================================================================================================================================\r
1264\r
1265\r
1266void AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()\r
1267{\r
1268 // book and fill histograms which hold phi, pt and eta weights\r
1269\r
1270 if(!fWeightsList)\r
1271 {\r
1272 cout<<"WARNING: fWeightsList is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1273 exit(0); \r
1274 }\r
1275 \r
1276 TString fUseParticleWeightsName = "fUseParticleWeightsQC";\r
1277 fUseParticleWeightsName += fAnalysisLabel->Data();\r
1278 fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",3,0,3);\r
1279 fUseParticleWeights->SetLabelSize(0.06);\r
1280 (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");\r
1281 (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");\r
1282 (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");\r
1283 fUseParticleWeights->Fill(0.5,(Int_t)fUsePhiWeights);\r
1284 fUseParticleWeights->Fill(1.5,(Int_t)fUsePtWeights);\r
1285 fUseParticleWeights->Fill(2.5,(Int_t)fUseEtaWeights);\r
1286 fWeightsList->Add(fUseParticleWeights); \r
1287 \r
1288 if(fUsePhiWeights)\r
1289 {\r
1290 if(fWeightsList->FindObject("phi_weights"))\r
1291 {\r
1292 fPhiWeights = dynamic_cast<TH1F*>(fWeightsList->FindObject("phi_weights"));\r
1293 if((fPhiWeights->GetBinWidth(1) > fPhiBinWidth) || (fPhiWeights->GetBinWidth(1) < fPhiBinWidth))\r
1294 {\r
1295 cout<<"WARNING: fPhiWeights->GetBinWidth(1) != fPhiBinWidth in AFAWQC::BAFWH() !!!! "<<endl;\r
1296 cout<<" This indicates inconsistent binning in phi histograms throughout the code."<<endl;\r
1297 exit(0);\r
1298 }\r
1299 } else \r
1300 {\r
1301 cout<<"WARNING: fWeightsList->FindObject(\"phi_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1302 exit(0);\r
1303 }\r
1304 } // end of if(fUsePhiWeights)\r
1305 \r
1306 if(fUsePtWeights) \r
1307 {\r
1308 if(fWeightsList->FindObject("pt_weights"))\r
1309 {\r
1310 fPtWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("pt_weights"));\r
1311 if((fPtWeights->GetBinWidth(1) > fPtBinWidth) || (fPtWeights->GetBinWidth(1) < fPtBinWidth))\r
1312 {\r
1313 cout<<"WARNING: fPtWeights->GetBinWidth(1) != fPtBinWidth in AFAWQC::BAFWH() !!!! "<<endl;\r
1314 cout<<" This indicates insconsistent binning in pt histograms throughout the code."<<endl;\r
1315 exit(0);\r
1316 }\r
1317 } else \r
1318 {\r
1319 cout<<"WARNING: fWeightsList->FindObject(\"pt_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1320 exit(0);\r
1321 }\r
1322 } // end of if(fUsePtWeights) \r
1323\r
1324 if(fUseEtaWeights) \r
1325 {\r
1326 if(fWeightsList->FindObject("eta_weights"))\r
1327 {\r
1328 fEtaWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("eta_weights"));\r
1329 if((fEtaWeights->GetBinWidth(1) > fEtaBinWidth) || (fEtaWeights->GetBinWidth(1) < fEtaBinWidth))\r
1330 {\r
1331 cout<<"WARNING: fEtaWeights->GetBinWidth(1) != fEtaBinWidth in AFAWQC::BAFWH() !!!! "<<endl;\r
1332 cout<<" This indicates insconsistent binning in eta histograms throughout the code."<<endl;\r
1333 exit(0);\r
1334 }\r
1335 } else \r
1336 {\r
1337 cout<<"WARNING: fUseEtaWeights && fWeightsList->FindObject(\"eta_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1338 exit(0);\r
1339 }\r
1340 } // end of if(fUseEtaWeights)\r
1341 \r
1342} // end of AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()\r
1343\r
1344\r
1345//================================================================================================================================\r
1346\r
1347\r
1348void AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()\r
1349{\r
1350 // Book all objects for integrated flow:\r
1351 // a) Book profile to hold all flags for integrated flow.\r
1352 // b) Book event-by-event quantities.\r
1353 // c) Book profiles. // to be improved (comment)\r
1354 // d) Book histograms holding the final results.\r
1355 \r
1356 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
1357 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)\r
1358 \r
1359 // a) Book profile to hold all flags for integrated flow:\r
1360 TString intFlowFlagsName = "fIntFlowFlags";\r
1361 intFlowFlagsName += fAnalysisLabel->Data();\r
1362 fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",3,0,3);\r
1363 fIntFlowFlags->SetTickLength(-0.01,"Y");\r
1364 fIntFlowFlags->SetMarkerStyle(25);\r
1365 fIntFlowFlags->SetLabelSize(0.05);\r
1366 fIntFlowFlags->SetLabelOffset(0.02,"Y");\r
1367 (fIntFlowFlags->GetXaxis())->SetBinLabel(1,"Particle Weights");\r
1368 (fIntFlowFlags->GetXaxis())->SetBinLabel(2,"Event Weights");\r
1369 (fIntFlowFlags->GetXaxis())->SetBinLabel(3,"Corrected for NUA?");\r
1370 fIntFlowList->Add(fIntFlowFlags);\r
1371\r
1372 // b) Book event-by-event quantities:\r
1373 // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M: \r
1374 fReQ = new TMatrixD(4,9);\r
1375 fImQ = new TMatrixD(4,9);\r
1376 fSMpk = new TMatrixD(8,9);\r
1377 // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):\r
1378 TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";\r
1379 intFlowCorrelationsEBEName += fAnalysisLabel->Data();\r
1380 fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);\r
1381 // weights for average correlations <2>, <4>, <6> and <8> for single event:\r
1382 TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";\r
1383 intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();\r
1384 fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);\r
1385 // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):\r
1386 TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";\r
1387 intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();\r
1388 fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),32,0,32);\r
1389 // average correction terms for non-uniform acceptance for single event \r
1390 // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):\r
1391 TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";\r
1392 fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();\r
1393 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1394 {\r
1395 fIntFlowCorrectionTermsForNUAEBE[sc] = new TH1D(Form("%s: %s terms",fIntFlowCorrectionTermsForNUAEBEName.Data(),sinCosFlag[sc].Data()),Form("Correction terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),10,0,10); \r
1396 }\r
1397 \r
1398 // c) Book profiles: // to be improved (comment)\r
1399 // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:\r
1400 TString avMultiplicityName = "fAvMultiplicity";\r
1401 avMultiplicityName += fAnalysisLabel->Data();\r
1402 fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average Multiplicities of RPs",9,0,9);\r
1403 fAvMultiplicity->SetTickLength(-0.01,"Y");\r
1404 fAvMultiplicity->SetMarkerStyle(25);\r
1405 fAvMultiplicity->SetLabelSize(0.05);\r
1406 fAvMultiplicity->SetLabelOffset(0.02,"Y");\r
1407 fAvMultiplicity->SetYTitle("Average Multiplicity");\r
1408 (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");\r
1409 (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");\r
1410 (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");\r
1411 (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");\r
1412 (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");\r
1413 (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");\r
1414 (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");\r
1415 (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");\r
1416 (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");\r
1417 fIntFlowProfiles->Add(fAvMultiplicity);\r
1418 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):\r
1419 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";\r
1420 intFlowCorrelationsProName += fAnalysisLabel->Data();\r
1421 fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");\r
1422 fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");\r
1423 fIntFlowCorrelationsPro->SetMarkerStyle(25);\r
1424 fIntFlowCorrelationsPro->SetLabelSize(0.06);\r
1425 fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1426 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<2>>");\r
1427 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<4>>");\r
1428 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(3,"<<6>>");\r
1429 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(4,"<<8>>");\r
1430 fIntFlowProfiles->Add(fIntFlowCorrelationsPro);\r
1431 // averaged all correlations for all events (with wrong errors!):\r
1432 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";\r
1433 intFlowCorrelationsAllProName += fAnalysisLabel->Data();\r
1434 fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average correlations for all events",32,0,32,"s");\r
1435 fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");\r
1436 fIntFlowCorrelationsAllPro->SetMarkerStyle(25);\r
1437 fIntFlowCorrelationsAllPro->SetLabelSize(0.03);\r
1438 fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");\r
1439 // 2-p correlations:\r
1440 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");\r
1441 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");\r
1442 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");\r
1443 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");\r
1444 // 3-p correlations:\r
1445 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");\r
1446 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");\r
1447 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");\r
1448 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");\r
1449 // 4-p correlations:\r
1450 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}"); \r
1451 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");\r
1452 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");\r
1453 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");\r
1454 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");\r
1455 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}"); \r
1456 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");\r
1457 // 5-p correlations:\r
1458 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}"); \r
1459 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");\r
1460 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");\r
1461 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");\r
1462 // 6-p correlations:\r
1463 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");\r
1464 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");\r
1465 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");\r
1466 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");\r
1467 // 7-p correlations: \r
1468 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");\r
1469 // 8-p correlations:\r
1470 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");\r
1471 fIntFlowProfiles->Add(fIntFlowCorrelationsAllPro);\r
1472 // when particle weights are used some extra correlations appear:\r
1473 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) \r
1474 {\r
1475 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";\r
1476 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();\r
1477 fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");\r
1478 fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");\r
1479 fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);\r
1480 fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);\r
1481 fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1482 // extra 2-p correlations:\r
1483 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");\r
1484 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");\r
1485 // ...\r
1486 fIntFlowProfiles->Add(fIntFlowExtraCorrelationsPro);\r
1487 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1488 // average product of correlations <2>, <4>, <6> and <8>: \r
1489 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";\r
1490 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();\r
1491 fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);\r
1492 fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");\r
1493 fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25); \r
1494 fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);\r
1495 fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1496 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<2><4>>");\r
1497 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<2><6>>");\r
1498 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(3,"<<2><8>>");\r
1499 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(4,"<<4><6>>");\r
1500 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(5,"<<4><8>>");\r
1501 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(6,"<<6><8>>");\r
1502 fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsPro);\r
1503 // average correction terms for non-uniform acceptance (with wrong errors!):\r
1504 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1505 {\r
1506 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";\r
1507 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
1508 fIntFlowCorrectionTermsForNUAPro[sc] = new TProfile(Form("%s: %s terms",intFlowCorrectionTermsForNUAProName.Data(),sinCosFlag[sc].Data()),Form("Correction terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),10,0,10,"s");\r
1509 fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");\r
1510 fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);\r
1511 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.03);\r
1512 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");\r
1513 // 1-particle terms:\r
1514 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("<<%s(n(phi1))>>",sinCosFlag[sc].Data()));\r
1515 // 2-particle terms:\r
1516 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("<<%s(n(phi1+phi2))>>",sinCosFlag[sc].Data())); \r
1517 // 3-particle terms:\r
1518 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("<<%s(n(phi1-phi2-phi3))>>",sinCosFlag[sc].Data())); \r
1519 // ... \r
1520 fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAPro[sc]);\r
1521 } // end of for(Int_t sc=0;sc<2;sc++) \r
1522 \r
1523 // d) Book histograms holding the final results:\r
1524 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):\r
1525 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";\r
1526 intFlowCorrelationsHistName += fAnalysisLabel->Data();\r
1527 fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);\r
1528 fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");\r
1529 fIntFlowCorrelationsHist->SetMarkerStyle(25);\r
1530 fIntFlowCorrelationsHist->SetLabelSize(0.06);\r
1531 fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");\r
1532 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"<<2>>");\r
1533 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"<<4>>");\r
1534 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"<<6>>");\r
1535 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"<<8>>");\r
1536 fIntFlowResults->Add(fIntFlowCorrelationsHist);\r
1537 // average all correlations for all events (with correct errors!):\r
1538 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";\r
1539 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();\r
1540 fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",32,0,32);\r
1541 fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");\r
1542 fIntFlowCorrelationsAllHist->SetMarkerStyle(25);\r
1543 fIntFlowCorrelationsAllHist->SetLabelSize(0.03);\r
1544 fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");\r
1545 // 2-p correlations:\r
1546 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");\r
1547 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");\r
1548 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");\r
1549 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");\r
1550 // 3-p correlations:\r
1551 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");\r
1552 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");\r
1553 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");\r
1554 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");\r
1555 // 4-p correlations:\r
1556 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}"); \r
1557 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");\r
1558 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");\r
1559 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");\r
1560 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");\r
1561 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}"); \r
1562 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");\r
1563 // 5-p correlations:\r
1564 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}"); \r
1565 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");\r
1566 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");\r
1567 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");\r
1568 // 6-p correlations:\r
1569 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");\r
1570 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");\r
1571 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");\r
1572 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");\r
1573 // 7-p correlations: \r
1574 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");\r
1575 // 8-p correlations:\r
1576 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");\r
1577 fIntFlowResults->Add(fIntFlowCorrelationsAllHist);\r
1578 // average correction terms for non-uniform acceptance (with correct errors!):\r
1579 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1580 {\r
1581 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";\r
1582 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
1583 fIntFlowCorrectionTermsForNUAHist[sc] = new TH1D(Form("%s: %s terms",intFlowCorrectionTermsForNUAHistName.Data(),sinCosFlag[sc].Data()),Form("Correction terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),10,0,10);\r
1584 fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");\r
1585 fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);\r
1586 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.03);\r
1587 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");\r
1588 // ......................................................................... \r
1589 // 1-p terms:\r
1590 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("%s(n(#phi_{1}))>",sinCosFlag[sc].Data()));\r
1591 // 2-p terms:\r
1592 // 3-p terms:\r
1593 // ...\r
1594 // ......................................................................... \r
1595 fIntFlowResults->Add(fIntFlowCorrectionTermsForNUAHist[sc]);\r
1596 } // end of for(Int_t sc=0;sc<2;sc++) \r
1597 // covariances (multiplied with weight dependent prefactor):\r
1598 TString intFlowCovariancesName = "fIntFlowCovariances";\r
1599 intFlowCovariancesName += fAnalysisLabel->Data();\r
1600 fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);\r
1601 fIntFlowCovariances->SetLabelSize(0.04);\r
1602 fIntFlowCovariances->SetMarkerStyle(25);\r
1603 (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(<2>,<4>)");\r
1604 (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(<2>,<6>)");\r
1605 (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(<2>,<8>)");\r
1606 (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(<4>,<6>)");\r
1607 (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(<4>,<8>)");\r
1608 (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(<6>,<8>)"); \r
1609 fIntFlowResults->Add(fIntFlowCovariances);\r
1610 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:\r
1611 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";\r
1612 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();\r
1613 for(Int_t power=0;power<2;power++)\r
1614 {\r
1615 fIntFlowSumOfEventWeights[power] = new TH1D(Form("%s: %s",intFlowSumOfEventWeightsName.Data(),powerFlag[power].Data()),Form("Sum of %s event weights for correlations",powerFlag[power].Data()),4,0,4);\r
1616 fIntFlowSumOfEventWeights[power]->SetLabelSize(0.05);\r
1617 fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);\r
1618 if(power == 0)\r
1619 {\r
1620 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>}");\r
1621 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<4>}");\r
1622 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<6>}");\r
1623 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<8>}");\r
1624 } else if (power == 1) \r
1625 {\r
1626 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>}^{2}");\r
1627 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<4>}^{2}");\r
1628 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<6>}^{2}");\r
1629 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<8>}^{2}");\r
1630 }\r
1631 fIntFlowResults->Add(fIntFlowSumOfEventWeights[power]);\r
1632 } \r
1633 // sum of products of event weights for correlations <2>, <4>, <6> and <8>: \r
1634 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";\r
1635 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();\r
1636 fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);\r
1637 fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.05);\r
1638 fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);\r
1639 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>} w_{<4>}");\r
1640 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<2>} w_{<6>}");\r
1641 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<2>} w_{<8>}");\r
1642 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<4>} w_{<6>}");\r
1643 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{<4>} w_{<8>}");\r
1644 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{<6>} w_{<8>}");\r
1645 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeights);\r
1646 // final results for integrated Q-cumulants:\r
1647 TString intFlowQcumulantsName = "fIntFlowQcumulants";\r
1648 intFlowQcumulantsName += fAnalysisLabel->Data();\r
1649 fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Integrated Q-cumulants",4,0,4);\r
1650 fIntFlowQcumulants->SetLabelSize(0.05);\r
1651 fIntFlowQcumulants->SetMarkerStyle(25);\r
1652 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(1,"QC{2}");\r
1653 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(2,"QC{4}");\r
1654 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(3,"QC{6}");\r
1655 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(4,"QC{8}");\r
1656 fIntFlowResults->Add(fIntFlowQcumulants);\r
1657 // final integrated flow estimates from Q-cumulants:\r
1658 TString intFlowName = "fIntFlow";\r
1659 intFlowName += fAnalysisLabel->Data(); \r
1660 // integrated flow from Q-cumulants:\r
1661 fIntFlow = new TH1D(intFlowName.Data(),"Integrated flow estimates from Q-cumulants",4,0,4);\r
1662 fIntFlow->SetLabelSize(0.05);\r
1663 fIntFlow->SetMarkerStyle(25);\r
1664 (fIntFlow->GetXaxis())->SetBinLabel(1,"v_{2}{2,QC}");\r
1665 (fIntFlow->GetXaxis())->SetBinLabel(2,"v_{2}{4,QC}");\r
1666 (fIntFlow->GetXaxis())->SetBinLabel(3,"v_{2}{6,QC}");\r
1667 (fIntFlow->GetXaxis())->SetBinLabel(4,"v_{2}{8,QC}");\r
1668 fIntFlowResults->Add(fIntFlow);\r
1669\r
1670 /* // to be improved (removed):\r
1671 // final average weighted multi-particle correlations for all events calculated from Q-vectors\r
1672 fQCorrelations[1] = new TProfile("Weighted correlations","final average multi-particle correlations from weighted Q-vectors",200,0,200,"s");\r
1673 fQCorrelations[1]->SetTickLength(-0.01,"Y");\r
1674 fQCorrelations[1]->SetMarkerStyle(25);\r
1675 fQCorrelations[1]->SetLabelSize(0.03);\r
1676 fQCorrelations[1]->SetLabelOffset(0.01,"Y");\r
1677 // 2-particle correlations:\r
1678 (fQCorrelations[1]->GetXaxis())->SetBinLabel(1,"<w_{1}w_{2}cos(n(#phi_{1}-#phi_{2}))>");\r
1679 (fQCorrelations[1]->GetXaxis())->SetBinLabel(2,"<w_{1}^{2}w_{2}^{2}cos(2n(#phi_{1}-#phi_{2}))>");\r
1680 (fQCorrelations[1]->GetXaxis())->SetBinLabel(3,"<w_{1}^{3}w_{2}^{3}cos(3n(#phi_{1}-#phi_{2}))>");\r
1681 (fQCorrelations[1]->GetXaxis())->SetBinLabel(4,"<w_{1}^{4}w_{2}^{4}cos(4n(#phi_{1}-#phi_{2}))>");\r
1682 (fQCorrelations[1]->GetXaxis())->SetBinLabel(5,"<w_{1}^{3}w_{2}cos(n(#phi_{1}-#phi_{2}))>");\r
1683 (fQCorrelations[1]->GetXaxis())->SetBinLabel(6,"<w_{1}^{2}w_{2}w_{3}cos(n(#phi_{1}-#phi_{2}))>");\r
1684 // 3-particle correlations:\r
1685 (fQCorrelations[1]->GetXaxis())->SetBinLabel(21,"<w_{1}w_{2}w_{3}^{2}cos(n(2#phi_{1}-#phi_{2}-#phi_{3}))>");\r
1686 // 4-particle correlations:\r
1687 (fQCorrelations[1]->GetXaxis())->SetBinLabel(41,"<w_{1}w_{2}w_{3}w_{4}cos(n(#phi_{1}+#phi_{2}-#phi_{3}-#phi_{4}))>");\r
1688 // add fQCorrelations[1] to the list fIntFlowList:\r
1689 fIntFlowList->Add(fQCorrelations[1]); \r
1690 */\r
1691 \r
1692} // end of AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()\r
1693\r
1694\r
1695//================================================================================================================================\r
1696\r
1697\r
1698void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()\r
1699{\r
1700 // Initialize arrays of all objects relevant for calculations with nested loops.\r
1701 \r
1702 // integrated flow:\r
1703 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1704 {\r
1705 fIntFlowDirectCorrectionTermsForNUA[sc] = NULL;\r
1706 } \r
1707\r
1708 // differential flow: \r
1709 // correlations:\r
1710 for(Int_t t=0;t<2;t++) // type: RP or POI\r
1711 { \r
1712 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1713 {\r
1714 for(Int_t ci=0;ci<4;ci++) // correlation index\r
1715 {\r
1716 fDiffFlowDirectCorrelations[t][pe][ci] = NULL;\r
1717 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index \r
1718 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1719 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
1720 // correction terms for non-uniform acceptance:\r
1721 for(Int_t t=0;t<2;t++) // type: RP or POI\r
1722 { \r
1723 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1724 {\r
1725 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1726 {\r
1727 for(Int_t cti=0;cti<9;cti++) // correction term index\r
1728 {\r
1729 fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = NULL;\r
1730 } \r
1731 }\r
1732 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1733 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
1734\r
1735\r
1736} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()\r
1737\r
1738\r
1739//================================================================================================================================\r
1740\r
1741\r
1742void AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()\r
1743{\r
1744 // Book all objects relevant for calculations with nested loops.\r
1745 \r
1746 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
1747 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)\r
1748 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)\r
1749 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)\r
1750 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
1751 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
1752\r
1753 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";\r
1754 evaluateNestedLoopsName += fAnalysisLabel->Data();\r
1755 fEvaluateNestedLoops = new TProfile(evaluateNestedLoopsName.Data(),"Flags for nested loops",4,0,4);\r
1756 fEvaluateNestedLoops->SetLabelSize(0.03);\r
1757 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(1,"fEvaluateIntFlowNestedLoops");\r
1758 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(2,"fEvaluateDiffFlowNestedLoops");\r
1759 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(3,"fCrossCheckInPtBinNo");\r
1760 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(4,"fCrossCheckInEtaBinNo");\r
1761 fEvaluateNestedLoops->Fill(0.5,(Int_t)fEvaluateIntFlowNestedLoops);\r
1762 fEvaluateNestedLoops->Fill(1.5,(Int_t)fEvaluateDiffFlowNestedLoops);\r
1763 fEvaluateNestedLoops->Fill(2.5,fCrossCheckInPtBinNo);\r
1764 fEvaluateNestedLoops->Fill(3.5,fCrossCheckInEtaBinNo);\r
1765 fNestedLoopsList->Add(fEvaluateNestedLoops);\r
1766 // nested loops for integrated flow:\r
1767 if(fEvaluateIntFlowNestedLoops)\r
1768 {\r
1769 // correlations:\r
1770 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";\r
1771 intFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
1772 fIntFlowDirectCorrelations = new TProfile(intFlowDirectCorrelationsName.Data(),"Multiparticle correlations calculated with nested loops (for int. flow)",32,0,32,"s");\r
1773 fNestedLoopsList->Add(fIntFlowDirectCorrelations);\r
1774 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1775 {\r
1776 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";\r
1777 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();\r
1778 fIntFlowExtraDirectCorrelations = new TProfile(intFlowExtraDirectCorrelationsName.Data(),"Extra multiparticle correlations calculated with nested loops (for int. flow)",100,0,100,"s");\r
1779 fNestedLoopsList->Add(fIntFlowExtraDirectCorrelations); \r
1780 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1781 // correction terms for non-uniform acceptance:\r
1782 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1783 {\r
1784 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";\r
1785 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
1786 fIntFlowDirectCorrectionTermsForNUA[sc] = new TProfile(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data()),Form("Correction terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),10,0,10,"s");\r
1787 fNestedLoopsList->Add(fIntFlowDirectCorrectionTermsForNUA[sc]);\r
1788 } // end of for(Int_t sc=0;sc<2;sc++) \r
1789 } // end of if(fEvaluateIntFlowNestedLoops)\r
1790 \r
1791 // nested loops for differential flow: \r
1792 if(fEvaluateDiffFlowNestedLoops)\r
1793 {\r
1794 // reduced correlations:\r
1795 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";\r
1796 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
1797 for(Int_t t=0;t<2;t++) // type: RP or POI\r
1798 { \r
1799 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1800 {\r
1801 for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
1802 {\r
1803 // reduced correlations:\r
1804 fDiffFlowDirectCorrelations[t][pe][rci] = new TProfile(Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),1,lowerPtEtaEdge[pe],upperPtEtaEdge[pe],"s");\r
1805 fDiffFlowDirectCorrelations[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());\r
1806 fNestedLoopsList->Add(fDiffFlowDirectCorrelations[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)\r
1807 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index\r
1808 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
1809 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI \r
1810 } // end of if(fEvaluateDiffFlowNestedLoops)\r
1811 // correction terms for non-uniform acceptance:\r
1812 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";\r
1813 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
1814 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
1815 { \r
1816 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1817 {\r
1818 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
1819 {\r
1820 for(Int_t cti=0;cti<9;cti++) // correction term index\r
1821 {\r
1822 fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = new TProfile(Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),1,lowerPtEtaEdge[pe],upperPtEtaEdge[pe],"s"); \r
1823 fNestedLoopsList->Add(fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]);\r
1824 }\r
1825 }\r
1826 }\r
1827 } \r
1828\r
1829} // end of AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()\r
1830\r
1831\r
1832//================================================================================================================================\r
1833\r
1834\r
1835void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()\r
1836{\r
1837 // calculate all correlations needed for integrated flow\r
1838 \r
1839 // multiplicity:\r
1840 Double_t dMult = (*fSMpk)(0,0);\r
1841 \r
1842 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
1843 Double_t dReQ1n = (*fReQ)(0,0);\r
1844 Double_t dReQ2n = (*fReQ)(1,0);\r
1845 Double_t dReQ3n = (*fReQ)(2,0);\r
1846 Double_t dReQ4n = (*fReQ)(3,0);\r
1847 Double_t dImQ1n = (*fImQ)(0,0);\r
1848 Double_t dImQ2n = (*fImQ)(1,0);\r
1849 Double_t dImQ3n = (*fImQ)(2,0);\r
1850 Double_t dImQ4n = (*fImQ)(3,0);\r
1851 \r
1852 // real and imaginary parts of some expressions involving various combinations of Q-vectors evaluated in harmonics n, 2n, 3n and 4n:\r
1853 // (these expression appear in the Eqs. for the multi-particle correlations bellow)\r
1854 \r
1855 // Re[Q_{2n} Q_{n}^* Q_{n}^*]\r
1856 Double_t reQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dReQ2n + 2.*dReQ1n*dImQ1n*dImQ2n - pow(dImQ1n,2.)*dReQ2n; \r
1857 \r
1858 // Im[Q_{2n} Q_{n}^* Q_{n}^*]\r
1859 //Double_t imQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dImQ2n-2.*dReQ1n*dImQ1n*dReQ2n-pow(dImQ1n,2.)*dImQ2n; \r
1860 \r
1861 // Re[Q_{n} Q_{n} Q_{2n}^*] = Re[Q_{2n} Q_{n}^* Q_{n}^*]\r
1862 Double_t reQ1nQ1nQ2nstar = reQ2nQ1nstarQ1nstar; \r
1863 \r
1864 // Re[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*]\r
1865 Double_t reQ3nQ1nQ2nstarQ2nstar = (pow(dReQ2n,2.)-pow(dImQ2n,2.))*(dReQ3n*dReQ1n-dImQ3n*dImQ1n) \r
1866 + 2.*dReQ2n*dImQ2n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);\r
1867\r
1868 // Im[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*] \r
1869 //Double_t imQ3nQ1nQ2nstarQ2nstar = calculate and implement this (deleteMe)\r
1870 \r
1871 // Re[Q_{2n} Q_{2n} Q_{3n}^* Q_{1n}^*] = Re[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*]\r
1872 Double_t reQ2nQ2nQ3nstarQ1nstar = reQ3nQ1nQ2nstarQ2nstar;\r
1873 \r
1874 // Re[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1875 Double_t reQ4nQ2nstarQ2nstar = pow(dReQ2n,2.)*dReQ4n+2.*dReQ2n*dImQ2n*dImQ4n-pow(dImQ2n,2.)*dReQ4n;\r
1876\r
1877 // Im[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1878 //Double_t imQ4nQ2nstarQ2nstar = calculate and implement this (deleteMe)\r
1879 \r
1880 // Re[Q_{2n} Q_{2n} Q_{4n}^*] = Re[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1881 Double_t reQ2nQ2nQ4nstar = reQ4nQ2nstarQ2nstar;\r
1882 \r
1883 // Re[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1884 Double_t reQ4nQ3nstarQ1nstar = dReQ4n*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)+dImQ4n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);\r
1885 \r
1886 // Re[Q_{3n} Q_{n} Q_{4n}^*] = Re[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1887 Double_t reQ3nQ1nQ4nstar = reQ4nQ3nstarQ1nstar;\r
1888 \r
1889 // Im[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1890 //Double_t imQ4nQ3nstarQ1nstar = calculate and implement this (deleteMe)\r
1891\r
1892 // Re[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1893 Double_t reQ3nQ2nstarQ1nstar = dReQ3n*dReQ2n*dReQ1n-dReQ3n*dImQ2n*dImQ1n+dImQ3n*dReQ2n*dImQ1n\r
1894 + dImQ3n*dImQ2n*dReQ1n;\r
1895 \r
1896 // Re[Q_{2n} Q_{n} Q_{3n}^*] = Re[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1897 Double_t reQ2nQ1nQ3nstar = reQ3nQ2nstarQ1nstar;\r
1898 \r
1899 // Im[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1900 //Double_t imQ3nQ2nstarQ1nstar; //calculate and implement this (deleteMe)\r
1901 \r
1902 // Re[Q_{3n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1903 Double_t reQ3nQ1nstarQ1nstarQ1nstar = dReQ3n*pow(dReQ1n,3)-3.*dReQ1n*dReQ3n*pow(dImQ1n,2)\r
1904 + 3.*dImQ1n*dImQ3n*pow(dReQ1n,2)-dImQ3n*pow(dImQ1n,3);\r
1905\r
1906 // Im[Q_{3n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1907 //Double_t imQ3nQ1nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1908 \r
1909 // |Q_{2n}|^2 |Q_{n}|^2\r
1910 Double_t dQ2nQ1nQ2nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));\r
1911 \r
1912 // Re[Q_{4n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1913 Double_t reQ4nQ2nstarQ1nstarQ1nstar = (dReQ4n*dReQ2n+dImQ4n*dImQ2n)*(pow(dReQ1n,2)-pow(dImQ1n,2))\r
1914 + 2.*dReQ1n*dImQ1n*(dImQ4n*dReQ2n-dReQ4n*dImQ2n); \r
1915 \r
1916 // Im[Q_{4n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1917 //Double_t imQ4nQ2nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1918 \r
1919 // Re[Q_{2n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1920 Double_t reQ2nQ1nQ1nstarQ1nstarQ1nstar = (dReQ2n*dReQ1n-dImQ2n*dImQ1n)*(pow(dReQ1n,3)-3.*dReQ1n*pow(dImQ1n,2))\r
1921 + (dReQ2n*dImQ1n+dReQ1n*dImQ2n)*(3.*dImQ1n*pow(dReQ1n,2)-pow(dImQ1n,3));\r
1922\r
1923 // Im[Q_{2n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^*] \r
1924 //Double_t imQ2nQ1nQ1nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1925 \r
1926 // Re[Q_{2n} Q_{2n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1927 Double_t reQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
1928 * (dReQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) + 2.*dImQ2n*dReQ1n*dImQ1n);\r
1929\r
1930 // Im[Q_{2n} Q_{2n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1931 //Double_t imQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
1932 // * (dImQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) - 2.*dReQ2n*dReQ1n*dImQ1n);\r
1933 \r
1934 // Re[Q_{4n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1935 Double_t reQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dReQ4n-6.*pow(dReQ1n,2.)*dReQ4n*pow(dImQ1n,2.)\r
1936 + pow(dImQ1n,4.)*dReQ4n+4.*pow(dReQ1n,3.)*dImQ1n*dImQ4n\r
1937 - 4.*pow(dImQ1n,3.)*dReQ1n*dImQ4n;\r
1938 \r
1939 // Im[Q_{4n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1940 //Double_t imQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dImQ4n-6.*pow(dReQ1n,2.)*dImQ4n*pow(dImQ1n,2.)\r
1941 // + pow(dImQ1n,4.)*dImQ4n+4.*pow(dImQ1n,3.)*dReQ1n*dReQ4n\r
1942 // - 4.*pow(dReQ1n,3.)*dImQ1n*dReQ4n;\r
1943 \r
1944 // Re[Q_{3n} Q_{n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1945 Double_t reQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
1946 * (dReQ1n*dReQ2n*dReQ3n-dReQ3n*dImQ1n*dImQ2n+dReQ2n*dImQ1n*dImQ3n+dReQ1n*dImQ2n*dImQ3n);\r
1947 \r
1948 // Im[Q_{3n} Q_{n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1949 //Double_t imQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
1950 // * (-dReQ2n*dReQ3n*dImQ1n-dReQ1n*dReQ3n*dImQ2n+dReQ1n*dReQ2n*dImQ3n-dImQ1n*dImQ2n*dImQ3n);\r
1951 \r
1952 \r
1953 // Re[Q_{2n} Q_{2n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1954 Double_t reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)*dReQ2n-2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)\r
1955 + dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dImQ2n)\r
1956 * (pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)\r
1957 - dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n+pow(dImQ1n,2.)*dImQ2n);\r
1958 \r
1959 // Im[Q_{2n} Q_{2n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1960 //Double_t imQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = 2.*(pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)\r
1961 // + 2.*dReQ1n*dImQ1n*dImQ2n)*(pow(dReQ1n,2.)*dImQ2n\r
1962 // - 2.*dReQ1n*dImQ1n*dReQ2n-pow(dImQ1n,2.)*dImQ2n);\r
1963 \r
1964 // Re[Q_{3n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1965 Double_t reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
1966 * (pow(dReQ1n,3.)*dReQ3n-3.*dReQ1n*dReQ3n*pow(dImQ1n,2.)\r
1967 + 3.*pow(dReQ1n,2.)*dImQ1n*dImQ3n-pow(dImQ1n,3.)*dImQ3n);\r
1968 \r
1969 // Im[Q_{3n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*] \r
1970 //Double_t imQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
1971 // * (pow(dImQ1n,3.)*dReQ3n-3.*dImQ1n*dReQ3n*pow(dReQ1n,2.)\r
1972 // - 3.*pow(dImQ1n,2.)*dReQ1n*dImQ3n+pow(dReQ1n,3.)*dImQ3n);\r
1973 \r
1974 // |Q_{2n}|^2 |Q_{n}|^4\r
1975 Double_t dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.);\r
1976 \r
1977 // Re[Q_{2n} Q_{n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1978 Double_t reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
1979 * (pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)\r
1980 + 2.*dReQ1n*dImQ1n*dImQ2n);\r
1981 \r
1982 // Im[Q_{2n} Q_{n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*] \r
1983 //Double_t imQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
1984 // * (pow(dReQ1n,2.)*dImQ2n-dImQ2n*pow(dImQ1n,2.)\r
1985 // - 2.*dReQ1n*dReQ2n*dImQ1n);\r
1986 \r
1987 \r
1988 \r
1989 \r
1990 // **************************************\r
1991 // **** multi-particle correlations: ****\r
1992 // **************************************\r
1993 //\r
1994 // Remark 1: multi-particle correlations calculated with non-weighted Q-vectors are stored in 1D profile fQCorrelations[0]. // to be improved (wrong profiles)\r
1995 // Remark 2: binning of fQCorrelations[0] is organized as follows: // to be improved (wrong profiles)\r
1996 // --------------------------------------------------------------------------------------------------------------------\r
1997 // 1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>\r
1998 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>\r
1999 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))> \r
2000 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>\r
2001 // 5th bin: ---- EMPTY ----\r
2002 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>\r
2003 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>\r
2004 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
2005 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>\r
2006 // 10th bin: ---- EMPTY ----\r
2007 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>\r
2008 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
2009 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>\r
2010 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
2011 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>\r
2012 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>\r
2013 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))> \r
2014 // 18th bin: ---- EMPTY ----\r
2015 // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
2016 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
2017 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
2018 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
2019 // 23rd bin: ---- EMPTY ----\r
2020 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2021 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
2022 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
2023 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
2024 // 28th bin: ---- EMPTY ----\r
2025 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
2026 // 30th bin: ---- EMPTY ----\r
2027 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2028 // --------------------------------------------------------------------------------------------------------------------\r
2029 \r
2030 // 2-particle:\r
2031 Double_t two1n1n = 0.; // <cos(n*(phi1-phi2))>\r
2032 Double_t two2n2n = 0.; // <cos(2n*(phi1-phi2))>\r
2033 Double_t two3n3n = 0.; // <cos(3n*(phi1-phi2))>\r
2034 Double_t two4n4n = 0.; // <cos(4n*(phi1-phi2))>\r
2035 \r
2036 if(dMult>1)\r
2037 {\r
2038 two1n1n = (pow(dReQ1n,2.)+pow(dImQ1n,2.)-dMult)/(dMult*(dMult-1.)); \r
2039 two2n2n = (pow(dReQ2n,2.)+pow(dImQ2n,2.)-dMult)/(dMult*(dMult-1.)); \r
2040 two3n3n = (pow(dReQ3n,2.)+pow(dImQ3n,2.)-dMult)/(dMult*(dMult-1.)); \r
2041 two4n4n = (pow(dReQ4n,2.)+pow(dImQ4n,2.)-dMult)/(dMult*(dMult-1.)); \r
2042 \r
2043 // average 2-particle correlations for single event: \r
2044 fIntFlowCorrelationsAllEBE->SetBinContent(1,two1n1n);\r
2045 fIntFlowCorrelationsAllEBE->SetBinContent(2,two2n2n);\r
2046 fIntFlowCorrelationsAllEBE->SetBinContent(3,two3n3n);\r
2047 fIntFlowCorrelationsAllEBE->SetBinContent(4,two4n4n);\r
2048 \r
2049 // average 2-particle correlations for all events: \r
2050 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1n,dMult*(dMult-1.)); \r
2051 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2n,dMult*(dMult-1.)); \r
2052 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3n,dMult*(dMult-1.)); \r
2053 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4n,dMult*(dMult-1.)); \r
2054 \r
2055 // store separetately <2> (to be improved: do I really need this?)\r
2056 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1n); // <2>\r
2057 \r
2058 // to be improved (this can be implemented better):\r
2059 Double_t mWeight2p = 0.;\r
2060 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2061 {\r
2062 mWeight2p = dMult*(dMult-1.);\r
2063 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2064 {\r
2065 mWeight2p = 1.; \r
2066 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2067 {\r
2068 mWeight2p = dMult; \r
2069 }\r
2070 \r
2071 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,mWeight2p); // eW_<2>\r
2072 fIntFlowCorrelationsPro->Fill(0.5,two1n1n,mWeight2p);\r
2073 \r
2074 // distribution of <cos(n*(phi1-phi2))>:\r
2075 //f2pDistribution->Fill(two1n1n,dMult*(dMult-1.)); \r
2076 } // end of if(dMult>1)\r
2077 \r
2078 // 3-particle:\r
2079 Double_t three2n1n1n = 0.; // <cos(n*(2.*phi1-phi2-phi3))>\r
2080 Double_t three3n2n1n = 0.; // <cos(n*(3.*phi1-2.*phi2-phi3))>\r
2081 Double_t three4n2n2n = 0.; // <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
2082 Double_t three4n3n1n = 0.; // <cos(n*(4.*phi1-3.*phi2-phi3))>\r
2083 \r
2084 if(dMult>2)\r
2085 {\r
2086 three2n1n1n = (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2087 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)\r
2088 / (dMult*(dMult-1.)*(dMult-2.)); \r
2089 three3n2n1n = (reQ3nQ2nstarQ1nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2090 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2091 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)\r
2092 / (dMult*(dMult-1.)*(dMult-2.));\r
2093 three4n2n2n = (reQ4nQ2nstarQ2nstar-2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2094 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*dMult)\r
2095 / (dMult*(dMult-1.)*(dMult-2.)); \r
2096 three4n3n1n = (reQ4nQ3nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))\r
2097 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2098 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)\r
2099 / (dMult*(dMult-1.)*(dMult-2.)); \r
2100 \r
2101 // average 3-particle correlations for single event: \r
2102 fIntFlowCorrelationsAllEBE->SetBinContent(6,three2n1n1n);\r
2103 fIntFlowCorrelationsAllEBE->SetBinContent(7,three3n2n1n);\r
2104 fIntFlowCorrelationsAllEBE->SetBinContent(8,three4n2n2n);\r
2105 fIntFlowCorrelationsAllEBE->SetBinContent(9,three4n3n1n);\r
2106 \r
2107 // average 3-particle correlations for all events: \r
2108 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.)); \r
2109 fIntFlowCorrelationsAllPro->Fill(6.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));\r
2110 fIntFlowCorrelationsAllPro->Fill(7.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.)); \r
2111 fIntFlowCorrelationsAllPro->Fill(8.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.)); \r
2112 } // end of if(dMult>2)\r
2113 \r
2114 // 4-particle:\r
2115 Double_t four1n1n1n1n = 0.; // <cos(n*(phi1+phi2-phi3-phi4))>\r
2116 Double_t four2n2n2n2n = 0.; // <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
2117 Double_t four2n1n2n1n = 0.; // <cos(n*(2.*phi1+phi2-2.*phi3-phi4))> \r
2118 Double_t four3n1n1n1n = 0.; // <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
2119 Double_t four4n2n1n1n = 0.; // <cos(n*(4.*phi1-2.*phi2-phi3-phi4))> \r
2120 Double_t four3n1n2n2n = 0.; // <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))> \r
2121 Double_t four3n1n3n1n = 0.; // <cos(n*(3.*phi1+phi2-3.*phi3-phi4))> \r
2122 \r
2123 if(dMult>3)\r
2124 {\r
2125 four1n1n1n1n = (2.*dMult*(dMult-3.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ1n,2.)\r
2126 + pow(dImQ1n,2.))-2.*reQ2nQ1nstarQ1nstar+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2127 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.)); \r
2128 four2n2n2n2n = (2.*dMult*(dMult-3.)+pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ2n,2.)\r
2129 + pow(dImQ2n,2.))-2.*reQ4nQ2nstarQ2nstar+(pow(dReQ4n,2.)+pow(dImQ4n,2.)))\r
2130 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));\r
2131 four2n1n2n1n = (dQ2nQ1nQ2nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar-2.*reQ2nQ1nstarQ1nstar)\r
2132 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2133 - ((dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2134 + (dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-(pow(dReQ3n,2.)+pow(dImQ3n,2.)))\r
2135 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2136 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2137 four3n1n1n1n = (reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar-3.*reQ2nQ1nstarQ1nstar)\r
2138 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2139 + (2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2140 + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)\r
2141 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2142 four4n2n1n1n = (reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar)\r
2143 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2144 - (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2145 - 3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2146 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2147 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2148 four3n1n2n2n = (reQ3nQ1nQ2nstarQ2nstar-reQ4nQ2nstarQ2nstar-reQ3nQ1nQ4nstar-2.*reQ3nQ2nstarQ1nstar)\r
2149 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2150 - (2.*reQ1nQ1nQ2nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2151 - 4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2152 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2153 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.)); \r
2154 four3n1n3n1n = ((pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2155 - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar)\r
2156 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2157 + ((pow(dReQ4n,2.)+pow(dImQ4n,2.))-(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2158 + (pow(dReQ2n,2.)+pow(dImQ2n,2.))-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2159 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2160 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2161 \r
2162 // average 4-particle correlations for single event: \r
2163 fIntFlowCorrelationsAllEBE->SetBinContent(11,four1n1n1n1n);\r
2164 fIntFlowCorrelationsAllEBE->SetBinContent(12,four2n1n2n1n);\r
2165 fIntFlowCorrelationsAllEBE->SetBinContent(13,four2n2n2n2n);\r
2166 fIntFlowCorrelationsAllEBE->SetBinContent(14,four3n1n1n1n);\r
2167 fIntFlowCorrelationsAllEBE->SetBinContent(15,four3n1n3n1n);\r
2168 fIntFlowCorrelationsAllEBE->SetBinContent(16,four3n1n2n2n);\r
2169 fIntFlowCorrelationsAllEBE->SetBinContent(17,four4n2n1n1n);\r
2170 \r
2171 // average 4-particle correlations for all events: \r
2172 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2173 fIntFlowCorrelationsAllPro->Fill(11.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2174 fIntFlowCorrelationsAllPro->Fill(12.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2175 fIntFlowCorrelationsAllPro->Fill(13.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2176 fIntFlowCorrelationsAllPro->Fill(14.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2177 fIntFlowCorrelationsAllPro->Fill(15.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
2178 fIntFlowCorrelationsAllPro->Fill(16.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
2179 \r
2180 // store separetately <4> (to be improved: do I really need this?)\r
2181 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1n); // <4>\r
2182 \r
2183 // to be improved (this can be implemented better):\r
2184 Double_t mWeight4p = 0.;\r
2185 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2186 {\r
2187 mWeight4p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.);\r
2188 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2189 {\r
2190 mWeight4p = 1.; \r
2191 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2192 {\r
2193 mWeight4p = dMult; \r
2194 }\r
2195 \r
2196 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,mWeight4p); // eW_<4>\r
2197 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1n,mWeight4p);\r
2198 \r
2199 // distribution of <cos(n*(phi1+phi2-phi3-phi4))>\r
2200 //f4pDistribution->Fill(four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2201 \r
2202 } // end of if(dMult>3)\r
2203\r
2204 // 5-particle:\r
2205 Double_t five2n1n1n1n1n = 0.; // <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
2206 Double_t five2n2n2n1n1n = 0.; // <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
2207 Double_t five3n1n2n1n1n = 0.; // <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
2208 Double_t five4n1n1n1n1n = 0.; // <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
2209 \r
2210 if(dMult>4)\r
2211 {\r
2212 five2n1n1n1n1n = (reQ2nQ1nQ1nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar+6.*reQ3nQ2nstarQ1nstar)\r
2213 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2214 - (reQ2nQ1nQ3nstar+3.*(dMult-6.)*reQ2nQ1nstarQ1nstar+3.*reQ1nQ1nQ2nstar)\r
2215 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2216 - (2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2217 + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.)) \r
2218 - 3.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2219 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2220 - 3.*(pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2221 - 2.*(2*dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult*(dMult-4.))\r
2222 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2223 \r
2224 five2n2n2n1n1n = (reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ2nQ2nQ3nstarQ1nstar)\r
2225 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2226 + 2.*(reQ4nQ2nstarQ2nstar+4.*reQ3nQ2nstarQ1nstar+reQ3nQ1nQ4nstar)\r
2227 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2228 + (reQ2nQ2nQ4nstar-2.*(dMult-5.)*reQ2nQ1nstarQ1nstar+2.*reQ1nQ1nQ2nstar)\r
2229 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2230 - (2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2231 + 1.*pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)\r
2232 - 2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2233 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2234 - (4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2235 - 4.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+4.*dMult*(dMult-6.))\r
2236 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)); \r
2237\r
2238 five4n1n1n1n1n = (reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ4nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nstarQ1nstarQ1nstar)\r
2239 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2240 + (8.*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+12.*reQ3nQ2nstarQ1nstar+12.*reQ2nQ1nstarQ1nstar)\r
2241 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2242 - (6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+8.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2243 + 12.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-24.*dMult)\r
2244 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2245 \r
2246 five3n1n2n1n1n = (reQ3nQ1nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar)\r
2247 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2248 - (reQ3nQ1nQ2nstarQ2nstar-3.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar)\r
2249 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2250 - ((2.*dMult-13.)*reQ3nQ2nstarQ1nstar-reQ3nQ1nQ4nstar-9.*reQ2nQ1nstarQ1nstar)\r
2251 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2252 - (2.*reQ1nQ1nQ2nstar+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))\r
2253 - 2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+2.*(pow(dReQ3n,2.)\r
2254 + pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2255 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2256 + (2.*(dMult-6.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2257 - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2258 - pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2259 + 2.*(3.*dMult-11.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2260 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2261 - 4.*(dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2262 \r
2263 // average 5-particle correlations for single event: \r
2264 fIntFlowCorrelationsAllEBE->SetBinContent(19,five2n1n1n1n1n);\r
2265 fIntFlowCorrelationsAllEBE->SetBinContent(20,five2n2n2n1n1n);\r
2266 fIntFlowCorrelationsAllEBE->SetBinContent(21,five3n1n2n1n1n);\r
2267 fIntFlowCorrelationsAllEBE->SetBinContent(22,five4n1n1n1n1n);\r
2268 \r
2269 // average 5-particle correlations for all events: \r
2270 fIntFlowCorrelationsAllPro->Fill(18.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)); \r
2271 fIntFlowCorrelationsAllPro->Fill(19.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2272 fIntFlowCorrelationsAllPro->Fill(20.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2273 fIntFlowCorrelationsAllPro->Fill(21.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2274 } // end of if(dMult>4)\r
2275 \r
2276 // 6-particle:\r
2277 Double_t six1n1n1n1n1n1n = 0.; // <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2278 Double_t six2n2n1n1n1n1n = 0.; // <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
2279 Double_t six3n1n1n1n1n1n = 0.; // <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
2280 Double_t six2n1n1n2n1n1n = 0.; // <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
2281 \r
2282 if(dMult>5)\r
2283 {\r
2284 six1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)+9.*dQ2nQ1nQ2nstarQ1nstar-6.*reQ2nQ1nQ1nstarQ1nstarQ1nstar)\r
2285 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2286 + 4.*(reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar)\r
2287 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2288 + 2.*(9.*(dMult-4.)*reQ2nQ1nstarQ1nstar+2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.)))\r
2289 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2290 - 9.*(pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2291 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-5.))\r
2292 + (18.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2293 / (dMult*(dMult-1)*(dMult-3)*(dMult-4))\r
2294 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2295 \r
2296 six2n1n1n2n1n1n = (dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2297 * (2.*five2n2n2n1n1n+4.*five2n1n1n1n1n+4.*five3n1n2n1n1n+4.*four2n1n2n1n+1.*four1n1n1n1n)\r
2298 - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four1n1n1n1n+4.*two1n1n\r
2299 + 2.*three2n1n1n+2.*three2n1n1n+4.*four3n1n1n1n+8.*three2n1n1n+2.*four4n2n1n1n\r
2300 + 4.*four2n1n2n1n+2.*two2n2n+8.*four2n1n2n1n+4.*four3n1n3n1n+8.*three3n2n1n\r
2301 + 4.*four3n1n2n2n+4.*four1n1n1n1n+4.*four2n1n2n1n+1.*four2n2n2n2n)\r
2302 - dMult*(dMult-1.)*(dMult-2.)*(2.*three2n1n1n+8.*two1n1n+4.*two1n1n+2.\r
2303 + 4.*two1n1n+4.*three2n1n1n+2.*two2n2n+4.*three2n1n1n+8.*three3n2n1n\r
2304 + 8.*two2n2n+4.*three4n3n1n+4.*two3n3n+4.*three3n2n1n+4.*two1n1n\r
2305 + 8.*three2n1n1n+4.*two1n1n+4.*three3n2n1n+4.*three2n1n1n+2.*two2n2n\r
2306 + 4.*three3n2n1n+2.*three4n2n2n)-dMult*(dMult-1.)\r
2307 * (4.*two1n1n+4.+4.*two1n1n+2.*two2n2n+1.+4.*two1n1n+4.*two2n2n+4.*two3n3n\r
2308 + 1.+2.*two2n2n+1.*two4n4n)-dMult)\r
2309 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2310 \r
2311 six2n2n1n1n1n1n = (reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2312 * (five4n1n1n1n1n+8.*five2n1n1n1n1n+6.*five2n2n2n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)\r
2313 * (4.*four3n1n1n1n+6.*four4n2n1n1n+12.*three2n1n1n+12.*four1n1n1n1n+24.*four2n1n2n1n\r
2314 + 4.*four3n1n2n2n+3.*four2n2n2n2n)-dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+12.*three3n2n1n\r
2315 + 4.*three4n3n1n+3.*three4n2n2n+8.*three2n1n1n+24.*two1n1n+12.*two2n2n+12.*three2n1n1n+8.*three3n2n1n\r
2316 + 1.*three4n2n2n)-dMult*(dMult-1.)*(4.*two1n1n+6.*two2n2n+4.*two3n3n+1.*two4n4n+2.*two2n2n+8.*two1n1n+6.)-dMult)\r
2317 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2318 \r
2319 six3n1n1n1n1n1n = (reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2320 * (five4n1n1n1n1n+4.*five2n1n1n1n1n+6.*five3n1n2n1n1n+4.*four3n1n1n1n)\r
2321 - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four3n1n1n1n+6.*four4n2n1n1n+6.*four1n1n1n1n\r
2322 + 12.*three2n1n1n+12.*four2n1n2n1n+6.*four3n1n1n1n+12.*three3n2n1n+4.*four3n1n3n1n+3.*four3n1n2n2n)\r
2323 - dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+12.*three3n2n1n+4.*three4n3n1n+3.*three4n2n2n+4.*two1n1n\r
2324 + 12.*two1n1n+6.*three2n1n1n+12.*three2n1n1n+4.*three3n2n1n+12.*two2n2n+4.*three3n2n1n+4.*two3n3n+1.*three4n3n1n\r
2325 + 6.*three3n2n1n)-dMult*(dMult-1.)*(4.*two1n1n+6.*two2n2n+4.*two3n3n+1.*two4n4n+1.*two1n1n+4.+6.*two1n1n+4.*two2n2n\r
2326 + 1.*two3n3n)-dMult)/(dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2327 \r
2328 // average 6-particle correlations for single event: \r
2329 fIntFlowCorrelationsAllEBE->SetBinContent(24,six1n1n1n1n1n1n);\r
2330 fIntFlowCorrelationsAllEBE->SetBinContent(25,six2n1n1n2n1n1n);\r
2331 fIntFlowCorrelationsAllEBE->SetBinContent(26,six2n2n1n1n1n1n);\r
2332 fIntFlowCorrelationsAllEBE->SetBinContent(27,six3n1n1n1n1n1n);\r
2333 \r
2334 // average 6-particle correlations for all events: \r
2335 fIntFlowCorrelationsAllPro->Fill(23.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2336 fIntFlowCorrelationsAllPro->Fill(24.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2337 fIntFlowCorrelationsAllPro->Fill(25.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));\r
2338 fIntFlowCorrelationsAllPro->Fill(26.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2339\r
2340 // store separetately <6> (to be improved: do I really need this?)\r
2341 fIntFlowCorrelationsEBE->SetBinContent(3,six1n1n1n1n1n1n); // <6>\r
2342 \r
2343 // to be improved (this can be implemented better):\r
2344 Double_t mWeight6p = 0.;\r
2345 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2346 {\r
2347 mWeight6p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.);\r
2348 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2349 {\r
2350 mWeight6p = 1.; \r
2351 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2352 {\r
2353 mWeight6p = dMult; \r
2354 }\r
2355 \r
2356 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(3,mWeight6p); // eW_<6>\r
2357 fIntFlowCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n,mWeight6p);\r
2358 \r
2359 // distribution of <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2360 //f6pDistribution->Fill(six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2361 } // end of if(dMult>5)\r
2362 \r
2363 // 7-particle:\r
2364 Double_t seven2n1n1n1n1n1n1n = 0.; // <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
2365 \r
2366 if(dMult>6)\r
2367 {\r
2368 seven2n1n1n1n1n1n1n = (reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)\r
2369 * (2.*six3n1n1n1n1n1n+4.*six1n1n1n1n1n1n+1.*six2n2n1n1n1n1n+6.*six2n1n1n2n1n1n+8.*five2n1n1n1n1n)\r
2370 - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(1.*five4n1n1n1n1n +8.*five2n1n1n1n1n+8.*four3n1n1n1n\r
2371 + 12.*five3n1n2n1n1n+4.*five2n1n1n1n1n+3.*five2n2n2n1n1n+6.*five2n2n2n1n1n+6.*four1n1n1n1n+24.*four1n1n1n1n\r
2372 + 12.*five2n1n1n1n1n+12.*five2n1n1n1n1n+12.*three2n1n1n+24.*four2n1n2n1n+4.*five3n1n2n1n1n+4.*five2n1n1n1n1n)\r
2373 - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four3n1n1n1n+6.*four4n2n1n1n+12.*four1n1n1n1n+24.*three2n1n1n\r
2374 + 24.*four2n1n2n1n+12.*four3n1n1n1n+24.*three3n2n1n+8.*four3n1n3n1n+6.*four3n1n2n2n+6.*three2n1n1n+12.*four1n1n1n1n\r
2375 + 12.*four2n1n2n1n+6.*three2n1n1n+12.*four2n1n2n1n+4.*four3n1n2n2n+3.*four2n2n2n2n+4.*four1n1n1n1n+6.*three2n1n1n\r
2376 + 24.*two1n1n+24.*four1n1n1n1n+4.*four3n1n1n1n+24.*two1n1n+24.*three2n1n1n+12.*two2n2n+24.*three2n1n1n+12.*four2n1n2n1n\r
2377 + 8.*three3n2n1n+8.*four2n1n2n1n+1.*four4n2n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+1.*three2n1n1n+8.*two1n1n\r
2378 + 12.*three3n2n1n+24.*two1n1n+12.*three2n1n1n+4.*three2n1n1n+8.*two1n1n+4.*three4n3n1n+24.*three2n1n1n+8.*three3n2n1n\r
2379 + 12.*two1n1n+12.*two1n1n+3.*three4n2n2n+24.*two2n2n+6.*two2n2n+12.+12.*three3n2n1n+8.*two3n3n+12.*three2n1n1n+24.*two1n1n\r
2380 + 4.*three3n2n1n+8.*three3n2n1n+2.*three4n3n1n+12.*two1n1n+8.*three2n1n1n+4.*three2n1n1n+2.*three3n2n1n+6.*two2n2n+8.*two2n2n\r
2381 + 1.*three4n2n2n+4.*three3n2n1n+6.*three2n1n1n)-dMult*(dMult-1.)*(4.*two1n1n+2.*two1n1n+6.*two2n2n+8.+1.*two2n2n+4.*two3n3n\r
2382 + 12.*two1n1n+4.*two1n1n+1.*two4n4n+8.*two2n2n+6.+2.*two3n3n+4.*two1n1n+1.*two2n2n)-dMult)\r
2383 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)); // to be improved (direct formula needed)\r
2384 \r
2385 // average 7-particle correlations for single event: \r
2386 fIntFlowCorrelationsAllEBE->SetBinContent(29,seven2n1n1n1n1n1n1n);\r
2387 \r
2388 // average 7-particle correlations for all events: \r
2389 fIntFlowCorrelationsAllPro->Fill(28.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.));\r
2390 } // end of if(dMult>6)\r
2391 \r
2392 // 8-particle:\r
2393 Double_t eight1n1n1n1n1n1n1n1n = 0.; // <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2394 if(dMult>7)\r
2395 {\r
2396 eight1n1n1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),4.)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)\r
2397 * (12.*seven2n1n1n1n1n1n1n+16.*six1n1n1n1n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)\r
2398 * (8.*six3n1n1n1n1n1n+48.*six1n1n1n1n1n1n+6.*six2n2n1n1n1n1n+96.*five2n1n1n1n1n+72.*four1n1n1n1n+36.*six2n1n1n2n1n1n)\r
2399 - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(2.*five4n1n1n1n1n+32.*five2n1n1n1n1n+36.*four1n1n1n1n\r
2400 + 32.*four3n1n1n1n+48.*five2n1n1n1n1n+48.*five3n1n2n1n1n+144.*five2n1n1n1n1n+288.*four1n1n1n1n+36.*five2n2n2n1n1n\r
2401 + 144.*three2n1n1n+96.*two1n1n+144.*four2n1n2n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)\r
2402 * (8.*four3n1n1n1n+48.*four1n1n1n1n+12.*four4n2n1n1n+96.*four2n1n2n1n+96.*three2n1n1n+72.*three2n1n1n+144.*two1n1n\r
2403 + 16.*four3n1n3n1n+48.*four3n1n1n1n+144.*four1n1n1n1n+72.*four1n1n1n1n+96.*three3n2n1n+24.*four3n1n2n2n+144.*four2n1n2n1n\r
2404 + 288.*two1n1n+288.*three2n1n1n+9.*four2n2n2n2n+72.*two2n2n+24.)-dMult*(dMult-1.)*(dMult-2.)*(12.*three2n1n1n+16.*two1n1n\r
2405 + 24.*three3n2n1n+48.*three2n1n1n+96.*two1n1n+8.*three4n3n1n+32.*three3n2n1n+96.*three2n1n1n+144.*two1n1n+6.*three4n2n2n\r
2406 + 96.*two2n2n+36.*two2n2n+72.+48.*three3n2n1n+16.*two3n3n+72.*three2n1n1n+144.*two1n1n)-dMult*(dMult-1.)*(8.*two1n1n\r
2407 + 12.*two2n2n+16.+8.*two3n3n+48.*two1n1n+1.*two4n4n+16.*two2n2n+18.)-dMult)\r
2408 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.)); // to be improved (direct formula needed)\r
2409 \r
2410 // average 8-particle correlations for single event: \r
2411 fIntFlowCorrelationsAllEBE->SetBinContent(31,eight1n1n1n1n1n1n1n1n);\r
2412 \r
2413 // average 8-particle correlations for all events: \r
2414 fIntFlowCorrelationsAllPro->Fill(30.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));\r
2415 \r
2416 // store separetately <8> (to be improved: do I really need this?)\r
2417 fIntFlowCorrelationsEBE->SetBinContent(4,eight1n1n1n1n1n1n1n1n); // <8>\r
2418 \r
2419 // to be improved (this can be implemented better):\r
2420 Double_t mWeight8p = 0.;\r
2421 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2422 {\r
2423 mWeight8p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.);\r
2424 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2425 {\r
2426 mWeight8p = 1.; \r
2427 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2428 {\r
2429 mWeight8p = dMult; \r
2430 }\r
2431 \r
2432 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(4,mWeight8p); // eW_<8>\r
2433 fIntFlowCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n,mWeight8p); \r
2434 \r
2435 // distribution of <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2436 //f8pDistribution->Fill(eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));\r
2437 } // end of if(dMult>7) \r
2438 \r
2439} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()\r
2440\r
2441\r
2442//================================================================================================================================\r
2443\r
2444\r
2445void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()\r
2446{\r
2447 // Calculate averages of products of correlations for integrated flow // to be improved (this method can be implemented better)\r
2448 \r
2449 // a) Binning of fIntFlowProductOfCorrelationsPro is organized as follows:\r
2450 // 1st bin: <<2><4>> \r
2451 // 2nd bin: <<2><6>>\r
2452 // 3rd bin: <<2><8>>\r
2453 // 4th bin: <<4><6>>\r
2454 // 5th bin: <<4><8>>\r
2455 // 6th bin: <<6><8>>\r
2456\r
2457 /*\r
2458 Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
2459\r
2460 Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>\r
2461 Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>\r
2462 Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>\r
2463 Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>\r
2464 \r
2465 Double_t eW2 = 0.; // event weight for <2>\r
2466 Double_t eW4 = 0.; // event weight for <4>\r
2467 Double_t eW6 = 0.; // event weight for <6>\r
2468 Double_t eW8 = 0.; // event weight for <8>\r
2469 \r
2470 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
2471 {\r
2472 eW2 = dMult*(dMult-1);\r
2473 eW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3);\r
2474 eW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5);\r
2475 eW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7);\r
2476 } else \r
2477 {\r
2478 eW2 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
2479 eW4 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1) \r
2480 + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
2481 + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
2482 }\r
2483 \r
2484 fIntFlowProductOfCorrelationsPro->Fill(0.5,twoEBE*fourEBE,eW2*eW4); // <<2><4>> \r
2485 fIntFlowProductOfCorrelationsPro->Fill(1.5,twoEBE*sixEBE,eW2*eW6); // <<2><6>>\r
2486 fIntFlowProductOfCorrelationsPro->Fill(2.5,twoEBE*eightEBE,eW2*eW8); // <<2><8>>\r
2487 fIntFlowProductOfCorrelationsPro->Fill(3.5,fourEBE*sixEBE,eW4*eW6); // <<4><6>>\r
2488 fIntFlowProductOfCorrelationsPro->Fill(4.5,fourEBE*eightEBE,eW4*eW8); // <<4><8>>\r
2489 fIntFlowProductOfCorrelationsPro->Fill(5.5,sixEBE*eightEBE,eW6*eW8); // <<6><8>>\r
2490 */\r
2491 \r
2492 \r
2493 Int_t counter = 0;\r
2494 \r
2495 for(Int_t ci1=1;ci1<4;ci1++)\r
2496 {\r
2497 for(Int_t ci2=ci1+1;ci2<=4;ci2++)\r
2498 {\r
2499 fIntFlowProductOfCorrelationsPro->Fill(0.5+counter++,\r
2500 fIntFlowCorrelationsEBE->GetBinContent(ci1)*fIntFlowCorrelationsEBE->GetBinContent(ci2),\r
2501 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));\r
2502 }\r
2503 }\r
2504 \r
2505} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()\r
2506\r
2507\r
2508//================================================================================================================================\r
2509\r
2510\r
2511void AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()\r
2512{\r
2513 // a) Calculate unbiased estimators Cov(<2>,<4>), Cov(<2>,<6>), Cov(<2>,<8>), Cov(<4>,<6>), Cov(<4>,<8>) and Cov(<6>,<8>)\r
2514 // for covariances V_(<2>,<4>), V_(<2>,<6>), V_(<2>,<8>), V_(<4>,<6>), V_(<4>,<8>) and V_(<6>,<8>).\r
2515 // b) Store in histogram fIntFlowCovariances for instance the following: \r
2516 //\r
2517 // Cov(<2>,<4>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4>}_j)]\r
2518 // \r
2519 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<4>} is event weight for <4>.\r
2520 // c) Binning of fIntFlowCovariances is organized as follows:\r
2521 // \r
2522 // 1st bin: Cov(<2>,<4>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4>}_j)] \r
2523 // 2nd bin: Cov(<2>,<6>) * (sum_{i=1}^{N} w_{<2>}_i w_{<6>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<6>}_j)]\r
2524 // 3rd bin: Cov(<2>,<8>) * (sum_{i=1}^{N} w_{<2>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2525 // 4th bin: Cov(<4>,<6>) * (sum_{i=1}^{N} w_{<4>}_i w_{<6>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<6>}_j)]\r
2526 // 5th bin: Cov(<4>,<8>) * (sum_{i=1}^{N} w_{<4>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2527 // 6th bin: Cov(<6>,<8>) * (sum_{i=1}^{N} w_{<6>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<6>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2528 \r
2529 for(Int_t power=0;power<2;power++)\r
2530 { \r
2531 if(!(fIntFlowCorrelationsPro && fIntFlowProductOfCorrelationsPro \r
2532 && fIntFlowSumOfEventWeights[power] && fIntFlowSumOfProductOfEventWeights\r
2533 && fIntFlowCovariances)) \r
2534 {\r
2535 cout<<"WARNING: fIntFlowCorrelationsPro && fIntFlowProductOfCorrelationsPro "<<endl;\r
2536 cout<<" && fIntFlowSumOfEventWeights[power] && fIntFlowSumOfProductOfEventWeights"<<endl;\r
2537 cout<<" && fIntFlowCovariances is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
2538 cout<<"power = "<<power<<endl;\r
2539 exit(0);\r
2540 }\r
2541 }\r
2542 \r
2543 // average 2-, 4-, 6- and 8-particle correlations for all events:\r
2544 Double_t correlation[4] = {0.};\r
2545 for(Int_t ci=0;ci<4;ci++)\r
2546 {\r
2547 correlation[ci] = fIntFlowCorrelationsPro->GetBinContent(ci+1);\r
2548 } \r
2549 // average products of 2-, 4-, 6- and 8-particle correlations: \r
2550 Double_t productOfCorrelations[4][4] = {{0.}};\r
2551 Int_t productOfCorrelationsLabel = 1;\r
2552 // denominators in the expressions for the unbiased estimator for covariance:\r
2553 Double_t denominator[4][4] = {{0.}};\r
2554 Int_t sumOfProductOfEventWeightsLabel1 = 1;\r
2555 // weight dependent prefactor which multiply unbiased estimators for covariances:\r
2556 Double_t wPrefactor[4][4] = {{0.}}; \r
2557 Int_t sumOfProductOfEventWeightsLabel2 = 1;\r
2558 for(Int_t c1=0;c1<4;c1++)\r
2559 {\r
2560 for(Int_t c2=c1+1;c2<4;c2++)\r
2561 {\r
2562 productOfCorrelations[c1][c2] = fIntFlowProductOfCorrelationsPro->GetBinContent(productOfCorrelationsLabel);\r
2563 if(fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1) && fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1))\r
2564 {\r
2565 denominator[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel1))/\r
2566 (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1) \r
2567 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));\r
2568 \r
2569 wPrefactor[c1][c2] = fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel2)/ \r
2570 (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)\r
2571 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));\r
2572 \r
2573 \r
2574 }\r
2575 productOfCorrelationsLabel++;\r
2576 sumOfProductOfEventWeightsLabel1++;\r
2577 sumOfProductOfEventWeightsLabel2++; \r
2578 }\r
2579 }\r
2580 \r
2581 // covariance label:\r
2582 Int_t covarianceLabel = 1;\r
2583 for(Int_t c1=0;c1<4;c1++)\r
2584 {\r
2585 for(Int_t c2=c1+1;c2<4;c2++)\r
2586 {\r
2587 if(denominator[c1][c2])\r
2588 {\r
2589 // covariances:\r
2590 Double_t cov = (productOfCorrelations[c1][c2]-correlation[c1]*correlation[c2])/denominator[c1][c2]; \r
2591 // covarianced multiplied with weight dependent prefactor:\r
2592 Double_t wCov = cov * wPrefactor[c1][c2];\r
2593 fIntFlowCovariances->SetBinContent(covarianceLabel,wCov);\r
2594 }\r
2595 covarianceLabel++;\r
2596 }\r
2597 }\r
2598 \r
2599} // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()\r
2600\r
2601\r
2602//================================================================================================================================\r
2603\r
2604\r
2605void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow() \r
2606{\r
2607 // From profile fIntFlowCorrelationsPro access measured correlations and spread, \r
2608 // correctly calculate the statistical errors and store the final results and \r
2609 // statistical errors for correlations in histogram fIntFlowCorrelationsHist.\r
2610 //\r
2611 // Remark: Statistical error of correlation is calculated as:\r
2612 //\r
2613 // statistical error = termA * spread * termB:\r
2614 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)\r
2615 // termB = 1/sqrt(1-termA^2) \r
2616 \r
2617 for(Int_t power=0;power<2;power++)\r
2618 { \r
2619 if(!(fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power])) \r
2620 {\r
2621 cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power] is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
2622 cout<<"power = "<<power<<endl;\r
2623 exit(0);\r
2624 }\r
2625 }\r
2626 \r
2627 for(Int_t ci=1;ci<=4;ci++) // correlation index\r
2628 {\r
2629 Double_t correlation = fIntFlowCorrelationsPro->GetBinContent(ci);\r
2630 Double_t spread = fIntFlowCorrelationsPro->GetBinError(ci);\r
2631 Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);\r
2632 Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);\r
2633 Double_t termA = 0.;\r
2634 Double_t termB = 0.;\r
2635 if(sumOfLinearEventWeights)\r
2636 {\r
2637 termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;\r
2638 } else\r
2639 {\r
2640 cout<<"WARNING: sumOfLinearEventWeights == 0 in AFAWQC::FCIF() !!!!"<<endl;\r
2641 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;\r
2642 }\r
2643 if(1.-pow(termA,2.) > 0.)\r
2644 {\r
2645 termB = 1./pow(1-pow(termA,2.),0.5);\r
2646 } else\r
2647 {\r
2648 cout<<"WARNING: 1.-pow(termA,2.) <= 0 in AFAWQC::FCIF() !!!!"<<endl; \r
2649 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;\r
2650 } \r
2651 Double_t statisticalError = termA * spread * termB;\r
2652 fIntFlowCorrelationsHist->SetBinContent(ci,correlation);\r
2653 fIntFlowCorrelationsHist->SetBinError(ci,statisticalError);\r
2654 } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index \r
2655 \r
2656} // end of AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()\r
2657\r
2658\r
2659//================================================================================================================================\r
2660\r
2661\r
2662void AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(Int_t nRP)\r
2663{\r
2664 // Fill profile fAverageMultiplicity to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8\r
2665 \r
2666 // Binning of fAverageMultiplicity is organized as follows:\r
2667 // 1st bin: all events (including the empty ones)\r
2668 // 2nd bin: event with # of RPs greater or equal to 1\r
2669 // 3rd bin: event with # of RPs greater or equal to 2\r
2670 // 4th bin: event with # of RPs greater or equal to 3\r
2671 // 5th bin: event with # of RPs greater or equal to 4\r
2672 // 6th bin: event with # of RPs greater or equal to 5\r
2673 // 7th bin: event with # of RPs greater or equal to 6\r
2674 // 8th bin: event with # of RPs greater or equal to 7\r
2675 // 9th bin: event with # of RPs greater or equal to 8\r
2676 \r
2677 if(!fAvMultiplicity)\r
2678 {\r
2679 cout<<"WARNING: fAvMultiplicity is NULL in AFAWQC::FAM() !!!!"<<endl;\r
2680 exit(0);\r
2681 }\r
2682 \r
2683 if(nRP<0)\r
2684 {\r
2685 cout<<"WARNING: nRP<0 in in AFAWQC::FAM() !!!!"<<endl;\r
2686 exit(0);\r
2687 }\r
2688 \r
2689 for(Int_t i=0;i<9;i++)\r
2690 {\r
2691 if(nRP>=i) fAvMultiplicity->Fill(i+0.5,nRP,1);\r
2692 }\r
2693 \r
2694} // end of AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(nRP)\r
2695\r
2696\r
2697//================================================================================================================================\r
2698\r
2699\r
2700void AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()\r
2701{\r
2702 // a) Calculate Q-cumulants from the measured multiparticle correlations.\r
2703 // b) Propagate the statistical errors of measured multiparticle correlations to statistical errors of Q-cumulants. \r
2704 // c) REMARK: Q-cumulants calculated in this method are biased by non-uniform acceptance of detector !!!! \r
2705 // Method ApplyCorrectionForNonUniformAcceptance* (to be improved: finalize the name here)\r
2706 // is called afterwards to correct for this bias. \r
2707 // d) Store the results and statistical error of Q-cumulants in histogram fCumulants.\r
2708 // Binning of fCumulants is organized as follows:\r
2709 //\r
2710 // 1st bin: QC{2}\r
2711 // 2nd bin: QC{4}\r
2712 // 3rd bin: QC{6}\r
2713 // 4th bin: QC{8}\r
2714 \r
2715 if(!(fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants))\r
2716 {\r
2717 cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants is NULL in AFAWQC::CCIF() !!!!"<<endl;\r
2718 exit(0);\r
2719 }\r
2720 \r
2721 // correlations:\r
2722 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>> \r
2723 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>> \r
2724 Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>> \r
2725 Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>> \r
2726 \r
2727 // statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:\r
2728 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2> \r
2729 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4> \r
2730 Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6> \r
2731 Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8> \r
2732 \r
2733 // covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):\r
2734 Double_t wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)\r
2735 Double_t wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)\r
2736 Double_t wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)\r
2737 Double_t wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)\r
2738 Double_t wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)\r
2739 Double_t wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)\r
2740 \r
2741 // Q-cumulants: \r
2742 Double_t qc2 = 0.; // QC{2}\r
2743 Double_t qc4 = 0.; // QC{4}\r
2744 Double_t qc6 = 0.; // QC{6}\r
2745 Double_t qc8 = 0.; // QC{8}\r
2746 if(two) qc2 = two; \r
2747 if(four) qc4 = four-2.*pow(two,2.); \r
2748 if(six) qc6 = six-9.*two*four+12.*pow(two,3.); \r
2749 if(eight) qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.); \r
2750 \r
2751 // statistical errors of Q-cumulants: \r
2752 Double_t qc2Error = 0.;\r
2753 Double_t qc4Error = 0.;\r
2754 Double_t qc6Error = 0.;\r
2755 Double_t qc8Error = 0.;\r
2756 \r
2757 // squared statistical errors of Q-cumulants: \r
2758 //Double_t qc2ErrorSquared = 0.;\r
2759 Double_t qc4ErrorSquared = 0.;\r
2760 Double_t qc6ErrorSquared = 0.;\r
2761 Double_t qc8ErrorSquared = 0.;\r
2762 \r
2763 // statistical error of QC{2}: \r
2764 qc2Error = twoError; \r
2765 \r
2766 // statistical error of QC{4}: \r
2767 qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)\r
2768 - 8.*two*wCov24; \r
2769 if(qc4ErrorSquared>0.)\r
2770 {\r
2771 qc4Error = pow(qc4ErrorSquared,0.5);\r
2772 } else \r
2773 {\r
2774 cout<<"WARNING: Statistical error of QC{4} is imaginary !!!!"<<endl;\r
2775 }\r
2776 \r
2777 // statistical error of QC{6}: \r
2778 qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)\r
2779 + 81.*pow(two,2.)*pow(fourError,2.)\r
2780 + pow(sixError,2.)\r
2781 - 162.*two*(4.*pow(two,2.)-four)*wCov24\r
2782 + 18.*(4.*pow(two,2.)-four)*wCov26\r
2783 - 18.*two*wCov46; \r
2784 \r
2785 if(qc6ErrorSquared>0.)\r
2786 {\r
2787 qc6Error = pow(qc6ErrorSquared,0.5);\r
2788 } else \r
2789 {\r
2790 cout<<"WARNING: Statistical error of QC{6} is imaginary !!!!"<<endl;\r
2791 }\r
2792 \r
2793 // statistical error of QC{8}: \r
2794 qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)\r
2795 + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)\r
2796 + 256.*pow(two,2.)*pow(sixError,2.)\r
2797 + pow(eightError,2.)\r
2798 - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24\r
2799 + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26\r
2800 - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28\r
2801 - 1152.*two*(4.*pow(two,2.)-four)*wCov46\r
2802 + 72.*(4.*pow(two,2.)-four)*wCov48\r
2803 - 32.*two*wCov68; \r
2804 if(qc8ErrorSquared>0.)\r
2805 {\r
2806 qc8Error = pow(qc8ErrorSquared,0.5);\r
2807 } else \r
2808 {\r
2809 cout<<"WARNING: Statistical error of QC{8} is imaginary !!!!"<<endl;\r
2810 }\r
2811\r
2812 // store the results and statistical errors for Q-cumulants:\r
2813 fIntFlowQcumulants->SetBinContent(1,qc2);\r
2814 fIntFlowQcumulants->SetBinError(1,qc2Error);\r
2815 fIntFlowQcumulants->SetBinContent(2,qc4);\r
2816 fIntFlowQcumulants->SetBinError(2,qc4Error);\r
2817 fIntFlowQcumulants->SetBinContent(3,qc6);\r
2818 fIntFlowQcumulants->SetBinError(3,qc6Error);\r
2819 fIntFlowQcumulants->SetBinContent(4,qc8); \r
2820 fIntFlowQcumulants->SetBinError(4,qc8Error); \r
2821 \r
2822} // end of AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()\r
2823\r
2824\r
2825//================================================================================================================================ \r
2826\r
2827\r
2828void AliFlowAnalysisWithQCumulants::CalculateIntFlow()\r
2829{\r
2830 // a) Calculate the final results for integrated flow estimates from Q-cumulants.\r
2831 // b) Propagate the statistical errors of measured multiparticle correlations to statistical errors of integrated flow estimates. \r
2832 // c) Store the results and statistical errors of integrated flow estimates in histogram fIntFlow.\r
2833 // Binning of fIntFlow is organized as follows:\r
2834 //\r
2835 // 1st bin: v{2,QC}\r
2836 // 2nd bin: v{4,QC}\r
2837 // 3rd bin: v{6,QC}\r
2838 // 4th bin: v{8,QC}\r
2839 \r
2840 if(!(fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants && fIntFlow))\r
2841 {\r
2842 cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants && fIntFlow is NULL in AFAWQC::CCIF() !!!!"<<endl;\r
2843 exit(0);\r
2844 }\r
2845 \r
2846 // Q-cumulants:\r
2847 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2} \r
2848 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4} \r
2849 Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6} \r
2850 Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}\r
2851 \r
2852 // correlations:\r
2853 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>> \r
2854 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>> \r
2855 Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>> \r
2856 Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>> \r
2857 \r
2858 // statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:\r
2859 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2> \r
2860 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4> \r
2861 Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6> \r
2862 Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8> \r
2863 \r
2864 // covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):\r
2865 Double_t wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)\r
2866 Double_t wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)\r
2867 Double_t wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)\r
2868 Double_t wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)\r
2869 Double_t wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)\r
2870 Double_t wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)\r
2871 \r
2872 // integrated flow estimates:\r
2873 Double_t v2 = 0.; // v{2,QC} \r
2874 Double_t v4 = 0.; // v{4,QC} \r
2875 Double_t v6 = 0.; // v{6,QC} \r
2876 Double_t v8 = 0.; // v{8,QC}\r
2877 \r
2878 // calculate integrated flow estimates from Q-cumulants: \r
2879 if(qc2>=0.) v2 = pow(qc2,1./2.); \r
2880 if(qc4<=0.) v4 = pow(-1.*qc4,1./4.); \r
2881 if(qc6>=0.) v6 = pow((1./4.)*qc6,1./6.); \r
2882 if(qc8<=0.) v8 = pow((-1./33.)*qc8,1./8.); \r
2883 \r
2884 // statistical errors of integrated flow estimates:\r
2885 Double_t v2Error = 0.; // statistical error of v{2,QC} \r
2886 Double_t v4Error = 0.; // statistical error of v{4,QC} \r
2887 Double_t v6Error = 0.; // statistical error of v{6,QC} \r
2888 Double_t v8Error = 0.; // statistical error of v{8,QC}\r
2889 \r
2890 // squares of statistical errors of integrated flow estimates:\r
2891 Double_t v2ErrorSquared = 0.; // squared statistical error of v{2,QC} \r
2892 Double_t v4ErrorSquared = 0.; // squared statistical error of v{4,QC} \r
2893 Double_t v6ErrorSquared = 0.; // squared statistical error of v{6,QC} \r
2894 Double_t v8ErrorSquared = 0.; // squared statistical error of v{8,QC} \r
2895 \r
2896 // calculate squared statistical errors of integrated flow estimates:\r
2897 if(two > 0.) \r
2898 { \r
2899 v2ErrorSquared = (1./(4.*two))*pow(twoError,2.);\r
2900 } \r
2901 if(2.*pow(two,2.)-four > 0.)\r
2902 {\r
2903 v4ErrorSquared = (1./pow(2.*pow(two,2.)-four,3./2.))*\r
2904 (pow(two,2.)*pow(twoError,2.)+(1./16.)*pow(fourError,2.)-(1./2.)*two*wCov24);\r
2905 }\r
2906 if(six-9.*four*two+12.*pow(two,3.) > 0.) \r
2907 {\r
2908 v6ErrorSquared = ((1./2.)*(1./pow(2.,2./3.))*(1./pow(six-9.*four*two+12.*pow(two,3.),5./3.)))*\r
2909 ((9./2.)*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.) \r
2910 + (9./2.)*pow(two,2.)*pow(fourError,2.)+(1./18.)*pow(sixError,2.)\r
2911 - 9.*two*(4.*pow(two,2.)-four)*wCov24+(4.*pow(two,2.)-four)*wCov26-two*wCov46); \r
2912 }\r
2913 if(-1.*eight+16.*six*two+18.*pow(four,2.)-144.*four*pow(two,2.)+144.*pow(two,4.) > 0.) \r
2914 {\r
2915 v8ErrorSquared = (4./pow(33,1./4.))*(1./pow(-1.*eight+16.*six*two+18.*pow(four,2.)-144.*four*pow(two,2.)+144.*pow(two,4.),7./4.))*\r
2916 (pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)\r
2917 + (81./16.)*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)\r
2918 + pow(two,2.)*pow(sixError,2.)\r
2919 + (1./256.)*pow(eightError,2.)\r
2920 - (9./2.)*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24\r
2921 + 2.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26\r
2922 - (1./8.)*(36.*pow(two,3.)-18.*four*two+six)*wCov28 \r
2923 - (9./2.)*two*(4.*pow(two,2.)-four)*wCov46 \r
2924 + (9./32.)*(4.*pow(two,2.)-four)*wCov48 \r
2925 - (1./8.)*two*wCov68);\r
2926 } \r
2927\r
2928 // calculate statistical errors of integrated flow estimates: \r
2929 if(v2ErrorSquared > 0.)\r
2930 {\r
2931 v2Error = pow(v2ErrorSquared,0.5);\r
2932 } else\r
2933 {\r
2934 cout<<"WARNING: Statistical error of v{2,QC} is imaginary !!!!"<<endl;\r
2935 } \r
2936 if(v4ErrorSquared > 0.)\r
2937 {\r
2938 v4Error = pow(v4ErrorSquared,0.5);\r
2939 } else\r
2940 {\r
2941 cout<<"WARNING: Statistical error of v{4,QC} is imaginary !!!!"<<endl;\r
2942 } \r
2943 if(v6ErrorSquared > 0.)\r
2944 {\r
2945 v6Error = pow(v6ErrorSquared,0.5);\r
2946 } else\r
2947 {\r
2948 cout<<"WARNING: Statistical error of v{6,QC} is imaginary !!!!"<<endl;\r
2949 } \r
2950 if(v8ErrorSquared > 0.)\r
2951 {\r
2952 v8Error = pow(v8ErrorSquared,0.5);\r
2953 } else\r
2954 {\r
2955 cout<<"WARNING: Statistical error of v{8,QC} is imaginary !!!!"<<endl;\r
2956 } \r
2957 \r
2958 // store the results and statistical errors of integrated flow estimates:\r
2959 fIntFlow->SetBinContent(1,v2);\r
2960 fIntFlow->SetBinError(1,v2Error);\r
2961 fIntFlow->SetBinContent(2,v4);\r
2962 fIntFlow->SetBinError(2,v4Error);\r
2963 fIntFlow->SetBinContent(3,v6);\r
2964 fIntFlow->SetBinError(3,v6Error);\r
2965 fIntFlow->SetBinContent(4,v8);\r
2966 fIntFlow->SetBinError(4,v8Error);\r
2967 \r
2968} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlow()\r
2969\r
2970\r
2971//================================================================================================================================ \r
2972\r
2973\r
2974void AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()\r
2975{\r
2976 // Fill in AliFlowCommonHistResults histograms relevant for 'NONAME' integrated flow (to be improved (name))\r
2977 \r
2978 if(!fIntFlow)\r
2979 {\r
2980 cout<<"WARNING: fIntFlow is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
2981 exit(0); \r
2982 } \r
2983 \r
2984 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
2985 {\r
2986 cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl; \r
2987 cout<<" is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
2988 exit(0);\r
2989 }\r
2990 \r
2991 Double_t v2 = fIntFlow->GetBinContent(1);\r
2992 Double_t v4 = fIntFlow->GetBinContent(2);\r
2993 Double_t v6 = fIntFlow->GetBinContent(3);\r
2994 Double_t v8 = fIntFlow->GetBinContent(4);\r
2995 \r
2996 Double_t v2Error = fIntFlow->GetBinError(1);\r
2997 Double_t v4Error = fIntFlow->GetBinError(2);\r
2998 Double_t v6Error = fIntFlow->GetBinError(3);\r
2999 Double_t v8Error = fIntFlow->GetBinError(4);\r
3000 \r
3001 fCommonHistsResults2nd->FillIntegratedFlow(v2,v2Error); // to be improved (hardwired 2nd in the name) \r
3002 fCommonHistsResults4th->FillIntegratedFlow(v4,v4Error); // to be improved (hardwired 4th in the name)\r
3003 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (calculate also 6th and 8th order)\r
3004 {\r
3005 fCommonHistsResults6th->FillIntegratedFlow(v6,v6Error); // to be improved (hardwired 6th in the name)\r
3006 fCommonHistsResults8th->FillIntegratedFlow(v8,v8Error); // to be improved (hardwired 8th in the name) \r
3007 }\r
3008 \r
3009} // end of AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()\r
3010\r
3011\r
3012//================================================================================================================================ \r
3013\r
3014\r
3015/*\r
3016void AliFlowAnalysisWithQCumulants::ApplyCorrectionForNonUniformAcceptanceToCumulantsForIntFlow(Bool_t useParticleWeights, TString eventWeights)\r
3017{\r
3018 // apply correction for non-uniform acceptance to cumulants for integrated flow \r
3019 // (Remark: non-corrected cumulants are accessed from fCumulants[pW][0], corrected cumulants are stored in fCumulants[pW][1])\r
3020 \r
3021 // shortcuts for the flags:\r
3022 Int_t pW = (Int_t)(useParticleWeights); // 0=pWeights not used, 1=pWeights used\r
3023 Int_t eW = -1;\r
3024 \r
3025 if(eventWeights == "exact")\r
3026 {\r
3027 eW = 0;\r
3028 }\r
3029 \r
3030 if(!(fCumulants[pW][eW][0] && fCumulants[pW][eW][1] && fCorrections[pW][eW]))\r
3031 {\r
3032 cout<<"WARNING: fCumulants[pW][eW][0] && fCumulants[pW][eW][1] && fCorrections[pW][eW] is NULL in AFAWQC::ACFNUATCFIF() !!!!"<<endl;\r
3033 cout<<"pW = "<<pW<<endl;\r
3034 cout<<"eW = "<<eW<<endl;\r
3035 exit(0);\r
3036 } \r
3037 \r
3038 // non-corrected cumulants:\r
3039 Double_t qc2 = fCumulants[pW][eW][0]->GetBinContent(1); \r
3040 Double_t qc4 = fCumulants[pW][eW][0]->GetBinContent(2); \r
3041 Double_t qc6 = fCumulants[pW][eW][0]->GetBinContent(3); \r
3042 Double_t qc8 = fCumulants[pW][eW][0]->GetBinContent(4); \r
3043 // statistical error of non-corrected cumulants: \r
3044 Double_t qc2Error = fCumulants[pW][eW][0]->GetBinError(1); \r
3045 Double_t qc4Error = fCumulants[pW][eW][0]->GetBinError(2); \r
3046 Double_t qc6Error = fCumulants[pW][eW][0]->GetBinError(3); \r
3047 Double_t qc8Error = fCumulants[pW][eW][0]->GetBinError(4); \r
3048 // corrections for non-uniform acceptance:\r
3049 Double_t qc2Correction = fCorrections[pW][eW]->GetBinContent(1); \r
3050 Double_t qc4Correction = fCorrections[pW][eW]->GetBinContent(2); \r
3051 Double_t qc6Correction = fCorrections[pW][eW]->GetBinContent(3); \r
3052 Double_t qc8Correction = fCorrections[pW][eW]->GetBinContent(4); \r
3053 // corrected cumulants:\r
3054 Double_t qc2Corrected = qc2 + qc2Correction;\r
3055 Double_t qc4Corrected = qc4 + qc4Correction;\r
3056 Double_t qc6Corrected = qc6 + qc6Correction;\r
3057 Double_t qc8Corrected = qc8 + qc8Correction;\r
3058 \r
3059 // ... to be improved (I need here also to correct error of QCs for NUA. \r
3060 // For simplicity sake I assume at the moment that this correction is negliglible, but it will be added eventually...)\r
3061 \r
3062 // store corrected results and statistical errors for cumulants: \r
3063 fCumulants[pW][eW][1]->SetBinContent(1,qc2Corrected);\r
3064 fCumulants[pW][eW][1]->SetBinContent(2,qc4Corrected);\r
3065 fCumulants[pW][eW][1]->SetBinContent(3,qc6Corrected);\r
3066 fCumulants[pW][eW][1]->SetBinContent(4,qc8Corrected);\r
3067 fCumulants[pW][eW][1]->SetBinError(1,qc2Error); // to be improved (correct also qc2Error for NUA)\r
3068 fCumulants[pW][eW][1]->SetBinError(2,qc4Error); // to be improved (correct also qc4Error for NUA)\r
3069 fCumulants[pW][eW][1]->SetBinError(3,qc6Error); // to be improved (correct also qc6Error for NUA)\r
3070 fCumulants[pW][eW][1]->SetBinError(4,qc8Error); // to be improved (correct also qc8Error for NUA) \r
3071 \r
3072} // end of AliFlowAnalysisWithQCumulants::ApplyCorrectionForNonUniformAcceptanceToCumulantsForIntFlow(Bool_t useParticleWeights, TString eventWeights)\r
3073*/\r
3074\r
3075\r
3076//================================================================================================================================\r
3077\r
3078\r
3079/* \r
3080void AliFlowAnalysisWithQCumulants::PrintQuantifyingCorrectionsForNonUniformAcceptance(Bool_t useParticleWeights, TString eventWeights)\r
3081{\r
3082 // print on the screen QC{n,biased}/QC{n,corrected}\r
3083 \r
3084 // shortcuts for the flags:\r
3085 Int_t pW = (Int_t)(useParticleWeights); // 0=pWeights not used, 1=pWeights used\r
3086 \r
3087 Int_t eW = -1;\r
3088 \r
3089 if(eventWeights == "exact")\r
3090 {\r
3091 eW = 0;\r
3092 } \r
3093 \r
3094 if(!(fCumulants[pW][eW][0] && fCumulants[pW][eW][1]))\r
3095 {\r
3096 cout<<"WARNING: fCumulants[pW][eW][0] && fCumulants[pW][eW][1] is NULL in AFAWQC::PQCFNUA() !!!!"<<endl;\r
3097 cout<<"pW = "<<pW<<endl;\r
3098 cout<<"eW = "<<eW<<endl;\r
3099 exit(0);\r
3100 }\r
3101 \r
3102 cout<<endl;\r
3103 cout<<" Quantifying the bias to Q-cumulants from"<<endl;\r
3104 cout<<" non-uniform acceptance of the detector:"<<endl;\r
3105 cout<<endl;\r
3106 \r
3107 if(fCumulants[pW][eW][1]->GetBinContent(1)) \r
3108 { \r
3109 cout<<" QC{2,biased}/QC{2,corrected} = "<<(fCumulants[pW][eW][0]->GetBinContent(1))/(fCumulants[pW][eW][1]->GetBinContent(1))<<endl; \r
3110 }\r
3111 if(fCumulants[pW][eW][1]->GetBinContent(2)) \r
3112 { \r
3113 cout<<" QC{4,biased}/QC{4,corrected} = "<<fCumulants[pW][eW][0]->GetBinContent(2)/fCumulants[pW][eW][1]->GetBinContent(2)<<endl; \r
3114 }\r
3115 \r
3116 cout<<endl;\r
3117 \r
3118} // end of AliFlowAnalysisWithQCumulants::PrintQuantifyingCorrectionsForNonUniformAcceptance(Bool_t useParticleWeights, TString eventWeights)\r
3119*/\r
3120\r
3121\r
3122//================================================================================================================================\r
3123\r
3124\r
3125void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()\r
3126{\r
3127 // Calculate all correlations needed for integrated flow using particle weights.\r
3128 \r
3129 // Remark 1: When particle weights are used the binning of fIntFlowCorrelationAllPro is organized as follows:\r
3130 //\r
3131 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>\r
3132 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
3133 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))> \r
3134 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
3135 // 5th bin: ---- EMPTY ----\r
3136 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
3137 // 7th bin: <3>_{3n|2n,1n} = ...\r
3138 // 8th bin: <3>_{4n|2n,2n} = ...\r
3139 // 9th bin: <3>_{4n|3n,1n} = ...\r
3140 // 10th bin: ---- EMPTY ----\r
3141 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
3142 // 12th bin: <4>_{2n,1n|2n,1n} = ...\r
3143 // 13th bin: <4>_{2n,2n|2n,2n} = ...\r
3144 // 14th bin: <4>_{3n|1n,1n,1n} = ... \r
3145 // 15th bin: <4>_{3n,1n|3n,1n} = ...\r
3146 // 16th bin: <4>_{3n,1n|2n,2n} = ...\r
3147 // 17th bin: <4>_{4n|2n,1n,1n} = ... \r
3148 // 18th bin: ---- EMPTY ----\r
3149 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...\r
3150 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...\r
3151 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...\r
3152 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...\r
3153 // 23rd bin: ---- EMPTY ----\r
3154 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...\r
3155 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...\r
3156 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...\r
3157 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...\r
3158 // 28th bin: ---- EMPTY ----\r
3159 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...\r
3160 // 30th bin: ---- EMPTY ----\r
3161 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...\r
3162 \r
3163 // Remark 2: When particle weights are used there are some extra correlations. They are stored in \r
3164 // fIntFlowExtraCorrelationsPro binning of which is organized as follows:\r
3165 \r
3166 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>\r
3167 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))> \r
3168 // ...\r
3169 \r
3170 // multiplicity (number of particles used to determine the reaction plane)\r
3171 Double_t dMult = (*fSMpk)(0,0);\r
3172 \r
3173 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3174 Double_t dReQ1n1k = (*fReQ)(0,1);\r
3175 Double_t dReQ2n2k = (*fReQ)(1,2);\r
3176 Double_t dReQ3n3k = (*fReQ)(2,3);\r
3177 Double_t dReQ4n4k = (*fReQ)(3,4);\r
3178 Double_t dReQ1n3k = (*fReQ)(0,3);\r
3179 Double_t dImQ1n1k = (*fImQ)(0,1);\r
3180 Double_t dImQ2n2k = (*fImQ)(1,2);\r
3181 Double_t dImQ3n3k = (*fImQ)(2,3);\r
3182 Double_t dImQ4n4k = (*fImQ)(3,4);\r
3183 Double_t dImQ1n3k = (*fImQ)(0,3);\r
3184\r
3185 // dMs are variables introduced in order to simplify some Eqs. bellow:\r
3186 //..............................................................................................\r
3187 Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
3188 Double_t dM22 = (*fSMpk)(1,2)-(*fSMpk)(0,4); // dM22 = sum_{i,j=1,i!=j}^M w_i^2 w_j^2\r
3189 Double_t dM33 = (*fSMpk)(1,3)-(*fSMpk)(0,6); // dM33 = sum_{i,j=1,i!=j}^M w_i^3 w_j^3\r
3190 Double_t dM44 = (*fSMpk)(1,4)-(*fSMpk)(0,8); // dM44 = sum_{i,j=1,i!=j}^M w_i^4 w_j^4\r
3191 Double_t dM31 = (*fSMpk)(0,3)*(*fSMpk)(0,1)-(*fSMpk)(0,4); // dM31 = sum_{i,j=1,i!=j}^M w_i^3 w_j\r
3192 Double_t dM211 = (*fSMpk)(0,2)*(*fSMpk)(1,1)-2.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3193 - (*fSMpk)(1,2)+2.*(*fSMpk)(0,4); // dM211 = sum_{i,j,k=1,i!=j!=k}^M w_i^2 w_j w_k\r
3194 Double_t dM1111 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1) \r
3195 + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3196 + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
3197 //..............................................................................................\r
3198\r
3199 // 2-particle correlations:\r
3200 Double_t two1n1nW1W1 = 0.; // <w1 w2 cos(n*(phi1-phi2))>\r
3201 Double_t two2n2nW2W2 = 0.; // <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
3202 Double_t two3n3nW3W3 = 0.; // <w1^3 w2^3 cos(3n*(phi1-phi2))>\r
3203 Double_t two4n4nW4W4 = 0.; // <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
3204 if(dMult>1) \r
3205 { \r
3206 if(dM11)\r
3207 {\r
3208 two1n1nW1W1 = (pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSMpk)(0,2))/dM11; \r
3209 // average correlation <w1 w2 cos(n*(phi1-phi2))> for single event: \r
3210 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1nW1W1);\r
3211 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,dM11);\r
3212 // average correlation <w1 w2 cos(n*(phi1-phi2))> for all events:\r
3213 fIntFlowCorrelationsPro->Fill(0.5,two1n1nW1W1,dM11); \r
3214 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1nW1W1,dM11); \r
3215 }\r
3216 if(dM22)\r
3217 {\r
3218 two2n2nW2W2 = (pow(dReQ2n2k,2)+pow(dImQ2n2k,2)-(*fSMpk)(0,4))/dM22; \r
3219 // ...\r
3220 // average correlation <w1^2 w2^2 cos(2n*(phi1-phi2))> for all events:\r
3221 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2nW2W2,dM22); \r
3222 }\r
3223 if(dM33)\r
3224 {\r
3225 two3n3nW3W3 = (pow(dReQ3n3k,2)+pow(dImQ3n3k,2)-(*fSMpk)(0,6))/dM33;\r
3226 // ...\r
3227 // average correlation <w1^3 w2^3 cos(3n*(phi1-phi2))> for all events:\r
3228 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3nW3W3,dM33); \r
3229 }\r
3230 if(dM44)\r
3231 {\r
3232 two4n4nW4W4 = (pow(dReQ4n4k,2)+pow(dImQ4n4k,2)-(*fSMpk)(0,8))/dM44; \r
3233 // ...\r
3234 // average correlation <w1^4 w2^4 cos(4n*(phi1-phi2))> for all events:\r
3235 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4nW4W4,dM44); \r
3236 }\r
3237 } // end of if(dMult>1) \r
3238\r
3239 // extra 2-particle correlations:\r
3240 Double_t two1n1nW3W1 = 0.; // <w1^3 w2 cos(n*(phi1-phi2))>\r
3241 Double_t two1n1nW1W1W2 = 0.; // <w1 w2 w3^2 cos(n*(phi1-phi2))> \r
3242 if(dMult>1) \r
3243 { \r
3244 if(dM31)\r
3245 {\r
3246 two1n1nW3W1 = (dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k-(*fSMpk)(0,4))/dM31; \r
3247 fIntFlowExtraCorrelationsPro->Fill(0.5,two1n1nW3W1,dM31); \r
3248 } \r
3249 if(dM211)\r
3250 {\r
3251 two1n1nW1W1W2 = ((*fSMpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSMpk)(0,2))\r
3252 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k\r
3253 - (*fSMpk)(0,4)))/dM211;\r
3254 fIntFlowExtraCorrelationsPro->Fill(1.5,two1n1nW1W1W2,dM211); \r
3255 } \r
3256 } // end of if(dMult>1)\r
3257 //..............................................................................................\r
3258 \r
3259 //..............................................................................................\r
3260 // 3-particle correlations:\r
3261 Double_t three2n1n1nW2W1W1 = 0.; // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
3262 \r
3263 if(dMult>2) \r
3264 { \r
3265 if(dM211)\r
3266 { \r
3267 three2n1n1nW2W1W1 = (pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k\r
3268 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)\r
3269 - pow(dReQ2n2k,2)-pow(dImQ2n2k,2)\r
3270 + 2.*(*fSMpk)(0,4))/dM211; \r
3271 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1nW2W1W1,dM211);\r
3272 } \r
3273 } // end of if(dMult>2) \r
3274 //..............................................................................................\r
3275 \r
3276 //..............................................................................................\r
3277 // 4-particle correlations:\r
3278 Double_t four1n1n1n1nW1W1W1W1 = 0.; // <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
3279 if(dMult>3) \r
3280 { \r
3281 if(dM1111)\r
3282 { \r
3283 four1n1n1n1nW1W1W1W1 = (pow(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.),2)\r
3284 - 2.*(pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k)\r
3285 + 8.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)\r
3286 + (pow(dReQ2n2k,2)+pow(dImQ2n2k,2))\r
3287 - 4.*(*fSMpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))\r
3288 - 6.*(*fSMpk)(0,4)+2.*(*fSMpk)(1,2))/dM1111; \r
3289 \r
3290 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for single event: \r
3291 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1nW1W1W1W1);\r
3292 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,dM1111);\r
3293 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:\r
3294 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1,dM1111); \r
3295 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1nW1W1W1W1,dM1111); \r
3296 } \r
3297 } // end of if(dMult>3) \r
3298 //..............................................................................................\r
3299 \r
3300} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()\r
3301\r
3302\r
3303//================================================================================================================================\r
3304\r
3305\r
3306void AliFlowAnalysisWithQCumulants::CalculateWeightedQProductsForIntFlow() // to be improved (completed)\r
3307{\r
3308 // calculate averages like <<2><4>>, <<2><6>>, <<4><6>>, etc. which are needed to calculate covariances \r
3309 // Remark: here we take weighted correlations!\r
3310 \r
3311 /*\r
3312 \r
3313 // binning of fQProductsW is organized as follows:\r
3314 // \r
3315 // 1st bin: <2><4> \r
3316 // 2nd bin: <2><6>\r
3317 // 3rd bin: <2><8>\r
3318 // 4th bin: <4><6>\r
3319 // 5th bin: <4><8>\r
3320 // 6th bin: <6><8>\r
3321 \r
3322 Double_t dMult = (*fSMpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)\r
3323\r
3324 Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
3325 Double_t dM1111 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1) \r
3326 + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3327 + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
3328\r
3329 Double_t twoEBEW = 0.; // <2>\r
3330 Double_t fourEBEW = 0.; // <4>\r
3331 \r
3332 twoEBEW = fQCorrelationsEBE[1]->GetBinContent(1);\r
3333 fourEBEW = fQCorrelationsEBE[1]->GetBinContent(11);\r
3334 \r
3335 // <2><4>\r
3336 if(dMult>3)\r
3337 {\r
3338 fQProducts[1][0]->Fill(0.5,twoEBEW*fourEBEW,dM11*dM1111);\r
3339 }\r
3340 \r
3341 */\r
3342 \r
3343} // end of AliFlowAnalysisWithQCumulants::CalculateWeightedQProductsForIntFlow() \r
3344\r
3345\r
3346//================================================================================================================================\r
3347\r
3348\r
3349void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()\r
3350{\r
3351 // Initialize all arrays used to calculate integrated flow.\r
3352 \r
3353 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3354 {\r
3355 fIntFlowCorrectionTermsForNUAEBE[sc] = NULL;\r
3356 fIntFlowCorrectionTermsForNUAPro[sc] = NULL;\r
3357 fIntFlowCorrectionTermsForNUAHist[sc] = NULL;\r
3358 }\r
3359 \r
3360 for(Int_t power=0;power<2;power++) // linear or quadratic \r
3361 {\r
3362 fIntFlowSumOfEventWeights[power] = NULL; \r
3363 }\r
3364 \r
3365} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()\r
3366\r
3367\r
3368//================================================================================================================================\r
3369\r
3370\r
3371void AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()\r
3372{\r
3373 // Initialize all arrays needed to calculate differential flow.\r
3374 // a) Initialize lists holding profiles;\r
3375 // b) Initialize lists holding histograms;\r
3376 // c) Initialize event-by-event quantities;\r
3377 // d) Initialize profiles;\r
3378 // e) Initialize histograms holding final results.\r
3379 \r
3380 // a) Initialize lists holding profiles;\r
3381 for(Int_t t=0;t<2;t++) // type (RP, POI)\r
3382 {\r
3383 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3384 {\r
3385 fDiffFlowCorrelationsProList[t][pe] = NULL;\r
3386 fDiffFlowProductOfCorrelationsProList[t][pe] = NULL;\r
3387 fDiffFlowCorrectionsProList[t][pe] = NULL;\r
3388 }\r
3389 } \r
3390 \r
3391 // b) Initialize lists holding histograms;\r
3392 for(Int_t t=0;t<2;t++) // type (RP, POI)\r
3393 {\r
3394 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3395 {\r
3396 fDiffFlowCorrelationsHistList[t][pe] = NULL;\r
3397 for(Int_t power=0;power<2;power++)\r
3398 {\r
3399 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = NULL;\r
3400 } // end of for(Int_t power=0;power<2;power++) \r
3401 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = NULL;\r
3402 fDiffFlowCorrectionsHistList[t][pe] = NULL;\r
3403 fDiffFlowCovariancesHistList[t][pe] = NULL;\r
3404 fDiffFlowCumulantsHistList[t][pe] = NULL;\r
3405 fDiffFlowHistList[t][pe] = NULL;\r
3406 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3407 } // enf of for(Int_t t=0;t<2;t++) // type (RP, POI) \r
3408 \r
3409 // c) Initialize event-by-event quantities:\r
3410 // 1D:\r
3411 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
3412 {\r
3413 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3414 { \r
3415 for(Int_t m=0;m<4;m++) // multiple of harmonic\r
3416 {\r
3417 for(Int_t k=0;k<9;k++) // power of weight\r
3418 {\r
3419 fReRPQ1dEBE[t][pe][m][k] = NULL;\r
3420 fImRPQ1dEBE[t][pe][m][k] = NULL;\r
3421 fs1dEBE[t][pe][k] = NULL; // to be improved (this doesn't need to be within loop over m)\r
3422 } \r
3423 }\r
3424 }\r
3425 }\r
3426 // 1D:\r
3427 for(Int_t t=0;t<2;t++) // type (RP or POI)\r
3428 {\r
3429 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3430 { \r
3431 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3432 {\r
3433 for(Int_t cti=0;cti<9;cti++) // correction term index\r
3434 {\r
3435 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = NULL;\r
3436 } \r
3437 }\r
3438 }\r
3439 }\r
3440 // 2D: \r
3441 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
3442 {\r
3443 for(Int_t m=0;m<4;m++) // multiple of harmonic\r
3444 {\r
3445 for(Int_t k=0;k<9;k++) // power of weight\r
3446 {\r
3447 fReRPQ2dEBE[t][m][k] = NULL;\r
3448 fImRPQ2dEBE[t][m][k] = NULL;\r
3449 fs2dEBE[t][k] = NULL; // to be improved (this doesn't need to be within loop over m)\r
3450 } \r
3451 }\r
3452 }\r
3453 \r
3454 // d) Initialize profiles:\r
3455 for(Int_t t=0;t<2;t++) // type: RP or POI\r
3456 { \r
3457 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3458 {\r
3459 for(Int_t ci=0;ci<4;ci++) // correlation index\r
3460 {\r
3461 fDiffFlowCorrelationsPro[t][pe][ci] = NULL;\r
3462 } // end of for(Int_t ci=0;ci<4;ci++) \r
3463 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
3464 {\r
3465 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3466 {\r
3467 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = NULL;\r
3468 } // end of for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3469 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index \r
3470 // correction terms for nua:\r
3471 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3472 {\r
3473 for(Int_t cti=0;cti<9;cti++) // correction term index\r
3474 {\r
3475 fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = NULL;\r
3476 } \r
3477 }\r
3478 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3479 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
3480 \r
3481 // e) Initialize histograms holding final results.\r
3482 for(Int_t t=0;t<2;t++) // type: RP or POI\r
3483 { \r
3484 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3485 {\r
3486 for(Int_t ci=0;ci<4;ci++) // correlation index\r
3487 {\r
3488 fDiffFlowCorrelationsHist[t][pe][ci] = NULL;\r
3489 fDiffFlowCumulants[t][pe][ci] = NULL;\r
3490 fDiffFlow[t][pe][ci] = NULL;\r
3491 } // end of for(Int_t ci=0;ci<4;ci++) \r
3492 for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++) \r
3493 {\r
3494 fDiffFlowCovariances[t][pe][covarianceIndex] = NULL; \r
3495 } // end of for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++) \r
3496 // correction terms for nua:\r
3497 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3498 {\r
3499 for(Int_t cti=0;cti<9;cti++) // correction term index\r
3500 {\r
3501 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = NULL;\r
3502 } \r
3503 }\r
3504 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3505 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
3506 \r
3507 // sum of event weights for reduced correlations:\r
3508 for(Int_t t=0;t<2;t++) // type = RP or POI\r
3509 {\r
3510 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3511 {\r
3512 for(Int_t p=0;p<2;p++) // power of weight is 1 or 2\r
3513 {\r
3514 for(Int_t ew=0;ew<4;ew++) // event weight index for reduced correlations\r
3515 {\r
3516 fDiffFlowSumOfEventWeights[t][pe][p][ew] = NULL;\r
3517 } \r
3518 } \r
3519 }\r
3520 }\r
3521 // product of event weights for both types of correlations:\r
3522 for(Int_t t=0;t<2;t++) // type = RP or POI\r
3523 {\r
3524 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3525 {\r
3526 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
3527 {\r
3528 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3529 {\r
3530 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = NULL;\r
3531 } \r
3532 } \r
3533 }\r
3534 }\r
3535\r
3536 \r
3537 \r
3538 \r
3539 /*\r
3540 \r
3541 // nested lists in fDiffFlowProfiles:\r
3542 for(Int_t t=0;t<2;t++)\r
3543 {\r
3544 fDFPType[t] = NULL;\r
3545 for(Int_t pW=0;pW<2;pW++) // particle weights not used (0) or used (1)\r
3546 {\r
3547 fDFPParticleWeights[t][pW] = NULL;\r
3548 for(Int_t eW=0;eW<2;eW++)\r
3549 { \r
3550 fDFPEventWeights[t][pW][eW] = NULL;\r
3551 fDiffFlowCorrelations[t][pW][eW] = NULL;\r
3552 fDiffFlowProductsOfCorrelations[t][pW][eW] = NULL;\r
3553 for(Int_t sc=0;sc<2;sc++)\r
3554 {\r
3555 fDiffFlowCorrectionTerms[t][pW][eW][sc] = NULL;\r
3556 }\r
3557 } \r
3558 }\r
3559 } \r
3560 \r
3561 \r
3562 */\r
3563 \r
3564 \r
3565 \r
3566 /*\r
3567 for(Int_t pW=0;pW<2;pW++) // particle weights not used (0) or used (1)\r
3568 {\r
3569 for(Int_t eW=0;eW<2;eW++)\r
3570 {\r
3571 // correlations:\r
3572 for(Int_t correlationIndex=0;correlationIndex<4;correlationIndex++)\r
3573 {\r
3574 fCorrelationsPro[t][pW][eW][correlationIndex] = NULL;\r
3575 }\r
3576 // products of correlations:\r
3577 for(Int_t productOfCorrelationsIndex=0;productOfCorrelationsIndex<6;productOfCorrelationsIndex++)\r
3578 {\r
3579 fProductsOfCorrelationsPro[t][pW][eW][productOfCorrelationsIndex] = NULL;\r
3580 }\r
3581 // correction terms:\r
3582 for(Int_t sc=0;sc<2;sc++)\r
3583 {\r
3584 for(Int_t correctionsIndex=0;correctionsIndex<2;correctionsIndex++)\r
3585 {\r
3586 fCorrectionTermsPro[t][pW][eW][sc][correctionsIndex] = NULL;\r
3587 } \r
3588 } \r
3589 }\r
3590 } \r
3591 */\r
3592 \r
3593} // end of AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()\r
3594\r
3595\r
3596//================================================================================================================================\r
3597 /*\r
3598\r
3599\r
3600void AliFlowAnalysisWithQCumulants::CalculateCorrelationsForDifferentialFlow2D(TString type)\r
3601{\r
3602 // calculate all reduced correlations needed for differential flow for each (pt,eta) bin: \r
3603 \r
3604 if(type == "RP") // to be improved (removed)\r
3605 {\r
3606 cout<<endl;\r
3607 }\r
3608 // ... \r
3609 \r
3610 \r
3611 Int_t typeFlag = -1; \r
3612 \r
3613 // reduced correlations ares stored in fCorrelationsPro[t][pW][index] and are indexed as follows:\r
3614 // index:\r
3615 // 0: <2'>\r
3616 // 1: <4'>\r
3617\r
3618 // multiplicity:\r
3619 Double_t dMult = (*fSMpk)(0,0);\r
3620 \r
3621 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3622 Double_t dReQ1n = (*fReQ)(0,0);\r
3623 Double_t dReQ2n = (*fReQ)(1,0);\r
3624 //Double_t dReQ3n = (*fReQ)(2,0);\r
3625 //Double_t dReQ4n = (*fReQ)(3,0);\r
3626 Double_t dImQ1n = (*fImQ)(0,0);\r
3627 Double_t dImQ2n = (*fImQ)(1,0);\r
3628 //Double_t dImQ3n = (*fImQ)(2,0);\r
3629 //Double_t dImQ4n = (*fImQ)(3,0);\r
3630\r
3631 // looping over all (pt,eta) bins and calculating correlations needed for differential flow: \r
3632 for(Int_t p=1;p<=fnBinsPt;p++)\r
3633 {\r
3634 for(Int_t e=1;e<=fnBinsEta;e++)\r
3635 {\r
3636 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin): \r
3637 Double_t p1n0kRe = 0.;\r
3638 Double_t p1n0kIm = 0.;\r
3639\r
3640 // number of POIs in particular (pt,eta) bin:\r
3641 Double_t mp = 0.;\r
3642\r
3643 // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin):\r
3644 Double_t q1n0kRe = 0.;\r
3645 Double_t q1n0kIm = 0.;\r
3646 Double_t q2n0kRe = 0.;\r
3647 Double_t q2n0kIm = 0.;\r
3648\r
3649 // number of particles which are both RPs and POIs in particular (pt,eta) bin:\r
3650 Double_t mq = 0.;\r
3651 \r
3652 // q_{m*n,0}:\r
3653 q1n0kRe = fReEBE2D[2][0][0]->GetBinContent(fReEBE2D[2][0][0]->GetBin(p,e))\r
3654 * fReEBE2D[2][0][0]->GetBinEntries(fReEBE2D[2][0][0]->GetBin(p,e));\r
3655 q1n0kIm = fImEBE2D[2][0][0]->GetBinContent(fImEBE2D[2][0][0]->GetBin(p,e))\r
3656 * fImEBE2D[2][0][0]->GetBinEntries(fImEBE2D[2][0][0]->GetBin(p,e));\r
3657 q2n0kRe = fReEBE2D[2][1][0]->GetBinContent(fReEBE2D[2][1][0]->GetBin(p,e))\r
3658 * fReEBE2D[2][1][0]->GetBinEntries(fReEBE2D[2][1][0]->GetBin(p,e));\r
3659 q2n0kIm = fImEBE2D[2][1][0]->GetBinContent(fImEBE2D[2][1][0]->GetBin(p,e))\r
3660 * fImEBE2D[2][1][0]->GetBinEntries(fImEBE2D[2][1][0]->GetBin(p,e));\r
3661 \r
3662 mq = fReEBE2D[2][0][0]->GetBinEntries(fReEBE2D[2][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)\r
3663 \r
3664 if(type == "POI")\r
3665 {\r
3666 // p_{m*n,0}:\r
3667 p1n0kRe = fReEBE2D[1][0][0]->GetBinContent(fReEBE2D[1][0][0]->GetBin(p,e))\r
3668 * fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3669 p1n0kIm = fImEBE2D[1][0][0]->GetBinContent(fImEBE2D[1][0][0]->GetBin(p,e)) \r
3670 * fImEBE2D[1][0][0]->GetBinEntries(fImEBE2D[1][0][0]->GetBin(p,e));\r
3671 \r
3672 mp = fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)\r
3673 \r
3674 typeFlag = 1;\r
3675 }\r
3676 else if(type == "RP")\r
3677 {\r
3678 // p_{m*n,0} = q_{m*n,0}:\r
3679 p1n0kRe = q1n0kRe; \r
3680 p1n0kIm = q1n0kIm; \r
3681 mp = mq; \r
3682 \r
3683 typeFlag = 0;\r
3684 }\r
3685 \r
3686 // count events with non-empty (pt,eta) bin:\r
3687 if(mp>0)\r
3688 {\r
3689 fNonEmptyBins2D[typeFlag]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,1);\r
3690 }\r
3691 \r
3692 // 2'-particle correlation for particular (pt,eta) bin:\r
3693 Double_t two1n1nPtEta = 0.;\r
3694 if(mp*dMult-mq)\r
3695 {\r
3696 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)\r
3697 / (mp*dMult-mq);\r
3698 \r
3699 // fill the 2D profile to get the average correlation for each (pt,eta) bin:\r
3700 if(type == "POI")\r
3701 { \r
3702 //f2pPtEtaPOI->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3703 \r
3704 fCorrelationsPro[1][0][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3705 }\r
3706 else if(type == "RP")\r
3707 {\r
3708 //f2pPtEtaRP->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq); \r
3709 fCorrelationsPro[0][0][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3710 }\r
3711 } // end of if(mp*dMult-mq)\r
3712 \r
3713 // 4'-particle correlation:\r
3714 Double_t four1n1n1n1nPtEta = 0.;\r
3715 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3716 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)\r
3717 {\r
3718 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
3719 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))\r
3720 - 2.*q2n0kIm*dReQ1n*dImQ1n\r
3721 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)\r
3722 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)\r
3723 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
3724 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq \r
3725 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n) \r
3726 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n) \r
3727 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n) \r
3728 + 2.*mq*dMult \r
3729 - 6.*mq) \r
3730 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3731 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
3732 \r
3733 // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3734 if(type == "POI")\r
3735 {\r
3736 //f4pPtEtaPOI->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3737 // (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3738 // + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
3739 \r
3740 fCorrelationsPro[1][0][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3741 (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3742 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
3743 }\r
3744 else if(type == "RP")\r
3745 {\r
3746 //f4pPtEtaRP->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3747 // (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3748 // + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
3749 \r
3750 fCorrelationsPro[0][0][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3751 (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3752 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
3753 }\r
3754 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3755 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
3756 \r
3757 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
3758 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
3759\r
3760 \r
3761 \r
3762 \r
3763 \r
3764} // end of AliFlowAnalysisWithQCumulants::CalculateCorrelationsForDifferentialFlow2D()\r
3765\r
3766\r
3767\r
3768 \r
3769 \r
3770\r
3771//================================================================================================================================\r
3772\r
3773\r
3774void AliFlowAnalysisWithQCumulants::CalculateWeightedCorrelationsForDifferentialFlow2D(TString type)\r
3775{\r
3776 // calculate all weighted correlations needed for differential flow \r
3777 \r
3778 if(type == "RP") // to be improved (removed)\r
3779 {\r
3780 cout<<endl;\r
3781 }\r
3782 // ... \r
3783 \r
3784 \r
3785 \r
3786 \r
3787 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3788 Double_t dReQ1n1k = (*fReQ)(0,1);\r
3789 Double_t dReQ2n2k = (*fReQ)(1,2);\r
3790 Double_t dReQ1n3k = (*fReQ)(0,3);\r
3791 //Double_t dReQ4n4k = (*fReQ)(3,4);\r
3792 Double_t dImQ1n1k = (*fImQ)(0,1);\r
3793 Double_t dImQ2n2k = (*fImQ)(1,2);\r
3794 Double_t dImQ1n3k = (*fImQ)(0,3);\r
3795 //Double_t dImQ4n4k = (*fImQ)(3,4);\r
3796 \r
3797 // S^M_{p,k} (see .h file for the definition of fSMpk):\r
3798 Double_t dSM1p1k = (*fSMpk)(0,1);\r
3799 Double_t dSM1p2k = (*fSMpk)(0,2);\r
3800 Double_t dSM1p3k = (*fSMpk)(0,3);\r
3801 Double_t dSM2p1k = (*fSMpk)(1,1);\r
3802 Double_t dSM3p1k = (*fSMpk)(2,1);\r
3803 \r
3804 // looping over all (pt,eta) bins and calculating weighted correlations needed for differential flow: \r
3805 for(Int_t p=1;p<=fnBinsPt;p++)\r
3806 {\r
3807 for(Int_t e=1;e<=fnBinsEta;e++)\r
3808 {\r
3809 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin): \r
3810 Double_t p1n0kRe = 0.;\r
3811 Double_t p1n0kIm = 0.;\r
3812\r
3813 // number of POIs in particular (pt,eta) bin):\r
3814 Double_t mp = 0.;\r
3815\r
3816 // real and imaginary parts of q_{m*n,k}: \r
3817 // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)\r
3818 Double_t q1n2kRe = 0.;\r
3819 Double_t q1n2kIm = 0.;\r
3820 Double_t q2n1kRe = 0.;\r
3821 Double_t q2n1kIm = 0.;\r
3822\r
3823 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
3824 Double_t s1p1k = 0.; \r
3825 Double_t s1p2k = 0.; \r
3826 Double_t s1p3k = 0.; \r
3827 \r
3828 // M0111 from Eq. (118) in QC2c (to be improved (notation))\r
3829 Double_t dM0111 = 0.;\r
3830 \r
3831 if(type == "POI")\r
3832 {\r
3833 // p_{m*n,0}:\r
3834 p1n0kRe = fReEBE2D[1][0][0]->GetBinContent(fReEBE2D[1][0][0]->GetBin(p,e))\r
3835 * fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3836 p1n0kIm = fImEBE2D[1][0][0]->GetBinContent(fImEBE2D[1][0][0]->GetBin(p,e))\r
3837 * fImEBE2D[1][0][0]->GetBinEntries(fImEBE2D[1][0][0]->GetBin(p,e)); \r
3838 \r
3839 mp = fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3840 \r
3841 // q_{m*n,k}: \r
3842 q1n2kRe = fReEBE2D[2][0][2]->GetBinContent(fReEBE2D[2][0][2]->GetBin(p,e))\r
3843 * fReEBE2D[2][0][2]->GetBinEntries(fReEBE2D[2][0][2]->GetBin(p,e));\r
3844 q1n2kIm = fImEBE2D[2][0][2]->GetBinContent(fImEBE2D[2][0][2]->GetBin(p,e))\r
3845 * fImEBE2D[2][0][2]->GetBinEntries(fImEBE2D[2][0][2]->GetBin(p,e));\r
3846 q2n1kRe = fReEBE2D[2][1][1]->GetBinContent(fReEBE2D[2][1][1]->GetBin(p,e))\r
3847 * fReEBE2D[2][1][1]->GetBinEntries(fReEBE2D[2][1][1]->GetBin(p,e)); \r
3848 q2n1kIm = fImEBE2D[2][1][1]->GetBinContent(fImEBE2D[2][1][1]->GetBin(p,e))\r
3849 * fImEBE2D[2][1][1]->GetBinEntries(fImEBE2D[2][1][1]->GetBin(p,e));\r
3850 \r
3851 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
3852 s1p1k = pow(fs2D[2][1]->GetBinContent(fs2D[2][1]->GetBin(p,e)),1.); \r
3853 s1p2k = pow(fs2D[2][2]->GetBinContent(fs2D[2][2]->GetBin(p,e)),1.); \r
3854 s1p3k = pow(fs2D[2][3]->GetBinContent(fs2D[2][3]->GetBin(p,e)),1.); \r
3855 \r
3856 // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
3857 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
3858 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
3859 + 2.*(s1p3k-s1p2k*dSM1p1k));\r
3860 }\r
3861 else if(type == "RP")\r
3862 {\r
3863 p1n0kRe = fReEBE2D[0][0][0]->GetBinContent(fReEBE2D[0][0][0]->GetBin(p,e))\r
3864 * fReEBE2D[0][0][0]->GetBinEntries(fReEBE2D[0][0][0]->GetBin(p,e));\r
3865 p1n0kIm = fImEBE2D[0][0][0]->GetBinContent(fImEBE2D[0][0][0]->GetBin(p,e))\r
3866 * fImEBE2D[0][0][0]->GetBinEntries(fImEBE2D[0][0][0]->GetBin(p,e));\r
3867 \r
3868 mp = fReEBE2D[0][0][0]->GetBinEntries(fReEBE2D[0][0][0]->GetBin(p,e));\r
3869 \r
3870 // q_{m*n,k}: \r
3871 q1n2kRe = fReEBE2D[0][0][2]->GetBinContent(fReEBE2D[0][0][2]->GetBin(p,e))\r
3872 * fReEBE2D[0][0][2]->GetBinEntries(fReEBE2D[0][0][2]->GetBin(p,e));\r
3873 q1n2kIm = fImEBE2D[0][0][2]->GetBinContent(fImEBE2D[0][0][2]->GetBin(p,e))\r
3874 * fImEBE2D[0][0][2]->GetBinEntries(fImEBE2D[0][0][2]->GetBin(p,e));\r
3875 q2n1kRe = fReEBE2D[0][1][1]->GetBinContent(fReEBE2D[0][1][1]->GetBin(p,e))\r
3876 * fReEBE2D[0][1][1]->GetBinEntries(fReEBE2D[0][1][1]->GetBin(p,e));\r
3877 q2n1kIm = fImEBE2D[0][1][1]->GetBinContent(fImEBE2D[0][1][1]->GetBin(p,e))\r
3878 * fImEBE2D[0][1][1]->GetBinEntries(fImEBE2D[0][1][1]->GetBin(p,e));\r
3879 \r
3880 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
3881 s1p1k = pow(fs2D[0][1]->GetBinContent(fs2D[0][1]->GetBin(p,e)),1.); \r
3882 s1p2k = pow(fs2D[0][2]->GetBinContent(fs2D[0][2]->GetBin(p,e)),1.); \r
3883 s1p3k = pow(fs2D[0][3]->GetBinContent(fs2D[0][3]->GetBin(p,e)),1.); \r
3884 \r
3885 // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
3886 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
3887 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
3888 + 2.*(s1p3k-s1p2k*dSM1p1k));\r
3889 //............................................................................................... \r
3890 }\r
3891 \r
3892 // 2'-particle correlation:\r
3893 Double_t two1n1nW0W1PtEta = 0.;\r
3894 if(mp*dSM1p1k-s1p1k)\r
3895 {\r
3896 two1n1nW0W1PtEta = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)\r
3897 / (mp*dSM1p1k-s1p1k);\r
3898 \r
3899 // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3900 if(type == "POI")\r
3901 {\r
3902 //f2pPtEtaPOIW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,\r
3903 // mp*dSM1p1k-s1p1k);\r
3904 fCorrelationsPro[1][1][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,mp*dSM1p1k-s1p1k);\r
3905 }\r
3906 else if(type == "RP")\r
3907 {\r
3908 //f2pPtEtaRPW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,\r
3909 // mp*dSM1p1k-s1p1k); \r
3910 fCorrelationsPro[0][1][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,mp*dSM1p1k-s1p1k); \r
3911 }\r
3912 } // end of if(mp*dMult-dmPrimePrimePtEta)\r
3913 \r
3914 // 4'-particle correlation:\r
3915 Double_t four1n1n1n1nW0W1W1W1PtEta = 0.;\r
3916 if(dM0111)\r
3917 {\r
3918 four1n1n1n1nW0W1W1W1PtEta = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
3919 - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))\r
3920 - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k\r
3921 - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)\r
3922 + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)\r
3923 - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
3924 - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k \r
3925 + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k) \r
3926 + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k) \r
3927 + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k) \r
3928 + 2.*s1p1k*dSM1p2k \r
3929 - 6.*s1p3k) \r
3930 / dM0111; // to be imropoved (notation of dM0111)\r
3931 \r
3932 // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3933 if(type == "POI")\r
3934 {\r
3935 //f4pPtEtaPOIW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111);\r
3936 fCorrelationsPro[1][1][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111);\r
3937 }\r
3938 else if(type == "RP")\r
3939 {\r
3940 //f4pPtEtaRPW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111); \r
3941 fCorrelationsPro[0][1][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111); \r
3942 }\r
3943 } // end of if(dM0111)\r
3944 \r
3945 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
3946 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
3947 \r
3948 \r
3949 \r
3950 \r
3951} // end of AliFlowAnalysisWithQCumulants::CalculateWeightedCorrelationsForDifferentialFlow2D(TString type)\r
3952\r
3953\r
3954//================================================================================================================================\r
3955\r
3956 */ \r
3957\r
3958/*\r
3959void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsForDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights)\r
3960{\r
3961 // 1.) Access average for 2D correlations from profiles and store them in 2D final results histograms;\r
3962 // 2.) Access spread for 2D correlations from profiles, calculate error and store it in 2D final results histograms;\r
3963 // 3.) Make projections along pt and eta axis and store results and errors in 1D final results histograms. \r
3964 \r
3965 Int_t typeFlag = -1;\r
3966 Int_t pWeightsFlag = -1;\r
3967 Int_t eWeightsFlag = -1;\r
3968\r
3969 if(type == "RP")\r
3970 {\r
3971 typeFlag = 0;\r
3972 } else if(type == "POI")\r
3973 {\r
3974 typeFlag = 1;\r
3975 } else \r
3976 {\r
3977 cout<<"WARNING: type must be either RP or POI in AFAWQC::FCFDF() !!!!"<<endl;\r
3978 exit(0);\r
3979 }\r
3980 \r
3981 if(!useParticleWeights)\r
3982 {\r
3983 pWeightsFlag = 0;\r
3984 } else \r
3985 {\r
3986 pWeightsFlag = 1; \r
3987 } \r
3988 \r
3989 if(eventWeights == "exact")\r
3990 {\r
3991 eWeightsFlag = 0;\r
3992 } \r
3993 \r
3994 // shortcuts:\r
3995 Int_t t = typeFlag;\r
3996 Int_t pW = pWeightsFlag;\r
3997 Int_t eW = eWeightsFlag;\r
3998 \r
3999 // from 2D histogram fNonEmptyBins2D make two 1D histograms fNonEmptyBins1D in pt and eta (to be improved (i.e. moved somewhere else)) \r
4000 // pt:\r
4001 for(Int_t p=1;p<fnBinsPt;p++)\r
4002 {\r
4003 Double_t contentPt = 0.;\r
4004 for(Int_t e=1;e<=fnBinsEta;e++)\r
4005 {\r
4006 contentPt += (fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e))); \r
4007 }\r
4008 fNonEmptyBins1D[t][0]->SetBinContent(p,contentPt);\r
4009 }\r
4010 // eta:\r
4011 for(Int_t e=1;e<fnBinsEta;e++)\r
4012 {\r
4013 Double_t contentEta = 0.;\r
4014 for(Int_t p=1;p<=fnBinsPt;p++)\r
4015 {\r
4016 contentEta += (fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e))); \r
4017 }\r
4018 fNonEmptyBins1D[t][1]->SetBinContent(e,contentEta);\r
4019 }\r
4020 \r
4021 // from 2D profile in (pt,eta) make two 1D profiles in (pt) and (eta):\r
4022 TProfile *profile[2][4]; // [0=pt,1=eta][correlation index] // to be improved (do not hardwire the correlation index)\r
4023 \r
4024 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4025 {\r
4026 for(Int_t ci=0;ci<4;ci++) // correlation index\r
4027 {\r
4028 if(pe==0) profile[pe][ci] = this->MakePtProjection(fCorrelationsPro[t][pW][eW][ci]);\r
4029 if(pe==1) profile[pe][ci] = this->MakeEtaProjection(fCorrelationsPro[t][pW][eW][ci]);\r
4030 }\r
4031 }\r
4032 \r
4033 // transfer 2D profile into 2D histogram:\r
4034 // to be improved (see in documentation if there is a method to transfer values from 2D profile into 2D histogram) \r
4035 for(Int_t ci=0;ci<4;ci++)\r
4036 {\r
4037 for(Int_t p=1;p<=fnBinsPt;p++)\r
4038 {\r
4039 for(Int_t e=1;e<=fnBinsEta;e++)\r
4040 {\r
4041 Double_t correlation = fCorrelationsPro[t][pW][eW][ci]->GetBinContent(fCorrelationsPro[t][pW][eW][ci]->GetBin(p,e)); \r
4042 Double_t spread = fCorrelationsPro[t][pW][eW][ci]->GetBinError(fCorrelationsPro[t][pW][eW][ci]->GetBin(p,e));\r
4043 Double_t nEvts = fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e));\r
4044 Double_t error = 0.;\r
4045 fFinalCorrelations2D[t][pW][eW][ci]->SetBinContent(fFinalCorrelations2D[t][pW][eW][ci]->GetBin(p,e),correlation); \r
4046 if(nEvts>0)\r
4047 {\r
4048 error = spread/pow(nEvts,0.5);\r
4049 fFinalCorrelations2D[t][pW][eW][ci]->SetBinError(fFinalCorrelations2D[t][pW][eW][ci]->GetBin(p,e),error);\r
4050 }\r
4051 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4052 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4053 } // end of for(Int_t ci=0;ci<4;ci++)\r
4054 \r
4055 // transfer 1D profile into 1D histogram (pt):\r
4056 // to be improved (see in documentation if there is a method to transfer values from 1D profile into 1D histogram) \r
4057 for(Int_t ci=0;ci<4;ci++)\r
4058 {\r
4059 for(Int_t p=1;p<=fnBinsPt;p++)\r
4060 {\r
4061 if(profile[0][ci])\r
4062 {\r
4063 Double_t correlation = profile[0][ci]->GetBinContent(p); \r
4064 Double_t spread = profile[0][ci]->GetBinError(p);\r
4065 Double_t nEvts = fNonEmptyBins1D[t][0]->GetBinContent(p);\r
4066 Double_t error = 0.;\r
4067 fFinalCorrelations1D[t][pW][eW][0][ci]->SetBinContent(p,correlation); \r
4068 if(nEvts>0)\r
4069 {\r
4070 error = spread/pow(nEvts,0.5);\r
4071 fFinalCorrelations1D[t][pW][eW][0][ci]->SetBinError(p,error);\r
4072 } \r
4073 } \r
4074 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4075 } // end of for(Int_t ci=0;ci<4;ci++)\r
4076 \r
4077 // transfer 1D profile into 1D histogram (eta):\r
4078 // to be improved (see in documentation if there is a method to transfer values from 1D profile into 1D histogram) \r
4079 for(Int_t ci=0;ci<4;ci++)\r
4080 {\r
4081 for(Int_t e=1;e<=fnBinsEta;e++)\r
4082 {\r
4083 if(profile[1][ci])\r
4084 {\r
4085 Double_t correlation = profile[1][ci]->GetBinContent(e); \r
4086 fFinalCorrelations1D[t][pW][eW][1][ci]->SetBinContent(e,correlation); \r
4087 } \r
4088 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4089 } // end of for(Int_t ci=0;ci<4;ci++)\r
4090 \r
4091} // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsForDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights)\r
4092*/\r
4093\r
4094\r
4095//================================================================================================================================\r
4096\r
4097\r
4098void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, TString ptOrEta)\r
4099{\r
4100 // calcualate cumulants for differential flow from measured correlations\r
4101 // Remark: cumulants calculated here are NOT corrected for non-uniform acceptance. This correction is applied in the method ...\r
4102 // to be improved (description) \r
4103 \r
4104 Int_t typeFlag = -1;\r
4105 Int_t ptEtaFlag = -1;\r
4106\r
4107 if(type == "RP")\r
4108 {\r
4109 typeFlag = 0;\r
4110 } else if(type == "POI")\r
4111 {\r
4112 typeFlag = 1;\r
4113 } \r
4114 \r
4115 if(ptOrEta == "Pt")\r
4116 {\r
4117 ptEtaFlag = 0;\r
4118 } else if(ptOrEta == "Eta")\r
4119 {\r
4120 ptEtaFlag = 1;\r
4121 } \r
4122 \r
4123 // shortcuts:\r
4124 Int_t t = typeFlag;\r
4125 Int_t pe = ptEtaFlag;\r
4126 \r
4127 // common:\r
4128 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
4129 \r
4130 // correlation <<2>>: \r
4131 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);\r
4132 \r
4133 // 1D:\r
4134 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4135 {\r
4136 // reduced correlations: \r
4137 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>(pt)\r
4138 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>(pt)\r
4139 // final statistical error of reduced correlations:\r
4140 //Double_t twoPrimeError = fFinalCorrelations1D[t][pW][eW][0][0]->GetBinError(p); \r
4141 // QC{2'}:\r
4142 Double_t qc2Prime = twoPrime; // QC{2'}\r
4143 //Double_t qc2PrimeError = twoPrimeError; // final stat. error of QC{2'}\r
4144 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime); \r
4145 //fFinalCumulantsPt[t][pW][eW][nua][0]->SetBinError(p,qc2PrimeError); \r
4146 // QC{4'}:\r
4147 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>\r
4148 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime); \r
4149 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4150 \r
4151 \r
4152 /* \r
4153 // 2D (pt,eta):\r
4154 // to be improved (see documentation if I can do all this without looping)\r
4155 for(Int_t p=1;p<=fnBinsPt;p++)\r
4156 {\r
4157 for(Int_t e=1;e<=fnBinsEta;e++) \r
4158 { \r
4159 // reduced correlations: \r
4160 Double_t twoPrime = fFinalCorrelations2D[t][pW][eW][0]->GetBinContent(fFinalCorrelations2D[t][pW][eW][0]->GetBin(p,e)); // <<2'>>(pt,eta)\r
4161 Double_t fourPrime = fFinalCorrelations2D[t][pW][eW][1]->GetBinContent(fFinalCorrelations2D[t][pW][eW][1]->GetBin(p,e)); // <<4'>>(pt,eta)\r
4162 for(Int_t nua=0;nua<2;nua++)\r
4163 {\r
4164 // QC{2'}:\r
4165 Double_t qc2Prime = twoPrime; // QC{2'} = <<2'>>\r
4166 fFinalCumulants2D[t][pW][eW][nua][0]->SetBinContent(fFinalCumulants2D[t][pW][eW][nua][0]->GetBin(p,e),qc2Prime); \r
4167 // QC{4'}:\r
4168 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>\r
4169 fFinalCumulants2D[t][pW][eW][nua][1]->SetBinContent(fFinalCumulants2D[t][pW][eW][nua][1]->GetBin(p,e),qc4Prime); \r
4170 } // end of for(Int_t nua=0;nua<2;nua++) \r
4171 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4172 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4173 */\r
4174 \r
4175} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, Bool_t useParticleWeights, TString eventWeights); \r
4176\r
4177\r
4178//================================================================================================================================\r
4179\r
4180\r
4181void AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)\r
4182{\r
4183 // calculate final results for integrated flow of RPs and POIs \r
4184 \r
4185 Int_t typeFlag = -1;\r
4186\r
4187 if(type == "RP")\r
4188 {\r
4189 typeFlag = 0;\r
4190 } else if(type == "POI")\r
4191 {\r
4192 typeFlag = 1;\r
4193 } else \r
4194 {\r
4195 cout<<"WARNING: type must be either RP or POI in AFAWQC::CDF() !!!!"<<endl;\r
4196 exit(0);\r
4197 }\r
4198 \r
4199 // shortcuts:\r
4200 Int_t t = typeFlag;\r
4201 \r
4202 // pt yield: \r
4203 TH1F *yield2ndPt = NULL;\r
4204 TH1F *yield4thPt = NULL;\r
4205 TH1F *yield6thPt = NULL;\r
4206 TH1F *yield8thPt = NULL;\r
4207 \r
4208 if(type == "POI")\r
4209 {\r
4210 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtPOI())->Clone();\r
4211 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtPOI())->Clone();\r
4212 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtPOI())->Clone();\r
4213 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtPOI())->Clone(); \r
4214 } \r
4215 else if(type == "RP")\r
4216 {\r
4217 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtRP())->Clone();\r
4218 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtRP())->Clone();\r
4219 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtRP())->Clone();\r
4220 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtRP())->Clone(); \r
4221 } \r
4222 \r
4223 Int_t nBinsPt = yield2ndPt->GetNbinsX();\r
4224 \r
4225 TH1D *flow2ndPt = NULL;\r
4226 TH1D *flow4thPt = NULL;\r
4227 TH1D *flow6thPt = NULL;\r
4228 TH1D *flow8thPt = NULL;\r
4229 \r
4230 // to be improved (hardwired pt index)\r
4231 flow2ndPt = (TH1D*)fDiffFlow[t][0][0]->Clone();\r
4232 flow4thPt = (TH1D*)fDiffFlow[t][0][1]->Clone();\r
4233 flow6thPt = (TH1D*)fDiffFlow[t][0][2]->Clone();\r
4234 flow8thPt = (TH1D*)fDiffFlow[t][0][3]->Clone(); \r
4235 \r
4236 Double_t dvn2nd = 0., dvn4th = 0., dvn6th = 0., dvn8th = 0.; // differential flow\r
4237 Double_t dErrvn2nd = 0., dErrvn4th = 0., dErrvn6th = 0., dErrvn8th = 0.; // error on differential flow\r
4238 \r
4239 Double_t dVn2nd = 0., dVn4th = 0., dVn6th = 0., dVn8th = 0.; // integrated flow \r
4240 Double_t dErrVn2nd = 0., dErrVn4th = 0., dErrVn6th = 0., dErrVn8th = 0.; // error on integrated flow\r
4241\r
4242 Double_t dYield2nd = 0., dYield4th = 0., dYield6th = 0., dYield8th = 0.; // pt yield \r
4243 Double_t dSum2nd = 0., dSum4th = 0., dSum6th = 0., dSum8th = 0.; // needed for normalizing integrated flow\r
4244 \r
4245 // looping over pt bins:\r
4246 for(Int_t p=1;p<nBinsPt+1;p++)\r
4247 {\r
4248 dvn2nd = flow2ndPt->GetBinContent(p);\r
4249 dvn4th = flow4thPt->GetBinContent(p);\r
4250 dvn6th = flow6thPt->GetBinContent(p);\r
4251 dvn8th = flow8thPt->GetBinContent(p);\r
4252 \r
4253 dErrvn2nd = flow2ndPt->GetBinError(p);\r
4254 dErrvn4th = flow4thPt->GetBinError(p);\r
4255 dErrvn6th = flow6thPt->GetBinError(p);\r
4256 dErrvn8th = flow8thPt->GetBinError(p);\r
4257\r
4258 dYield2nd = yield2ndPt->GetBinContent(p); \r
4259 dYield4th = yield4thPt->GetBinContent(p);\r
4260 dYield6th = yield6thPt->GetBinContent(p);\r
4261 dYield8th = yield8thPt->GetBinContent(p);\r
4262 \r
4263 dVn2nd += dvn2nd*dYield2nd;\r
4264 dVn4th += dvn4th*dYield4th;\r
4265 dVn6th += dvn6th*dYield6th;\r
4266 dVn8th += dvn8th*dYield8th;\r
4267 \r
4268 dSum2nd += dYield2nd;\r
4269 dSum4th += dYield4th;\r
4270 dSum6th += dYield6th;\r
4271 dSum8th += dYield8th;\r
4272 \r
4273 dErrVn2nd += dYield2nd*dYield2nd*dErrvn2nd*dErrvn2nd; // ro be improved (check this relation)\r
4274 dErrVn4th += dYield4th*dYield4th*dErrvn4th*dErrvn4th;\r
4275 dErrVn6th += dYield6th*dYield6th*dErrvn6th*dErrvn6th;\r
4276 dErrVn8th += dYield8th*dYield8th*dErrvn8th*dErrvn8th;\r
4277 \r
4278 } // end of for(Int_t p=1;p<nBinsPt+1;p++)\r
4279\r
4280 // normalizing the results for integrated flow:\r
4281 if(dSum2nd) \r
4282 {\r
4283 dVn2nd /= dSum2nd;\r
4284 dErrVn2nd /= (dSum2nd*dSum2nd);\r
4285 dErrVn2nd = TMath::Sqrt(dErrVn2nd);\r
4286 } \r
4287 if(dSum4th) \r
4288 {\r
4289 dVn4th /= dSum4th;\r
4290 dErrVn4th /= (dSum4th*dSum4th);\r
4291 dErrVn4th = TMath::Sqrt(dErrVn4th);\r
4292 } \r
4293 //if(dSum6th) dVn6th/=dSum6th;\r
4294 //if(dSum8th) dVn8th/=dSum8th;\r
4295 \r
4296 // storing the results for integrated flow in common histos: (to be improved: new method for this?)\r
4297 if(type == "POI")\r
4298 {\r
4299 fCommonHistsResults2nd->FillIntegratedFlowPOI(dVn2nd,dErrVn2nd); \r
4300 fCommonHistsResults4th->FillIntegratedFlowPOI(dVn4th,dErrVn4th); \r
4301 fCommonHistsResults6th->FillIntegratedFlowPOI(dVn6th,0.); // to be improved (errors)\r
4302 fCommonHistsResults8th->FillIntegratedFlowPOI(dVn8th,0.); // to be improved (errors)\r
4303 }\r
4304 else if (type == "RP")\r
4305 {\r
4306 fCommonHistsResults2nd->FillIntegratedFlowRP(dVn2nd,dErrVn2nd); \r
4307 fCommonHistsResults4th->FillIntegratedFlowRP(dVn4th,dErrVn4th);\r
4308 fCommonHistsResults6th->FillIntegratedFlowRP(dVn6th,0.); // to be improved (errors)\r
4309 fCommonHistsResults8th->FillIntegratedFlowRP(dVn8th,0.); // to be improved (errors)\r
4310 }\r
4311 \r
4312 delete flow2ndPt;\r
4313 delete flow4thPt;\r
4314 //delete flow6thPt;\r
4315 //delete flow8thPt;\r
4316 \r
4317 delete yield2ndPt;\r
4318 delete yield4thPt;\r
4319 delete yield6thPt;\r
4320 delete yield8thPt;\r
4321 \r
4322} // end of AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)\r
4323\r
4324\r
4325//================================================================================================================================\r
4326\r
4327\r
4328void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()\r
4329{\r
4330 // initialize arrays used for distributions:\r
4331 \r
4332 /*\r
4333 \r
4334 for(Int_t pW=0;pW<2;pW++) // particle weights not used (0) or used (1)\r
4335 {\r
4336 for(Int_t eW=0;eW<2;eW++)\r
4337 {\r
4338 for(Int_t di=0;di<4;di++) // distribution index\r
4339 {\r
4340 fDistributions[pW][eW][di] = NULL;\r
4341 }\r
4342 } \r
4343 }\r
4344 \r
4345 */\r
4346 \r
4347} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()\r
4348\r
4349\r
4350//================================================================================================================================\r
4351\r
4352\r
4353void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()\r
4354{\r
4355 // book all histograms for distributions\r
4356 \r
4357 /*\r
4358 //weighted <2>_{n|n} distribution\r
4359 f2pDistribution = new TH1D("f2pDistribution","<2>_{n|n} distribution",100000,-0.02,0.1);\r
4360 f2pDistribution->SetXTitle("<2>_{n|n}");\r
4361 f2pDistribution->SetYTitle("Counts");\r
4362 fHistList->Add(f2pDistribution);\r
4363\r
4364 //weighted <4>_{n,n|n,n} distribution\r
4365 f4pDistribution = new TH1D("f4pDistribution","<4>_{n,n|n,n} distribution",100000,-0.00025,0.002);\r
4366 f4pDistribution->SetXTitle("<4>_{n,n|n,n}");\r
4367 f4pDistribution->SetYTitle("Counts");\r
4368 fHistList->Add(f4pDistribution); \r
4369 \r
4370 //weighted <6>_{n,n,n|n,n,n} distribution\r
4371 f6pDistribution = new TH1D("f6pDistribution","<6>_{n,n,n|n,n,n} distribution",100000,-0.000005,0.000025);\r
4372 f6pDistribution->SetXTitle("<6>_{n,n,n|n,n,n}");\r
4373 f6pDistribution->SetYTitle("Counts");\r
4374 fHistList->Add(f6pDistribution);\r
4375 \r
4376 //weighted <8>_{n,n,n,n|n,n,n,n} distribution\r
4377 f8pDistribution = new TH1D("f8pDistribution","<8>_{n,n,n,n|n,n,n,n} distribution",100000,-0.000000001,0.00000001);\r
4378 f8pDistribution->SetXTitle("<8>_{n,n,n,n|n,n,n,n}");\r
4379 f8pDistribution->SetYTitle("Counts");\r
4380 fHistList->Add(f8pDistribution);\r
4381 */\r
4382 \r
4383} // end of void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()\r
4384\r
4385\r
4386//================================================================================================================================\r
4387\r
4388\r
4389void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()\r
4390{\r
4391 // Book and nest all lists nested in the base list fHistList.\r
4392 // a) Book and nest lists for integrated flow;\r
4393 // b) Book and nest lists for differential flow;\r
4394 // c) Book and nest list for particle weights;\r
4395 // d) Book and nest list for distributions;\r
4396 // e) Book and nest list for nested loops;\r
4397 \r
4398 // a) Book and nest all lists for integrated flow:\r
4399 // base list for integrated flow:\r
4400 fIntFlowList = new TList();\r
4401 fIntFlowList->SetName("Integrated Flow");\r
4402 fIntFlowList->SetOwner(kTRUE);\r
4403 fHistList->Add(fIntFlowList);\r
4404 // list holding profiles: \r
4405 fIntFlowProfiles = new TList();\r
4406 fIntFlowProfiles->SetName("Profiles");\r
4407 fIntFlowProfiles->SetOwner(kTRUE);\r
4408 fIntFlowList->Add(fIntFlowProfiles);\r
4409 // list holding histograms with results:\r
4410 fIntFlowResults = new TList();\r
4411 fIntFlowResults->SetName("Results");\r
4412 fIntFlowResults->SetOwner(kTRUE);\r
4413 fIntFlowList->Add(fIntFlowResults);\r
4414 \r
4415 // b) Book and nest lists for differential flow;\r
4416 fDiffFlowList = new TList();\r
4417 fDiffFlowList->SetName("Differential Flow");\r
4418 fDiffFlowList->SetOwner(kTRUE); \r
4419 fHistList->Add(fDiffFlowList);\r
4420 // list holding profiles: \r
4421 fDiffFlowProfiles = new TList(); \r
4422 fDiffFlowProfiles->SetName("Profiles");\r
4423 fDiffFlowProfiles->SetOwner(kTRUE);\r
4424 fDiffFlowList->Add(fDiffFlowProfiles);\r
4425 // list holding histograms with results: \r
4426 fDiffFlowResults = new TList();\r
4427 fDiffFlowResults->SetName("Results");\r
4428 fDiffFlowResults->SetOwner(kTRUE);\r
4429 fDiffFlowList->Add(fDiffFlowResults);\r
4430 // flags used for naming nested lists in list fDiffFlowProfiles and fDiffFlowResults: \r
4431 TList list;\r
4432 list.SetOwner(kTRUE);\r
4433 TString typeFlag[2] = {"RP","POI"}; \r
4434 TString ptEtaFlag[2] = {"p_{T}","#eta"}; \r
4435 TString powerFlag[2] = {"linear","quadratic"}; \r
4436 // nested lists in fDiffFlowProfiles (~/Differential Flow/Profiles):\r
4437 for(Int_t t=0;t<2;t++) // type: RP or POI\r
4438 {\r
4439 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4440 {\r
4441 // list holding profiles with correlations:\r
4442 fDiffFlowCorrelationsProList[t][pe] = (TList*)list.Clone();\r
4443 fDiffFlowCorrelationsProList[t][pe]->SetName(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4444 fDiffFlowProfiles->Add(fDiffFlowCorrelationsProList[t][pe]);\r
4445 // list holding profiles with products of correlations:\r
4446 fDiffFlowProductOfCorrelationsProList[t][pe] = (TList*)list.Clone();\r
4447 fDiffFlowProductOfCorrelationsProList[t][pe]->SetName(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4448 fDiffFlowProfiles->Add(fDiffFlowProductOfCorrelationsProList[t][pe]);\r
4449 // list holding profiles with corrections:\r
4450 fDiffFlowCorrectionsProList[t][pe] = (TList*)list.Clone();\r
4451 fDiffFlowCorrectionsProList[t][pe]->SetName(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4452 fDiffFlowProfiles->Add(fDiffFlowCorrectionsProList[t][pe]); \r
4453 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
4454 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI \r
4455 // nested lists in fDiffFlowResults (~/Differential Flow/Results):\r
4456 for(Int_t t=0;t<2;t++) // type: RP or POI\r
4457 {\r
4458 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4459 {\r
4460 // list holding histograms with correlations:\r
4461 fDiffFlowCorrelationsHistList[t][pe] = (TList*)list.Clone();\r
4462 fDiffFlowCorrelationsHistList[t][pe]->SetName(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4463 fDiffFlowResults->Add(fDiffFlowCorrelationsHistList[t][pe]);\r
4464 // list holding histograms with corrections:\r
4465 fDiffFlowCorrectionsHistList[t][pe] = (TList*)list.Clone();\r
4466 fDiffFlowCorrectionsHistList[t][pe]->SetName(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4467 fDiffFlowResults->Add(fDiffFlowCorrectionsHistList[t][pe]); \r
4468 for(Int_t power=0;power<2;power++)\r
4469 {\r
4470 // list holding histograms with sums of event weights:\r
4471 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = (TList*)list.Clone();\r
4472 fDiffFlowSumOfEventWeightsHistList[t][pe][power]->SetName(Form("Sum of %s event weights (%s, %s)",powerFlag[power].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4473 fDiffFlowResults->Add(fDiffFlowSumOfEventWeightsHistList[t][pe][power]); \r
4474 } // end of for(Int_t power=0;power<2;power++)\r
4475 // list holding histograms with sums of products of event weights:\r
4476 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = (TList*)list.Clone();\r
4477 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->SetName(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4478 fDiffFlowResults->Add(fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]);\r
4479 // list holding histograms with covariances of correlations:\r
4480 fDiffFlowCovariancesHistList[t][pe] = (TList*)list.Clone();\r
4481 fDiffFlowCovariancesHistList[t][pe]->SetName(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4482 fDiffFlowResults->Add(fDiffFlowCovariancesHistList[t][pe]);\r
4483 // list holding histograms with differential Q-cumulants:\r
4484 fDiffFlowCumulantsHistList[t][pe] = (TList*)list.Clone();\r
4485 fDiffFlowCumulantsHistList[t][pe]->SetName(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4486 fDiffFlowResults->Add(fDiffFlowCumulantsHistList[t][pe]); \r
4487 // list holding histograms with differential flow estimates from Q-cumulants:\r
4488 fDiffFlowHistList[t][pe] = (TList*)list.Clone();\r
4489 fDiffFlowHistList[t][pe]->SetName(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4490 fDiffFlowResults->Add(fDiffFlowHistList[t][pe]); \r
4491 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4492 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
4493 \r
4494 // c) Book and nest list for particle weights:\r
4495 fWeightsList->SetName("Weights");\r
4496 fWeightsList->SetOwner(kTRUE); \r
4497 fHistList->Add(fWeightsList); \r
4498\r
4499 // d) Book and nest list for distributions:\r
4500 fDistributionsList = new TList();\r
4501 fDistributionsList->SetName("Distributions");\r
4502 fDistributionsList->SetOwner(kTRUE);\r
4503 fHistList->Add(fDistributionsList);\r
4504 \r
4505 // e) Book and nest list for nested loops:\r
4506 fNestedLoopsList = new TList();\r
4507 fNestedLoopsList->SetName("Nested Loops");\r
4508 fNestedLoopsList->SetOwner(kTRUE);\r
4509 fHistList->Add(fNestedLoopsList);\r
4510 \r
4511} // end of void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()\r
4512\r
4513\r
4514//================================================================================================================================\r
4515\r
4516\r
4517void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type)\r
4518{\r
4519 // fill common result histograms for differential flow\r
4520 \r
4521 Int_t typeFlag = -1;\r
4522 //Int_t ptEtaFlag = -1;\r
4523\r
4524 if(type == "RP")\r
4525 {\r
4526 typeFlag = 0;\r
4527 } else if(type == "POI")\r
4528 {\r
4529 typeFlag = 1;\r
4530 } \r
4531 \r
4532 // shortcuts:\r
4533 Int_t t = typeFlag;\r
4534 //Int_t pe = ptEtaFlag;\r
4535\r
4536 // to be improved (implement protection here)\r
4537 \r
4538 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
4539 {\r
4540 cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl; \r
4541 cout<<" is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
4542 exit(0);\r
4543 }\r
4544 \r
4545 // pt:\r
4546 for(Int_t p=1;p<=fnBinsPt;p++)\r
4547 {\r
4548 Double_t v2 = fDiffFlow[t][0][0]->GetBinContent(p);\r
4549 Double_t v4 = fDiffFlow[t][0][1]->GetBinContent(p);\r
4550 Double_t v6 = fDiffFlow[t][0][2]->GetBinContent(p);\r
4551 Double_t v8 = fDiffFlow[t][0][3]->GetBinContent(p);\r
4552 \r
4553 Double_t v2Error = fDiffFlow[t][0][0]->GetBinError(p);\r
4554 Double_t v4Error = fDiffFlow[t][0][1]->GetBinError(p);\r
4555 //Double_t v6Error = fFinalFlow1D[t][pW][nua][0][2]->GetBinError(p);\r
4556 //Double_t v8Error = fFinalFlow1D[t][pW][nua][0][3]->GetBinError(p);\r
4557 \r
4558 if(type == "RP")\r
4559 {\r
4560 fCommonHistsResults2nd->FillDifferentialFlowPtRP(p,v2,v2Error);\r
4561 fCommonHistsResults4th->FillDifferentialFlowPtRP(p,v4,v4Error);\r
4562 fCommonHistsResults6th->FillDifferentialFlowPtRP(p,v6,0.);\r
4563 fCommonHistsResults8th->FillDifferentialFlowPtRP(p,v8,0.);\r
4564 } else if(type == "POI")\r
4565 {\r
4566 fCommonHistsResults2nd->FillDifferentialFlowPtPOI(p,v2,v2Error);\r
4567 fCommonHistsResults4th->FillDifferentialFlowPtPOI(p,v4,v4Error);\r
4568 fCommonHistsResults6th->FillDifferentialFlowPtPOI(p,v6,0.);\r
4569 fCommonHistsResults8th->FillDifferentialFlowPtPOI(p,v8,0.);\r
4570 }\r
4571 } // end of for(Int_t p=1;p<=fnBinsPt;p++) \r
4572 \r
4573 // eta:\r
4574 for(Int_t e=1;e<=fnBinsEta;e++)\r
4575 {\r
4576 Double_t v2 = fDiffFlow[t][1][0]->GetBinContent(e);\r
4577 Double_t v4 = fDiffFlow[t][1][1]->GetBinContent(e);\r
4578 Double_t v6 = fDiffFlow[t][1][2]->GetBinContent(e);\r
4579 Double_t v8 = fDiffFlow[t][1][3]->GetBinContent(e);\r
4580 \r
4581 Double_t v2Error = fDiffFlow[t][1][0]->GetBinError(e);\r
4582 Double_t v4Error = fDiffFlow[t][1][1]->GetBinError(e);\r
4583 //Double_t v6Error = fDiffFlow[t][1][2]->GetBinError(e);\r
4584 //Double_t v8Error = fDiffFlow[t][1][3]->GetBinError(e);\r
4585 \r
4586 if(type == "RP")\r
4587 {\r
4588 fCommonHistsResults2nd->FillDifferentialFlowEtaRP(e,v2,v2Error);\r
4589 fCommonHistsResults4th->FillDifferentialFlowEtaRP(e,v4,v4Error);\r
4590 fCommonHistsResults6th->FillDifferentialFlowEtaRP(e,v6,0.);\r
4591 fCommonHistsResults8th->FillDifferentialFlowEtaRP(e,v8,0.);\r
4592 } else if(type == "POI")\r
4593 {\r
4594 fCommonHistsResults2nd->FillDifferentialFlowEtaPOI(e,v2,v2Error);\r
4595 fCommonHistsResults4th->FillDifferentialFlowEtaPOI(e,v4,v4Error);\r
4596 fCommonHistsResults6th->FillDifferentialFlowEtaPOI(e,v6,0.);\r
4597 fCommonHistsResults8th->FillDifferentialFlowEtaPOI(e,v8,0.);\r
4598 }\r
4599 } // end of for(Int_t e=1;e<=fnBinsEta;e++) \r
4600 \r
4601} // end of void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights, Bool_t correctedForNUA)\r
4602\r
4603\r
4604//================================================================================================================================\r
4605\r
4606\r
4607void AliFlowAnalysisWithQCumulants::AccessConstants()\r
4608{\r
4609 // access needed common constants from AliFlowCommonConstants\r
4610 \r
4611 fnBinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();\r
4612 fPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin(); \r
4613 fPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();\r
4614 if(fnBinsPhi) fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi; \r
4615 fnBinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();\r
4616 fPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin(); \r
4617 fPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();\r
4618 if(fnBinsPt) fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt; \r
4619 fnBinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();\r
4620 fEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin(); \r
4621 fEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();\r
4622 if(fnBinsEta) fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta; \r
4623 \r
4624} // end of void AliFlowAnalysisWithQCumulants::AccessConstants()\r
4625\r
4626\r
4627//================================================================================================================================\r
4628\r
4629\r
4630void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()\r
4631{\r
4632 // Calculate sum of linear and quadratic event weights for correlations\r
4633 \r
4634 \r
4635 /*\r
4636 Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
4637\r
4638 Double_t eventWeight[4] = {0}; \r
4639 \r
4640 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
4641 {\r
4642 eventWeight[0] = dMult*(dMult-1); // event weight for <2> \r
4643 eventWeight[1] = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
4644 eventWeight[2] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
4645 eventWeight[3] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
4646 } else\r
4647 {\r
4648 eventWeight[0] = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
4649 eventWeight[1] = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1) \r
4650 + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
4651 + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
4652 //eventWeight[2] = ... // to be improved (calculated) \r
4653 //eventWeight[3] = ... // to be improved (calculated) \r
4654 }\r
4655 */\r
4656 \r
4657 \r
4658 for(Int_t p=0;p<2;p++) // power-1\r
4659 {\r
4660 for(Int_t ci=0;ci<4;ci++) // correlation index\r
4661 { \r
4662 fIntFlowSumOfEventWeights[p]->Fill(ci+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1)); \r
4663 }\r
4664 }\r
4665 \r
4666} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()\r
4667\r
4668\r
4669//================================================================================================================================\r
4670\r
4671\r
4672void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()\r
4673{\r
4674 // Calculate sum of product of event weights for correlations\r
4675 \r
4676 \r
4677 /*\r
4678 Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
4679\r
4680 Double_t eventWeight[4] = {0}; \r
4681 \r
4682 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
4683 {\r
4684 eventWeight[0] = dMult*(dMult-1); // event weight for <2> \r
4685 eventWeight[1] = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
4686 eventWeight[2] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
4687 eventWeight[3] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
4688 } else\r
4689 {\r
4690 eventWeight[0] = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
4691 eventWeight[1] = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1) \r
4692 + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
4693 + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
4694 //eventWeight[2] = ... // to be improved (calculated) \r
4695 //eventWeight[3] = ... // to be improved (calculated) \r
4696 }\r
4697\r
4698 fIntFlowSumOfProductOfEventWeights->Fill(0.5,eventWeight[0]*eventWeight[1]); \r
4699 fIntFlowSumOfProductOfEventWeights->Fill(1.5,eventWeight[0]*eventWeight[2]); \r
4700 fIntFlowSumOfProductOfEventWeights->Fill(2.5,eventWeight[0]*eventWeight[3]); \r
4701 fIntFlowSumOfProductOfEventWeights->Fill(3.5,eventWeight[1]*eventWeight[2]); \r
4702 fIntFlowSumOfProductOfEventWeights->Fill(4.5,eventWeight[1]*eventWeight[3]); \r
4703 fIntFlowSumOfProductOfEventWeights->Fill(5.5,eventWeight[2]*eventWeight[3]); \r
4704 */\r
4705 \r
4706 \r
4707 Int_t counter = 0;\r
4708 \r
4709 for(Int_t ci1=1;ci1<4;ci1++)\r
4710 {\r
4711 for(Int_t ci2=ci1+1;ci2<=4;ci2++)\r
4712 {\r
4713 fIntFlowSumOfProductOfEventWeights->Fill(0.5+counter++,\r
4714 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));\r
4715 }\r
4716 }\r
4717\r
4718 \r
4719\r
4720} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowIntFlowSumOfProductOfEventWeights()\r
4721\r
4722\r
4723//================================================================================================================================\r
4724\r
4725\r
4726void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta)\r
4727{\r
4728 // calculate reduced correlations for RPs or POIs in pt or eta bins\r
4729\r
4730 // multiplicity:\r
4731 Double_t dMult = (*fSMpk)(0,0);\r
4732 \r
4733 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
4734 Double_t dReQ1n = (*fReQ)(0,0);\r
4735 Double_t dReQ2n = (*fReQ)(1,0);\r
4736 //Double_t dReQ3n = (*fReQ)(2,0);\r
4737 //Double_t dReQ4n = (*fReQ)(3,0);\r
4738 Double_t dImQ1n = (*fImQ)(0,0);\r
4739 Double_t dImQ2n = (*fImQ)(1,0);\r
4740 //Double_t dImQ3n = (*fImQ)(2,0);\r
4741 //Double_t dImQ4n = (*fImQ)(3,0);\r
4742\r
4743 // reduced correlations are stored in fDiffFlowCorrelationsPro[0=RP,1=POI][0=pt,1=eta][correlation index]. Correlation index runs as follows:\r
4744 // \r
4745 // 0: <<2'>>\r
4746 // 1: <<4'>>\r
4747 // 2: <<6'>>\r
4748 // 3: <<8'>>\r
4749 \r
4750 Int_t t = -1; // type flag \r
4751 Int_t pe = -1; // ptEta flag\r
4752 \r
4753 if(type == "RP")\r
4754 {\r
4755 t = 0;\r
4756 } else if(type == "POI")\r
4757 {\r
4758 t = 1;\r
4759 }\r
4760\r
4761 if(ptOrEta == "Pt")\r
4762 {\r
4763 pe = 0;\r
4764 } else if(ptOrEta == "Eta")\r
4765 {\r
4766 pe = 1;\r
4767 }\r
4768 \r
4769 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
4770 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
4771 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
4772 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
4773\r
4774 // looping over all bins and calculating reduced correlations: \r
4775 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4776 {\r
4777 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
4778 Double_t p1n0kRe = 0.;\r
4779 Double_t p1n0kIm = 0.;\r
4780\r
4781 // number of POIs in particular pt or eta bin:\r
4782 Double_t mp = 0.;\r
4783\r
4784 // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
4785 Double_t q1n0kRe = 0.;\r
4786 Double_t q1n0kIm = 0.;\r
4787 Double_t q2n0kRe = 0.;\r
4788 Double_t q2n0kIm = 0.;\r
4789\r
4790 // number of particles which are both RPs and POIs in particular pt or eta bin:\r
4791 Double_t mq = 0.;\r
4792 \r
4793 if(type == "POI")\r
4794 {\r
4795 // q_{m*n,0}:\r
4796 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
4797 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
4798 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
4799 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
4800 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
4801 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
4802 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
4803 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b)); \r
4804 \r
4805 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
4806 } \r
4807 else if(type == "RP")\r
4808 {\r
4809 // q_{m*n,0}:\r
4810 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
4811 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
4812 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
4813 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
4814 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
4815 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
4816 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
4817 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b)); \r
4818 \r
4819 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here) \r
4820 }\r
4821 \r
4822 if(type == "POI")\r
4823 {\r
4824 // p_{m*n,0}:\r
4825 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
4826 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
4827 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b)) \r
4828 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
4829 \r
4830 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
4831 \r
4832 t = 1; // typeFlag = RP or POI\r
4833 }\r
4834 else if(type == "RP")\r
4835 {\r
4836 // p_{m*n,0} = q_{m*n,0}:\r
4837 p1n0kRe = q1n0kRe; \r
4838 p1n0kIm = q1n0kIm; \r
4839 \r
4840 mp = mq; \r
4841 \r
4842 t = 0; // typeFlag = RP or POI\r
4843 }\r
4844 \r
4845 // 2'-particle correlation for particular (pt,eta) bin:\r
4846 Double_t two1n1nPtEta = 0.;\r
4847 if(mp*dMult-mq)\r
4848 {\r
4849 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)\r
4850 / (mp*dMult-mq);\r
4851 \r
4852 if(type == "POI") // to be improved (I do not this if)\r
4853 { \r
4854 // fill profile to get <<2'>> for POIs\r
4855 fDiffFlowCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mp*dMult-mq);\r
4856 // histogram to store <2'> for POIs e-b-e (needed in some other methods):\r
4857 fDiffFlowCorrelationsEBE[1][pe][0]->SetBinContent(b,two1n1nPtEta); \r
4858 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][0]->SetBinContent(b,mp*dMult-mq); \r
4859 }\r
4860 else if(type == "RP") // to be improved (I do not this if)\r
4861 {\r
4862 // profile to get <<2'>> for RPs:\r
4863 fDiffFlowCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mp*dMult-mq);\r
4864 // histogram to store <2'> for RPs e-b-e (needed in some other methods):\r
4865 fDiffFlowCorrelationsEBE[0][pe][0]->SetBinContent(b,two1n1nPtEta); \r
4866 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][0]->SetBinContent(b,mp*dMult-mq); \r
4867 }\r
4868 } // end of if(mp*dMult-mq)\r
4869 \r
4870 // 4'-particle correlation:\r
4871 Double_t four1n1n1n1nPtEta = 0.;\r
4872 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4873 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)\r
4874 {\r
4875 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
4876 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))\r
4877 - 2.*q2n0kIm*dReQ1n*dImQ1n\r
4878 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)\r
4879 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)\r
4880 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
4881 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq \r
4882 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n) \r
4883 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n) \r
4884 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n) \r
4885 + 2.*mq*dMult \r
4886 - 6.*mq) \r
4887 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4888 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
4889 \r
4890 if(type == "POI")\r
4891 {\r
4892 // profile to get <<4'>> for POIs:\r
4893 fDiffFlowCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,\r
4894 (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4895 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
4896 // histogram to store <4'> for POIs e-b-e (needed in some other methods):\r
4897 fDiffFlowCorrelationsEBE[1][pe][1]->SetBinContent(b,four1n1n1n1nPtEta); \r
4898 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][1]->SetBinContent(b,(mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4899 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
4900 }\r
4901 else if(type == "RP")\r
4902 {\r
4903 // profile to get <<4'>> for RPs:\r
4904 fDiffFlowCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,\r
4905 (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4906 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
4907 // histogram to store <4'> for RPs e-b-e (needed in some other methods):\r
4908 fDiffFlowCorrelationsEBE[0][pe][1]->SetBinContent(b,four1n1n1n1nPtEta); \r
4909 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][1]->SetBinContent(b,(mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4910 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
4911 }\r
4912 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4913 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
4914 \r
4915 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4916 \r
4917 \r
4918} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta);\r
4919\r
4920\r
4921//================================================================================================================================\r
4922\r
4923\r
4924void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights(TString type, TString ptOrEta)\r
4925{\r
4926 // Calculate sums of various event weights for reduced correlations. \r
4927 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)\r
4928\r
4929 Int_t typeFlag = -1;\r
4930 Int_t ptEtaFlag = -1;\r
4931\r
4932 if(type == "RP")\r
4933 {\r
4934 typeFlag = 0;\r
4935 } else if(type == "POI")\r
4936 {\r
4937 typeFlag = 1;\r
4938 } \r
4939 \r
4940 if(ptOrEta == "Pt")\r
4941 {\r
4942 ptEtaFlag = 0;\r
4943 } else if(ptOrEta == "Eta")\r
4944 {\r
4945 ptEtaFlag = 1;\r
4946 } \r
4947 \r
4948 // shortcuts:\r
4949 Int_t t = typeFlag;\r
4950 Int_t pe = ptEtaFlag;\r
4951 \r
4952 // binning:\r
4953 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
4954 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
4955 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
4956 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
4957 \r
4958 for(Int_t rpq=0;rpq<3;rpq++)\r
4959 {\r
4960 for(Int_t m=0;m<4;m++)\r
4961 {\r
4962 for(Int_t k=0;k<9;k++)\r
4963 {\r
4964 if(!fReRPQ1dEBE[rpq][pe][m][k])\r
4965 {\r
4966 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;\r
4967 cout<<"pe = "<<pe<<endl;\r
4968 cout<<"rpq = "<<rpq<<endl;\r
4969 cout<<"m = "<<m<<endl;\r
4970 cout<<"k = "<<k<<endl;\r
4971 exit(0); \r
4972 }\r
4973 }\r
4974 }\r
4975 } \r
4976\r
4977 // multiplicities:\r
4978 Double_t dMult = (*fSMpk)(0,0); // total event multiplicity\r
4979 //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
4980 Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
4981 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
4982 \r
4983 // event weights for reduced correlations:\r
4984 Double_t dw2 = 0.; // event weight for <2'>\r
4985 Double_t dw4 = 0.; // event weight for <4'>\r
4986 //Double_t dw6 = 0.; // event weight for <6'>\r
4987 //Double_t dw8 = 0.; // event weight for <8'>\r
4988\r
4989 // looping over bins:\r
4990 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4991 {\r
4992 if(type == "RP")\r
4993 {\r
4994 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
4995 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
4996 } else if(type == "POI")\r
4997 {\r
4998 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
4999 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b); \r
5000 }\r
5001 \r
5002 // event weight for <2'>:\r
5003 dw2 = mp*dMult-mq; \r
5004 fDiffFlowSumOfEventWeights[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2);\r
5005 fDiffFlowSumOfEventWeights[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw2,2.));\r
5006 \r
5007 // event weight for <4'>:\r
5008 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5009 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); \r
5010 fDiffFlowSumOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4);\r
5011 fDiffFlowSumOfEventWeights[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw4,2.));\r
5012 \r
5013 // event weight for <6'>:\r
5014 //dw6 = ...; \r
5015 //fDiffFlowSumOfEventWeights[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6);\r
5016 //fDiffFlowSumOfEventWeights[t][pe][t][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw6,2.));\r
5017 \r
5018 // event weight for <8'>:\r
5019 //dw8 = ...; \r
5020 //fDiffFlowSumOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw8);\r
5021 //fDiffFlowSumOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw8,2.)); \r
5022 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++) \r
5023 \r
5024} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights()\r
5025\r
5026\r
5027//================================================================================================================================\r
5028\r
5029\r
5030void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)\r
5031{\r
5032 // Calculate sum of products of various event weights for both types of correlations (the ones for int. and diff. flow). \r
5033 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)\r
5034 //\r
5035 // Important: To fill fDiffFlowSumOfProductOfEventWeights[][][][] use bellow table (i,j) with following constraints: \r
5036 // 1.) i<j \r
5037 // 2.) do not store terms which DO NOT include reduced correlations;\r
5038 // Table:\r
5039 // [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>] x [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>]\r
5040 \r
5041 Int_t typeFlag = -1;\r
5042 Int_t ptEtaFlag = -1;\r
5043\r
5044 if(type == "RP")\r
5045 {\r
5046 typeFlag = 0;\r
5047 } else if(type == "POI")\r
5048 {\r
5049 typeFlag = 1;\r
5050 } \r
5051 \r
5052 if(ptOrEta == "Pt")\r
5053 {\r
5054 ptEtaFlag = 0;\r
5055 } else if(ptOrEta == "Eta")\r
5056 {\r
5057 ptEtaFlag = 1;\r
5058 } \r
5059 \r
5060 // shortcuts:\r
5061 Int_t t = typeFlag;\r
5062 Int_t pe = ptEtaFlag;\r
5063 \r
5064 // binning:\r
5065 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5066 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5067 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
5068 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5069 \r
5070 // protection:\r
5071 for(Int_t rpq=0;rpq<3;rpq++)\r
5072 {\r
5073 for(Int_t m=0;m<4;m++)\r
5074 {\r
5075 for(Int_t k=0;k<9;k++)\r
5076 {\r
5077 if(!fReRPQ1dEBE[rpq][pe][m][k])\r
5078 {\r
5079 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;\r
5080 cout<<"pe = "<<pe<<endl;\r
5081 cout<<"rpq = "<<rpq<<endl;\r
5082 cout<<"m = "<<m<<endl;\r
5083 cout<<"k = "<<k<<endl;\r
5084 exit(0); \r
5085 }\r
5086 }\r
5087 }\r
5088 } \r
5089 \r
5090 // multiplicities:\r
5091 Double_t dMult = (*fSMpk)(0,0); // total event multiplicity\r
5092 //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
5093 Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
5094 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
5095 \r
5096 // event weights for correlations:\r
5097 Double_t dW2 = dMult*(dMult-1); // event weight for <2> \r
5098 Double_t dW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
5099 Double_t dW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
5100 Double_t dW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
5101\r
5102 // event weights for reduced correlations:\r
5103 Double_t dw2 = 0.; // event weight for <2'>\r
5104 Double_t dw4 = 0.; // event weight for <4'>\r
5105 //Double_t dw6 = 0.; // event weight for <6'>\r
5106 //Double_t dw8 = 0.; // event weight for <8'>\r
5107 \r
5108 // looping over bins:\r
5109 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5110 {\r
5111 if(type == "RP")\r
5112 {\r
5113 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
5114 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
5115 } else if(type == "POI")\r
5116 {\r
5117 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
5118 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b); \r
5119 }\r
5120 \r
5121 // event weight for <2'>:\r
5122 dw2 = mp*dMult-mq; \r
5123 fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw2); // storing product of even weights for <2> and <2'>\r
5124 fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW4); // storing product of even weights for <4> and <2'>\r
5125 fDiffFlowSumOfProductOfEventWeights[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW6); // storing product of even weights for <6> and <2'>\r
5126 fDiffFlowSumOfProductOfEventWeights[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW8); // storing product of even weights for <8> and <2'>\r
5127 \r
5128 // event weight for <4'>:\r
5129 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5130 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); \r
5131 fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw4); // storing product of even weights for <2> and <4'>\r
5132 fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw4); // storing product of even weights for <2'> and <4'>\r
5133 fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw4); // storing product of even weights for <4> and <4'>\r
5134 fDiffFlowSumOfProductOfEventWeights[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW6); // storing product of even weights for <6> and <4'> \r
5135 fDiffFlowSumOfProductOfEventWeights[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW8); // storing product of even weights for <8> and <4'>\r
5136\r
5137 // event weight for <6'>:\r
5138 //dw6 = ...; \r
5139 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw6); // storing product of even weights for <2> and <6'>\r
5140 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw6); // storing product of even weights for <2'> and <6'>\r
5141 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw6); // storing product of even weights for <4> and <6'>\r
5142 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw6); // storing product of even weights for <4'> and <6'> \r
5143 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw6); // storing product of even weights for <6> and <6'>\r
5144 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dW8); // storing product of even weights for <6'> and <8>\r
5145 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>\r
5146\r
5147 // event weight for <8'>:\r
5148 //dw8 = ...; \r
5149 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw8); // storing product of even weights for <2> and <8'>\r
5150 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw8); // storing product of even weights for <2'> and <8'>\r
5151 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw8); // storing product of even weights for <4> and <8'>\r
5152 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw8); // storing product of even weights for <4'> and <8'> \r
5153 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw8); // storing product of even weights for <6> and <8'>\r
5154 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>\r
5155 //fDiffFlowSumOfProductOfEventWeights[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW8*dw8); // storing product of even weights for <8> and <8'>\r
5156 \r
5157 // Table:\r
5158 // [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>] x [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>]\r
5159 \r
5160 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5161 \r
5162\r
5163\r
5164} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)\r
5165\r
5166\r
5167//================================================================================================================================\r
5168\r
5169\r
5170void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)\r
5171{\r
5172 // Transfer profiles into histograms and calculate statistical errors correctly.\r
5173\r
5174 Int_t typeFlag = -1;\r
5175 Int_t ptEtaFlag = -1;\r
5176\r
5177 if(type == "RP")\r
5178 {\r
5179 typeFlag = 0;\r
5180 } else if(type == "POI")\r
5181 {\r
5182 typeFlag = 1;\r
5183 } \r
5184 \r
5185 if(ptOrEta == "Pt")\r
5186 {\r
5187 ptEtaFlag = 0;\r
5188 } else if(ptOrEta == "Eta")\r
5189 {\r
5190 ptEtaFlag = 1;\r
5191 } \r
5192 \r
5193 // shortcuts:\r
5194 Int_t t = typeFlag;\r
5195 Int_t pe = ptEtaFlag;\r
5196 \r
5197 for(Int_t rci=0;rci<4;rci++)\r
5198 {\r
5199 if(!fDiffFlowCorrelationsPro[t][pe][rci])\r
5200 {\r
5201 cout<<"WARNING: fDiffFlowCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;\r
5202 cout<<"t = "<<t<<endl; \r
5203 cout<<"pe = "<<pe<<endl; \r
5204 cout<<"rci = "<<rci<<endl;\r
5205 exit(0); \r
5206 }\r
5207 for(Int_t power=0;power<2;power++)\r
5208 {\r
5209 if(!fDiffFlowSumOfEventWeights[t][pe][power][rci])\r
5210 {\r
5211 cout<<"WARNING: fDiffFlowSumOfEventWeights[t][pe][power][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;\r
5212 cout<<"t = "<<t<<endl; \r
5213 cout<<"pe = "<<pe<<endl;\r
5214 cout<<"power = "<<power<<endl; \r
5215 cout<<"rci = "<<rci<<endl;\r
5216 exit(0); \r
5217 } \r
5218 } // end of for(Int_t power=0;power<2;power++)\r
5219 } // end of for(Int_t rci=0;rci<4;rci++)\r
5220 \r
5221 // common:\r
5222 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5223 \r
5224 // transfer 1D profile into 1D histogram:\r
5225 Double_t correlation = 0.;\r
5226 Double_t spread = 0.;\r
5227 Double_t sumOfWeights = 0.; // sum of weights for particular reduced correlations for particular pt or eta bin\r
5228 Double_t sumOfSquaredWeights = 0.; // sum of squared weights for particular reduced correlations for particular pt or eta bin\r
5229 Double_t error = 0.; // error = termA * spread * termB\r
5230 // termA = (sqrt(sumOfSquaredWeights)/sumOfWeights) \r
5231 // termB = 1/pow(1-termA^2,0.5)\r
5232 Double_t termA = 0.; \r
5233 Double_t termB = 0.; \r
5234 for(Int_t rci=0;rci<4;rci++) // index of reduced correlation\r
5235 {\r
5236 for(Int_t b=1;b<=nBinsPtEta[pe];b++) // number of pt or eta bins\r
5237 {\r
5238 correlation = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(b); \r
5239 spread = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinError(b);\r
5240 sumOfWeights = fDiffFlowSumOfEventWeights[t][pe][0][rci]->GetBinContent(b);\r
5241 sumOfSquaredWeights = fDiffFlowSumOfEventWeights[t][pe][1][rci]->GetBinContent(b);\r
5242 if(sumOfWeights) termA = (pow(sumOfSquaredWeights,0.5)/sumOfWeights);\r
5243 if(1.-pow(termA,2.)>0.) termB = 1./pow(1.-pow(termA,2.),0.5); \r
5244 error = termA*spread*termB; // final error (unbiased estimator for standard deviation)\r
5245 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinContent(b,correlation); \r
5246 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinError(b,error); \r
5247 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5248 } // end of for(Int_t rci=0;rci<4;rci++)\r
5249 \r
5250} // end of void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)\r
5251\r
5252\r
5253//================================================================================================================================\r
5254\r
5255\r
5256void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)\r
5257{\r
5258 // store products: <2><2'>, <2><4'>, <2><6'>, <2><8'>, <2'><4>, \r
5259 // <2'><4'>, <2'><6>, <2'><6'>, <2'><8>, <2'><8'>,\r
5260 // <4><4'>, <4><6'>, <4><8'>, <4'><6>, <4'><6'>, \r
5261 // <4'><8>, <4'><8'>, <6><6'>, <6><8'>, <6'><8>, \r
5262 // <6'><8'>, <8><8'>.\r
5263 \r
5264 Int_t typeFlag = -1;\r
5265 Int_t ptEtaFlag = -1;\r
5266\r
5267 if(type == "RP")\r
5268 {\r
5269 typeFlag = 0;\r
5270 } else if(type == "POI")\r
5271 {\r
5272 typeFlag = 1;\r
5273 } \r
5274 \r
5275 if(ptOrEta == "Pt")\r
5276 {\r
5277 ptEtaFlag = 0;\r
5278 } else if(ptOrEta == "Eta")\r
5279 {\r
5280 ptEtaFlag = 1;\r
5281 } \r
5282 \r
5283 // shortcuts:\r
5284 Int_t t = typeFlag;\r
5285 Int_t pe = ptEtaFlag;\r
5286 \r
5287 // common:\r
5288 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5289 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5290 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5291 \r
5292 // protections // to be improved (add protection for all pointers in this method)\r
5293 if(!fIntFlowCorrelationsEBE)\r
5294 {\r
5295 cout<<"WARNING: fIntFlowCorrelationsEBE is NULL in AFAWQC::CDFPOC() !!!!"<<endl;\r
5296 exit(0);\r
5297 } \r
5298 \r
5299 /* \r
5300 Double_t dMult = (*fSMpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)\r
5301 //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
5302 Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
5303 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
5304 */\r
5305\r
5306 // e-b-e correlations:\r
5307 Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>\r
5308 Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>\r
5309 Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>\r
5310 Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>\r
5311 \r
5312 // event weights for correlations:\r
5313 Double_t dW2 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1); // event weight for <2> \r
5314 Double_t dW4 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2); // event weight for <4> \r
5315 Double_t dW6 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(3); // event weight for <6> \r
5316 Double_t dW8 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(4); // event weight for <8> \r
5317 \r
5318 // e-b-e reduced correlations:\r
5319 Double_t twoReducedEBE = 0.; // <2'>\r
5320 Double_t fourReducedEBE = 0.; // <4'>\r
5321 Double_t sixReducedEBE = 0.; // <6'>\r
5322 Double_t eightReducedEBE = 0.; // <8'> \r
5323 \r
5324 // event weights for reduced correlations:\r
5325 Double_t dw2 = 0.; // event weight for <2'>\r
5326 Double_t dw4 = 0.; // event weight for <4'>\r
5327 //Double_t dw6 = 0.; // event weight for <6'>\r
5328 //Double_t dw8 = 0.; // event weight for <8'>\r
5329\r
5330 // looping over bins:\r
5331 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5332 {\r
5333 // e-b-e reduced correlations:\r
5334 twoReducedEBE = fDiffFlowCorrelationsEBE[t][pe][0]->GetBinContent(b);\r
5335 fourReducedEBE = fDiffFlowCorrelationsEBE[t][pe][1]->GetBinContent(b);\r
5336 sixReducedEBE = fDiffFlowCorrelationsEBE[t][pe][2]->GetBinContent(b);\r
5337 eightReducedEBE = fDiffFlowCorrelationsEBE[t][pe][3]->GetBinContent(b);\r
5338 \r
5339 /*\r
5340 // to be improved (I should not do this here again)\r
5341 if(type == "RP")\r
5342 {\r
5343 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
5344 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
5345 } else if(type == "POI")\r
5346 {\r
5347 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
5348 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b); \r
5349 }\r
5350 \r
5351 // event weights for reduced correlations:\r
5352 dw2 = mp*dMult-mq; // weight for <2'> \r
5353 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5354 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); // weight for <4'>\r
5355 //dw6 = ... \r
5356 //dw8 = ... \r
5357 \r
5358 */\r
5359 \r
5360 dw2 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->GetBinContent(b);\r
5361 dw4 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->GetBinContent(b);\r
5362 \r
5363 // storing all products:\r
5364 fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*twoReducedEBE,dW2*dw2); // storing <2><2'>\r
5365 fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*twoReducedEBE,dW4*dw2); // storing <4><2'>\r
5366 fDiffFlowProductOfCorrelationsPro[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*twoReducedEBE,dW6*dw2); // storing <6><2'>\r
5367 fDiffFlowProductOfCorrelationsPro[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*twoReducedEBE,dW8*dw2); // storing <8><2'>\r
5368 \r
5369 // event weight for <4'>:\r
5370 fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*fourReducedEBE,dW2*dw4); // storing <2><4'>\r
5371 fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*fourReducedEBE,dw2*dw4); // storing <2'><4'>\r
5372 fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*fourReducedEBE,dW4*dw4); // storing <4><4'>\r
5373 fDiffFlowProductOfCorrelationsPro[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*fourReducedEBE,dW6*dw4); // storing <6><4'> \r
5374 fDiffFlowProductOfCorrelationsPro[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*fourReducedEBE,dW8*dw4); // storing <8><4'>\r
5375\r
5376 // event weight for <6'>:\r
5377 //dw6 = ...; \r
5378 //fDiffFlowProductOfCorrelationsPro[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*sixReducedEBE,dW2*dw6); // storing <2><6'>\r
5379 //fDiffFlowProductOfCorrelationsPro[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*sixReducedEBE,dw2*dw6); // storing <2'><6'>\r
5380 //fDiffFlowProductOfCorrelationsPro[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*sixReducedEBE,dW4*dw6); // storing <4><6'>\r
5381 //fDiffFlowProductOfCorrelationsPro[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*sixReducedEBE,dw4*dw6); // storing <4'><6'> \r
5382 //fDiffFlowProductOfCorrelationsPro[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*sixReducedEBE,dW6*dw6); // storing <6><6'>\r
5383 //fDiffFlowProductOfCorrelationsPro[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightEBE,dw6*dW8); // storing <6'><8>\r
5384 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>\r
5385\r
5386 // event weight for <8'>:\r
5387 //dw8 = ...; \r
5388 //fDiffFlowProductOfCorrelationsPro[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*eightReducedEBE,dW2*dw8); // storing <2><8'>\r
5389 //fDiffFlowProductOfCorrelationsPro[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*eightReducedEBE,dw2*dw8); // storing <2'><8'>\r
5390 //fDiffFlowProductOfCorrelationsPro[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*eightReducedEBE,dW4*dw8); // storing <4><8'>\r
5391 //fDiffFlowProductOfCorrelationsPro[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*eightReducedEBE,dw4*dw8); // storing <4'><8'> \r
5392 //fDiffFlowProductOfCorrelationsPro[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*eightReducedEBE,dW6*dw8); // storing <6><8'>\r
5393 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>\r
5394 //fDiffFlowProductOfCorrelationsPro[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*eightReducedEBE,dW8*dw8); // storing <8><8'> \r
5395 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++ \r
5396 \r
5397} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)\r
5398\r
5399\r
5400//================================================================================================================================\r
5401 \r
5402 \r
5403void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta) // to be improved (reimplemented)\r
5404{\r
5405 // a) Calculate unbiased estimators Cov(<2>,<2'>), Cov(<2>,<4'>), Cov(<4>,<2'>), Cov(<4>,<4'>) and Cov(<2'>,<4'>)\r
5406 // for covariances V(<2>,<2'>), V(<2>,<4'>), V(<4>,<2'>), V(<4>,<4'>) and V(<2'>,<4'>). \r
5407 // b) Store in histogram fDiffFlowCovariances[t][pe][index] for instance the following: \r
5408 //\r
5409 // Cov(<2>,<2'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)]\r
5410 // \r
5411 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<2'>} is event weight for <2'>.\r
5412 // c) Binning of fDiffFlowCovariances[t][pe][index] is organized as follows:\r
5413 // \r
5414 // 1st bin: Cov(<2>,<2'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)] \r
5415 // 2nd bin: Cov(<2>,<4'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5416 // 3rd bin: Cov(<4>,<2'>) * (sum_{i=1}^{N} w_{<4>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)] \r
5417 // 4th bin: Cov(<4>,<4'>) * (sum_{i=1}^{N} w_{<4>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5418 // 5th bin: Cov(<2'>,<4'>) * (sum_{i=1}^{N} w_{<2'>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<2'>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5419 // ...\r
5420 \r
5421 Int_t typeFlag = -1;\r
5422 Int_t ptEtaFlag = -1;\r
5423\r
5424 if(type == "RP")\r
5425 {\r
5426 typeFlag = 0;\r
5427 } else if(type == "POI")\r
5428 {\r
5429 typeFlag = 1;\r
5430 } \r
5431 \r
5432 if(ptOrEta == "Pt")\r
5433 {\r
5434 ptEtaFlag = 0;\r
5435 } else if(ptOrEta == "Eta")\r
5436 {\r
5437 ptEtaFlag = 1;\r
5438 } \r
5439 \r
5440 // shortcuts:\r
5441 Int_t t = typeFlag;\r
5442 Int_t pe = ptEtaFlag;\r
5443 \r
5444 // common:\r
5445 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5446 //Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5447 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
5448 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5449 \r
5450 // average correlations:\r
5451 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
5452 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
5453 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>\r
5454 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>\r
5455 \r
5456 // sum of weights for correlation:\r
5457 Double_t sumOfWeightsForTwo = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // sum_{i=1}^{N} w_{<2>}\r
5458 Double_t sumOfWeightsForFour = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // sum_{i=1}^{N} w_{<4>}\r
5459 //Double_t sumOfWeightsForSix = fIntFlowSumOfEventWeights[0]->GetBinContent(3); // sum_{i=1}^{N} w_{<6>}\r
5460 //Double_t sumOfWeightsForEight = fIntFlowSumOfEventWeights[0]->GetBinContent(4); // sum_{i=1}^{N} w_{<8>}\r
5461 \r
5462 // average reduced correlations:\r
5463 Double_t twoReduced = 0.; // <<2'>> \r
5464 Double_t fourReduced = 0.; // <<4'>>\r
5465 //Double_t sixReduced = 0.; // <<6'>>\r
5466 //Double_t eightReduced = 0.; // <<8'>>\r
5467\r
5468 // sum of weights for reduced correlation:\r
5469 Double_t sumOfWeightsForTwoReduced = 0.; // sum_{i=1}^{N} w_{<2'>}\r
5470 Double_t sumOfWeightsForFourReduced = 0.; // sum_{i=1}^{N} w_{<4'>}\r
5471 //Double_t sumOfWeightsForSixReduced = 0.; // sum_{i=1}^{N} w_{<6'>}\r
5472 //Double_t sumOfWeightsForEightReduced = 0.; // sum_{i=1}^{N} w_{<8'>}\r
5473 \r
5474 // product of weights for reduced correlation:\r
5475 Double_t productOfWeightsForTwoTwoReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<2'>}\r
5476 Double_t productOfWeightsForTwoFourReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<4'>}\r
5477 Double_t productOfWeightsForFourTwoReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<2'>}\r
5478 Double_t productOfWeightsForFourFourReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<4'>}\r
5479 Double_t productOfWeightsForTwoReducedFourReduced = 0.; // sum_{i=1}^{N} w_{<2'>}w_{<4'>}\r
5480 // ...\r
5481 \r
5482 // products for differential flow:\r
5483 Double_t twoTwoReduced = 0; // <<2><2'>> \r
5484 Double_t twoFourReduced = 0; // <<2><4'>> \r
5485 Double_t fourTwoReduced = 0; // <<4><2'>> \r
5486 Double_t fourFourReduced = 0; // <<4><4'>> \r
5487 Double_t twoReducedFourReduced = 0; // <<2'><4'>> \r
5488\r
5489 // denominators in the expressions for the unbiased estimators for covariances:\r
5490 // denominator = 1 - term1/(term2*term3)\r
5491 // prefactor = term1/(term2*term3)\r
5492 Double_t denominator = 0.; \r
5493 Double_t prefactor = 0.;\r
5494 Double_t term1 = 0.; \r
5495 Double_t term2 = 0.; \r
5496 Double_t term3 = 0.; \r
5497 \r
5498 // unbiased estimators for covariances for differential flow:\r
5499 Double_t covTwoTwoReduced = 0.; // Cov(<2>,<2'>)\r
5500 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(w_{<2>},w_{<2'>})\r
5501 Double_t covTwoFourReduced = 0.; // Cov(<2>,<4'>)\r
5502 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(w_{<2>},w_{<4'>})\r
5503 Double_t covFourTwoReduced = 0.; // Cov(<4>,<2'>)\r
5504 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(w_{<4>},w_{<2'>})\r
5505 Double_t covFourFourReduced = 0.; // Cov(<4>,<4'>)\r
5506 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(w_{<4>},w_{<4'>})\r
5507 Double_t covTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>)\r
5508 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(w_{<2'>},w_{<4'>})\r
5509 \r
5510 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5511 {\r
5512 // average reduced corelations:\r
5513 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);\r
5514 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);\r
5515 // average products:\r
5516 twoTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->GetBinContent(b);\r
5517 twoFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->GetBinContent(b);\r
5518 fourTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->GetBinContent(b);\r
5519 fourFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->GetBinContent(b);\r
5520 twoReducedFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->GetBinContent(b); \r
5521 // sum of weights for reduced correlations:\r
5522 sumOfWeightsForTwoReduced = fDiffFlowSumOfEventWeights[t][pe][0][0]->GetBinContent(b);\r
5523 sumOfWeightsForFourReduced = fDiffFlowSumOfEventWeights[t][pe][0][1]->GetBinContent(b);\r
5524 // products of weights for correlations:\r
5525 productOfWeightsForTwoTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->GetBinContent(b); \r
5526 productOfWeightsForTwoFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->GetBinContent(b);\r
5527 productOfWeightsForFourTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->GetBinContent(b);\r
5528 productOfWeightsForFourFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->GetBinContent(b);\r
5529 productOfWeightsForTwoReducedFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->GetBinContent(b);\r
5530 // denominator for the unbiased estimator for covariances: 1 - term1/(term2*term3) \r
5531 // prefactor (multiplies Cov's) = term1/(term2*term3) \r
5532 // <2>,<2'>:\r
5533 term1 = productOfWeightsForTwoTwoReduced; \r
5534 term2 = sumOfWeightsForTwo;\r
5535 term3 = sumOfWeightsForTwoReduced; \r
5536 if(term2*term3>0.)\r
5537 {\r
5538 denominator = 1.-term1/(term2*term3);\r
5539 prefactor = term1/(term2*term3);\r
5540 if(denominator!=0)\r
5541 {\r
5542 covTwoTwoReduced = (twoTwoReduced-two*twoReduced)/denominator; \r
5543 wCovTwoTwoReduced = covTwoTwoReduced*prefactor; \r
5544 fDiffFlowCovariances[t][pe][0]->SetBinContent(b,wCovTwoTwoReduced);\r
5545 }\r
5546 }\r
5547 // <2>,<4'>:\r
5548 term1 = productOfWeightsForTwoFourReduced; \r
5549 term2 = sumOfWeightsForTwo;\r
5550 term3 = sumOfWeightsForFourReduced; \r
5551 if(term2*term3>0.)\r
5552 {\r
5553 denominator = 1.-term1/(term2*term3);\r
5554 prefactor = term1/(term2*term3);\r
5555 if(denominator!=0)\r
5556 {\r
5557 covTwoFourReduced = (twoFourReduced-two*fourReduced)/denominator; \r
5558 wCovTwoFourReduced = covTwoFourReduced*prefactor; \r
5559 fDiffFlowCovariances[t][pe][1]->SetBinContent(b,wCovTwoFourReduced);\r
5560 }\r
5561 }\r
5562 // <4>,<2'>:\r
5563 term1 = productOfWeightsForFourTwoReduced; \r
5564 term2 = sumOfWeightsForFour;\r
5565 term3 = sumOfWeightsForTwoReduced; \r
5566 if(term2*term3>0.)\r
5567 {\r
5568 denominator = 1.-term1/(term2*term3);\r
5569 prefactor = term1/(term2*term3);\r
5570 if(denominator!=0)\r
5571 {\r
5572 covFourTwoReduced = (fourTwoReduced-four*twoReduced)/denominator; \r
5573 wCovFourTwoReduced = covFourTwoReduced*prefactor; \r
5574 fDiffFlowCovariances[t][pe][2]->SetBinContent(b,wCovFourTwoReduced);\r
5575 }\r
5576 }\r
5577 // <4>,<4'>:\r
5578 term1 = productOfWeightsForFourFourReduced; \r
5579 term2 = sumOfWeightsForFour;\r
5580 term3 = sumOfWeightsForFourReduced; \r
5581 if(term2*term3>0.)\r
5582 {\r
5583 denominator = 1.-term1/(term2*term3);\r
5584 prefactor = term1/(term2*term3);\r
5585 if(denominator!=0)\r
5586 {\r
5587 covFourFourReduced = (fourFourReduced-four*fourReduced)/denominator; \r
5588 wCovFourFourReduced = covFourFourReduced*prefactor; \r
5589 fDiffFlowCovariances[t][pe][3]->SetBinContent(b,wCovFourFourReduced);\r
5590 }\r
5591 }\r
5592 // <2'>,<4'>:\r
5593 term1 = productOfWeightsForTwoReducedFourReduced; \r
5594 term2 = sumOfWeightsForTwoReduced;\r
5595 term3 = sumOfWeightsForFourReduced; \r
5596 if(term2*term3>0.)\r
5597 {\r
5598 denominator = 1.-term1/(term2*term3);\r
5599 prefactor = term1/(term2*term3);\r
5600 if(denominator!=0)\r
5601 {\r
5602 covTwoReducedFourReduced = (twoReducedFourReduced-twoReduced*fourReduced)/denominator; \r
5603 wCovTwoReducedFourReduced = covTwoReducedFourReduced*prefactor; \r
5604 fDiffFlowCovariances[t][pe][4]->SetBinContent(b,wCovTwoReducedFourReduced);\r
5605 }\r
5606 } \r
5607 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5608 \r
5609} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta)\r
5610\r
5611\r
5612//================================================================================================================================\r
5613\r
5614\r
5615void AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, TString ptOrEta)\r
5616{\r
5617 // calculate differential flow from differential cumulants and previously obtained integrated flow: (to be improved: description)\r
5618 \r
5619 Int_t typeFlag = -1;\r
5620 Int_t ptEtaFlag = -1;\r
5621\r
5622 if(type == "RP")\r
5623 {\r
5624 typeFlag = 0;\r
5625 } else if(type == "POI")\r
5626 {\r
5627 typeFlag = 1;\r
5628 } \r
5629 \r
5630 if(ptOrEta == "Pt")\r
5631 {\r
5632 ptEtaFlag = 0;\r
5633 } else if(ptOrEta == "Eta")\r
5634 {\r
5635 ptEtaFlag = 1;\r
5636 } \r
5637 \r
5638 // shortcuts:\r
5639 Int_t t = typeFlag;\r
5640 Int_t pe = ptEtaFlag;\r
5641 \r
5642 // common:\r
5643 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5644 \r
5645 // correlations:\r
5646 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
5647 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
5648 \r
5649 // statistical errors of correlations:\r
5650 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);\r
5651 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); \r
5652 \r
5653 // reduced correlations:\r
5654 Double_t twoReduced = 0.; // <<2'>>\r
5655 Double_t fourReduced = 0.; // <<4'>>\r
5656 \r
5657 // statistical errors of reduced correlations:\r
5658 Double_t twoReducedError = 0.; \r
5659 Double_t fourReducedError = 0.; \r
5660\r
5661 // covariances:\r
5662 Double_t wCovTwoFour = fIntFlowCovariances->GetBinContent(1);// // Cov(<2>,<4>) * prefactor(<2>,<4>)\r
5663 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(<2>,<2'>)\r
5664 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(<2>,<4'>)\r
5665 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(<4>,<2'>)\r
5666 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(<4>,<4'>)\r
5667 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)\r
5668 \r
5669 // differential flow:\r
5670 Double_t v2Prime = 0.; // v'{2} \r
5671 Double_t v4Prime = 0.; // v'{4}\r
5672 \r
5673 // statistical error of differential flow:\r
5674 Double_t v2PrimeError = 0.; \r
5675 Double_t v4PrimeError = 0.; \r
5676 \r
5677 // squared statistical error of differential flow:\r
5678 Double_t v2PrimeErrorSquared = 0.; \r
5679 Double_t v4PrimeErrorSquared = 0.; \r
5680 \r
5681 // loop over pt or eta bins:\r
5682 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5683 {\r
5684 // reduced correlations and statistical errors:\r
5685 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);\r
5686 twoReducedError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b);\r
5687 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);\r
5688 fourReducedError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b);\r
5689 // covariances:\r
5690 wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b);\r
5691 wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b);\r
5692 wCovFourTwoReduced = fDiffFlowCovariances[t][pe][2]->GetBinContent(b);\r
5693 wCovFourFourReduced = fDiffFlowCovariances[t][pe][3]->GetBinContent(b);\r
5694 wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b);\r
5695 // differential flow:\r
5696 // v'{2}:\r
5697 if(two>0.) \r
5698 {\r
5699 v2Prime = twoReduced/pow(two,0.5);\r
5700 v2PrimeErrorSquared = (1./4.)*pow(two,-3.)*\r
5701 (pow(twoReduced,2.)*pow(twoError,2.)\r
5702 + 4.*pow(two,2.)*pow(twoReducedError,2.)\r
5703 - 4.*two*twoReduced*wCovTwoTwoReduced);\r
5704 \r
5705 \r
5706 if(v2PrimeErrorSquared>0.) v2PrimeError = pow(v2PrimeErrorSquared,0.5);\r
5707 fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime); \r
5708 fDiffFlow[t][pe][0]->SetBinError(b,v2PrimeError); \r
5709 }\r
5710 // differential flow:\r
5711 // v'{4}\r
5712 if(2.*pow(two,2.)-four > 0.) \r
5713 {\r
5714 v4Prime = (2.*two*twoReduced-fourReduced)/pow(2.*pow(two,2.)-four,3./4.);\r
5715 v4PrimeErrorSquared = pow(2.*pow(two,2.)-four,-7./2.)*\r
5716 (pow(2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced,2.)*pow(twoError,2.)\r
5717 + (9./16.)*pow(2.*two*twoReduced-fourReduced,2.)*pow(fourError,2.)\r
5718 + 4.*pow(two,2.)*pow(2.*pow(two,2.)-four,2.)*pow(twoReducedError,2.)\r
5719 + pow(2.*pow(two,2.)-four,2.)*pow(fourReducedError,2.) \r
5720 - (3./2.)*(2.*two*twoReduced-fourReduced)\r
5721 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFour\r
5722 - 4.*two*(2.*pow(two,2.)-four)\r
5723 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoTwoReduced\r
5724 + 2.*(2.*pow(two,2.)-four)\r
5725 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFourReduced\r
5726 + 3.*two*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourTwoReduced\r
5727 - (3./2.)*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourFourReduced \r
5728 - 4.*two*pow(2.*pow(two,2.)-four,2.)*wCovTwoReducedFourReduced); \r
5729 if(v4PrimeErrorSquared>0.) v4PrimeError = pow(v4PrimeErrorSquared,0.5); \r
5730 fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);\r
5731 fDiffFlow[t][pe][1]->SetBinError(b,v4PrimeError); \r
5732 }\r
5733 \r
5734 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)\r
5735 \r
5736 \r
5737 \r
5738 \r
5739 /*\r
5740 // 2D:\r
5741 for(Int_t nua=0;nua<2;nua++)\r
5742 {\r
5743 for(Int_t p=1;p<=fnBinsPt;p++)\r
5744 {\r
5745 for(Int_t e=1;e<=fnBinsEta;e++) \r
5746 { \r
5747 // differential cumulants:\r
5748 Double_t qc2Prime = fFinalCumulants2D[t][pW][eW][nua][0]->GetBinContent(fFinalCumulants2D[t][pW][eW][nua][0]->GetBin(p,e)); // QC{2'} \r
5749 Double_t qc4Prime = fFinalCumulants2D[t][pW][eW][nua][1]->GetBinContent(fFinalCumulants2D[t][pW][eW][nua][1]->GetBin(p,e)); // QC{4'}\r
5750 // differential flow:\r
5751 Double_t v2Prime = 0.; \r
5752 Double_t v4Prime = 0.; \r
5753 if(v2) \r
5754 {\r
5755 v2Prime = qc2Prime/v2;\r
5756 fFinalFlow2D[t][pW][eW][nua][0]->SetBinContent(fFinalFlow2D[t][pW][eW][nua][0]->GetBin(p,e),v2Prime); \r
5757 } \r
5758 if(v4)\r
5759 {\r
5760 v4Prime = -qc4Prime/pow(v4,3.); \r
5761 fFinalFlow2D[t][pW][eW][nua][1]->SetBinContent(fFinalFlow2D[t][pW][eW][nua][1]->GetBin(p,e),v4Prime); \r
5762 } \r
5763 } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
5764 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
5765 } // end of for(Int_t nua=0;nua<2;nua++)\r
5766 */\r
5767\r
5768} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, Bool_t useParticleWeights)\r
5769\r
5770\r
5771//================================================================================================================================\r
5772\r
5773\r
5774void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()\r
5775{\r
5776 // a) Store all flags for integrated flow in profile fIntFlowFlags.\r
5777 \r
5778 if(!fIntFlowFlags)\r
5779 {\r
5780 cout<<"WARNING: fIntFlowFlags is NULL in AFAWQC::SFFIF() !!!!"<<endl;\r
5781 exit(0);\r
5782 } \r
5783\r
5784 fIntFlowFlags->Fill(0.5,(Int_t)fUsePhiWeights||fUsePtWeights||fUseEtaWeights); // particle weights used or not\r
5785 //fIntFlowFlags->Fill(1.5,""); // which event weight was used? // to be improved\r
5786 fIntFlowFlags->Fill(2.5,(Int_t)fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not\r
5787 \r
5788} // end of void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()\r
5789\r
5790\r
5791//================================================================================================================================\r
5792\r
5793\r
5794void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()\r
5795{\r
5796 // Store all flags for differential flow in the profile fDiffFlowFlags.\r
5797 \r
5798 if(!fDiffFlowFlags)\r
5799 {\r
5800 cout<<"WARNING: fDiffFlowFlags is NULL in AFAWQC::SFFDF() !!!!"<<endl;\r
5801 exit(0);\r
5802 } \r
5803 \r
5804 fDiffFlowFlags->Fill(0.5,fUsePhiWeights||fUsePtWeights||fUseEtaWeights); // particle weights used or not\r
5805 //fDiffFlowFlags->Fill(1.5,""); // which event weight was used? // to be improved\r
5806 fDiffFlowFlags->Fill(2.5,fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not\r
5807 fDiffFlowFlags->Fill(3.5,fCalculate2DFlow); // calculate also 2D differential flow in (pt,eta) or not\r
5808 \r
5809} // end of void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()\r
5810\r
5811\r
5812//================================================================================================================================\r
5813\r
5814\r
5815void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms(TList *outputListHistos) \r
5816{\r
5817 // Access all pointers to common control and common result histograms and profiles.\r
5818 \r
5819 if(outputListHistos) \r
5820 {\r
5821 TString commonHistsName = "AliFlowCommonHistQC";\r
5822 commonHistsName += fAnalysisLabel->Data();\r
5823 AliFlowCommonHist *commonHist = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHistsName.Data()));\r
5824 if(commonHist) this->SetCommonHists(commonHist); \r
5825 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";\r
5826 commonHists2ndOrderName += fAnalysisLabel->Data();\r
5827 AliFlowCommonHist *commonHist2nd = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists2ndOrderName.Data()));\r
5828 if(commonHist2nd) this->SetCommonHists2nd(commonHist2nd); \r
5829 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";\r
5830 commonHists4thOrderName += fAnalysisLabel->Data();\r
5831 AliFlowCommonHist *commonHist4th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists4thOrderName.Data()));\r
5832 if(commonHist4th) this->SetCommonHists4th(commonHist4th); \r
5833 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";\r
5834 commonHists6thOrderName += fAnalysisLabel->Data();\r
5835 AliFlowCommonHist *commonHist6th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists6thOrderName.Data()));\r
5836 if(commonHist6th) this->SetCommonHists6th(commonHist6th); \r
5837 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";\r
5838 commonHists8thOrderName += fAnalysisLabel->Data();\r
5839 AliFlowCommonHist *commonHist8th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists8thOrderName.Data()));\r
5840 if(commonHist8th) this->SetCommonHists8th(commonHist8th); \r
5841 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC"; \r
5842 commonHistResults2ndOrderName += fAnalysisLabel->Data(); \r
5843 AliFlowCommonHistResults *commonHistRes2nd = dynamic_cast<AliFlowCommonHistResults*>\r
5844 (outputListHistos->FindObject(commonHistResults2ndOrderName.Data()));\r
5845 if(commonHistRes2nd) this->SetCommonHistsResults2nd(commonHistRes2nd); \r
5846 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";\r
5847 commonHistResults4thOrderName += fAnalysisLabel->Data();\r
5848 AliFlowCommonHistResults *commonHistRes4th = dynamic_cast<AliFlowCommonHistResults*>\r
5849 (outputListHistos->FindObject(commonHistResults4thOrderName.Data()));\r
5850 if(commonHistRes4th) this->SetCommonHistsResults4th(commonHistRes4th); \r
5851 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";\r
5852 commonHistResults6thOrderName += fAnalysisLabel->Data();\r
5853 AliFlowCommonHistResults *commonHistRes6th = dynamic_cast<AliFlowCommonHistResults*>\r
5854 (outputListHistos->FindObject(commonHistResults6thOrderName.Data()));\r
5855 if(commonHistRes6th) this->SetCommonHistsResults6th(commonHistRes6th); \r
5856 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";\r
5857 commonHistResults8thOrderName += fAnalysisLabel->Data();\r
5858 AliFlowCommonHistResults *commonHistRes8th = dynamic_cast<AliFlowCommonHistResults*>\r
5859 (outputListHistos->FindObject(commonHistResults8thOrderName.Data())); \r
5860 if(commonHistRes8th) this->SetCommonHistsResults8th(commonHistRes8th);\r
5861 } else\r
5862 {\r
5863 cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFCH() !!!!"<<endl;\r
5864 exit(0);\r
5865 }\r
5866 \r
5867} // end of void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms(TList *outputListHistos) \r
5868\r
5869\r
5870//================================================================================================================================\r
5871\r
5872\r
5873void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms(TList *outputListHistos) \r
5874{\r
5875 // Get pointers for histograms with particle weights.\r
5876\r
5877 if(outputListHistos)\r
5878 {\r
5879 TList *weightsList = dynamic_cast<TList*>(outputListHistos->FindObject("Weights"));\r
5880 if(weightsList) this->SetWeightsList(weightsList);\r
5881 TString fUseParticleWeightsName = "fUseParticleWeightsQC"; // to be improved (hirdwired label QC)\r
5882 fUseParticleWeightsName += fAnalysisLabel->Data();\r
5883 TProfile *useParticleWeights = dynamic_cast<TProfile*>(weightsList->FindObject(fUseParticleWeightsName.Data()));\r
5884 if(useParticleWeights)\r
5885 {\r
5886 this->SetUseParticleWeights(useParticleWeights); \r
5887 fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1); \r
5888 fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2); \r
5889 fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3); \r
5890 }\r
5891 } else\r
5892 {\r
5893 cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFPWH() !!!!"<<endl;\r
5894 exit(0);\r
5895 }\r
5896\r
5897} // end of void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms(TList *outputListHistos); \r
5898\r
5899\r
5900//================================================================================================================================\r
5901\r
5902\r
5903void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms(TList *outputListHistos) \r
5904{\r
5905 // Get pointers for histograms and profiles relevant for integrated flow:\r
5906 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults.\r
5907 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow.\r
5908 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds. \r
5909 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds. \r
5910 \r
5911 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data member?)\r
5912 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data member?)\r
5913 \r
5914 if(outputListHistos)\r
5915 {\r
5916 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults:\r
5917 TList *intFlowList = NULL;\r
5918 intFlowList = dynamic_cast<TList*>(outputListHistos->FindObject("Integrated Flow"));\r
5919 if(!intFlowList) \r
5920 {\r
5921 cout<<"WARNING: intFlowList is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
5922 exit(0); \r
5923 } \r
5924 \r
5925 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow:\r
5926 TString intFlowFlagsName = "fIntFlowFlags";\r
5927 intFlowFlagsName += fAnalysisLabel->Data();\r
5928 TProfile *intFlowFlags = dynamic_cast<TProfile*>(intFlowList->FindObject(intFlowFlagsName.Data()));\r
5929 Bool_t bApplyCorrectionForNUA = kFALSE;\r
5930 if(intFlowFlags)\r
5931 {\r
5932 this->SetIntFlowFlags(intFlowFlags); \r
5933 bApplyCorrectionForNUA = (Int_t)intFlowFlags->GetBinContent(3); \r
5934 this->SetApplyCorrectionForNUA(bApplyCorrectionForNUA); \r
5935 } else \r
5936 {\r
5937 cout<<"WARNING: intFlowFlags is NULL in FAWQC::GPFIFH() !!!!"<<endl;\r
5938 }\r
5939 \r
5940 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds:\r
5941 TList *intFlowProfiles = NULL;\r
5942 intFlowProfiles = dynamic_cast<TList*>(intFlowList->FindObject("Profiles"));\r
5943 if(intFlowProfiles) \r
5944 {\r
5945 // average multiplicities:\r
5946 TString avMultiplicityName = "fAvMultiplicity";\r
5947 avMultiplicityName += fAnalysisLabel->Data();\r
5948 TProfile *avMultiplicity = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(avMultiplicityName.Data()));\r
5949 if(avMultiplicity) \r
5950 {\r
5951 this->SetAvMultiplicity(avMultiplicity);\r
5952 } else \r
5953 {\r
5954 cout<<"WARNING: avMultiplicity is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
5955 }\r
5956 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with wrong errors!):\r
5957 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";\r
5958 intFlowCorrelationsProName += fAnalysisLabel->Data();\r
5959 TProfile *intFlowCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsProName.Data()));\r
5960 if(intFlowCorrelationsPro) \r
5961 {\r
5962 this->SetIntFlowCorrelationsPro(intFlowCorrelationsPro);\r
5963 } else \r
5964 {\r
5965 cout<<"WARNING: intFlowCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
5966 } \r
5967 // average all correlations for integrated flow (with wrong errors!):\r
5968 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";\r
5969 intFlowCorrelationsAllProName += fAnalysisLabel->Data();\r
5970 TProfile *intFlowCorrelationsAllPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsAllProName.Data()));\r
5971 if(intFlowCorrelationsAllPro) \r
5972 {\r
5973 this->SetIntFlowCorrelationsAllPro(intFlowCorrelationsAllPro);\r
5974 } else \r
5975 {\r
5976 cout<<"WARNING: intFlowCorrelationsAllPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
5977 } \r
5978 // average extra correlations for integrated flow (which appear only when particle weights are used):\r
5979 // (to be improved: Weak point in implementation, I am assuming here that method GetPointersForParticleWeightsHistograms() was called)\r
5980 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
5981 {\r
5982 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";\r
5983 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();\r
5984 TProfile *intFlowExtraCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowExtraCorrelationsProName.Data()));\r
5985 if(intFlowExtraCorrelationsPro) \r
5986 {\r
5987 this->SetIntFlowExtraCorrelationsPro(intFlowExtraCorrelationsPro);\r
5988 } else \r
5989 {\r
5990 cout<<"WARNING: intFlowExtraCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
5991 }\r
5992 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) \r
5993 // average products of correlations <2>, <4>, <6> and <8>: \r
5994 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";\r
5995 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();\r
5996 TProfile *intFlowProductOfCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrelationsProName.Data()));\r
5997 if(intFlowProductOfCorrelationsPro) \r
5998 {\r
5999 this->SetIntFlowProductOfCorrelationsPro(intFlowProductOfCorrelationsPro);\r
6000 } else \r
6001 {\r
6002 cout<<"WARNING: intFlowProductOfCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6003 } \r
6004 // average correction terms for non-uniform acceptance (with wrong errors!):\r
6005 for(Int_t sc=0;sc<2;sc++)\r
6006 {\r
6007 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";\r
6008 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
6009 TProfile *intFlowCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAProName.Data(),sinCosFlag[sc].Data()))));\r
6010 if(intFlowCorrectionTermsForNUAPro) \r
6011 {\r
6012 this->SetIntFlowCorrectionTermsForNUAPro(intFlowCorrectionTermsForNUAPro,sc);\r
6013 } else \r
6014 {\r
6015 cout<<"WARNING: intFlowCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6016 cout<<"sc = "<<sc<<endl;\r
6017 } \r
6018 } // end of for(Int_t sc=0;sc<2;sc++) \r
6019 } else // to if(intFlowProfiles) \r
6020 {\r
6021 cout<<"WARNING: intFlowProfiles is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6022 }\r
6023 \r
6024 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds. \r
6025 TList *intFlowResults = NULL;\r
6026 intFlowResults = dynamic_cast<TList*>(intFlowList->FindObject("Results"));\r
6027 if(intFlowResults)\r
6028 {\r
6029 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!):\r
6030 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";\r
6031 intFlowCorrelationsHistName += fAnalysisLabel->Data();\r
6032 TH1D *intFlowCorrelationsHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsHistName.Data()));\r
6033 if(intFlowCorrelationsHist) \r
6034 {\r
6035 this->SetIntFlowCorrelationsHist(intFlowCorrelationsHist);\r
6036 } else \r
6037 {\r
6038 cout<<"WARNING: intFlowCorrelationsHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6039 } \r
6040 // average all correlations for integrated flow (with correct errors!):\r
6041 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";\r
6042 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();\r
6043 TH1D *intFlowCorrelationsAllHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsAllHistName.Data()));\r
6044 if(intFlowCorrelationsAllHist) \r
6045 {\r
6046 this->SetIntFlowCorrelationsAllHist(intFlowCorrelationsAllHist);\r
6047 } else \r
6048 {\r
6049 cout<<"WARNING: intFlowCorrelationsAllHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6050 } \r
6051 // average correction terms for non-uniform acceptance (with correct errors!):\r
6052 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";\r
6053 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
6054 for(Int_t sc=0;sc<2;sc++)\r
6055 {\r
6056 TH1D *intFlowCorrectionTermsForNUAHist = dynamic_cast<TH1D*>(intFlowResults->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAHistName.Data(),sinCosFlag[sc].Data()))));\r
6057 if(intFlowCorrectionTermsForNUAHist) \r
6058 {\r
6059 this->SetIntFlowCorrectionTermsForNUAHist(intFlowCorrectionTermsForNUAHist,sc);\r
6060 } else \r
6061 {\r
6062 cout<<"WARNING: intFlowCorrectionTermsForNUAHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6063 cout<<"sc = "<<sc<<endl;\r
6064 } \r
6065 } // end of for(Int_t sc=0;sc<2;sc++) \r
6066 // covariances (multiplied with weight dependent prefactor):\r
6067 TString intFlowCovariancesName = "fIntFlowCovariances";\r
6068 intFlowCovariancesName += fAnalysisLabel->Data();\r
6069 TH1D *intFlowCovariances = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesName.Data()));\r
6070 if(intFlowCovariances) \r
6071 {\r
6072 this->SetIntFlowCovariances(intFlowCovariances); \r
6073 } else \r
6074 {\r
6075 cout<<"WARNING: intFlowCovariances is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6076 } \r
6077 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:\r
6078 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";\r
6079 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();\r
6080 for(Int_t power=0;power<2;power++)\r
6081 {\r
6082 TH1D *intFlowSumOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s",intFlowSumOfEventWeightsName.Data(),powerFlag[power].Data())));\r
6083 if(intFlowSumOfEventWeights) \r
6084 {\r
6085 this->SetIntFlowSumOfEventWeights(intFlowSumOfEventWeights,power);\r
6086 } else \r
6087 {\r
6088 cout<<"WARNING: intFlowSumOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6089 cout<<"power = "<<power<<endl;\r
6090 } \r
6091 } // end of for(Int_t power=0;power<2;power++) \r
6092 // sum of products of event weights for correlations <2>, <4>, <6> and <8>: \r
6093 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";\r
6094 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();\r
6095 TH1D *intFlowSumOfProductOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsName.Data()));\r
6096 if(intFlowSumOfProductOfEventWeights) \r
6097 {\r
6098 this->SetIntFlowSumOfProductOfEventWeights(intFlowSumOfProductOfEventWeights);\r
6099 } else \r
6100 {\r
6101 cout<<"WARNING: intFlowSumOfProductOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6102 } \r
6103 // final results for integrated Q-cumulants:\r
6104 TString intFlowQcumulantsName = "fIntFlowQcumulants";\r
6105 intFlowQcumulantsName += fAnalysisLabel->Data();\r
6106 TH1D *intFlowQcumulants = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsName.Data()));\r
6107 if(intFlowQcumulants) \r
6108 {\r
6109 this->SetIntFlowQcumulants(intFlowQcumulants);\r
6110 } else \r
6111 {\r
6112 cout<<"WARNING: intFlowQcumulants is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6113 } \r
6114 // final integrated flow estimates from Q-cumulants:\r
6115 TString intFlowName = "fIntFlow";\r
6116 intFlowName += fAnalysisLabel->Data();\r
6117 TH1D *intFlow = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowName.Data()));\r
6118 if(intFlow) \r
6119 {\r
6120 this->SetIntFlow(intFlow);\r
6121 } else \r
6122 {\r
6123 cout<<"WARNING: intFlow is NULL in AFAWQC::GPFIFH() !!!!"<<endl; \r
6124 } \r
6125 } else // to if(intFlowResults)\r
6126 {\r
6127 cout<<"WARNING: intFlowResults is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6128 }\r
6129 } // end of if(outputListHistos)\r
6130\r
6131} // end of void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms(TList *outputListHistos)\r
6132\r
6133\r
6134//================================================================================================================================\r
6135\r
6136\r
6137void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms(TList *outputListHistos)\r
6138{\r
6139 // Get pointer to all objects relevant for differential flow.\r
6140 // a) Define flags locally (to be improved: should I promote flags to data members?);\r
6141 // b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults;\r
6142 // c) Get pointer to profile fDiffFlowFlags holding all flags for differential flow;\r
6143 // d) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;\r
6144 // e) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.\r
6145 \r
6146 // a) Define flags locally (to be improved: should I promote flags to data members?): \r
6147 TString typeFlag[2] = {"RP","POI"}; \r
6148 TString ptEtaFlag[2] = {"p_{T}","#eta"};\r
6149 TString powerFlag[2] = {"linear","quadratic"};\r
6150 TString sinCosFlag[2] = {"sin","cos"};\r
6151 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"}; \r
6152 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"}; \r
6153 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};\r
6154 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};\r
6155 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"}; \r
6156 \r
6157 // b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults:\r
6158 TList *diffFlowList = NULL;\r
6159 diffFlowList = dynamic_cast<TList*>(outputListHistos->FindObject("Differential Flow")); \r
6160 if(!diffFlowList)\r
6161 { \r
6162 cout<<"WARNING: diffFlowList is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6163 exit(0);\r
6164 }\r
6165 // list holding nested lists containing profiles:\r
6166 TList *diffFlowListProfiles = NULL;\r
6167 diffFlowListProfiles = dynamic_cast<TList*>(diffFlowList->FindObject("Profiles"));\r
6168 if(!diffFlowListProfiles)\r
6169 { \r
6170 cout<<"WARNING: diffFlowListProfiles is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6171 exit(0);\r
6172 }\r
6173 // list holding nested lists containing 2D and 1D histograms with final results:\r
6174 TList *diffFlowListResults = NULL;\r
6175 diffFlowListResults = dynamic_cast<TList*>(diffFlowList->FindObject("Results"));\r
6176 if(!diffFlowListResults)\r
6177 { \r
6178 cout<<"WARNING: diffFlowListResults is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6179 exit(0);\r
6180 }\r
6181 \r
6182 // c) Get pointer to profile holding all flags for differential flow;\r
6183 TString diffFlowFlagsName = "fDiffFlowFlags";\r
6184 diffFlowFlagsName += fAnalysisLabel->Data();\r
6185 TProfile *diffFlowFlags = dynamic_cast<TProfile*>(diffFlowList->FindObject(diffFlowFlagsName.Data()));\r
6186 Bool_t bCalculate2DFlow = kFALSE;\r
6187 if(diffFlowFlags)\r
6188 {\r
6189 this->SetDiffFlowFlags(diffFlowFlags); \r
6190 bCalculate2DFlow = (Int_t)diffFlowFlags->GetBinContent(4);\r
6191 this->SetCalculate2DFlow(bCalculate2DFlow); // to be improved (shoul I call this setter somewhere else?) \r
6192 }\r
6193 \r
6194 // d) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;\r
6195 // correlations:\r
6196 TList *diffFlowCorrelationsProList[2][2] = {{NULL}};\r
6197 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";\r
6198 diffFlowCorrelationsProName += fAnalysisLabel->Data();\r
6199 TProfile *diffFlowCorrelationsPro[2][2][4] = {{{NULL}}}; \r
6200 // products of correlations:\r
6201 TList *diffFlowProductOfCorrelationsProList[2][2] = {{NULL}};\r
6202 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";\r
6203 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data(); \r
6204 TProfile *diffFlowProductOfCorrelationsPro[2][2][8][8] = {{{{NULL}}}}; \r
6205 // corrections:\r
6206 TList *diffFlowCorrectionsProList[2][2] = {{NULL}};\r
6207 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";\r
6208 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data(); \r
6209 TProfile *diffFlowCorrectionTermsForNUAPro[2][2][2][10] = {{{{NULL}}}}; \r
6210 for(Int_t t=0;t<2;t++)\r
6211 {\r
6212 for(Int_t pe=0;pe<2;pe++)\r
6213 {\r
6214 diffFlowCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6215 if(!diffFlowCorrelationsProList[t][pe])\r
6216 { \r
6217 cout<<"WARNING: diffFlowCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6218 cout<<"t = "<<t<<endl;\r
6219 cout<<"pe = "<<pe<<endl;\r
6220 exit(0);\r
6221 }\r
6222 for(Int_t ci=0;ci<4;ci++) // correlation index\r
6223 {\r
6224 diffFlowCorrelationsPro[t][pe][ci] = dynamic_cast<TProfile*>(diffFlowCorrelationsProList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[ci].Data())));\r
6225 if(diffFlowCorrelationsPro[t][pe][ci])\r
6226 {\r
6227 this->SetDiffFlowCorrelationsPro(diffFlowCorrelationsPro[t][pe][ci],t,pe,ci);\r
6228 } else\r
6229 {\r
6230 cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6231 cout<<"t = "<<t<<endl;\r
6232 cout<<"pe = "<<pe<<endl; \r
6233 cout<<"ci = "<<ci<<endl;\r
6234 } \r
6235 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index \r
6236 // products of correlations: \r
6237 diffFlowProductOfCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()))); \r
6238 if(!diffFlowProductOfCorrelationsProList[t][pe])\r
6239 { \r
6240 cout<<"WARNING: ddiffFlowProductOfCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6241 cout<<"t = "<<t<<endl;\r
6242 cout<<"pe = "<<pe<<endl;\r
6243 exit(0);\r
6244 }\r
6245 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6246 {\r
6247 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6248 {\r
6249 diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = dynamic_cast<TProfile*>(diffFlowProductOfCorrelationsProList[t][pe]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data())));\r
6250 if(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2])\r
6251 {\r
6252 this->SetDiffFlowProductOfCorrelationsPro(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2],t,pe,mci1,mci2);\r
6253 } else\r
6254 {\r
6255 cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6256 cout<<"t = "<<t<<endl;\r
6257 cout<<"pe = "<<pe<<endl; \r
6258 cout<<"mci1 = "<<mci1<<endl;\r
6259 cout<<"mci2 = "<<mci2<<endl;\r
6260 }\r
6261 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6262 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6263 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index \r
6264 // corrections:\r
6265 diffFlowCorrectionsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6266 if(!diffFlowCorrectionsProList[t][pe])\r
6267 { \r
6268 cout<<"WARNING: diffFlowCorrectionsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6269 cout<<"t = "<<t<<endl;\r
6270 cout<<"pe = "<<pe<<endl;\r
6271 exit(0);\r
6272 }\r
6273 // correction terms for NUA:\r
6274 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6275 {\r
6276 for(Int_t cti=0;cti<9;cti++) // correction term index\r
6277 {\r
6278 diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = dynamic_cast<TProfile*>(diffFlowCorrectionsProList[t][pe]->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
6279 if(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti])\r
6280 {\r
6281 this->SetDiffFlowCorrectionTermsForNUAPro(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti],t,pe,sc,cti);\r
6282 } else\r
6283 {\r
6284 cout<<"WARNING: diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6285 cout<<"t = "<<t<<endl;\r
6286 cout<<"pe = "<<pe<<endl; \r
6287 cout<<"sc = "<<sc<<endl;\r
6288 cout<<"cti = "<<cti<<endl;\r
6289 } \r
6290 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
6291 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6292 // ...\r
6293 } // end of for(Int_t pe=0;pe<2;pe++)\r
6294 } // end of for(Int_t t=0;t<2;t++)\r
6295 \r
6296 // e) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.\r
6297 // reduced correlations:\r
6298 TList *diffFlowCorrelationsHistList[2][2] = {{NULL}};\r
6299 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";\r
6300 diffFlowCorrelationsHistName += fAnalysisLabel->Data(); \r
6301 TH1D *diffFlowCorrelationsHist[2][2][4] = {{{NULL}}};\r
6302 // corrections for NUA:\r
6303 TList *diffFlowCorrectionsHistList[2][2] = {{NULL}};\r
6304 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";\r
6305 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data(); \r
6306 TH1D *diffFlowCorrectionTermsForNUAHist[2][2][2][10] = {{{{NULL}}}};\r
6307 // differential Q-cumulants:\r
6308 TList *diffFlowCumulantsHistList[2][2] = {{NULL}};\r
6309 TString diffFlowCumulantsName = "fDiffFlowCumulants";\r
6310 diffFlowCumulantsName += fAnalysisLabel->Data(); \r
6311 TH1D *diffFlowCumulants[2][2][4] = {{{NULL}}};\r
6312 // differential flow estimates from Q-cumulants:\r
6313 TList *diffFlowHistList[2][2] = {{NULL}};\r
6314 TString diffFlowName = "fDiffFlow";\r
6315 diffFlowName += fAnalysisLabel->Data(); \r
6316 TH1D *diffFlow[2][2][4] = {{{NULL}}};\r
6317 // differential covariances:\r
6318 TList *diffFlowCovariancesHistList[2][2] = {{NULL}};\r
6319 TString diffFlowCovariancesName = "fDiffFlowCovariances";\r
6320 diffFlowCovariancesName += fAnalysisLabel->Data(); \r
6321 TH1D *diffFlowCovariances[2][2][5] = {{{NULL}}};\r
6322 for(Int_t t=0;t<2;t++) // type: RP or POI\r
6323 { \r
6324 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6325 {\r
6326 // reduced correlations:\r
6327 diffFlowCorrelationsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6328 if(!diffFlowCorrelationsHistList[t][pe])\r
6329 { \r
6330 cout<<"WARNING: diffFlowCorrelationsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6331 cout<<"t = "<<t<<endl;\r
6332 cout<<"pe = "<<pe<<endl;\r
6333 exit(0);\r
6334 }\r
6335 for(Int_t index=0;index<4;index++) \r
6336 {\r
6337 diffFlowCorrelationsHist[t][pe][index] = dynamic_cast<TH1D*>(diffFlowCorrelationsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data())));\r
6338 if(diffFlowCorrelationsHist[t][pe][index])\r
6339 {\r
6340 this->SetDiffFlowCorrelationsHist(diffFlowCorrelationsHist[t][pe][index],t,pe,index);\r
6341 } else \r
6342 {\r
6343 cout<<"WARNING: diffFlowCorrelationsHist[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6344 cout<<"t = "<<t<<endl;\r
6345 cout<<"pe = "<<pe<<endl;\r
6346 cout<<"index = "<<index<<endl;\r
6347 exit(0); \r
6348 } \r
6349 } // end of for(Int_t index=0;index<4;index++)\r
6350 // corrections:\r
6351 diffFlowCorrectionsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6352 if(!diffFlowCorrectionsHistList[t][pe])\r
6353 { \r
6354 cout<<"WARNING: diffFlowCorrectionsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6355 cout<<"t = "<<t<<endl;\r
6356 cout<<"pe = "<<pe<<endl;\r
6357 exit(0);\r
6358 }\r
6359 // correction terms for NUA:\r
6360 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6361 {\r
6362 for(Int_t cti=0;cti<9;cti++) // correction term index\r
6363 {\r
6364 diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = dynamic_cast<TH1D*>(diffFlowCorrectionsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
6365 if(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti])\r
6366 {\r
6367 this->SetDiffFlowCorrectionTermsForNUAHist(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti],t,pe,sc,cti);\r
6368 } else\r
6369 {\r
6370 cout<<"WARNING: diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6371 cout<<"t = "<<t<<endl;\r
6372 cout<<"pe = "<<pe<<endl; \r
6373 cout<<"sc = "<<sc<<endl;\r
6374 cout<<"cti = "<<cti<<endl;\r
6375 } \r
6376 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
6377 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6378 // ...\r
6379 // differential Q-cumulants:\r
6380 diffFlowCumulantsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6381 if(!diffFlowCumulantsHistList[t][pe])\r
6382 { \r
6383 cout<<"WARNING: diffFlowCumulantsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6384 cout<<"t = "<<t<<endl;\r
6385 cout<<"pe = "<<pe<<endl;\r
6386 exit(0);\r
6387 }\r
6388 for(Int_t index=0;index<4;index++) \r
6389 {\r
6390 diffFlowCumulants[t][pe][index] = dynamic_cast<TH1D*>(diffFlowCumulantsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data())));\r
6391 if(diffFlowCumulants[t][pe][index])\r
6392 {\r
6393 this->SetDiffFlowCumulants(diffFlowCumulants[t][pe][index],t,pe,index);\r
6394 } else \r
6395 {\r
6396 cout<<"WARNING: diffFlowCumulants[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6397 cout<<"t = "<<t<<endl;\r
6398 cout<<"pe = "<<pe<<endl;\r
6399 cout<<"index = "<<index<<endl;\r
6400 exit(0); \r
6401 } \r
6402 } // end of for(Int_t index=0;index<4;index++)\r
6403 // differential flow estimates from Q-cumulants:\r
6404 diffFlowHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6405 if(!diffFlowHistList[t][pe])\r
6406 { \r
6407 cout<<"WARNING: diffFlowHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6408 cout<<"t = "<<t<<endl;\r
6409 cout<<"pe = "<<pe<<endl;\r
6410 exit(0);\r
6411 }\r
6412 for(Int_t index=0;index<4;index++) \r
6413 {\r
6414 diffFlow[t][pe][index] = dynamic_cast<TH1D*>(diffFlowHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data())));\r
6415 if(diffFlow[t][pe][index])\r
6416 {\r
6417 this->SetDiffFlow(diffFlow[t][pe][index],t,pe,index);\r
6418 } else \r
6419 {\r
6420 cout<<"WARNING: diffFlow[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6421 cout<<"t = "<<t<<endl;\r
6422 cout<<"pe = "<<pe<<endl;\r
6423 cout<<"index = "<<index<<endl;\r
6424 exit(0); \r
6425 } \r
6426 } // end of for(Int_t index=0;index<4;index++)\r
6427 // differential covariances:\r
6428 diffFlowCovariancesHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6429 if(!diffFlowCovariancesHistList[t][pe])\r
6430 { \r
6431 cout<<"WARNING: diffFlowCovariancesHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6432 cout<<"t = "<<t<<endl;\r
6433 cout<<"pe = "<<pe<<endl;\r
6434 exit(0);\r
6435 }\r
6436 for(Int_t covIndex=0;covIndex<5;covIndex++) \r
6437 {\r
6438 diffFlowCovariances[t][pe][covIndex] = dynamic_cast<TH1D*>(diffFlowCovariancesHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data())));\r
6439 if(diffFlowCovariances[t][pe][covIndex])\r
6440 {\r
6441 this->SetDiffFlowCovariances(diffFlowCovariances[t][pe][covIndex],t,pe,covIndex);\r
6442 } else \r
6443 {\r
6444 cout<<"WARNING: diffFlowCovariances[t][pe][covIndex] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6445 cout<<"t = "<<t<<endl;\r
6446 cout<<"pe = "<<pe<<endl;\r
6447 cout<<"covIndex = "<<covIndex<<endl;\r
6448 exit(0); \r
6449 } \r
6450 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index \r
6451 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6452 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI \r
6453 // sum of event weights for reduced correlations:\r
6454 TList *diffFlowSumOfEventWeightsHistList[2][2][2] = {{{NULL}}};\r
6455 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";\r
6456 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data(); \r
6457 TH1D *diffFlowSumOfEventWeights[2][2][2][4] = {{{{NULL}}}};\r
6458 for(Int_t t=0;t<2;t++) // type is RP or POI\r
6459 { \r
6460 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6461 { \r
6462 for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2\r
6463 {\r
6464 diffFlowSumOfEventWeightsHistList[t][pe][p] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of %s event weights (%s, %s)",powerFlag[p].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6465 if(!diffFlowSumOfEventWeightsHistList[t][pe][p])\r
6466 { \r
6467 cout<<"WARNING: diffFlowSumOfEventWeightsHistList[t][pe][p] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6468 cout<<"t = "<<t<<endl;\r
6469 cout<<"pe = "<<pe<<endl;\r
6470 cout<<"power = "<<p<<endl;\r
6471 exit(0);\r
6472 }\r
6473 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation\r
6474 {\r
6475 diffFlowSumOfEventWeights[t][pe][p][ew] = dynamic_cast<TH1D*>(diffFlowSumOfEventWeightsHistList[t][pe][p]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data()))); \r
6476 if(diffFlowSumOfEventWeights[t][pe][p][ew])\r
6477 {\r
6478 this->SetDiffFlowSumOfEventWeights(diffFlowSumOfEventWeights[t][pe][p][ew],t,pe,p,ew);\r
6479 } else \r
6480 {\r
6481 cout<<"WARNING: diffFlowSumOfEventWeights[t][pe][p][ew] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6482 cout<<"t = "<<t<<endl;\r
6483 cout<<"pe = "<<pe<<endl;\r
6484 cout<<"power = "<<p<<endl;\r
6485 cout<<"ew = "<<ew<<endl;\r
6486 exit(0); \r
6487 } \r
6488 }\r
6489 } // end of for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2\r
6490 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6491 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI\r
6492 // \r
6493 TList *diffFlowSumOfProductOfEventWeightsHistList[2][2] = {{NULL}};\r
6494 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";\r
6495 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data(); \r
6496 TH1D *diffFlowSumOfProductOfEventWeights[2][2][8][8] = {{{{NULL}}}};\r
6497 for(Int_t t=0;t<2;t++) // type is RP or POI\r
6498 { \r
6499 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6500 { \r
6501 diffFlowSumOfProductOfEventWeightsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6502 if(!diffFlowSumOfProductOfEventWeightsHistList[t][pe])\r
6503 { \r
6504 cout<<"WARNING: diffFlowSumOfProductOfEventWeightsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6505 cout<<"t = "<<t<<endl;\r
6506 cout<<"pe = "<<pe<<endl;\r
6507 exit(0);\r
6508 }\r
6509 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6510 {\r
6511 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6512 {\r
6513 diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = dynamic_cast<TH1D*>(diffFlowSumOfProductOfEventWeightsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()))); \r
6514 if(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2])\r
6515 {\r
6516 this->SetDiffFlowSumOfProductOfEventWeights(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2],t,pe,mci1,mci2);\r
6517 } else \r
6518 {\r
6519 cout<<"WARNING: diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6520 cout<<"t = "<<t<<endl;\r
6521 cout<<"pe = "<<pe<<endl;\r
6522 cout<<"mci1 = "<<mci1<<endl;\r
6523 cout<<"mci2 = "<<mci2<<endl;\r
6524 exit(0); \r
6525 } \r
6526 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6527 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6528 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6529 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6530 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI\r
6531\r
6532} // end void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms(TList *outputListHistos)\r
6533\r
6534\r
6535//================================================================================================================================\r
6536\r
6537\r
6538void AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()\r
6539{\r
6540 // Book all histograms and profiles needed for differential flow.\r
6541 // a) Define flags locally (to be improved: should I promote flags to data members?);\r
6542 // b) Book profile to hold all flags for differential flow;\r
6543 // c) Book e-b-e quantities;\r
6544 // d) Book profiles;\r
6545 // e) Book histograms holding final results. \r
6546 \r
6547 // a) Define flags locally (to be improved: should I promote flags to data members?): \r
6548 TString typeFlag[2] = {"RP","POI"}; \r
6549 TString ptEtaFlag[2] = {"p_{T}","#eta"};\r
6550 TString powerFlag[2] = {"linear","quadratic"};\r
6551 TString sinCosFlag[2] = {"sin","cos"};\r
6552 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"}; \r
6553 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"}; \r
6554 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};\r
6555 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};\r
6556 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"}; \r
6557 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
6558 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
6559 Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
6560 \r
6561 // b) Book profile to hold all flags for differential flow:\r
6562 TString diffFlowFlagsName = "fDiffFlowFlags";\r
6563 diffFlowFlagsName += fAnalysisLabel->Data();\r
6564 fDiffFlowFlags = new TProfile(diffFlowFlagsName.Data(),"Flags for Differential Flow",4,0,4);\r
6565 fDiffFlowFlags->SetTickLength(-0.01,"Y");\r
6566 fDiffFlowFlags->SetMarkerStyle(25);\r
6567 fDiffFlowFlags->SetLabelSize(0.05);\r
6568 fDiffFlowFlags->SetLabelOffset(0.02,"Y");\r
6569 (fDiffFlowFlags->GetXaxis())->SetBinLabel(1,"Particle Weights");\r
6570 (fDiffFlowFlags->GetXaxis())->SetBinLabel(2,"Event Weights");\r
6571 (fDiffFlowFlags->GetXaxis())->SetBinLabel(3,"Corrected for NUA?");\r
6572 (fDiffFlowFlags->GetXaxis())->SetBinLabel(4,"Calculated 2D flow?");\r
6573 fDiffFlowList->Add(fDiffFlowFlags);\r
6574\r
6575 // c) Book e-b-e quantities:\r
6576 // Event-by-event r_{m*n,k}(pt,eta), p_{m*n,k}(pt,eta) and q_{m*n,k}(pt,eta)\r
6577 // Explanantion of notation:\r
6578 // 1.) n is harmonic, m is multiple of harmonic;\r
6579 // 2.) k is power of particle weight;\r
6580 // 3.) r_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for RPs in particular (pt,eta) bin (i-th RP is weighted with w_i^k); \r
6581 // 4.) p_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for POIs in particular (pt,eta) bin \r
6582 // (if i-th POI is also RP, than it is weighted with w_i^k); \r
6583 // 5.) q_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for particles which are both RPs and POIs in particular (pt,eta) bin \r
6584 // (i-th RP&&POI is weighted with w_i^k) \r
6585 \r
6586 // 1D:\r
6587 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP && POI )\r
6588 { \r
6589 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6590 {\r
6591 for(Int_t m=0;m<4;m++) // multiple of harmonic\r
6592 {\r
6593 for(Int_t k=0;k<9;k++) // power of particle weight\r
6594 {\r
6595 fReRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),\r
6596 Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6597 fImRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),\r
6598 Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6599 }\r
6600 }\r
6601 }\r
6602 } \r
6603 // to be improved (add explanation of fs1dEBE[t][pe][k]): \r
6604 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6605 { \r
6606 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6607 {\r
6608 for(Int_t k=0;k<9;k++) // power of particle weight\r
6609 {\r
6610 fs1dEBE[t][pe][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),\r
6611 Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6612 }\r
6613 }\r
6614 }\r
6615 // correction terms for nua:\r
6616 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6617 { \r
6618 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6619 {\r
6620 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6621 {\r
6622 for(Int_t cti=0;cti<9;cti++) // correction term index\r
6623 {\r
6624 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = new TH1D(Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),\r
6625 Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6626 }\r
6627 }\r
6628 }\r
6629 } \r
6630 // 2D:\r
6631 TProfile2D styleRe("typeMultiplePowerRe","typeMultiplePowerRe",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6632 TProfile2D styleIm("typeMultiplePowerIm","typeMultiplePowerIm",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6633 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6634 { \r
6635 for(Int_t m=0;m<4;m++)\r
6636 {\r
6637 for(Int_t k=0;k<9;k++)\r
6638 {\r
6639 fReRPQ2dEBE[t][m][k] = (TProfile2D*)styleRe.Clone(Form("typeFlag%dmultiple%dpower%dRe",t,m,k)); \r
6640 fImRPQ2dEBE[t][m][k] = (TProfile2D*)styleIm.Clone(Form("typeFlag%dmultiple%dpower%dIm",t,m,k));\r
6641 }\r
6642 } \r
6643 } \r
6644 TProfile2D styleS("typePower","typePower",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6645 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6646 { \r
6647 for(Int_t k=0;k<9;k++)\r
6648 {\r
6649 fs2dEBE[t][k] = (TProfile2D*)styleS.Clone(Form("typeFlag%dpower%d",t,k));\r
6650 }\r
6651 }\r
6652 // reduced correlations e-b-e:\r
6653 TString diffFlowCorrelationsEBEName = "fDiffFlowCorrelationsEBE";\r
6654 diffFlowCorrelationsEBEName += fAnalysisLabel->Data();\r
6655 for(Int_t t=0;t<2;t++) // type: RP or POI\r
6656 { \r
6657 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6658 {\r
6659 for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
6660 {\r
6661 fDiffFlowCorrelationsEBE[t][pe][rci] = new TH1D(Form("%s, %s, %s, %s",diffFlowCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6662 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index\r
6663 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6664 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6665 // event weights for reduced correlations e-b-e:\r
6666 TString diffFlowEventWeightsForCorrelationsEBEName = "fDiffFlowEventWeightsForCorrelationsEBE";\r
6667 diffFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();\r
6668 for(Int_t t=0;t<2;t++) // type: RP or POI\r
6669 { \r
6670 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6671 {\r
6672 for(Int_t rci=0;rci<4;rci++) // event weight for reduced correlation index\r
6673 {\r
6674 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci] = new TH1D(Form("%s, %s, %s, eW for %s",diffFlowEventWeightsForCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, eW for %s",diffFlowEventWeightsForCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6675 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index\r
6676 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6677 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6678 \r
6679 // d) Book profiles;\r
6680 // reduced correlations:\r
6681 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";\r
6682 diffFlowCorrelationsProName += fAnalysisLabel->Data();\r
6683 // corrections terms:\r
6684 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";\r
6685 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
6686 for(Int_t t=0;t<2;t++) // type: RP or POI\r
6687 { \r
6688 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6689 {\r
6690 for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
6691 {\r
6692 // reduced correlations:\r
6693 fDiffFlowCorrelationsPro[t][pe][rci] = new TProfile(Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe],"s");\r
6694 fDiffFlowCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());\r
6695 fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)\r
6696 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index\r
6697 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6698 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6699 // correction terms for nua:\r
6700 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6701 { \r
6702 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6703 {\r
6704 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6705 {\r
6706 for(Int_t cti=0;cti<9;cti++) // correction term index\r
6707 {\r
6708 fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = new TProfile(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6709 fDiffFlowCorrectionsProList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]);\r
6710 }\r
6711 }\r
6712 }\r
6713 } \r
6714 // e) Book histograms holding final results. \r
6715 // reduced correlations:\r
6716 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";\r
6717 diffFlowCorrelationsHistName += fAnalysisLabel->Data();\r
6718 // corrections terms:\r
6719 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";\r
6720 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
6721 // differential covariances:\r
6722 TString diffFlowCovariancesName = "fDiffFlowCovariances";\r
6723 diffFlowCovariancesName += fAnalysisLabel->Data();\r
6724 // differential Q-cumulants:\r
6725 TString diffFlowCumulantsName = "fDiffFlowCumulants";\r
6726 diffFlowCumulantsName += fAnalysisLabel->Data();\r
6727 // differential flow:\r
6728 TString diffFlowName = "fDiffFlow";\r
6729 diffFlowName += fAnalysisLabel->Data();\r
6730 for(Int_t t=0;t<2;t++) // type: RP or POI\r
6731 { \r
6732 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6733 {\r
6734 for(Int_t index=0;index<4;index++) \r
6735 {\r
6736 // reduced correlations:\r
6737 fDiffFlowCorrelationsHist[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6738 fDiffFlowCorrelationsHist[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6739 fDiffFlowCorrelationsHistList[t][pe]->Add(fDiffFlowCorrelationsHist[t][pe][index]); \r
6740 // differential Q-cumulants:\r
6741 fDiffFlowCumulants[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6742 fDiffFlowCumulants[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6743 fDiffFlowCumulantsHistList[t][pe]->Add(fDiffFlowCumulants[t][pe][index]); \r
6744 // differential flow estimates from Q-cumulants:\r
6745 fDiffFlow[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6746 fDiffFlow[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6747 fDiffFlowHistList[t][pe]->Add(fDiffFlow[t][pe][index]); \r
6748 } // end of for(Int_t index=0;index<4;index++) \r
6749 for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index \r
6750 {\r
6751 // differential covariances:\r
6752 fDiffFlowCovariances[t][pe][covIndex] = new TH1D(Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data()),Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6753 fDiffFlowCovariances[t][pe][covIndex]->SetXTitle(ptEtaFlag[pe].Data());\r
6754 fDiffFlowCovariancesHistList[t][pe]->Add(fDiffFlowCovariances[t][pe][covIndex]); \r
6755 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index\r
6756 // products of both types of correlations: \r
6757 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";\r
6758 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data(); \r
6759 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6760 {\r
6761 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6762 {\r
6763 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = new TProfile(Form("%s, %s, %s, %s, %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),Form("%s, %s, %s, %s #times %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6764 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());\r
6765 fDiffFlowProductOfCorrelationsProList[t][pe]->Add(fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]); \r
6766 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6767 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6768 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index \r
6769 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6770 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6771 // sums of event weights for reduced correlations: \r
6772 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";\r
6773 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data(); \r
6774 for(Int_t t=0;t<2;t++) // type is RP or POI\r
6775 { \r
6776 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6777 { \r
6778 for(Int_t p=0;p<2;p++) // power of weights is either 1 or 2\r
6779 {\r
6780 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation\r
6781 {\r
6782 fDiffFlowSumOfEventWeights[t][pe][p][ew] = new TH1D(Form("%s, %s, %s, %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data()),Form("%s, %s, %s, power = %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6783 fDiffFlowSumOfEventWeights[t][pe][p][ew]->SetXTitle(ptEtaFlag[pe].Data());\r
6784 fDiffFlowSumOfEventWeightsHistList[t][pe][p]->Add(fDiffFlowSumOfEventWeights[t][pe][p][ew]); // to be improved (add dedicated list to hold all this)\r
6785 }\r
6786 }\r
6787 }\r
6788 } \r
6789 // sum of products of event weights for both types of correlations: \r
6790 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";\r
6791 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data(); \r
6792 for(Int_t t=0;t<2;t++) // type is RP or POI\r
6793 {\r
6794 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6795 { \r
6796 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6797 {\r
6798 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6799 {\r
6800 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = new TH1D(Form("%s, %s, %s, %s, %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),Form("%s, %s, %s, %s #times %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6801 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());\r
6802 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->Add(fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]); \r
6803 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6804 }\r
6805 }\r
6806 }\r
6807 } \r
6808 // correction terms for nua:\r
6809 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6810 { \r
6811 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6812 {\r
6813 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6814 {\r
6815 for(Int_t cti=0;cti<9;cti++) // correction term index\r
6816 {\r
6817 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = new TH1D(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6818 fDiffFlowCorrectionsHistList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]);\r
6819 }\r
6820 }\r
6821 }\r
6822 } \r
6823 \r
6824} // end of AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()\r
6825\r
6826\r
6827//================================================================================================================================\r
6828\r
6829/*\r
6830void AliFlowAnalysisWithQCumulants::CalculateCorrectionsForNUAForIntQcumulants() // to be improved (do I really need this method?)\r
6831{\r
6832 // Calculate final corrections for non-uniform acceptance for Q-cumulants.\r
6833 \r
6834 // Corrections for non-uniform acceptance are stored in histogram fCorrectionsForNUA,\r
6835 // binning of fCorrectionsForNUA is organized as follows:\r
6836 //\r
6837 // 1st bin: correction to QC{2}\r
6838 // 2nd bin: correction to QC{4}\r
6839 // 3rd bin: correction to QC{6}\r
6840 // 4th bin: correction to QC{8}\r
6841 \r
6842 // shortcuts flags:\r
6843 Int_t pW = (Int_t)(useParticleWeights);\r
6844 \r
6845 Int_t eW = -1;\r
6846 \r
6847 if(eventWeights == "exact")\r
6848 {\r
6849 eW = 0;\r
6850 }\r
6851\r
6852 for(Int_t sc=0;sc<2;sc++) // sin or cos terms flag\r
6853 {\r
6854 if(!(fQCorrelations[pW][eW] && fQCorrections[pW][eW][sc] && fCorrections[pW][eW]))\r
6855 {\r
6856 cout<<"WARNING: fQCorrelations[pW][eW] && fQCorrections[pW][eW][sc] && fCorrections[pW][eW] is NULL in AFAWQC::CFCFNUAFIF() !!!!"<<endl;\r
6857 cout<<"pW = "<<pW<<endl;\r
6858 cout<<"eW = "<<eW<<endl;\r
6859 cout<<"sc = "<<sc<<endl;\r
6860 exit(0);\r
6861 }\r
6862 } \r
6863\r
6864 // measured 2-, 4-, 6- and 8-particle azimuthal correlations (biased with non-uniform acceptance!):\r
6865 Double_t two = fQCorrelations[pW][eW]->GetBinContent(1); // <<2>>\r
6866 //Double_t four = fQCorrelations[pW][eW]->GetBinContent(11); // <<4>>\r
6867 //Double_t six = fQCorrelations[pW][eW]->GetBinContent(24); // <<6>>\r
6868 //Double_t eight = fQCorrelations[pW][eW]->GetBinContent(31); // <<8>>\r
6869 \r
6870 // correction terms to QC{2}:\r
6871 // <<cos(n*phi1)>>^2\r
6872 Double_t two1stTerm = pow(fQCorrections[pW][eW][1]->GetBinContent(1),2); \r
6873 // <<sin(n*phi1)>>^2\r
6874 Double_t two2ndTerm = pow(fQCorrections[pW][eW][0]->GetBinContent(1),2); \r
6875 // final corrections for non-uniform acceptance to QC{2}:\r
6876 Double_t correctionQC2 = -1.*two1stTerm-1.*two2ndTerm;\r
6877 fCorrections[pW][eW]->SetBinContent(1,correctionQC2); \r
6878 \r
6879 // correction terms to QC{4}:\r
6880 // <<cos(n*phi1)>> <<cos(n*(phi1-phi2-phi3))>>\r
6881 Double_t four1stTerm = fQCorrections[pW][eW][1]->GetBinContent(1)*fQCorrections[pW][eW][1]->GetBinContent(3); \r
6882 // <<sin(n*phi1)>> <<sin(n*(phi1-phi2-phi3))>>\r
6883 Double_t four2ndTerm = fQCorrections[pW][eW][0]->GetBinContent(1)*fQCorrections[pW][eW][0]->GetBinContent(3); \r
6884 // <<cos(n*(phi1+phi2))>>^2\r
6885 Double_t four3rdTerm = pow(fQCorrections[pW][eW][1]->GetBinContent(2),2); \r
6886 // <<sin(n*(phi1+phi2))>>^2\r
6887 Double_t four4thTerm = pow(fQCorrections[pW][eW][0]->GetBinContent(2),2); \r
6888 // <<cos(n*(phi1+phi2))>> (<<cos(n*phi1)>>^2 - <<sin(n*phi1)>>^2)\r
6889 Double_t four5thTerm = fQCorrections[pW][eW][1]->GetBinContent(2)\r
6890 * (pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)-pow(fQCorrections[pW][eW][0]->GetBinContent(1),2));\r
6891 // <<sin(n*(phi1+phi2))>> <<cos(n*phi1)>> <<sin(n*phi1)>>\r
6892 Double_t four6thTerm = fQCorrections[pW][eW][0]->GetBinContent(2)\r
6893 * fQCorrections[pW][eW][1]->GetBinContent(1)\r
6894 * fQCorrections[pW][eW][0]->GetBinContent(1); \r
6895 // <<cos(n*(phi1-phi2))>> (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)\r
6896 Double_t four7thTerm = two*(pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)+pow(fQCorrections[pW][eW][0]->GetBinContent(1),2)); \r
6897 // (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)^2\r
6898 Double_t four8thTerm = pow(pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)+pow(fQCorrections[pW][eW][0]->GetBinContent(1),2),2); \r
6899 // final correction to QC{4}:\r
6900 Double_t correctionQC4 = -4.*four1stTerm+4.*four2ndTerm-four3rdTerm-four4thTerm\r
6901 + 4.*four5thTerm+8.*four6thTerm+8.*four7thTerm-6.*four8thTerm; \r
6902 fCorrections[pW][eW]->SetBinContent(2,correctionQC4); \r
6903\r
6904 // ... to be improved (continued for 6th and 8th order) \r
6905\r
6906\r
6907} // end of AliFlowAnalysisWithQCumulants::CalculateCorrectionsForNUAForIntQcumulants()\r
6908*/\r
6909\r
6910//================================================================================================================================\r
6911\r
6912\r
6913void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()\r
6914{\r
6915 // Calculate generalized Q-cumulants (cumulants corrected for non-unifom acceptance).\r
6916 \r
6917 // measured 2-, 4-, 6- and 8-particle correlations (biased by non-uniform acceptance!):\r
6918 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
6919 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
6920 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>\r
6921 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>\r
6922 \r
6923 // statistical error of measured 2-, 4-, 6- and 8-particle correlations:\r
6924 //Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <<2>>\r
6925 //Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <<4>>\r
6926 //Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <<6>>\r
6927 //Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <<8>>\r
6928\r
6929 // QC{2}:\r
6930 // <<cos(n*phi1)>>^2\r
6931 Double_t two1stTerm = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2); \r
6932 //Double_t two1stTermErrorSquared = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(1),2); \r
6933 // <<sin(n*phi1)>>^2\r
6934 Double_t two2ndTerm = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2); \r
6935 //Double_t two2ndTermErrorSquared = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(1),2); \r
6936 // generalized QC{2}:\r
6937 Double_t gQC2 = two - two1stTerm - two2ndTerm; // to be improved (terminology, notation)\r
6938 fIntFlowQcumulants->SetBinContent(1,gQC2); \r
6939 //fIntFlowQcumulants->SetBinError(1,0.); // to be improved (propagate error) \r
6940 \r
6941 // QC{4}:\r
6942 // <<cos(n*phi1)>> <<cos(n*(phi1-phi2-phi3))>>\r
6943 Double_t four1stTerm = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1)\r
6944 * fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); \r
6945 // <<sin(n*phi1)>> <<sin(n*(phi1-phi2-phi3))>>\r
6946 Double_t four2ndTerm = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1)\r
6947 * fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); \r
6948 // <<cos(n*(phi1+phi2))>>^2\r
6949 Double_t four3rdTerm = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2),2); \r
6950 // <<sin(n*(phi1+phi2))>>^2\r
6951 Double_t four4thTerm = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2),2); \r
6952 // <<cos(n*(phi1+phi2))>> (<<cos(n*phi1)>>^2 - <<sin(n*phi1)>>^2)\r
6953 Double_t four5thTerm = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2)\r
6954 * (pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
6955 - pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2));\r
6956 // <<sin(n*(phi1+phi2))>> <<cos(n*phi1)>> <<sin(n*phi1)>>\r
6957 Double_t four6thTerm = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2)\r
6958 * fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1)\r
6959 * fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); \r
6960 // <<cos(n*(phi1-phi2))>> (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)\r
6961 Double_t four7thTerm = two*(pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
6962 + pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2)); \r
6963 // (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)^2\r
6964 Double_t four8thTerm = pow(pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
6965 + pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2),2); \r
6966 // generalized QC{4}:\r
6967 Double_t gQC4 = four-2.*pow(two,2.)-4.*four1stTerm+4.*four2ndTerm-four3rdTerm\r
6968 - four4thTerm+4.*four5thTerm+8.*four6thTerm+8.*four7thTerm-6.*four8thTerm; \r
6969 fIntFlowQcumulants->SetBinContent(2,gQC4); \r
6970 //fIntFlowQcumulants->SetBinError(2,0.); // to be improved (propagate error) \r
6971\r
6972 // ... to be improved (continued for 6th and 8th order) \r
6973 \r
6974} // end of void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()\r
6975\r
6976\r
6977//================================================================================================================================\r
6978\r
6979\r
6980void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectedForNUA()\r
6981{\r
6982 // Calculate integrated flow from generalized Q-cumulants (corrected for non-uniform acceptance).\r
6983 \r
6984 // to be improved: add protection for NULL pointers, propagate statistical errors from \r
6985 // measured correlations and correction terms\r
6986 \r
6987 // generalized Q-cumulants:\r
6988 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2} \r
6989 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4} \r
6990 //Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6} \r
6991 //Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}\r
6992 \r
6993 // integrated flow estimates:\r
6994 Double_t v2 = 0.; // v{2,QC} \r
6995 Double_t v4 = 0.; // v{4,QC} \r
6996 //Double_t v6 = 0.; // v{6,QC} \r
6997 //Double_t v8 = 0.; // v{8,QC}\r
6998\r
6999 // calculate integrated flow estimates from generalized Q-cumulants: \r
7000 if(qc2>=0.) v2 = pow(qc2,1./2.); \r
7001 if(qc4<=0.) v4 = pow(-1.*qc4,1./4.); \r
7002 //if(qc6>=0.) v6 = pow((1./4.)*qc6,1./6.); \r
7003 //if(qc8<=0.) v8 = pow((-1./33.)*qc8,1./8.); \r
7004\r
7005 // store integrated flow estimates from generalized Q-cumulants:\r
7006 fIntFlow->SetBinContent(1,v2);\r
7007 fIntFlow->SetBinContent(2,v4);\r
7008 //fIntFlow->SetBinContent(3,v6);\r
7009 //fIntFlow->SetBinContent(4,v8);\r
7010\r
7011} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectedForNUA()\r
7012\r
7013 \r
7014//================================================================================================================================\r
7015\r
7016\r
7017void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow() \r
7018{\r
7019 // From profile fIntFlowCorrectionTermsForNUAPro[2] access measured corretion terms\r
7020 // and their spread, correctly calculate the statistical errors and store the final \r
7021 // results and statistical errors for correction terms in histogram fIntFlowCorrectionTermsForNUAHist[2].\r
7022 //\r
7023 // Remark: Statistical error of correction temrs is calculated as:\r
7024 //\r
7025 // statistical error = termA * spread * termB:\r
7026 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)\r
7027 // termB = 1/sqrt(1-termA^2) \r
7028 \r
7029 /* // to be improved (implement protection here)\r
7030 for(Int_t power=0;power<2;power++)\r
7031 { \r
7032 if(!(fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power])) \r
7033 {\r
7034 cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power] is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
7035 cout<<"power = "<<power<<endl;\r
7036 exit(0);\r
7037 }\r
7038 }\r
7039 */\r
7040 \r
7041 for(Int_t sc=0;sc<2;sc++) // sin or cos correction terms \r
7042 {\r
7043 for(Int_t ci=1;ci<=10;ci++) // correction term index\r
7044 {\r
7045 Double_t correction = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci);\r
7046 //Double_t spread = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinError(ci);\r
7047 //Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);\r
7048 //Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);\r
7049 //Double_t termA = 0.;\r
7050 //Double_t termB = 0.;\r
7051 //if(sumOfLinearEventWeights)\r
7052 //{\r
7053 // termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;\r
7054 //} else\r
7055 // {\r
7056 // cout<<"WARNING: sumOfLinearEventWeights == 0 in AFAWQC::FCIF() !!!!"<<endl;\r
7057 // cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;\r
7058 // }\r
7059 /*\r
7060 if(1.-pow(termA,2.) > 0.)\r
7061 {\r
7062 termB = 1./pow(1-pow(termA,2.),0.5);\r
7063 } else\r
7064 {\r
7065 cout<<"WARNING: 1.-pow(termA,2.) <= 0 in AFAWQC::FCIF() !!!!"<<endl; \r
7066 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;\r
7067 } \r
7068 Double_t statisticalError = termA * spread * termB;\r
7069 */\r
7070 fIntFlowCorrectionTermsForNUAHist[sc]->SetBinContent(ci,correction);\r
7071 //fIntFlowCorrectionTermsForNUAHist[sc]->SetBinError(ci,statisticalError);\r
7072 } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index\r
7073 } // end of for(Int sc=0;sc<2;sc++) // sin or cos correction terms \r
7074 \r
7075} // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()\r
7076\r
7077\r
7078//================================================================================================================================\r
7079\r
7080\r
7081void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms(TList *outputListHistos)\r
7082{\r
7083 // Get pointers to all objects relevant for calculations with nested loops.\r
7084 \r
7085 if(outputListHistos)\r
7086 {\r
7087 TList *nestedLoopsList = dynamic_cast<TList*>(outputListHistos->FindObject("Nested Loops"));\r
7088 if(nestedLoopsList) \r
7089 {\r
7090 this->SetNestedLoopsList(nestedLoopsList);\r
7091 } else\r
7092 {\r
7093 cout<<"WARNING: nestedLoopsList is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7094 exit(0);\r
7095 }\r
7096 \r
7097 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
7098 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)\r
7099 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)\r
7100 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)\r
7101 \r
7102 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";\r
7103 evaluateNestedLoopsName += fAnalysisLabel->Data(); \r
7104 TProfile *evaluateNestedLoops = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(evaluateNestedLoopsName.Data()));\r
7105 Bool_t bEvaluateIntFlowNestedLoops = kFALSE;\r
7106 Bool_t bEvaluateDiffFlowNestedLoops = kFALSE;\r
7107 if(evaluateNestedLoops)\r
7108 {\r
7109 this->SetEvaluateNestedLoops(evaluateNestedLoops);\r
7110 bEvaluateIntFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(1);\r
7111 bEvaluateDiffFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(2);\r
7112 }\r
7113 // nested loops relevant for integrated flow: \r
7114 if(bEvaluateIntFlowNestedLoops)\r
7115 {\r
7116 // correlations:\r
7117 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";\r
7118 intFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
7119 TProfile *intFlowDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowDirectCorrelationsName.Data()));\r
7120 if(intFlowDirectCorrelations) \r
7121 { \r
7122 this->SetIntFlowDirectCorrelations(intFlowDirectCorrelations);\r
7123 } else\r
7124 {\r
7125 cout<<"WARNING: intFlowDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7126 exit(0);\r
7127 }\r
7128 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) \r
7129 {\r
7130 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";\r
7131 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();\r
7132 TProfile *intFlowExtraDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowExtraDirectCorrelationsName.Data()));\r
7133 if(intFlowExtraDirectCorrelations) \r
7134 { \r
7135 this->SetIntFlowExtraDirectCorrelations(intFlowExtraDirectCorrelations);\r
7136 } else\r
7137 {\r
7138 cout<<"WARNING: intFlowExtraDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7139 exit(0);\r
7140 } \r
7141 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) \r
7142 // correction terms for non-uniform acceptance:\r
7143 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";\r
7144 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
7145 TProfile *intFlowDirectCorrectionTermsForNUA[2] = {NULL};\r
7146 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
7147 {\r
7148 intFlowDirectCorrectionTermsForNUA[sc] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data())));\r
7149 if(intFlowDirectCorrectionTermsForNUA[sc]) \r
7150 { \r
7151 this->SetIntFlowDirectCorrectionTermsForNUA(intFlowDirectCorrectionTermsForNUA[sc],sc);\r
7152 } else\r
7153 {\r
7154 cout<<"WARNING: intFlowDirectCorrectionTermsForNUA[sc] is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7155 cout<<"sc = "<<sc<<endl;\r
7156 exit(0);\r
7157 }\r
7158 } // end of for(Int_t sc=0;sc<2;sc++) \r
7159 } // end of if(bEvaluateIntFlowNestedLoops)\r
7160 \r
7161 // nested loops relevant for differential flow: \r
7162 if(bEvaluateDiffFlowNestedLoops)\r
7163 {\r
7164 // correlations:\r
7165 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";\r
7166 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
7167 TProfile *diffFlowDirectCorrelations[2][2][4] = {{{NULL}}};\r
7168 for(Int_t t=0;t<2;t++)\r
7169 {\r
7170 for(Int_t pe=0;pe<2;pe++)\r
7171 {\r
7172 for(Int_t ci=0;ci<4;ci++) // correlation index\r
7173 {\r
7174 diffFlowDirectCorrelations[t][pe][ci] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[ci].Data())));\r
7175 if(diffFlowDirectCorrelations[t][pe][ci])\r
7176 {\r
7177 this->SetDiffFlowDirectCorrelations(diffFlowDirectCorrelations[t][pe][ci],t,pe,ci);\r
7178 } else\r
7179 {\r
7180 cout<<"WARNING: diffFlowDirectCorrelations[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
7181 cout<<"t = "<<t<<endl;\r
7182 cout<<"pe = "<<pe<<endl; \r
7183 cout<<"ci = "<<ci<<endl;\r
7184 } \r
7185 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index \r
7186 } // end of for(Int_t pe=0;pe<2;pe++)\r
7187 } // end of for(Int_t t=0;t<2;t++) \r
7188 // correction terms for non-uniform acceptance:\r
7189 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";\r
7190 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data(); \r
7191 TProfile *diffFlowDirectCorrectionTermsForNUA[2][2][2][10] = {{{{NULL}}}}; \r
7192 for(Int_t t=0;t<2;t++)\r
7193 {\r
7194 for(Int_t pe=0;pe<2;pe++)\r
7195 {\r
7196 // correction terms for NUA:\r
7197 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7198 {\r
7199 for(Int_t cti=0;cti<9;cti++) // correction term index\r
7200 {\r
7201 diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
7202 if(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti])\r
7203 {\r
7204 this->SetDiffFlowDirectCorrectionTermsForNUA(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti],t,pe,sc,cti);\r
7205 } else\r
7206 {\r
7207 cout<<"WARNING: diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
7208 cout<<"t = "<<t<<endl;\r
7209 cout<<"pe = "<<pe<<endl; \r
7210 cout<<"sc = "<<sc<<endl;\r
7211 cout<<"cti = "<<cti<<endl;\r
7212 } \r
7213 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
7214 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7215 } // end of for(Int_t pe=0;pe<2;pe++)\r
7216 } // end of for(Int_t t=0;t<2;t++)\r
7217 } // end of if(bEvaluateDiffFlowNestedLoops)\r
7218 } else // to if(outputListHistos)\r
7219 {\r
7220 cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7221 exit(0);\r
7222 }\r
7223\r
7224} // end of void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms(TList *outputListHistos)\r
7225\r
7226\r
7227//================================================================================================================================\r
7228\r
7229\r
7230void AliFlowAnalysisWithQCumulants::StoreHarmonic()\r
7231{\r
7232 // Store flow harmonic in common control histograms.\r
7233\r
7234 (fCommonHists->GetHarmonic())->Fill(0.5,fHarmonic);\r
7235 (fCommonHists2nd->GetHarmonic())->Fill(0.5,fHarmonic);\r
7236 (fCommonHists4th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7237 (fCommonHists6th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7238 (fCommonHists8th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7239\r
7240} // end of void AliFlowAnalysisWithQCumulants::StoreHarmonic()\r
7241\r
7242\r
7243//================================================================================================================================\r
7244\r
7245\r
7246void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta) // type = RP or POI \r
7247{\r
7248 // Calculate all correlations needed for differential flow using particle weights.\r
7249 \r
7250 Int_t t = -1; // type flag \r
7251 Int_t pe = -1; // ptEta flag\r
7252 \r
7253 if(type == "RP")\r
7254 {\r
7255 t = 0;\r
7256 } else if(type == "POI")\r
7257 {\r
7258 t = 1;\r
7259 }\r
7260\r
7261 if(ptOrEta == "Pt")\r
7262 {\r
7263 pe = 0;\r
7264 } else if(ptOrEta == "Eta")\r
7265 {\r
7266 pe = 1;\r
7267 }\r
7268 \r
7269 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7270 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7271 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7272 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7273\r
7274 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7275 Double_t dReQ1n1k = (*fReQ)(0,1);\r
7276 Double_t dReQ2n2k = (*fReQ)(1,2);\r
7277 Double_t dReQ1n3k = (*fReQ)(0,3);\r
7278 //Double_t dReQ4n4k = (*fReQ)(3,4);\r
7279 Double_t dImQ1n1k = (*fImQ)(0,1);\r
7280 Double_t dImQ2n2k = (*fImQ)(1,2);\r
7281 Double_t dImQ1n3k = (*fImQ)(0,3);\r
7282 //Double_t dImQ4n4k = (*fImQ)(3,4);\r
7283 \r
7284 // S^M_{p,k} (see .h file for the definition of fSMpk):\r
7285 Double_t dSM1p1k = (*fSMpk)(0,1);\r
7286 Double_t dSM1p2k = (*fSMpk)(0,2);\r
7287 Double_t dSM1p3k = (*fSMpk)(0,3);\r
7288 Double_t dSM2p1k = (*fSMpk)(1,1);\r
7289 Double_t dSM3p1k = (*fSMpk)(2,1);\r
7290 \r
7291 // looping over all bins and calculating reduced correlations: \r
7292 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7293 {\r
7294 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin): \r
7295 Double_t p1n0kRe = 0.;\r
7296 Double_t p1n0kIm = 0.;\r
7297\r
7298 // number of POIs in particular (pt,eta) bin):\r
7299 Double_t mp = 0.;\r
7300\r
7301 // real and imaginary parts of q_{m*n,k}: \r
7302 // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)\r
7303 Double_t q1n2kRe = 0.;\r
7304 Double_t q1n2kIm = 0.;\r
7305 Double_t q2n1kRe = 0.;\r
7306 Double_t q2n1kIm = 0.;\r
7307\r
7308 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
7309 Double_t s1p1k = 0.; \r
7310 Double_t s1p2k = 0.; \r
7311 Double_t s1p3k = 0.; \r
7312 \r
7313 // M0111 from Eq. (118) in QC2c (to be improved (notation))\r
7314 Double_t dM0111 = 0.;\r
7315 \r
7316 if(type == "POI")\r
7317 {\r
7318 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7319 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7320 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b)) \r
7321 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7322 \r
7323 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7324 \r
7325 t = 1; // typeFlag = RP or POI\r
7326 \r
7327 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!)) \r
7328 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))\r
7329 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));\r
7330 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))\r
7331 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));\r
7332 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))\r
7333 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));\r
7334 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))\r
7335 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));\r
7336 \r
7337 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
7338 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.); \r
7339 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.); \r
7340 s1p3k = pow(fs1dEBE[2][pe][3]->GetBinContent(b)*fs1dEBE[2][pe][3]->GetBinEntries(b),1.); \r
7341 \r
7342 // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
7343 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
7344 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
7345 + 2.*(s1p3k-s1p2k*dSM1p1k));\r
7346 }\r
7347 else if(type == "RP")\r
7348 {\r
7349 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!)) \r
7350 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
7351 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
7352 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
7353 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
7354 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
7355 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
7356 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
7357 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
7358\r
7359 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation) \r
7360 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.); \r
7361 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.); \r
7362 s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.); \r
7363 \r
7364 // to be improved (cross-checked):\r
7365 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7366 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7367 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b)) \r
7368 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7369 \r
7370 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7371 \r
7372 t = 0; // typeFlag = RP or POI\r
7373 \r
7374 // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
7375 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
7376 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
7377 + 2.*(s1p3k-s1p2k*dSM1p1k));\r
7378 //............................................................................................... \r
7379 }\r
7380 \r
7381 // 2'-particle correlation:\r
7382 Double_t two1n1nW0W1 = 0.;\r
7383 if(mp*dSM1p1k-s1p1k)\r
7384 {\r
7385 two1n1nW0W1 = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)\r
7386 / (mp*dSM1p1k-s1p1k);\r
7387 \r
7388 // fill profile to get <<2'>> \r
7389 fDiffFlowCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1,mp*dSM1p1k-s1p1k);\r
7390 // histogram to store <2'> e-b-e (needed in some other methods):\r
7391 fDiffFlowCorrelationsEBE[t][pe][0]->SetBinContent(b,two1n1nW0W1); \r
7392 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->SetBinContent(b,mp*dSM1p1k-s1p1k); \r
7393 } // end of if(mp*dSM1p1k-s1p1k)\r
7394 \r
7395 // 4'-particle correlation:\r
7396 Double_t four1n1n1n1nW0W1W1W1 = 0.;\r
7397 if(dM0111)\r
7398 {\r
7399 four1n1n1n1nW0W1W1W1 = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
7400 - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))\r
7401 - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k\r
7402 - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)\r
7403 + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)\r
7404 - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
7405 - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k \r
7406 + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k) \r
7407 + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k) \r
7408 + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k) \r
7409 + 2.*s1p1k*dSM1p2k \r
7410 - 6.*s1p3k) \r
7411 / dM0111; // to be improved (notation of dM0111)\r
7412 \r
7413 // fill profile to get <<4'>> \r
7414 fDiffFlowCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1,dM0111);\r
7415 // histogram to store <4'> e-b-e (needed in some other methods):\r
7416 fDiffFlowCorrelationsEBE[t][pe][1]->SetBinContent(b,four1n1n1n1nW0W1W1W1); \r
7417 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->SetBinContent(b,dM0111); \r
7418 } // end of if(dM0111)\r
7419 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7420\r
7421} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta); // type = RP or POI \r
7422\r
7423\r
7424//================================================================================================================================\r
7425\r
7426\r
7427void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)\r
7428{\r
7429 // Fill common control histograms.\r
7430 \r
7431 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)\r
7432 fCommonHists->FillControlHistograms(anEvent); \r
7433 if(nRP>1)\r
7434 {\r
7435 fCommonHists2nd->FillControlHistograms(anEvent); \r
7436 if(nRP>3)\r
7437 {\r
7438 fCommonHists4th->FillControlHistograms(anEvent); \r
7439 if(nRP>5)\r
7440 {\r
7441 fCommonHists6th->FillControlHistograms(anEvent); \r
7442 if(nRP>7)\r
7443 {\r
7444 fCommonHists8th->FillControlHistograms(anEvent); \r
7445 } // end of if(nRP>7) \r
7446 } // end of if(nRP>5) \r
7447 } // end of if(nRP>3) \r
7448 } // end of if(nRP>1) \r
7449 \r
7450} // end of void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)\r
7451\r
7452\r
7453//================================================================================================================================\r
7454\r
7455\r
7456void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities()\r
7457{\r
7458 // Reset all event by event quantities.\r
7459 \r
7460 // integrated flow:\r
7461 fReQ->Zero();\r
7462 fImQ->Zero();\r
7463 fSMpk->Zero();\r
7464 fIntFlowCorrelationsEBE->Reset();\r
7465 fIntFlowEventWeightsForCorrelationsEBE->Reset();\r
7466 fIntFlowCorrelationsAllEBE->Reset();\r
7467 \r
7468 if(fApplyCorrectionForNUA) \r
7469 {\r
7470 for(Int_t sc=0;sc<2;sc++)\r
7471 {\r
7472 fIntFlowCorrectionTermsForNUAEBE[sc]->Reset();\r
7473 } \r
7474 }\r
7475 \r
7476 // differential flow:\r
7477 // 1D:\r
7478 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
7479 {\r
7480 for(Int_t pe=0;pe<2;pe++) // 1D in pt or eta\r
7481 {\r
7482 for(Int_t m=0;m<4;m++) // multiple of harmonic\r
7483 {\r
7484 for(Int_t k=0;k<9;k++) // power of weight\r
7485 {\r
7486 if(fReRPQ1dEBE[t][pe][m][k]) fReRPQ1dEBE[t][pe][m][k]->Reset();\r
7487 if(fImRPQ1dEBE[t][pe][m][k]) fImRPQ1dEBE[t][pe][m][k]->Reset();\r
7488 } \r
7489 }\r
7490 }\r
7491 }\r
7492 \r
7493 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )\r
7494 { \r
7495 for(Int_t pe=0;pe<2;pe++) // 1D in pt or eta\r
7496 {\r
7497 for(Int_t k=0;k<9;k++)\r
7498 {\r
7499 if(fs1dEBE[t][pe][k]) fs1dEBE[t][pe][k]->Reset();\r
7500 }\r
7501 }\r
7502 }\r
7503\r
7504 // e-b-e reduced correlations:\r
7505 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)\r
7506 { \r
7507 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
7508 {\r
7509 for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
7510 {\r
7511 if(fDiffFlowCorrelationsEBE[t][pe][rci]) fDiffFlowCorrelationsEBE[t][pe][rci]->Reset();\r
7512 if(fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]) fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]->Reset();\r
7513 }\r
7514 }\r
7515 }\r
7516 \r
7517 // correction terms for NUA:\r
7518 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)\r
7519 { \r
7520 for(Int_t pe=0;pe<2;pe++) // pt or eta\r
7521 {\r
7522 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7523 {\r
7524 for(Int_t cti=0;cti<9;cti++) // correction term index\r
7525 {\r
7526 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti]->Reset(); \r
7527 }\r
7528 }\r
7529 } \r
7530 }\r
7531 \r
7532 // 2D (pt,eta)\r
7533 if(fCalculate2DFlow)\r
7534 {\r
7535 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
7536 {\r
7537 for(Int_t m=0;m<4;m++) // multiple of harmonic\r
7538 {\r
7539 for(Int_t k=0;k<9;k++) // power of weight\r
7540 {\r
7541 if(fReRPQ2dEBE[t][m][k]) fReRPQ2dEBE[t][m][k]->Reset();\r
7542 if(fImRPQ2dEBE[t][m][k]) fImRPQ2dEBE[t][m][k]->Reset();\r
7543 } \r
7544 }\r
7545 }\r
7546 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )\r
7547 { \r
7548 for(Int_t k=0;k<9;k++)\r
7549 {\r
7550 if(fs2dEBE[t][k]) fs2dEBE[t][k]->Reset();\r
7551 }\r
7552 } \r
7553 } // end of if(fCalculate2DFlow) \r
7554\r
7555} // end of void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities();\r
7556\r
7557\r
7558//================================================================================================================================\r
7559\r
7560\r
7561void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)\r
7562{\r
7563 // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).\r
7564 \r
7565 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:\r
7566 // 0: <<sin n(psi1)>>\r
7567 // 1: <<sin n(psi1+phi2)>>\r
7568 // 2: <<sin n(psi1+phi2-phi3)>>\r
7569 // 3: <<sin n(psi1-phi2-phi3)>>:\r
7570 // 4:\r
7571 // 5:\r
7572 // 6:\r
7573 \r
7574 // multiplicity:\r
7575 Double_t dMult = (*fSMpk)(0,0);\r
7576 \r
7577 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7578 Double_t dReQ1n = (*fReQ)(0,0);\r
7579 Double_t dReQ2n = (*fReQ)(1,0);\r
7580 //Double_t dReQ3n = (*fReQ)(2,0);\r
7581 //Double_t dReQ4n = (*fReQ)(3,0);\r
7582 Double_t dImQ1n = (*fImQ)(0,0);\r
7583 Double_t dImQ2n = (*fImQ)(1,0);\r
7584 //Double_t dImQ3n = (*fImQ)(2,0);\r
7585 //Double_t dImQ4n = (*fImQ)(3,0);\r
7586\r
7587 Int_t t = -1; // type flag \r
7588 Int_t pe = -1; // ptEta flag\r
7589 \r
7590 if(type == "RP")\r
7591 {\r
7592 t = 0;\r
7593 } else if(type == "POI")\r
7594 {\r
7595 t = 1;\r
7596 }\r
7597\r
7598 if(ptOrEta == "Pt")\r
7599 {\r
7600 pe = 0;\r
7601 } else if(ptOrEta == "Eta")\r
7602 {\r
7603 pe = 1;\r
7604 }\r
7605 \r
7606 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7607 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7608 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7609 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7610\r
7611 // looping over all bins and calculating correction terms: \r
7612 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7613 {\r
7614 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
7615 Double_t p1n0kRe = 0.;\r
7616 Double_t p1n0kIm = 0.;\r
7617\r
7618 // number of POIs in particular pt or eta bin:\r
7619 Double_t mp = 0.;\r
7620\r
7621 // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
7622 Double_t q1n0kRe = 0.;\r
7623 Double_t q1n0kIm = 0.;\r
7624 Double_t q2n0kRe = 0.;\r
7625 Double_t q2n0kIm = 0.;\r
7626\r
7627 // number of particles which are both RPs and POIs in particular pt or eta bin:\r
7628 Double_t mq = 0.;\r
7629 \r
7630 if(type == "POI")\r
7631 {\r
7632 // q_{m*n,0}:\r
7633 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7634 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7635 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7636 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7637 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7638 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
7639 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7640 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b)); \r
7641 \r
7642 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7643 } \r
7644 else if(type == "RP")\r
7645 {\r
7646 // q_{m*n,0}:\r
7647 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7648 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7649 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7650 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7651 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7652 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
7653 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7654 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b)); \r
7655 \r
7656 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here) \r
7657 } \r
7658 if(type == "POI")\r
7659 {\r
7660 // p_{m*n,0}:\r
7661 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7662 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7663 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b)) \r
7664 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7665 \r
7666 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7667 \r
7668 t = 1; // typeFlag = RP or POI\r
7669 }\r
7670 else if(type == "RP")\r
7671 {\r
7672 // p_{m*n,0} = q_{m*n,0}:\r
7673 p1n0kRe = q1n0kRe; \r
7674 p1n0kIm = q1n0kIm; \r
7675 \r
7676 mp = mq; \r
7677 \r
7678 t = 0; // typeFlag = RP or POI\r
7679 }\r
7680\r
7681 // <<sin n(psi1)>>:\r
7682 Double_t sinP1nPsi = 0.;\r
7683 if(mp)\r
7684 {\r
7685 sinP1nPsi = p1n0kIm/mp;\r
7686 // fill profile for <<sin n(psi1)>>:\r
7687 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);\r
7688 // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):\r
7689 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);\r
7690 } // end of if(mp) \r
7691 \r
7692 // <<sin n(psi1+phi2)>>:\r
7693 Double_t sinP1nPsiP1nPhi = 0.;\r
7694 if(mp*dMult-mq)\r
7695 {\r
7696 sinP1nPsiP1nPhi = (p1n0kRe*dImQ1n+p1n0kIm*dReQ1n-q2n0kIm)/(mp*dMult-mq);\r
7697 // fill profile for <<sin n(psi1+phi2)>>:\r
7698 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhi,mp*dMult-mq);\r
7699 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7700 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhi);\r
7701 } // end of if(mp*dMult-mq) \r
7702 \r
7703 // <<sin n(psi1+phi2-phi3)>>:\r
7704 Double_t sinP1nPsi1P1nPhi2MPhi3 = 0.;\r
7705 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7706 {\r
7707 sinP1nPsi1P1nPhi2MPhi3 = (p1n0kIm*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
7708 - 1.*(q2n0kIm*dReQ1n-q2n0kRe*dImQ1n) \r
7709 - mq*dImQ1n+2.*q1n0kIm)\r
7710 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7711 // fill profile for <<sin n(psi1+phi2)>>:\r
7712 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7713 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7714 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3);\r
7715 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.)) \r
7716 \r
7717 // <<sin n(psi1-phi2-phi3)>>:\r
7718 Double_t sinP1nPsi1M1nPhi2MPhi3 = 0.;\r
7719 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7720 {\r
7721 sinP1nPsi1M1nPhi2MPhi3 = (p1n0kIm*(pow(dReQ1n,2.)-pow(dImQ1n,2.))-2.*p1n0kRe*dReQ1n*dImQ1n\r
7722 - 1.*(p1n0kIm*dReQ2n-p1n0kRe*dImQ2n)\r
7723 + 2.*mq*dImQ1n-2.*q1n0kIm)\r
7724 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7725 // fill profile for <<sin n(psi1+phi2)>>:\r
7726 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7727 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7728 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3);\r
7729 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.)) \r
7730 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7731 \r
7732} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)\r
7733\r
7734\r
7735//================================================================================================================================\r
7736\r
7737\r
7738void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)\r
7739{\r
7740 // Calculate correction terms for non-uniform acceptance for differential flow (cos terms).\r
7741 \r
7742 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:\r
7743 // 0: <<cos n(psi)>>\r
7744 // 1: <<cos n(psi1+phi2)>>\r
7745 // 2: <<cos n(psi1+phi2-phi3)>>\r
7746 // 3: <<cos n(psi1-phi2-phi3)>>\r
7747 // 4:\r
7748 // 5:\r
7749 // 6:\r
7750 \r
7751 // multiplicity:\r
7752 Double_t dMult = (*fSMpk)(0,0);\r
7753 \r
7754 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7755 Double_t dReQ1n = (*fReQ)(0,0);\r
7756 Double_t dReQ2n = (*fReQ)(1,0);\r
7757 //Double_t dReQ3n = (*fReQ)(2,0);\r
7758 //Double_t dReQ4n = (*fReQ)(3,0);\r
7759 Double_t dImQ1n = (*fImQ)(0,0);\r
7760 Double_t dImQ2n = (*fImQ)(1,0);\r
7761 //Double_t dImQ3n = (*fImQ)(2,0);\r
7762 //Double_t dImQ4n = (*fImQ)(3,0);\r
7763\r
7764 Int_t t = -1; // type flag \r
7765 Int_t pe = -1; // ptEta flag\r
7766 \r
7767 if(type == "RP")\r
7768 {\r
7769 t = 0;\r
7770 } else if(type == "POI")\r
7771 {\r
7772 t = 1;\r
7773 }\r
7774\r
7775 if(ptOrEta == "Pt")\r
7776 {\r
7777 pe = 0;\r
7778 } else if(ptOrEta == "Eta")\r
7779 {\r
7780 pe = 1;\r
7781 }\r
7782 \r
7783 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7784 Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7785 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7786 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7787\r
7788 // looping over all bins and calculating correction terms: \r
7789 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7790 {\r
7791 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
7792 Double_t p1n0kRe = 0.;\r
7793 Double_t p1n0kIm = 0.;\r
7794\r
7795 // number of POIs in particular pt or eta bin:\r
7796 Double_t mp = 0.;\r
7797\r
7798 // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
7799 Double_t q1n0kRe = 0.;\r
7800 Double_t q1n0kIm = 0.;\r
7801 Double_t q2n0kRe = 0.;\r
7802 Double_t q2n0kIm = 0.;\r
7803\r
7804 // number of particles which are both RPs and POIs in particular pt or eta bin:\r
7805 Double_t mq = 0.;\r
7806 \r
7807 if(type == "POI")\r
7808 {\r
7809 // q_{m*n,0}:\r
7810 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7811 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7812 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7813 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7814 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7815 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
7816 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7817 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b)); \r
7818 \r
7819 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7820 } \r
7821 else if(type == "RP")\r
7822 {\r
7823 // q_{m*n,0}:\r
7824 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7825 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7826 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7827 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7828 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7829 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
7830 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7831 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b)); \r
7832 \r
7833 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here) \r
7834 } \r
7835 if(type == "POI")\r
7836 {\r
7837 // p_{m*n,0}:\r
7838 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7839 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7840 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b)) \r
7841 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7842 \r
7843 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7844 \r
7845 t = 1; // typeFlag = RP or POI\r
7846 }\r
7847 else if(type == "RP")\r
7848 {\r
7849 // p_{m*n,0} = q_{m*n,0}:\r
7850 p1n0kRe = q1n0kRe; \r
7851 p1n0kIm = q1n0kIm; \r
7852 \r
7853 mp = mq; \r
7854 \r
7855 t = 0; // typeFlag = RP or POI\r
7856 }\r
7857\r
7858 // <<cos n(psi1)>>:\r
7859 Double_t cosP1nPsi = 0.;\r
7860 if(mp)\r
7861 {\r
7862 cosP1nPsi = p1n0kRe/mp;\r
7863 \r
7864 // fill profile for <<cos n(psi1)>>:\r
7865 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);\r
7866 // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):\r
7867 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);\r
7868 } // end of if(mp) \r
7869 \r
7870 // <<cos n(psi1+phi2)>>:\r
7871 Double_t cosP1nPsiP1nPhi = 0.;\r
7872 if(mp*dMult-mq)\r
7873 {\r
7874 cosP1nPsiP1nPhi = (p1n0kRe*dReQ1n-p1n0kIm*dImQ1n-q2n0kRe)/(mp*dMult-mq);\r
7875 // fill profile for <<sin n(psi1+phi2)>>:\r
7876 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhi,mp*dMult-mq);\r
7877 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7878 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhi);\r
7879 } // end of if(mp*dMult-mq) \r
7880 \r
7881 // <<cos n(psi1+phi2-phi3)>>:\r
7882 Double_t cosP1nPsi1P1nPhi2MPhi3 = 0.;\r
7883 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7884 {\r
7885 cosP1nPsi1P1nPhi2MPhi3 = (p1n0kRe*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
7886 - 1.*(q2n0kRe*dReQ1n+q2n0kIm*dImQ1n) \r
7887 - mq*dReQ1n+2.*q1n0kRe)\r
7888 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7889 // fill profile for <<sin n(psi1+phi2)>>:\r
7890 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7891 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7892 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3);\r
7893 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.)) \r
7894 \r
7895 // <<cos n(psi1-phi2-phi3)>>:\r
7896 Double_t cosP1nPsi1M1nPhi2MPhi3 = 0.;\r
7897 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7898 {\r
7899 cosP1nPsi1M1nPhi2MPhi3 = (p1n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))+2.*p1n0kIm*dReQ1n*dImQ1n\r
7900 - 1.*(p1n0kRe*dReQ2n+p1n0kIm*dImQ2n) \r
7901 - 2.*mq*dReQ1n+2.*q1n0kRe)\r
7902 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7903 // fill profile for <<sin n(psi1+phi2)>>:\r
7904 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7905 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7906 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3);\r
7907 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.)) \r
7908 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7909 \r
7910} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)\r
7911\r
7912\r
7913//==================================================================================================================================\r
7914\r
7915\r
7916void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)\r
7917{\r
7918 // Transfer prolfiles into histogams and correctly propagate the error (to be improved: description)\r
7919 \r
7920 // to be improved: debugged - I do not correctly transfer all profiles into histos (bug appears only after merging) \r
7921 \r
7922 Int_t t = -1; // type flag \r
7923 Int_t pe = -1; // ptEta flag\r
7924 \r
7925 if(type == "RP")\r
7926 {\r
7927 t = 0;\r
7928 } else if(type == "POI")\r
7929 {\r
7930 t = 1;\r
7931 }\r
7932\r
7933 if(ptOrEta == "Pt")\r
7934 {\r
7935 pe = 0;\r
7936 } else if(ptOrEta == "Eta")\r
7937 {\r
7938 pe = 1;\r
7939 }\r
7940 \r
7941 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7942 //Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7943 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7944 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7945\r
7946 for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7947 {\r
7948 for(Int_t cti=0;cti<9;cti++) // correction term index\r
7949 {\r
7950 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7951 {\r
7952 Double_t correctionTerm = fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(b);\r
7953 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]->SetBinContent(b,correctionTerm);\r
7954 // to be improved (propagate error correctly)\r
7955 // ...\r
7956 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7957 } // correction term index\r
7958 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7959\r
7960}// end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)\r
7961\r
7962\r
7963//==================================================================================================================================\r
7964\r
7965\r
7966void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)\r
7967{ \r
7968 // Calculate generalized differential flow Q-cumulants (corrected for non-uniform acceptance)\r
7969 \r
7970 Int_t typeFlag = -1;\r
7971 Int_t ptEtaFlag = -1;\r
7972\r
7973 if(type == "RP")\r
7974 {\r
7975 typeFlag = 0;\r
7976 } else if(type == "POI")\r
7977 {\r
7978 typeFlag = 1;\r
7979 } \r
7980 \r
7981 if(ptOrEta == "Pt")\r
7982 {\r
7983 ptEtaFlag = 0;\r
7984 } else if(ptOrEta == "Eta")\r
7985 {\r
7986 ptEtaFlag = 1;\r
7987 } \r
7988 \r
7989 // shortcuts:\r
7990 Int_t t = typeFlag;\r
7991 Int_t pe = ptEtaFlag;\r
7992 \r
7993 // common:\r
7994 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7995 \r
7996 // 2-particle correlation:\r
7997 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
7998 // sin term coming from integrated flow: \r
7999 Double_t sinP1nPhi = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>\r
8000 Double_t sinP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>\r
8001 Double_t sinP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>\r
8002 // cos term coming from integrated flow: \r
8003 Double_t cosP1nPhi = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>\r
8004 Double_t cosP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>\r
8005 Double_t cosP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>\r
8006\r
8007 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8008 {\r
8009 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>\r
8010 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>\r
8011 Double_t sinP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][0]->GetBinContent(b); // <<sin n(Psi)>> \r
8012 Double_t cosP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][0]->GetBinContent(b); // <<cos n(Psi)>> \r
8013 Double_t sinP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][1]->GetBinContent(b); // <<sin n(psi1+phi2)>> \r
8014 Double_t cosP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][1]->GetBinContent(b); // <<cos n(psi1+phi2)>> \r
8015 Double_t sinP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][2]->GetBinContent(b); // <<sin n(psi1+phi2-phi3)>> \r
8016 Double_t cosP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][2]->GetBinContent(b); // <<cos n(psi1+phi2-phi3)>> \r
8017 Double_t sinP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][3]->GetBinContent(b); // <<sin n(psi1-phi2-phi3)>> \r
8018 Double_t cosP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][3]->GetBinContent(b); // <<cos n(psi1-phi2-phi3)>> \r
8019 // generalized QC{2'}:\r
8020 Double_t qc2Prime = twoPrime - sinP1nPsi*sinP1nPhi - cosP1nPsi*cosP1nPhi;\r
8021 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);\r
8022 // generalized QC{4'}:\r
8023 Double_t qc4Prime = fourPrime-2.*twoPrime*two\r
8024 - cosP1nPsi*cosP1nPhi1M1nPhi2M1nPhi3\r
8025 + sinP1nPsi*sinP1nPhi1M1nPhi2M1nPhi3\r
8026 - cosP1nPhi*cosP1nPsi1M1nPhi2M1nPhi3\r
8027 + sinP1nPhi*sinP1nPsi1M1nPhi2M1nPhi3\r
8028 - 2.*cosP1nPhi*cosP1nPsi1P1nPhi2M1nPhi3\r
8029 - 2.*sinP1nPhi*sinP1nPsi1P1nPhi2M1nPhi3\r
8030 - cosP1nPsi1P1nPhi2*cosP1nPhi1P1nPhi2\r
8031 - sinP1nPsi1P1nPhi2*sinP1nPhi1P1nPhi2\r
8032 + 2.*cosP1nPhi1P1nPhi2*(cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)\r
8033 + 2.*sinP1nPhi1P1nPhi2*(cosP1nPsi*sinP1nPhi+sinP1nPsi*cosP1nPhi)\r
8034 + 4.*two*(cosP1nPsi*cosP1nPhi+sinP1nPsi*sinP1nPhi)\r
8035 + 2.*cosP1nPsi1P1nPhi2*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))\r
8036 + 4.*sinP1nPsi1P1nPhi2*cosP1nPhi*sinP1nPhi\r
8037 + 4.*twoPrime*(pow(cosP1nPhi,2.)+pow(sinP1nPhi,2.))\r
8038 - 6.*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.)) \r
8039 * (cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)\r
8040 - 12.*cosP1nPhi*sinP1nPhi\r
8041 * (sinP1nPsi*cosP1nPhi+cosP1nPsi*sinP1nPhi);\r
8042 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime); \r
8043 } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
8044 \r
8045} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)\r
8046\r
8047\r
8048//==================================================================================================================================\r
8049 \r
8050\r
8051void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)\r
8052{\r
8053 // Calculate differential flow corrected for non-uniform acceptance.\r
8054 \r
8055 // to be improved (rewritten completely)\r
8056 \r
8057 Int_t typeFlag = -1;\r
8058 Int_t ptEtaFlag = -1;\r
8059\r
8060 if(type == "RP")\r
8061 {\r
8062 typeFlag = 0;\r
8063 } else if(type == "POI")\r
8064 {\r
8065 typeFlag = 1;\r
8066 } \r
8067 \r
8068 if(ptOrEta == "Pt")\r
8069 {\r
8070 ptEtaFlag = 0;\r
8071 } else if(ptOrEta == "Eta")\r
8072 {\r
8073 ptEtaFlag = 1;\r
8074 } \r
8075 \r
8076 // shortcuts:\r
8077 Int_t t = typeFlag;\r
8078 Int_t pe = ptEtaFlag;\r
8079 \r
8080 // common:\r
8081 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
8082 \r
8083 // to be improved: access here generalized QC{2} and QC{4} instead: \r
8084 Double_t dV2 = fIntFlow->GetBinContent(1); \r
8085 Double_t dV4 = fIntFlow->GetBinContent(2); \r
8086 \r
8087 // loop over pt or eta bins:\r
8088 for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8089 {\r
8090 // generalized QC{2'}:\r
8091 Double_t gQC2Prime = fDiffFlowCumulants[t][pe][0]->GetBinContent(b);\r
8092 // v'{2}:\r
8093 if(dV2>0)\r
8094 { \r
8095 Double_t v2Prime = gQC2Prime/dV2;\r
8096 fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime); \r
8097 } \r
8098 // generalized QC{4'}:\r
8099 Double_t gQC4Prime = fDiffFlowCumulants[t][pe][1]->GetBinContent(b);\r
8100 // v'{4}:\r
8101 if(dV4>0)\r
8102 { \r
8103 Double_t v4Prime = -gQC4Prime/pow(dV4,3.);\r
8104 fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime); \r
8105 } \r
8106 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)\r
8107 \r
8108} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta); \r
8109\r
8110\r
8111//==================================================================================================================================\r
8112\r
8113\r
8114void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)\r
8115{\r
8116 // Evaluate with nested loops multiparticle correlations for integrated flow (without using the particle weights). \r
8117\r
8118 // Remark: Results are stored in profile fIntFlowDirectCorrelations whose binning is organized as follows:\r
8119 // \r
8120 // 1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>\r
8121 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>\r
8122 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))> \r
8123 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>\r
8124 // 5th bin: ---- EMPTY ----\r
8125 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>\r
8126 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>\r
8127 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
8128 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>\r
8129 // 10th bin: ---- EMPTY ----\r
8130 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>\r
8131 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
8132 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>\r
8133 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
8134 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>\r
8135 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>\r
8136 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))> \r
8137 // 18th bin: ---- EMPTY ----\r
8138 // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
8139 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
8140 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
8141 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
8142 // 23rd bin: ---- EMPTY ----\r
8143 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
8144 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
8145 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
8146 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
8147 // 28th bin: ---- EMPTY ----\r
8148 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
8149 // 30th bin: ---- EMPTY ----\r
8150 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
8151 \r
8152 Int_t nPrim = anEvent->NumberOfTracks(); \r
8153 AliFlowTrackSimple *aftsTrack = NULL; \r
8154 Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.; \r
8155 Int_t n = fHarmonic; \r
8156 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8157 Double_t dMult = (*fSMpk)(0,0);\r
8158 cout<<endl;\r
8159 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8160 if(dMult<2)\r
8161 {\r
8162 cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8163 } else if (dMult>fMaxAllowedMultiplicity)\r
8164 {\r
8165 cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8166 } else \r
8167 { \r
8168 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;\r
8169 } \r
8170 \r
8171 // 2-particle correlations: \r
8172 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8173 {\r
8174 for(Int_t i1=0;i1<nPrim;i1++)\r
8175 {\r
8176 aftsTrack=anEvent->GetTrack(i1);\r
8177 if(!(aftsTrack->InRPSelection())) continue;\r
8178 phi1=aftsTrack->Phi(); \r
8179 for(Int_t i2=0;i2<nPrim;i2++)\r
8180 {\r
8181 if(i2==i1)continue;\r
8182 aftsTrack=anEvent->GetTrack(i2);\r
8183 if(!(aftsTrack->InRPSelection())) continue;\r
8184 phi2=aftsTrack->Phi();\r
8185 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8186 // fill the profile with 2-p correlations: \r
8187 fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),1.); // <cos(n*(phi1-phi2))>\r
8188 fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),1.); // <cos(2n*(phi1-phi2))>\r
8189 fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),1.); // <cos(3n*(phi1-phi2))>\r
8190 fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),1.); // <cos(4n*(phi1-phi2))> \r
8191 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8192 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8193 } // end of if(nPrim>=2)\r
8194 \r
8195 // 3-particle correlations: \r
8196 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8197 {\r
8198 for(Int_t i1=0;i1<nPrim;i1++)\r
8199 {\r
8200 aftsTrack=anEvent->GetTrack(i1);\r
8201 if(!(aftsTrack->InRPSelection())) continue;\r
8202 phi1=aftsTrack->Phi();\r
8203 for(Int_t i2=0;i2<nPrim;i2++)\r
8204 {\r
8205 if(i2==i1)continue;\r
8206 aftsTrack=anEvent->GetTrack(i2);\r
8207 if(!(aftsTrack->InRPSelection())) continue;\r
8208 phi2=aftsTrack->Phi();\r
8209 for(Int_t i3=0;i3<nPrim;i3++)\r
8210 {\r
8211 if(i3==i1||i3==i2)continue;\r
8212 aftsTrack=anEvent->GetTrack(i3);\r
8213 if(!(aftsTrack->InRPSelection())) continue;\r
8214 phi3=aftsTrack->Phi();\r
8215 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;\r
8216 // fill the profile with 3-p correlations: \r
8217 fIntFlowDirectCorrelations->Fill(5.,cos(2.*n*phi1-n*(phi2+phi3)),1.); //<3>_{2n|nn,n}\r
8218 fIntFlowDirectCorrelations->Fill(6.,cos(3.*n*phi1-2.*n*phi2-n*phi3),1.); //<3>_{3n|2n,n}\r
8219 fIntFlowDirectCorrelations->Fill(7.,cos(4.*n*phi1-2.*n*phi2-2.*n*phi3),1.); //<3>_{4n|2n,2n}\r
8220 fIntFlowDirectCorrelations->Fill(8.,cos(4.*n*phi1-3.*n*phi2-n*phi3),1.); //<3>_{4n|3n,n}\r
8221 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8222 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8223 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8224 } // end of if(nPrim>=3)\r
8225\r
8226 // 4-particle correlations:\r
8227 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)\r
8228 { \r
8229 for(Int_t i1=0;i1<nPrim;i1++)\r
8230 { \r
8231 aftsTrack=anEvent->GetTrack(i1);\r
8232 if(!(aftsTrack->InRPSelection())) continue;\r
8233 phi1=aftsTrack->Phi();\r
8234 for(Int_t i2=0;i2<nPrim;i2++)\r
8235 {\r
8236 if(i2==i1)continue;\r
8237 aftsTrack=anEvent->GetTrack(i2);\r
8238 if(!(aftsTrack->InRPSelection())) continue;\r
8239 phi2=aftsTrack->Phi();\r
8240 for(Int_t i3=0;i3<nPrim;i3++)\r
8241 {\r
8242 if(i3==i1||i3==i2)continue;\r
8243 aftsTrack=anEvent->GetTrack(i3);\r
8244 if(!(aftsTrack->InRPSelection())) continue;\r
8245 phi3=aftsTrack->Phi();\r
8246 for(Int_t i4=0;i4<nPrim;i4++)\r
8247 {\r
8248 if(i4==i1||i4==i2||i4==i3)continue;\r
8249 aftsTrack=anEvent->GetTrack(i4);\r
8250 if(!(aftsTrack->InRPSelection())) continue;\r
8251 phi4=aftsTrack->Phi();\r
8252 if(nPrim==4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush;\r
8253 // fill the profile with 4-p correlations: \r
8254 fIntFlowDirectCorrelations->Fill(10.,cos(n*phi1+n*phi2-n*phi3-n*phi4),1.); // <4>_{n,n|n,n} \r
8255 fIntFlowDirectCorrelations->Fill(11.,cos(2.*n*phi1+n*phi2-2.*n*phi3-n*phi4),1.); // <4>_{2n,n|2n,n}\r
8256 fIntFlowDirectCorrelations->Fill(12.,cos(2.*n*phi1+2*n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{2n,2n|2n,2n}\r
8257 fIntFlowDirectCorrelations->Fill(13.,cos(3.*n*phi1-n*phi2-n*phi3-n*phi4),1.); // <4>_{3n|n,n,n}\r
8258 fIntFlowDirectCorrelations->Fill(14.,cos(3.*n*phi1+n*phi2-3.*n*phi3-n*phi4),1.); // <4>_{3n,n|3n,n} \r
8259 fIntFlowDirectCorrelations->Fill(15.,cos(3.*n*phi1+n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{3n,n|2n,2n}\r
8260 fIntFlowDirectCorrelations->Fill(16.,cos(4.*n*phi1-2.*n*phi2-n*phi3-n*phi4),1.); // <4>_{4n|2n,n,n} \r
8261 } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8262 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8263 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8264 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8265 } // end of if(nPrim>=)\r
8266\r
8267 // 5-particle correlations: \r
8268 if(nPrim>=5 && nPrim<=fMaxAllowedMultiplicity)\r
8269 {\r
8270 for(Int_t i1=0;i1<nPrim;i1++)\r
8271 {\r
8272 aftsTrack=anEvent->GetTrack(i1);\r
8273 if(!(aftsTrack->InRPSelection())) continue; \r
8274 phi1=aftsTrack->Phi();\r
8275 for(Int_t i2=0;i2<nPrim;i2++)\r
8276 {\r
8277 if(i2==i1)continue;\r
8278 aftsTrack=anEvent->GetTrack(i2);\r
8279 if(!(aftsTrack->InRPSelection())) continue;\r
8280 phi2=aftsTrack->Phi();\r
8281 for(Int_t i3=0;i3<nPrim;i3++)\r
8282 {\r
8283 if(i3==i1||i3==i2)continue;\r
8284 aftsTrack=anEvent->GetTrack(i3);\r
8285 if(!(aftsTrack->InRPSelection())) continue;\r
8286 phi3=aftsTrack->Phi();\r
8287 for(Int_t i4=0;i4<nPrim;i4++)\r
8288 {\r
8289 if(i4==i1||i4==i2||i4==i3)continue;\r
8290 aftsTrack=anEvent->GetTrack(i4);\r
8291 if(!(aftsTrack->InRPSelection())) continue;\r
8292 phi4=aftsTrack->Phi();\r
8293 for(Int_t i5=0;i5<nPrim;i5++)\r
8294 {\r
8295 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8296 aftsTrack=anEvent->GetTrack(i5);\r
8297 if(!(aftsTrack->InRPSelection())) continue;\r
8298 phi5=aftsTrack->Phi();\r
8299 if(nPrim==5) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<"\r"<<flush;\r
8300 // fill the profile with 5-p correlations: \r
8301 fIntFlowDirectCorrelations->Fill(18.,cos(2.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5),1.); //<5>_{2n,n|n,n,n}\r
8302 fIntFlowDirectCorrelations->Fill(19.,cos(2.*n*phi1+2.*n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); //<5>_{2n,2n|2n,n,n}\r
8303 fIntFlowDirectCorrelations->Fill(20.,cos(3.*n*phi1+n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); //<5>_{3n,n|2n,n,n}\r
8304 fIntFlowDirectCorrelations->Fill(21.,cos(4.*n*phi1-n*phi2-n*phi3-n*phi4-n*phi5),1.); //<5>_{4n|n,n,n,n}\r
8305 } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8306 } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8307 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8308 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8309 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8310 } // end of if(nPrim>=5)\r
8311 \r
8312 // 6-particle correlations:\r
8313 if(nPrim>=6 && nPrim<=fMaxAllowedMultiplicity)\r
8314 {\r
8315 for(Int_t i1=0;i1<nPrim;i1++)\r
8316 {\r
8317 aftsTrack=anEvent->GetTrack(i1);\r
8318 if(!(aftsTrack->InRPSelection())) continue;\r
8319 phi1=aftsTrack->Phi();\r
8320 for(Int_t i2=0;i2<nPrim;i2++)\r
8321 {\r
8322 if(i2==i1)continue;\r
8323 aftsTrack=anEvent->GetTrack(i2);\r
8324 if(!(aftsTrack->InRPSelection())) continue;\r
8325 phi2=aftsTrack->Phi();\r
8326 for(Int_t i3=0;i3<nPrim;i3++)\r
8327 {\r
8328 if(i3==i1||i3==i2)continue;\r
8329 aftsTrack=anEvent->GetTrack(i3);\r
8330 if(!(aftsTrack->InRPSelection())) continue;\r
8331 phi3=aftsTrack->Phi();\r
8332 for(Int_t i4=0;i4<nPrim;i4++)\r
8333 {\r
8334 if(i4==i1||i4==i2||i4==i3)continue;\r
8335 aftsTrack=anEvent->GetTrack(i4);\r
8336 if(!(aftsTrack->InRPSelection())) continue;\r
8337 phi4=aftsTrack->Phi();\r
8338 for(Int_t i5=0;i5<nPrim;i5++)\r
8339 {\r
8340 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8341 aftsTrack=anEvent->GetTrack(i5);\r
8342 if(!(aftsTrack->InRPSelection())) continue;\r
8343 phi5=aftsTrack->Phi();\r
8344 for(Int_t i6=0;i6<nPrim;i6++)\r
8345 {\r
8346 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8347 aftsTrack=anEvent->GetTrack(i6);\r
8348 if(!(aftsTrack->InRPSelection())) continue;\r
8349 phi6=aftsTrack->Phi(); \r
8350 if(nPrim==6) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<"\r"<<flush;\r
8351 // fill the profile with 6-p correlations: \r
8352 fIntFlowDirectCorrelations->Fill(23.,cos(n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6),1.); //<6>_{n,n,n|n,n,n}\r
8353 fIntFlowDirectCorrelations->Fill(24.,cos(2.*n*phi1+n*phi2+n*phi3-2.*n*phi4-n*phi5-n*phi6),1.); //<6>_{2n,n,n|2n,n,n}\r
8354 fIntFlowDirectCorrelations->Fill(25.,cos(2.*n*phi1+2.*n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.); //<6>_{2n,2n|n,n,n,n}\r
8355 fIntFlowDirectCorrelations->Fill(26.,cos(3.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.); //<6>_{3n,n|n,n,n,n} \r
8356 } // end of for(Int_t i6=0;i6<nPrim;i6++)\r
8357 } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8358 } // end of for(Int_t i4=0;i4<nPrim;i4++)\r
8359 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8360 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8361 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8362 } // end of if(nPrim>=6)\r
8363 \r
8364 // 7-particle correlations:\r
8365 if(nPrim>=7 && nPrim<=fMaxAllowedMultiplicity)\r
8366 {\r
8367 for(Int_t i1=0;i1<nPrim;i1++)\r
8368 { \r
8369 aftsTrack=anEvent->GetTrack(i1);\r
8370 if(!(aftsTrack->InRPSelection())) continue;\r
8371 phi1=aftsTrack->Phi();\r
8372 for(Int_t i2=0;i2<nPrim;i2++)\r
8373 {\r
8374 if(i2==i1)continue;\r
8375 aftsTrack=anEvent->GetTrack(i2);\r
8376 if(!(aftsTrack->InRPSelection())) continue;\r
8377 phi2=aftsTrack->Phi();\r
8378 for(Int_t i3=0;i3<nPrim;i3++)\r
8379 {\r
8380 if(i3==i1||i3==i2)continue;\r
8381 aftsTrack=anEvent->GetTrack(i3);\r
8382 if(!(aftsTrack->InRPSelection())) continue;\r
8383 phi3=aftsTrack->Phi();\r
8384 for(Int_t i4=0;i4<nPrim;i4++)\r
8385 {\r
8386 if(i4==i1||i4==i2||i4==i3)continue;\r
8387 aftsTrack=anEvent->GetTrack(i4);\r
8388 if(!(aftsTrack->InRPSelection())) continue;\r
8389 phi4=aftsTrack->Phi();\r
8390 for(Int_t i5=0;i5<nPrim;i5++)\r
8391 {\r
8392 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8393 aftsTrack=anEvent->GetTrack(i5);\r
8394 if(!(aftsTrack->InRPSelection())) continue;\r
8395 phi5=aftsTrack->Phi();\r
8396 for(Int_t i6=0;i6<nPrim;i6++)\r
8397 {\r
8398 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8399 aftsTrack=anEvent->GetTrack(i6);\r
8400 if(!(aftsTrack->InRPSelection())) continue;\r
8401 phi6=aftsTrack->Phi(); \r
8402 for(Int_t i7=0;i7<nPrim;i7++)\r
8403 {\r
8404 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;\r
8405 aftsTrack=anEvent->GetTrack(i7);\r
8406 if(!(aftsTrack->InRPSelection())) continue;\r
8407 phi7=aftsTrack->Phi(); \r
8408 if(nPrim==7) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<"\r"<<flush;\r
8409 // fill the profile with 7-p correlation: \r
8410 fIntFlowDirectCorrelations->Fill(28.,cos(2.*n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6-n*phi7),1.); // <7>_{2n,n,n|n,n,n,n}\r
8411 } // end of for(Int_t i7=0;i7<nPrim;i7++)\r
8412 } // end of for(Int_t i6=0;i6<nPrim;i6++) \r
8413 } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8414 } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8415 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8416 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8417 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8418 } // end of if(nPrim>=7)\r
8419 \r
8420 // 8-particle correlations:\r
8421 if(nPrim>=8 && nPrim<=fMaxAllowedMultiplicity)\r
8422 {\r
8423 for(Int_t i1=0;i1<nPrim;i1++)\r
8424 {\r
8425 aftsTrack=anEvent->GetTrack(i1);\r
8426 if(!(aftsTrack->InRPSelection())) continue;\r
8427 phi1=aftsTrack->Phi();\r
8428 for(Int_t i2=0;i2<nPrim;i2++)\r
8429 {\r
8430 if(i2==i1)continue;\r
8431 aftsTrack=anEvent->GetTrack(i2);\r
8432 if(!(aftsTrack->InRPSelection())) continue;\r
8433 phi2=aftsTrack->Phi();\r
8434 for(Int_t i3=0;i3<nPrim;i3++)\r
8435 {\r
8436 if(i3==i1||i3==i2)continue;\r
8437 aftsTrack=anEvent->GetTrack(i3);\r
8438 if(!(aftsTrack->InRPSelection())) continue;\r
8439 phi3=aftsTrack->Phi();\r
8440 for(Int_t i4=0;i4<nPrim;i4++)\r
8441 {\r
8442 if(i4==i1||i4==i2||i4==i3)continue;\r
8443 aftsTrack=anEvent->GetTrack(i4);\r
8444 if(!(aftsTrack->InRPSelection())) continue;\r
8445 phi4=aftsTrack->Phi();\r
8446 for(Int_t i5=0;i5<nPrim;i5++)\r
8447 {\r
8448 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8449 aftsTrack=anEvent->GetTrack(i5);\r
8450 if(!(aftsTrack->InRPSelection())) continue;\r
8451 phi5=aftsTrack->Phi();\r
8452 for(Int_t i6=0;i6<nPrim;i6++)\r
8453 {\r
8454 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8455 aftsTrack=anEvent->GetTrack(i6);\r
8456 if(!(aftsTrack->InRPSelection())) continue;\r
8457 phi6=aftsTrack->Phi();\r
8458 for(Int_t i7=0;i7<nPrim;i7++)\r
8459 {\r
8460 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;\r
8461 aftsTrack=anEvent->GetTrack(i7);\r
8462 if(!(aftsTrack->InRPSelection())) continue;\r
8463 phi7=aftsTrack->Phi();\r
8464 for(Int_t i8=0;i8<nPrim;i8++)\r
8465 {\r
8466 if(i8==i1||i8==i2||i8==i3||i8==i4||i8==i5||i8==i6||i8==i7)continue;\r
8467 aftsTrack=anEvent->GetTrack(i8);\r
8468 if(!(aftsTrack->InRPSelection())) continue;\r
8469 phi8=aftsTrack->Phi();\r
8470 cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<" "<<i8<<"\r"<<flush;\r
8471 // fill the profile with 8-p correlation: \r
8472 fIntFlowDirectCorrelations->Fill(30.,cos(n*phi1+n*phi2+n*phi3+n*phi4-n*phi5-n*phi6-n*phi7-n*phi8),1.); // <8>_{n,n,n,n|n,n,n,n}\r
8473 } // end of for(Int_t i8=0;i8<nPrim;i8++)\r
8474 } // end of for(Int_t i7=0;i7<nPrim;i7++) \r
8475 } // end of for(Int_t i6=0;i6<nPrim;i6++) \r
8476 } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8477 } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8478 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8479 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8480 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8481 } // end of if(nPrim>=8)\r
8482 \r
8483 cout<<endl;\r
8484\r
8485} // end of AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)\r
8486\r
8487\r
8488//==================================================================================================================================\r
8489\r
8490\r
8491void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()\r
8492{\r
8493 // Cross-check results for multiparticle correlations needed for int. flow: results from Q-vectors vs results from nested loops.\r
8494\r
8495 cout<<endl;\r
8496 cout<<endl;\r
8497 cout<<" *****************************************"<<endl;\r
8498 cout<<" **** cross-checking the correlations ****"<<endl;\r
8499 cout<<" **** for integrated flow ****"<<endl;\r
8500 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
8501 {\r
8502 cout<<" **** (particle weights not used) ****"<<endl;\r
8503 } else\r
8504 {\r
8505 cout<<" **** (particle weights used) ****"<<endl;\r
8506 } \r
8507 cout<<" *****************************************"<<endl;\r
8508 cout<<endl;\r
8509 cout<<endl;\r
8510\r
8511 Int_t ciMax = 32; // to be improved (removed eventually when I calculate 6th and 8th order with particle weights)\r
8512 \r
8513 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
8514 {\r
8515 ciMax = 11;\r
8516 }\r
8517\r
8518 for(Int_t ci=1;ci<=ciMax;ci++)\r
8519 {\r
8520 if(strcmp((fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)\r
8521 cout<<(fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)\r
8522 cout<<"from Q-vectors = "<<fIntFlowCorrelationsAllPro->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)\r
8523 cout<<"from nested loops = "<<fIntFlowDirectCorrelations->GetBinContent(ci)<<endl;\r
8524 cout<<endl;\r
8525 }\r
8526 \r
8527} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()\r
8528\r
8529\r
8530//================================================================================================================================\r
8531\r
8532\r
8533void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()\r
8534{\r
8535 // Cross-check results for corrections terms for non-uniform acceptance needed for int. flow: results from Q-vectors vs results from nested loops.\r
8536\r
8537 cout<<endl;\r
8538 cout<<endl;\r
8539 cout<<" *********************************************"<<endl;\r
8540 cout<<" **** cross-checking the correction terms ****"<<endl;\r
8541 cout<<" **** for non-uniform acceptance relevant ****"<<endl;\r
8542 cout<<" **** for integrated flow ****"<<endl;\r
8543 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
8544 {\r
8545 cout<<" **** (particle weights not used) ****"<<endl;\r
8546 } else\r
8547 {\r
8548 cout<<" **** (particle weights used) ****"<<endl;\r
8549 } \r
8550 cout<<" *********************************************"<<endl;\r
8551 cout<<endl;\r
8552 cout<<endl;\r
8553\r
8554 for(Int_t ci=1;ci<=10;ci++) // correction term index\r
8555 {\r
8556 for(Int_t sc=0;sc<2;sc++) // sin or cos term\r
8557 {\r
8558 if(strcmp((fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)\r
8559 cout<<(fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)\r
8560 cout<<"from Q-vectors = "<<fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)\r
8561 cout<<"from nested loops = "<<fIntFlowDirectCorrectionTermsForNUA[sc]->GetBinContent(ci)<<endl;\r
8562 cout<<endl;\r
8563 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos term\r
8564 } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index\r
8565 \r
8566} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA() \r
8567\r
8568\r
8569//================================================================================================================================\r
8570\r
8571\r
8572void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
8573{\r
8574 // Evaluate with nested loops multiparticle correlations for integrated flow (using the particle weights). \r
8575\r
8576 // Results are stored in profile fIntFlowDirectCorrelations. \r
8577 // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrelations is organized as follows:\r
8578 //\r
8579 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>\r
8580 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
8581 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))> \r
8582 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
8583 // 5th bin: ---- EMPTY ----\r
8584 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
8585 // 7th bin: <3>_{3n|2n,1n} = ...\r
8586 // 8th bin: <3>_{4n|2n,2n} = ...\r
8587 // 9th bin: <3>_{4n|3n,1n} = ...\r
8588 // 10th bin: ---- EMPTY ----\r
8589 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
8590 // 12th bin: <4>_{2n,1n|2n,1n} = ...\r
8591 // 13th bin: <4>_{2n,2n|2n,2n} = ...\r
8592 // 14th bin: <4>_{3n|1n,1n,1n} = ... \r
8593 // 15th bin: <4>_{3n,1n|3n,1n} = ...\r
8594 // 16th bin: <4>_{3n,1n|2n,2n} = ...\r
8595 // 17th bin: <4>_{4n|2n,1n,1n} = ... \r
8596 // 18th bin: ---- EMPTY ----\r
8597 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...\r
8598 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...\r
8599 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...\r
8600 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...\r
8601 // 23rd bin: ---- EMPTY ----\r
8602 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...\r
8603 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...\r
8604 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...\r
8605 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...\r
8606 // 28th bin: ---- EMPTY ----\r
8607 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...\r
8608 // 30th bin: ---- EMPTY ----\r
8609 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...\r
8610 \r
8611 // Remark 2: When particle weights are used there are some extra correlations. They are stored in \r
8612 // fIntFlowExtraDirectCorrelations binning of which is organized as follows:\r
8613 \r
8614 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>\r
8615 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))> \r
8616 // ...\r
8617 \r
8618 Int_t nPrim = anEvent->NumberOfTracks(); \r
8619 AliFlowTrackSimple *aftsTrack = NULL;\r
8620 //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;\r
8621 //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;\r
8622 Double_t phi1=0., phi2=0., phi3=0., phi4=0.;\r
8623 Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1.;\r
8624 Int_t n = fHarmonic; \r
8625 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8626 Double_t dMult = (*fSMpk)(0,0);\r
8627 cout<<endl;\r
8628 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8629 if(dMult<2)\r
8630 {\r
8631 cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8632 } else if (dMult>fMaxAllowedMultiplicity)\r
8633 {\r
8634 cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8635 } else \r
8636 { \r
8637 cout<<"... evaluating nested loops (using particle weights) ..."<<endl;\r
8638 } \r
8639 \r
8640 // 2-particle correlations: \r
8641 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8642 {\r
8643 // 2 nested loops multiparticle correlations using particle weights: \r
8644 for(Int_t i1=0;i1<nPrim;i1++)\r
8645 {\r
8646 aftsTrack=anEvent->GetTrack(i1);\r
8647 if(!(aftsTrack->InRPSelection())) continue;\r
8648 phi1=aftsTrack->Phi();\r
8649 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8650 for(Int_t i2=0;i2<nPrim;i2++)\r
8651 {\r
8652 if(i2==i1)continue;\r
8653 aftsTrack=anEvent->GetTrack(i2);\r
8654 if(!(aftsTrack->InRPSelection())) continue;\r
8655 phi2=aftsTrack->Phi();\r
8656 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi()))); \r
8657 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8658 // 2-p correlations using particle weights:\r
8659 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),wPhi1*wPhi2); // <w1 w2 cos( n*(phi1-phi2))>\r
8660 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),pow(wPhi1,2)*pow(wPhi2,2)); // <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
8661 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),pow(wPhi1,3)*pow(wPhi2,3)); // <w1^3 w2^3 cos(3n*(phi1-phi2))>\r
8662 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),pow(wPhi1,4)*pow(wPhi2,4)); // <w1^4 w2^4 cos(4n*(phi1-phi2))> \r
8663 // extra correlations: \r
8664 // 2-p extra correlations (do not appear if particle weights are not used):\r
8665 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),pow(wPhi1,3)*wPhi2); // <w1^3 w2 cos(n*(phi1-phi2))>\r
8666 // ...\r
8667 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8668 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8669 } // end of if(nPrim>=2)\r
8670\r
8671 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8672 { \r
8673 // 3 nested loops multiparticle correlations using particle weights: \r
8674 for(Int_t i1=0;i1<nPrim;i1++)\r
8675 {\r
8676 aftsTrack=anEvent->GetTrack(i1);\r
8677 if(!(aftsTrack->InRPSelection())) continue;\r
8678 phi1=aftsTrack->Phi();\r
8679 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8680 for(Int_t i2=0;i2<nPrim;i2++)\r
8681 {\r
8682 if(i2==i1)continue;\r
8683 aftsTrack=anEvent->GetTrack(i2);\r
8684 if(!(aftsTrack->InRPSelection())) continue;\r
8685 phi2=aftsTrack->Phi();\r
8686 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
8687 for(Int_t i3=0;i3<nPrim;i3++)\r
8688 {\r
8689 if(i3==i1||i3==i2)continue;\r
8690 aftsTrack=anEvent->GetTrack(i3);\r
8691 if(!(aftsTrack->InRPSelection())) continue;\r
8692 phi3=aftsTrack->Phi();\r
8693 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
8694 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;\r
8695 // 3-p correlations using particle weights:\r
8696 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(5.5,cos(2.*n*phi1-n*(phi2+phi3)),pow(wPhi1,2)*wPhi2*wPhi3); // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
8697 // ...\r
8698 // extra correlations: \r
8699 // 2-p extra correlations (do not appear if particle weights are not used):\r
8700 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(1.5,cos(n*(phi1-phi2)),wPhi1*wPhi2*pow(wPhi3,2)); // <w1 w2 w3^2 cos(n*(phi1-phi2))>\r
8701 // ...\r
8702 // 3-p extra correlations (do not appear if particle weights are not used):\r
8703 // ...\r
8704 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8705 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8706 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8707 } // end of if(nPrim>=3)\r
8708 \r
8709 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)\r
8710 {\r
8711 // 4 nested loops multiparticle correlations using particle weights: \r
8712 for(Int_t i1=0;i1<nPrim;i1++)\r
8713 {\r
8714 aftsTrack=anEvent->GetTrack(i1);\r
8715 if(!(aftsTrack->InRPSelection())) continue;\r
8716 phi1=aftsTrack->Phi();\r
8717 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8718 for(Int_t i2=0;i2<nPrim;i2++)\r
8719 {\r
8720 if(i2==i1)continue;\r
8721 aftsTrack=anEvent->GetTrack(i2);\r
8722 if(!(aftsTrack->InRPSelection())) continue;\r
8723 phi2=aftsTrack->Phi();\r
8724 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
8725 for(Int_t i3=0;i3<nPrim;i3++)\r
8726 {\r
8727 if(i3==i1||i3==i2)continue;\r
8728 aftsTrack=anEvent->GetTrack(i3);\r
8729 if(!(aftsTrack->InRPSelection())) continue;\r
8730 phi3=aftsTrack->Phi();\r
8731 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
8732 for(Int_t i4=0;i4<nPrim;i4++)\r
8733 {\r
8734 if(i4==i1||i4==i2||i4==i3)continue;\r
8735 aftsTrack=anEvent->GetTrack(i4);\r
8736 if(!(aftsTrack->InRPSelection())) continue;\r
8737 phi4=aftsTrack->Phi();\r
8738 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));\r
8739 if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))\r
8740 // 4-p correlations using particle weights:\r
8741 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4); \r
8742 // extra correlations: \r
8743 // 2-p extra correlations (do not appear if particle weights are not used):\r
8744 // ...\r
8745 // 3-p extra correlations (do not appear if particle weights are not used):\r
8746 // ...\r
8747 // 4-p extra correlations (do not appear if particle weights are not used):\r
8748 // ...\r
8749 } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8750 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8751 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8752 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8753 } // end of if(nPrim>=4)\r
8754\r
8755 cout<<endl; \r
8756\r
8757} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
8758\r
8759\r
8760//================================================================================================================================\r
8761\r
8762\r
8763void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()\r
8764{\r
8765 // Cross-check results for extra multiparticle correlations needed for int. flow \r
8766 // which appear only when particle weights are used: results from Q-vectors vs results from nested loops.\r
8767\r
8768 cout<<endl;\r
8769 cout<<endl;\r
8770 cout<<" ***********************************************"<<endl;\r
8771 cout<<" **** cross-checking the extra correlations ****"<<endl;\r
8772 cout<<" **** for integrated flow ****"<<endl;\r
8773 cout<<" ***********************************************"<<endl;\r
8774 cout<<endl;\r
8775 cout<<endl;\r
8776 \r
8777 for(Int_t eci=1;eci<=2;eci++) // to be improved (increased eciMax eventually when I calculate 6th and 8th)\r
8778 {\r
8779 if(strcmp((fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci), "") == 0) continue;\r
8780 cout<<(fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci)<<":"<<endl;\r
8781 cout<<"from Q-vectors = "<<fIntFlowExtraCorrelationsPro->GetBinContent(eci)<<endl;\r
8782 cout<<"from nested loops = "<<fIntFlowExtraDirectCorrelations->GetBinContent(eci)<<endl;\r
8783 cout<<endl;\r
8784 }\r
8785\r
8786} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()\r
8787\r
8788\r
8789//================================================================================================================================\r
8790\r
8791\r
8792void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoops(AliFlowEventSimple* anEvent)\r
8793{\r
8794 // Evaluate with nested loops correction terms for non-uniform acceptance relevant for NONAME integrated flow (to be improved (name)).\r
8795 //\r
8796 // Remark: Both sin and cos correction terms are calculated in this method. Sin terms are stored in fIntFlowDirectCorrectionTermsForNUA[0],\r
8797 // and cos terms in fIntFlowCorrectionTermsForNUAPro[sc]fIntFlowDirectCorrectionTermsForNUA[1]. Binning of fIntFlowDirectCorrectionTermsForNUA[sc] is organized as follows \r
8798 // (sc stands for either sin or cos):\r
8799 \r
8800 // 1st bin: <<sc(n*(phi1))>> \r
8801 // 2nd bin: <<sc(n*(phi1+phi2))>> \r
8802 // 3rd bin: <<sc(n*(phi1-phi2-phi3))>>\r
8803 // ...\r
8804 \r
8805 Int_t nPrim = anEvent->NumberOfTracks(); \r
8806 AliFlowTrackSimple *aftsTrack = NULL;\r
8807 Double_t phi1=0., phi2=0., phi3=0.;\r
8808 Int_t n = fHarmonic; \r
8809 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8810 Double_t dMult = (*fSMpk)(0,0);\r
8811 cout<<endl;\r
8812 cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8813 if(dMult<1)\r
8814 {\r
8815 cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8816 } else if (dMult>fMaxAllowedMultiplicity)\r
8817 {\r
8818 cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8819 } else \r
8820 { \r
8821 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;\r
8822 }\r
8823 \r
8824 if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)\r
8825 {\r
8826 // 1-particle correction terms for non-uniform acceptance: \r
8827 for(Int_t i1=0;i1<nPrim;i1++)\r
8828 {\r
8829 aftsTrack=anEvent->GetTrack(i1);\r
8830 if(!(aftsTrack->InRPSelection())) continue;\r
8831 phi1=aftsTrack->Phi();\r
8832 if(nPrim==1) cout<<i1<<"\r"<<flush;\r
8833 // sin terms:\r
8834 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),1.); // <sin(n*phi1)> \r
8835 // cos terms:\r
8836 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),1.); // <cos(n*phi1)>\r
8837 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8838 } // end of if(nPrim>=1) \r
8839 \r
8840 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8841 {\r
8842 // 2-particle correction terms for non-uniform acceptance: \r
8843 for(Int_t i1=0;i1<nPrim;i1++)\r
8844 {\r
8845 aftsTrack=anEvent->GetTrack(i1);\r
8846 if(!(aftsTrack->InRPSelection())) continue;\r
8847 phi1=aftsTrack->Phi(); \r
8848 for(Int_t i2=0;i2<nPrim;i2++)\r
8849 {\r
8850 if(i2==i1)continue;\r
8851 aftsTrack=anEvent->GetTrack(i2);\r
8852 if(!(aftsTrack->InRPSelection())) continue;\r
8853 phi2=aftsTrack->Phi();\r
8854 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8855 // sin terms:\r
8856 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),1.); // <<sin(n*(phi1+phi2))>>\r
8857 // cos terms:\r
8858 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),1.); // <<cos(n*(phi1+phi2))>>\r
8859 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8860 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8861 } // end of if(nPrim>=2)\r
8862\r
8863 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8864 {\r
8865 // 3-particle correction terms for non-uniform acceptance: \r
8866 for(Int_t i1=0;i1<nPrim;i1++)\r
8867 {\r
8868 aftsTrack=anEvent->GetTrack(i1);\r
8869 if(!(aftsTrack->InRPSelection())) continue;\r
8870 phi1=aftsTrack->Phi();\r
8871 for(Int_t i2=0;i2<nPrim;i2++)\r
8872 {\r
8873 if(i2==i1)continue;\r
8874 aftsTrack=anEvent->GetTrack(i2);\r
8875 if(!(aftsTrack->InRPSelection())) continue;\r
8876 phi2=aftsTrack->Phi();\r
8877 for(Int_t i3=0;i3<nPrim;i3++)\r
8878 {\r
8879 if(i3==i1||i3==i2)continue;\r
8880 aftsTrack=anEvent->GetTrack(i3);\r
8881 if(!(aftsTrack->InRPSelection())) continue;\r
8882 phi3=aftsTrack->Phi();\r
8883 if(nPrim>=3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush; // to be improved (eventually I will change this if statement)\r
8884 // sin terms:\r
8885 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),1.); // <<sin(n*(phi1-phi2-phi3))>>\r
8886 // cos terms:\r
8887 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),1.); // <<cos(n*(phi1-phi2-phi3))>>\r
8888 } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8889 } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8890 } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8891 } // end of if(nPrim>=3)\r
8892\r
8893 cout<<endl;\r
8894}\r
8895//================================================================================================================================\r
8896void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
8897{\r
8898 // Evaluate reduced correlations with nested loops without using the particle weights.\r
8899 \r
8900 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
8901 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:\r
8902 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>] \r
8903 // Remark 3: <2'> = <cos(n*(psi1-phi2))>\r
8904 // <4'> = <cos(n*(psi1+phi2-phi3-phi4))>\r
8905 // ...\r
8906 \r
8907 Int_t typeFlag = -1;\r
8908 Int_t ptEtaFlag = -1;\r
8909 if(type == "RP")\r
8910 {\r
8911 typeFlag = 0;\r
8912 } else if(type == "POI")\r
8913 {\r
8914 typeFlag = 1;\r
8915 } \r
8916 if(ptOrEta == "Pt")\r
8917 {\r
8918 ptEtaFlag = 0;\r
8919 } else if(ptOrEta == "Eta")\r
8920 {\r
8921 ptEtaFlag = 1;\r
8922 } \r
8923 // shortcuts:\r
8924 Int_t t = typeFlag;\r
8925 Int_t pe = ptEtaFlag;\r
8926 \r
8927 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
8928 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
8929 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
8930 \r
8931 Int_t nPrim = anEvent->NumberOfTracks(); \r
8932 AliFlowTrackSimple *aftsTrack = NULL;\r
8933 \r
8934 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
8935 \r
8936 Int_t n = fHarmonic; \r
8937 \r
8938 // 2'-particle correlations:\r
8939 for(Int_t i1=0;i1<nPrim;i1++)\r
8940 {\r
8941 aftsTrack=anEvent->GetTrack(i1);\r
8942 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
8943 if(ptOrEta == "Pt")\r
8944 { \r
8945 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
8946 } else if (ptOrEta == "Eta")\r
8947 {\r
8948 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue; \r
8949 }\r
8950 psi1=aftsTrack->Phi(); \r
8951 for(Int_t i2=0;i2<nPrim;i2++)\r
8952 {\r
8953 if(i2==i1)continue;\r
8954 aftsTrack=anEvent->GetTrack(i2);\r
8955 // RP condition (!(first) particle in the correlator must be RP):\r
8956 if(!(aftsTrack->InRPSelection()))continue;\r
8957 phi2=aftsTrack->Phi(); \r
8958 // 2'-particle correlations: \r
8959 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),1.); // <cos(n*(psi1-phi2)) \r
8960 }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
8961 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
8962 \r
8963 /*\r
8964 \r
8965 // 3'-particle correlations:\r
8966 for(Int_t i1=0;i1<nPrim;i1++)\r
8967 {\r
8968 aftsTrack=anEvent->GetTrack(i1);\r
8969 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
8970 if(ptOrEta == "Pt")\r
8971 { \r
8972 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
8973 } else if (ptOrEta == "Eta")\r
8974 {\r
8975 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue; \r
8976 }\r
8977 psi1=aftsTrack->Phi();\r
8978 for(Int_t i2=0;i2<nPrim;i2++)\r
8979 {\r
8980 if(i2==i1)continue;\r
8981 aftsTrack=anEvent->GetTrack(i2);\r
8982 // RP condition (!(first) particle in the correlator must be RP):\r
8983 if(!(aftsTrack->InRPSelection())) continue;\r
8984 phi2=aftsTrack->Phi();\r
8985 for(Int_t i3=0;i3<nPrim;i3++)\r
8986 {\r
8987 if(i3==i1||i3==i2)continue;\r
8988 aftsTrack=anEvent->GetTrack(i3);\r
8989 // RP condition (!(first) particle in the correlator must be RP):\r
8990 if(!(aftsTrack->InRPSelection())) continue;\r
8991 phi3=aftsTrack->Phi();\r
8992 // to be improved : where to store it? ->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(2.*phi1-phi2-phi3)),1.); // <w1 w2 w3 cos(n(2psi1-phi2-phi3))> \r
8993 }//end of for(Int_t i3=0;i3<nPrim;i3++) \r
8994 }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
8995 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
8996 \r
8997 */\r
8998 \r
8999 // 4'-particle correlations:\r
9000 for(Int_t i1=0;i1<nPrim;i1++)\r
9001 {\r
9002 aftsTrack=anEvent->GetTrack(i1);\r
9003 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9004 if(ptOrEta == "Pt")\r
9005 { \r
9006 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9007 } else if (ptOrEta == "Eta")\r
9008 {\r
9009 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue; \r
9010 }\r
9011 psi1=aftsTrack->Phi();\r
9012 for(Int_t i2=0;i2<nPrim;i2++)\r
9013 {\r
9014 if(i2==i1) continue;\r
9015 aftsTrack=anEvent->GetTrack(i2);\r
9016 // RP condition (!(first) particle in the correlator must be RP): \r
9017 if(!(aftsTrack->InRPSelection())) continue;\r
9018 phi2=aftsTrack->Phi();\r
9019 for(Int_t i3=0;i3<nPrim;i3++)\r
9020 { \r
9021 if(i3==i1||i3==i2) continue;\r
9022 aftsTrack=anEvent->GetTrack(i3);\r
9023 // RP condition (!(first) particle in the correlator must be RP):\r
9024 if(!(aftsTrack->InRPSelection())) continue;\r
9025 phi3=aftsTrack->Phi();\r
9026 for(Int_t i4=0;i4<nPrim;i4++)\r
9027 {\r
9028 if(i4==i1||i4==i2||i4==i3) continue;\r
9029 aftsTrack=anEvent->GetTrack(i4);\r
9030 // RP condition (!(first) particle in the correlator must be RP):\r
9031 if(!(aftsTrack->InRPSelection())) continue; \r
9032 phi4=aftsTrack->Phi();\r
9033 // 4'-particle correlations:\r
9034 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),1.); // <cos(n(psi1+phi2-phi3-phi4))> \r
9035 }//end of for(Int_t i4=0;i4<nPrim;i4++)\r
9036 }//end of for(Int_t i3=0;i3<nPrim;i3++)\r
9037 }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
9038 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9039 \r
9040 \r
9041} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9042\r
9043\r
9044//================================================================================================================================\r
9045\r
9046\r
9047void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)\r
9048{\r
9049 // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors\r
9050 \r
9051 Int_t typeFlag = -1;\r
9052 Int_t ptEtaFlag = -1;\r
9053 if(type == "RP")\r
9054 {\r
9055 typeFlag = 0;\r
9056 } else if(type == "POI")\r
9057 {\r
9058 typeFlag = 1;\r
9059 } \r
9060 if(ptOrEta == "Pt")\r
9061 {\r
9062 ptEtaFlag = 0;\r
9063 } else if(ptOrEta == "Eta")\r
9064 {\r
9065 ptEtaFlag = 1;\r
9066 } \r
9067 // shortcuts:\r
9068 Int_t t = typeFlag;\r
9069 Int_t pe = ptEtaFlag;\r
9070 \r
9071 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9072 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9073 TString reducedCorrelations[4] = {"<<cos(n(psi1-phi2))>>","<<cos(n(psi1+phi2-phi3-phi4))>>","",""}; // to be improved (access this from pro or hist)\r
9074 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9075 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9076 \r
9077 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};\r
9078 \r
9079\r
9080 cout<<endl;\r
9081 cout<<" *****************************************"<<endl;\r
9082 cout<<" **** cross-checking the correlations ****"<<endl;\r
9083 cout<<" **** for differential flow ****"<<endl;\r
9084 cout<<" **** "<<rpORpoiString[t]<<" ****"<<endl;\r
9085 cout<<" *****************************************"<<endl; \r
9086 cout<<endl;\r
9087 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;\r
9088 cout<<endl;\r
9089 \r
9090 for(Int_t rci=0;rci<2;rci++) // to be improved (calculate 6th and 8th order)\r
9091 {\r
9092 cout<<" "<<reducedCorrelations[rci].Data()<<":"<<endl;\r
9093 cout<<" from Q-vectors = "<<fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;\r
9094 cout<<" from nested loops = "<<fDiffFlowDirectCorrelations[t][pe][rci]->GetBinContent(1)<<endl;\r
9095 cout<<endl; \r
9096 } // end of for(Int_t rci=0;rci<4;rci++)\r
9097 \r
9098} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)\r
9099\r
9100\r
9101//================================================================================================================================\r
9102\r
9103\r
9104void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9105{\r
9106 // Evaluate reduced correlations with nested loops without using the particle weights.\r
9107 \r
9108 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
9109 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:\r
9110 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>] \r
9111 // Remark 3: <2'> = <w2 cos(n*(psi1-phi2))>\r
9112 // <4'> = <w2 w3 w4 cos(n*(psi1+phi2-phi3-phi4))>\r
9113 // ...\r
9114 \r
9115 Int_t typeFlag = -1;\r
9116 Int_t ptEtaFlag = -1;\r
9117 if(type == "RP")\r
9118 {\r
9119 typeFlag = 0;\r
9120 } else if(type == "POI")\r
9121 {\r
9122 typeFlag = 1;\r
9123 } \r
9124 if(ptOrEta == "Pt")\r
9125 {\r
9126 ptEtaFlag = 0;\r
9127 } else if(ptOrEta == "Eta")\r
9128 {\r
9129 ptEtaFlag = 1;\r
9130 } \r
9131 // shortcuts:\r
9132 Int_t t = typeFlag;\r
9133 Int_t pe = ptEtaFlag;\r
9134 \r
9135 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9136 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9137 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9138 \r
9139 Int_t nPrim = anEvent->NumberOfTracks(); \r
9140 AliFlowTrackSimple *aftsTrack = NULL;\r
9141 \r
9142 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
9143 Double_t wPhi2=1., wPhi3=1., wPhi4=1.;// wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;\r
9144 \r
9145 Int_t n = fHarmonic; \r
9146 \r
9147 // 2'-particle correlations:\r
9148 for(Int_t i1=0;i1<nPrim;i1++)\r
9149 {\r
9150 aftsTrack=anEvent->GetTrack(i1);\r
9151 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9152 if(ptOrEta == "Pt")\r
9153 { \r
9154 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9155 } else if (ptOrEta == "Eta")\r
9156 {\r
9157 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue; \r
9158 }\r
9159 psi1=aftsTrack->Phi(); \r
9160 for(Int_t i2=0;i2<nPrim;i2++)\r
9161 {\r
9162 if(i2==i1) continue;\r
9163 aftsTrack=anEvent->GetTrack(i2);\r
9164 // RP condition (!(first) particle in the correlator must be RP):\r
9165 if(!(aftsTrack->InRPSelection())) continue;\r
9166 phi2=aftsTrack->Phi(); \r
9167 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9168 // 2'-particle correlations: \r
9169 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),wPhi2); // <w2 cos(n*(psi1-phi2)) \r
9170 }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
9171 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9172 \r
9173 // 4'-particle correlations:\r
9174 for(Int_t i1=0;i1<nPrim;i1++)\r
9175 {\r
9176 aftsTrack=anEvent->GetTrack(i1);\r
9177 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9178 if(ptOrEta == "Pt")\r
9179 { \r
9180 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9181 } else if (ptOrEta == "Eta")\r
9182 {\r
9183 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue; \r
9184 }\r
9185 psi1=aftsTrack->Phi();\r
9186 for(Int_t i2=0;i2<nPrim;i2++)\r
9187 {\r
9188 if(i2==i1) continue;\r
9189 aftsTrack=anEvent->GetTrack(i2);\r
9190 // RP condition (!(first) particle in the correlator must be RP): \r
9191 if(!(aftsTrack->InRPSelection())) continue;\r
9192 phi2=aftsTrack->Phi();\r
9193 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9194 for(Int_t i3=0;i3<nPrim;i3++)\r
9195 { \r
9196 if(i3==i1||i3==i2) continue;\r
9197 aftsTrack=anEvent->GetTrack(i3);\r
9198 // RP condition (!(first) particle in the correlator must be RP):\r
9199 if(!(aftsTrack->InRPSelection())) continue;\r
9200 phi3=aftsTrack->Phi();\r
9201 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
9202 for(Int_t i4=0;i4<nPrim;i4++)\r
9203 {\r
9204 if(i4==i1||i4==i2||i4==i3) continue;\r
9205 aftsTrack=anEvent->GetTrack(i4);\r
9206 // RP condition (!(first) particle in the correlator must be RP):\r
9207 if(!(aftsTrack->InRPSelection())) continue; \r
9208 phi4=aftsTrack->Phi();\r
9209 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));\r
9210 // 4'-particle correlations <w2 w3 w4 cos(n(psi1+phi2-phi3-phi4))>:\r
9211 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),wPhi2*wPhi3*wPhi4); \r
9212 }//end of for(Int_t i4=0;i4<nPrim;i4++)\r
9213 }//end of for(Int_t i3=0;i3<nPrim;i3++)\r
9214 }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
9215 }//end of for(Int_t i1=0;i1<nPrim;i1++) \r
9216 \r
9217} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9218\r
9219\r
9220//================================================================================================================================\r
9221\r
9222 \r
9223void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9224{\r
9225 // Evaluate with nested loops correction terms for non-uniform acceptance (both sin and cos terms) relevant for differential flow.\r
9226 \r
9227 // Remark 1: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo \r
9228 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
9229 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as: \r
9230 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows: \r
9231 // cti: \r
9232 // 0: <<sc n(psi1)>>\r
9233 // 1: <<sc n(psi1+phi2)>> \r
9234 // 2: <<sc n(psi1+phi2-phi3)>>\r
9235 // 3: <<sc n(psi1-phi2-phi3)>>\r
9236 // 4:\r
9237 // 5:\r
9238 // 6:\r
9239 \r
9240 Int_t typeFlag = -1;\r
9241 Int_t ptEtaFlag = -1;\r
9242 if(type == "RP")\r
9243 {\r
9244 typeFlag = 0;\r
9245 } else if(type == "POI")\r
9246 {\r
9247 typeFlag = 1;\r
9248 } \r
9249 if(ptOrEta == "Pt")\r
9250 {\r
9251 ptEtaFlag = 0;\r
9252 } else if(ptOrEta == "Eta")\r
9253 {\r
9254 ptEtaFlag = 1;\r
9255 } \r
9256 // shortcuts:\r
9257 Int_t t = typeFlag;\r
9258 Int_t pe = ptEtaFlag;\r
9259 \r
9260 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9261 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9262 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9263 \r
9264 Int_t nPrim = anEvent->NumberOfTracks(); \r
9265 AliFlowTrackSimple *aftsTrack = NULL;\r
9266 \r
9267 Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
9268 \r
9269 Int_t n = fHarmonic; \r
9270 \r
9271 // 1-particle correction terms:\r
9272 for(Int_t i1=0;i1<nPrim;i1++)\r
9273 {\r
9274 aftsTrack=anEvent->GetTrack(i1);\r
9275 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9276 if(ptOrEta == "Pt")\r
9277 { \r
9278 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9279 } else if (ptOrEta == "Eta")\r
9280 {\r
9281 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue; \r
9282 }\r
9283 psi1=aftsTrack->Phi(); \r
9284 // sin terms: \r
9285 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>> \r
9286 // cos terms: \r
9287 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>> \r
9288 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9289 \r
9290 // 2-particle correction terms:\r
9291 for(Int_t i1=0;i1<nPrim;i1++)\r
9292 {\r
9293 aftsTrack=anEvent->GetTrack(i1);\r
9294 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9295 if(ptOrEta == "Pt")\r
9296 { \r
9297 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9298 } else if (ptOrEta == "Eta")\r
9299 {\r
9300 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue; \r
9301 }\r
9302 psi1=aftsTrack->Phi(); \r
9303 for(Int_t i2=0;i2<nPrim;i2++)\r
9304 {\r
9305 if(i2==i1) continue;\r
9306 aftsTrack=anEvent->GetTrack(i2);\r
9307 // RP condition (!(first) particle in the correlator must be RP):\r
9308 if(!(aftsTrack->InRPSelection())) continue;\r
9309 phi2=aftsTrack->Phi(); \r
9310 // sin terms: \r
9311 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),1.); // <<sin(n*(psi1+phi2))>> \r
9312 // cos terms: \r
9313 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),1.); // <<cos(n*(psi1+phi2))>> \r
9314 }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
9315 }//end of for(Int_t i1=0;i1<nPrim;i1++) \r
9316 \r
9317 // 3-particle correction terms:\r
9318 for(Int_t i1=0;i1<nPrim;i1++)\r
9319 {\r
9320 aftsTrack=anEvent->GetTrack(i1);\r
9321 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9322 if(ptOrEta == "Pt")\r
9323 { \r
9324 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9325 } else if (ptOrEta == "Eta")\r
9326 {\r
9327 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue; \r
9328 }\r
9329 psi1=aftsTrack->Phi();\r
9330 for(Int_t i2=0;i2<nPrim;i2++)\r
9331 {\r
9332 if(i2==i1) continue;\r
9333 aftsTrack=anEvent->GetTrack(i2);\r
9334 // RP condition (!(first) particle in the correlator must be RP):\r
9335 if(!(aftsTrack->InRPSelection())) continue;\r
9336 phi2=aftsTrack->Phi();\r
9337 for(Int_t i3=0;i3<nPrim;i3++)\r
9338 {\r
9339 if(i3==i1||i3==i2) continue;\r
9340 aftsTrack=anEvent->GetTrack(i3);\r
9341 // RP condition (!(first) particle in the correlator must be RP):\r
9342 if(!(aftsTrack->InRPSelection())) continue;\r
9343 phi3=aftsTrack->Phi();\r
9344 // sin terms: \r
9345 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),1.); // <<sin(n*(psi1+phi2-phi3))>> \r
9346 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),1.); // <<sin(n*(psi1-phi2-phi3))>> \r
9347 // cos terms: \r
9348 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),1.); // <<cos(n*(psi1+phi2-phi3))>> \r
9349 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),1.); // <<cos(n*(psi1-phi2-phi3))>> \r
9350 }//end of for(Int_t i3=0;i3<nPrim;i3++) \r
9351 }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
9352 }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9353 \r
9354} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9355\r
9356\r
9357//================================================================================================================================\r
9358\r
9359\r
9360void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)\r
9361{\r
9362 // Compare corrections temrs for non-uniform acceptance needed for diff. flow calculated with nested loops and those calculated from Q-vectors\r
9363 \r
9364 Int_t typeFlag = -1;\r
9365 Int_t ptEtaFlag = -1;\r
9366 if(type == "RP")\r
9367 {\r
9368 typeFlag = 0;\r
9369 } else if(type == "POI")\r
9370 {\r
9371 typeFlag = 1;\r
9372 } \r
9373 if(ptOrEta == "Pt")\r
9374 {\r
9375 ptEtaFlag = 0;\r
9376 } else if(ptOrEta == "Eta")\r
9377 {\r
9378 ptEtaFlag = 1;\r
9379 } \r
9380 // shortcuts:\r
9381 Int_t t = typeFlag;\r
9382 Int_t pe = ptEtaFlag;\r
9383 \r
9384 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9385 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9386 //TString sinCosFlag[2] = {"sin","cos"}; // to be improved (eventually promote to data member)\r
9387 TString reducedCorrectionSinTerms[4] = {"<<sin(n(psi1))>>","<<sin(n(psi1+phi2))>>","<<sin(n*(psi1+phi2-phi3))>>","<<sin(n*(psi1-phi2-phi3))>>"}; // to be improved (access this from pro or hist)\r
9388 TString reducedCorrectionCosTerms[4] = {"<<cos(n(psi1))>>","<<cos(n(psi1+phi2))>>","<<cos(n*(psi1+phi2-phi3))>>","<<cos(n*(psi1-phi2-phi3))>>"}; // to be improved (access this from pro or hist)\r
9389 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9390 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9391 \r
9392 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};\r
9393 \r
9394 cout<<endl;\r
9395 cout<<" ******************************************"<<endl;\r
9396 cout<<" **** cross-checking the correction ****"<<endl;\r
9397 cout<<" **** terms for non-uniform acceptance ****"<<endl;\r
9398 cout<<" **** for differential flow ****"<<endl;\r
9399 cout<<" **** "<<rpORpoiString[t]<<" ****"<<endl;\r
9400 cout<<" ******************************************"<<endl; \r
9401 cout<<endl;\r
9402 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;\r
9403 cout<<endl;\r
9404 \r
9405 for(Int_t cti=0;cti<4;cti++) // correction term index\r
9406 {\r
9407 for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
9408 {\r
9409 if(sc==0) // to be improved (this can be implemented better)\r
9410 { \r
9411 cout<<" "<<reducedCorrectionSinTerms[cti].Data()<<":"<<endl;\r
9412 } else\r
9413 {\r
9414 cout<<" "<<reducedCorrectionCosTerms[cti].Data()<<":"<<endl; \r
9415 }\r
9416 cout<<" from Q-vectors = "<<fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;\r
9417 cout<<" from nested loops = "<<fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]->GetBinContent(1)<<endl;\r
9418 cout<<endl; \r
9419 } \r
9420 } // end of for(Int_t rci=0;rci<4;rci++)\r
9421\r
9422} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)\r
9423\r
9424\r
9425//================================================================================================================================\r