]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG/FLOW/Base/AliFlowAnalysisWithQCumulants.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
allow to reuse tracks
[u/mrichter/AliRoot.git] / PWG / FLOW / Base / AliFlowAnalysisWithQCumulants.cxx
CommitLineData
489d5531 1/*************************************************************************
2* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
3* *
4* Author: The ALICE Off-line Project. *
5* Contributors are mentioned in the code where appropriate. *
6* *
7* Permission to use, copy, modify and distribute this software and its *
8* documentation strictly for non-commercial purposes is hereby granted *
9* without fee, provided that the above copyright notice appears in all *
10* copies and that both the copyright notice and this permission notice *
11* appear in the supporting documentation. The authors make no claims *
12* about the suitability of this software for any purpose. It is *
13* provided "as is" without express or implied warranty. *
14**************************************************************************/
15
16/**********************************
17 * flow analysis with Q-cumulants *
18 * *
ff70ca91 19 * author: Ante Bilandzic *
20 * (abilandzic@gmail.com) *
489d5531 21 *********************************/
22
23#define AliFlowAnalysisWithQCumulants_cxx
24
25#include "Riostream.h"
26#include "AliFlowCommonConstants.h"
27#include "AliFlowCommonHist.h"
28#include "AliFlowCommonHistResults.h"
29#include "TChain.h"
30
31#include "TFile.h"
32#include "TList.h"
33#include "TGraph.h"
34#include "TParticle.h"
35#include "TRandom3.h"
36#include "TStyle.h"
37#include "TProfile.h"
38#include "TProfile2D.h"
489d5531 39#include "TMath.h"
40#include "TArrow.h"
41#include "TPaveLabel.h"
42#include "TCanvas.h"
43#include "AliFlowEventSimple.h"
44#include "AliFlowTrackSimple.h"
45#include "AliFlowAnalysisWithQCumulants.h"
46#include "TArrayD.h"
47#include "TRandom.h"
48#include "TF1.h"
49
50class TH1;
51class TH2;
52class TGraph;
53class TPave;
54class TLatex;
55class TMarker;
56class TRandom3;
57class TObjArray;
58class TList;
59class TCanvas;
60class TSystem;
61class TROOT;
62class AliFlowVector;
63class TVector;
64
489d5531 65//================================================================================================================
66
489d5531 67ClassImp(AliFlowAnalysisWithQCumulants)
68
69AliFlowAnalysisWithQCumulants::AliFlowAnalysisWithQCumulants():
70 // 0.) base:
71 fHistList(NULL),
72 // 1.) common:
62d19320 73 fBookOnlyBasicCCH(kFALSE),
489d5531 74 fCommonHists(NULL),
75 fCommonHists2nd(NULL),
76 fCommonHists4th(NULL),
77 fCommonHists6th(NULL),
78 fCommonHists8th(NULL),
79 fCommonHistsResults2nd(NULL),
80 fCommonHistsResults4th(NULL),
81 fCommonHistsResults6th(NULL),
82 fCommonHistsResults8th(NULL),
83 fnBinsPhi(0),
84 fPhiMin(0),
85 fPhiMax(0),
86 fPhiBinWidth(0),
87 fnBinsPt(0),
88 fPtMin(0),
89 fPtMax(0),
90 fPtBinWidth(0),
91 fnBinsEta(0),
92 fEtaMin(0),
93 fEtaMax(0),
94 fEtaBinWidth(0),
1268c371 95 fCommonConstants(NULL),
dd442cd2 96 fFillMultipleControlHistograms(kFALSE),
489d5531 97 fHarmonic(2),
98 fAnalysisLabel(NULL),
99 // 2a.) particle weights:
100 fWeightsList(NULL),
101 fUsePhiWeights(kFALSE),
102 fUsePtWeights(kFALSE),
103 fUseEtaWeights(kFALSE),
403e3389 104 fUseTrackWeights(kFALSE),
489d5531 105 fUseParticleWeights(NULL),
106 fPhiWeights(NULL),
107 fPtWeights(NULL),
108 fEtaWeights(NULL),
109 // 2b.) event weights:
110 fMultiplicityWeight(NULL),
111 // 3.) integrated flow:
112 fIntFlowList(NULL),
113 fIntFlowProfiles(NULL),
114 fIntFlowResults(NULL),
3435cacb 115 fIntFlowAllCorrelationsVsM(NULL),
489d5531 116 fIntFlowFlags(NULL),
b92ea2b9 117 fApplyCorrectionForNUA(kFALSE),
2001bc3a 118 fApplyCorrectionForNUAVsM(kFALSE),
9da1a4f3 119 fnBinsMult(10000),
067e9bc8 120 fMinMult(0.),
121 fMaxMult(10000.),
b77b6434 122 fPropagateErrorAlsoFromNIT(kFALSE),
8ed4edc7 123 fCalculateCumulantsVsM(kFALSE),
3435cacb 124 fCalculateAllCorrelationsVsM(kFALSE),
0dd3b008 125 fMinimumBiasReferenceFlow(kTRUE),
e5834fcb 126 fForgetAboutCovariances(kFALSE),
127 fStorePhiDistributionForOneEvent(kFALSE),
489d5531 128 fReQ(NULL),
129 fImQ(NULL),
1268c371 130 fSpk(NULL),
489d5531 131 fIntFlowCorrelationsEBE(NULL),
132 fIntFlowEventWeightsForCorrelationsEBE(NULL),
133 fIntFlowCorrelationsAllEBE(NULL),
e5834fcb 134 fReferenceMultiplicityEBE(0.),
489d5531 135 fAvMultiplicity(NULL),
136 fIntFlowCorrelationsPro(NULL),
b40a910e 137 fIntFlowSquaredCorrelationsPro(NULL),
489d5531 138 fIntFlowCorrelationsAllPro(NULL),
139 fIntFlowExtraCorrelationsPro(NULL),
140 fIntFlowProductOfCorrelationsPro(NULL),
0328db2d 141 fIntFlowProductOfCorrectionTermsForNUAPro(NULL),
489d5531 142 fIntFlowCorrelationsHist(NULL),
143 fIntFlowCorrelationsAllHist(NULL),
144 fIntFlowCovariances(NULL),
145 fIntFlowSumOfProductOfEventWeights(NULL),
0328db2d 146 fIntFlowCovariancesNUA(NULL),
147 fIntFlowSumOfProductOfEventWeightsNUA(NULL),
489d5531 148 fIntFlowQcumulants(NULL),
b92ea2b9 149 fIntFlowQcumulantsRebinnedInM(NULL),
150 fIntFlowQcumulantsErrorSquaredRatio(NULL),
489d5531 151 fIntFlow(NULL),
b3dacf6b 152 fIntFlowRebinnedInM(NULL),
2001bc3a 153 fIntFlowDetectorBias(NULL),
489d5531 154 // 4.) differential flow:
155 fDiffFlowList(NULL),
156 fDiffFlowProfiles(NULL),
157 fDiffFlowResults(NULL),
1268c371 158 fDiffFlow2D(NULL),
489d5531 159 fDiffFlowFlags(NULL),
1268c371 160 fCalculateDiffFlow(kTRUE),
161 fCalculate2DDiffFlow(kFALSE),
62e36168 162 fCalculateDiffFlowVsEta(kTRUE),
64e500e3 163 // 5.) other differential correlators:
164 fOtherDiffCorrelatorsList(NULL),
165 // 6.) distributions:
57340a27 166 fDistributionsList(NULL),
167 fDistributionsFlags(NULL),
489d5531 168 fStoreDistributions(kFALSE),
64e500e3 169 // 7.) various:
e5834fcb 170 fVariousList(NULL),
171 fPhiDistributionForOneEvent(NULL),
489d5531 172 // x.) debugging and cross-checking:
173 fNestedLoopsList(NULL),
174 fEvaluateIntFlowNestedLoops(kFALSE),
175 fEvaluateDiffFlowNestedLoops(kFALSE),
176 fMaxAllowedMultiplicity(10),
177 fEvaluateNestedLoops(NULL),
178 fIntFlowDirectCorrelations(NULL),
179 fIntFlowExtraDirectCorrelations(NULL),
180 fCrossCheckInPtBinNo(10),
3b552efe 181 fCrossCheckInEtaBinNo(20),
489d5531 182 fNoOfParticlesInBin(NULL)
183 {
184 // constructor
185
186 // base list to hold all output objects:
187 fHistList = new TList();
188 fHistList->SetName("cobjQC");
189 fHistList->SetOwner(kTRUE);
190
191 // list to hold histograms with phi, pt and eta weights:
192 fWeightsList = new TList();
193
194 // multiplicity weight:
195 fMultiplicityWeight = new TString("combinations");
196
197 // analysis label;
198 fAnalysisLabel = new TString();
199
200 // initialize all arrays:
201 this->InitializeArraysForIntFlow();
202 this->InitializeArraysForDiffFlow();
203 this->InitializeArraysForDistributions();
e5834fcb 204 this->InitializeArraysForVarious();
489d5531 205 this->InitializeArraysForNestedLoops();
206
207 } // end of constructor
208
489d5531 209//================================================================================================================
210
489d5531 211AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()
212{
213 // destructor
214
215 delete fHistList;
216
217} // end of AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()
218
489d5531 219//================================================================================================================
220
489d5531 221void AliFlowAnalysisWithQCumulants::Init()
222{
3b552efe 223 // a) Cross check if the settings make sense before starting the QC adventure;
489d5531 224 // b) Access all common constants;
225 // c) Book all objects;
3b552efe 226 // d) Store flags for integrated and differential flow;
489d5531 227 // e) Store flags for distributions of corelations;
228 // f) Store harmonic which will be estimated.
3b552efe 229
489d5531 230 //save old value and prevent histograms from being added to directory
231 //to avoid name clashes in case multiple analaysis objects are used
232 //in an analysis
233 Bool_t oldHistAddStatus = TH1::AddDirectoryStatus();
234 TH1::AddDirectory(kFALSE);
235
3b552efe 236 // a) Cross check if the settings make sense before starting the QC adventure;
489d5531 237 this->CrossCheckSettings();
1268c371 238 // b) Access all common constants and book a profile to hold them:
239 this->CommonConstants("Init");
489d5531 240 // c) Book all objects:
1268c371 241 this->BookAndFillWeightsHistograms();
489d5531 242 this->BookAndNestAllLists();
243 this->BookCommonHistograms();
244 this->BookEverythingForIntegratedFlow();
245 this->BookEverythingForDifferentialFlow();
1268c371 246 this->BookEverythingFor2DDifferentialFlow();
489d5531 247 this->BookEverythingForDistributions();
e5834fcb 248 this->BookEverythingForVarious();
489d5531 249 this->BookEverythingForNestedLoops();
250 // d) Store flags for integrated and differential flow:
251 this->StoreIntFlowFlags();
3b552efe 252 this->StoreDiffFlowFlags();
489d5531 253 // e) Store flags for distributions of corelations:
254 this->StoreFlagsForDistributions();
255 // f) Store harmonic which will be estimated:
256 this->StoreHarmonic();
257
258 TH1::AddDirectory(oldHistAddStatus);
259} // end of void AliFlowAnalysisWithQCumulants::Init()
260
489d5531 261//================================================================================================================
262
489d5531 263void AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)
264{
265 // Running over data only in this method.
266
b3dacf6b 267 // a) Check all pointers used in this method;
268 // b) Define local variables;
269 // c) Fill the common control histograms and call the method to fill fAvMultiplicity;
1268c371 270 // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k};
271 // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!);
272 // f) Call the methods which calculate correlations for reference flow;
273 // g) Call the methods which calculate correlations for differential flow;
274 // h) Call the methods which calculate correlations for 2D differential flow;
64e500e3 275 // i) Call the methods which calculate other differential correlators;
276 // j) Distributions of correlations;
277 // k) Store phi distribution for one event to illustrate flow;
278 // l) Cross-check with nested loops correlators for reference flow;
279 // m) Cross-check with nested loops correlators for differential flow;
280 // n) Reset all event-by-event quantities (very important !!!!).
489d5531 281
b3dacf6b 282 // a) Check all pointers used in this method:
283 this->CheckPointersUsedInMake();
284
285 // b) Define local variables:
489d5531 286 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
287 Double_t dPt = 0.; // transverse momentum
288 Double_t dEta = 0.; // pseudorapidity
489d5531 289 Double_t wPhi = 1.; // phi weight
290 Double_t wPt = 1.; // pt weight
291 Double_t wEta = 1.; // eta weight
38a1e8b3 292 Double_t wTrack = 1.; // track weight
1268c371 293 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of reference particles)
e5834fcb 294 fReferenceMultiplicityEBE = anEvent->GetReferenceMultiplicity(); // reference multiplicity for current event
1268c371 295 Double_t ptEta[2] = {0.,0.}; // 0 = dPt, 1 = dEta
9f33751d 296
b3dacf6b 297 // c) Fill the common control histograms and call the method to fill fAvMultiplicity:
489d5531 298 this->FillCommonControlHistograms(anEvent);
299 this->FillAverageMultiplicities(nRP);
300
1268c371 301 // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k}:
9f33751d 302 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI where:
1268c371 303 // nRP = # of reference particles;
304 // nPOI = # of particles of interest.
489d5531 305 AliFlowTrackSimple *aftsTrack = NULL;
1268c371 306 Int_t n = fHarmonic; // shortcut for the harmonic
489d5531 307 for(Int_t i=0;i<nPrim;i++)
308 {
309 aftsTrack=anEvent->GetTrack(i);
310 if(aftsTrack)
311 {
1268c371 312 if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())){continue;} // safety measure: consider only tracks which are RPs or POIs
489d5531 313 if(aftsTrack->InRPSelection()) // RP condition:
314 {
315 dPhi = aftsTrack->Phi();
316 dPt = aftsTrack->Pt();
317 dEta = aftsTrack->Eta();
318 if(fUsePhiWeights && fPhiWeights && fnBinsPhi) // determine phi weight for this particle:
319 {
320 wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
321 }
322 if(fUsePtWeights && fPtWeights && fnBinsPt) // determine pt weight for this particle:
323 {
324 wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth)));
325 }
326 if(fUseEtaWeights && fEtaWeights && fEtaBinWidth) // determine eta weight for this particle:
327 {
328 wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
38a1e8b3 329 }
330 // Access track weight:
403e3389 331 if(fUseTrackWeights)
332 {
333 wTrack = aftsTrack->Weight();
334 }
1268c371 335 // Calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}] for this event (m = 1,2,...,6, k = 0,1,...,8):
336 for(Int_t m=0;m<6;m++) // to be improved - hardwired 6
489d5531 337 {
1268c371 338 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 339 {
38a1e8b3 340 (*fReQ)(m,k)+=pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1)*n*dPhi);
341 (*fImQ)(m,k)+=pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1)*n*dPhi);
489d5531 342 }
343 }
1268c371 344 // Calculate S_{p,k} for this event (Remark: final calculation of S_{p,k} follows after the loop over data bellow):
489d5531 345 for(Int_t p=0;p<8;p++)
346 {
347 for(Int_t k=0;k<9;k++)
348 {
38a1e8b3 349 (*fSpk)(p,k)+=pow(wPhi*wPt*wEta*wTrack,k);
489d5531 350 }
351 }
1268c371 352 // Differential flow:
353 if(fCalculateDiffFlow || fCalculate2DDiffFlow)
489d5531 354 {
1268c371 355 ptEta[0] = dPt;
356 ptEta[1] = dEta;
357 // Calculate r_{m*n,k} and s_{p,k} (r_{m,k} is 'p-vector' for RPs):
358 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 359 {
1268c371 360 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 361 {
1268c371 362 if(fCalculateDiffFlow)
363 {
62e36168 364 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 365 {
38a1e8b3 366 fReRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
367 fImRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 368 if(m==0) // s_{p,k} does not depend on index m
369 {
38a1e8b3 370 fs1dEBE[0][pe][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 371 } // end of if(m==0) // s_{p,k} does not depend on index m
372 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
373 } // end of if(fCalculateDiffFlow)
374 if(fCalculate2DDiffFlow)
375 {
38a1e8b3 376 fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
377 fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 378 if(m==0) // s_{p,k} does not depend on index m
379 {
38a1e8b3 380 fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 381 } // end of if(m==0) // s_{p,k} does not depend on index m
382 } // end of if(fCalculate2DDiffFlow)
383 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
384 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
385 // Checking if RP particle is also POI particle:
386 if(aftsTrack->InPOISelection())
489d5531 387 {
1268c371 388 // Calculate q_{m*n,k} and s_{p,k} ('q-vector' and 's' for RPs && POIs):
389 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 390 {
1268c371 391 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 392 {
1268c371 393 if(fCalculateDiffFlow)
394 {
62e36168 395 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 396 {
38a1e8b3 397 fReRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
398 fImRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 399 if(m==0) // s_{p,k} does not depend on index m
400 {
38a1e8b3 401 fs1dEBE[2][pe][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 402 } // end of if(m==0) // s_{p,k} does not depend on index m
403 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
404 } // end of if(fCalculateDiffFlow)
405 if(fCalculate2DDiffFlow)
406 {
38a1e8b3 407 fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
408 fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 409 if(m==0) // s_{p,k} does not depend on index m
410 {
38a1e8b3 411 fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 412 } // end of if(m==0) // s_{p,k} does not depend on index m
413 } // end of if(fCalculate2DDiffFlow)
414 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
415 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
416 } // end of if(aftsTrack->InPOISelection())
417 } // end of if(fCalculateDiffFlow || fCalculate2DDiffFlow)
489d5531 418 } // end of if(pTrack->InRPSelection())
489d5531 419 if(aftsTrack->InPOISelection())
420 {
421 dPhi = aftsTrack->Phi();
422 dPt = aftsTrack->Pt();
423 dEta = aftsTrack->Eta();
38a1e8b3 424 wPhi = 1.;
425 wPt = 1.;
426 wEta = 1.;
427 wTrack = 1.;
428 if(fUsePhiWeights && fPhiWeights && fnBinsPhi && aftsTrack->InRPSelection()) // determine phi weight for POI && RP particle:
429 {
430 wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
431 }
432 if(fUsePtWeights && fPtWeights && fnBinsPt && aftsTrack->InRPSelection()) // determine pt weight for POI && RP particle:
433 {
434 wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth)));
435 }
436 if(fUseEtaWeights && fEtaWeights && fEtaBinWidth && aftsTrack->InRPSelection()) // determine eta weight for POI && RP particle:
437 {
438 wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
439 }
440 // Access track weight for POI && RP particle:
403e3389 441 if(aftsTrack->InRPSelection() && fUseTrackWeights)
38a1e8b3 442 {
443 wTrack = aftsTrack->Weight();
444 }
1268c371 445 ptEta[0] = dPt;
446 ptEta[1] = dEta;
447 // Calculate p_{m*n,k} ('p-vector' for POIs):
448 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 449 {
1268c371 450 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 451 {
1268c371 452 if(fCalculateDiffFlow)
453 {
62e36168 454 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 455 {
38a1e8b3 456 fReRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
457 fImRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 458 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
459 } // end of if(fCalculateDiffFlow)
460 if(fCalculate2DDiffFlow)
461 {
38a1e8b3 462 fReRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
463 fImRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 464 } // end of if(fCalculate2DDiffFlow)
465 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
466 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
b77b6434 467 } // end of if(pTrack->InPOISelection())
489d5531 468 } else // to if(aftsTrack)
469 {
38a1e8b3 470 printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
489d5531 471 }
472 } // end of for(Int_t i=0;i<nPrim;i++)
473
1268c371 474 // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
489d5531 475 for(Int_t p=0;p<8;p++)
476 {
477 for(Int_t k=0;k<9;k++)
478 {
1268c371 479 (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
480 // ... for the time being s_{p,k} dosn't need higher powers, so no need to finalize it here ...
481 } // end of for(Int_t k=0;k<9;k++)
482 } // end of for(Int_t p=0;p<8;p++)
489d5531 483
1268c371 484 // f) Call the methods which calculate correlations for reference flow:
489d5531 485 if(!fEvaluateIntFlowNestedLoops)
486 {
403e3389 487 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 488 {
1268c371 489 if(nRP>1){this->CalculateIntFlowCorrelations();} // without using particle weights
403e3389 490 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 491 {
1268c371 492 if(nRP>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
493 }
494 // Whether or not using particle weights the following is calculated in the same way:
495 if(nRP>3){this->CalculateIntFlowProductOfCorrelations();}
496 if(nRP>1){this->CalculateIntFlowSumOfEventWeights();}
497 if(nRP>1){this->CalculateIntFlowSumOfProductOfEventWeights();}
498 // Non-isotropic terms:
403e3389 499 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 500 {
1268c371 501 if(nRP>0){this->CalculateIntFlowCorrectionsForNUASinTerms();}
502 if(nRP>0){this->CalculateIntFlowCorrectionsForNUACosTerms();}
403e3389 503 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b92ea2b9 504 {
1268c371 505 if(nRP>0){this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights();}
506 if(nRP>0){this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights();}
507 }
508 // Whether or not using particle weights the following is calculated in the same way:
509 if(nRP>0){this->CalculateIntFlowProductOfCorrectionTermsForNUA();}
510 if(nRP>0){this->CalculateIntFlowSumOfEventWeightsNUA();}
511 if(nRP>0){this->CalculateIntFlowSumOfProductOfEventWeightsNUA();}
489d5531 512 } // end of if(!fEvaluateIntFlowNestedLoops)
513
1268c371 514 // g) Call the methods which calculate correlations for differential flow:
515 if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 516 {
403e3389 517 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 518 {
1268c371 519 // Without using particle weights:
489d5531 520 this->CalculateDiffFlowCorrelations("RP","Pt");
62e36168 521 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelations("RP","Eta");}
489d5531 522 this->CalculateDiffFlowCorrelations("POI","Pt");
62e36168 523 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelations("POI","Eta");}
1268c371 524 // Non-isotropic terms:
b92ea2b9 525 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");
62e36168 526 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");}
b92ea2b9 527 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");
62e36168 528 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");}
b92ea2b9 529 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");
62e36168 530 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");}
b92ea2b9 531 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");
62e36168 532 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");}
403e3389 533 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 534 {
1268c371 535 // With using particle weights:
489d5531 536 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt");
62e36168 537 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta");}
489d5531 538 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt");
62e36168 539 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta");}
1268c371 540 // Non-isotropic terms:
b92ea2b9 541 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");
62e36168 542 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");}
b92ea2b9 543 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");
62e36168 544 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");}
b92ea2b9 545 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");
62e36168 546 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");}
b92ea2b9 547 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");
62e36168 548 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");}
1268c371 549 }
550 // Whether or not using particle weights the following is calculated in the same way:
489d5531 551 this->CalculateDiffFlowProductOfCorrelations("RP","Pt");
62e36168 552 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowProductOfCorrelations("RP","Eta");}
489d5531 553 this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
62e36168 554 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowProductOfCorrelations("POI","Eta");}
489d5531 555 this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
62e36168 556 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfEventWeights("RP","Eta");}
489d5531 557 this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
62e36168 558 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfEventWeights("POI","Eta");}
489d5531 559 this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Pt");
62e36168 560 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Eta");}
489d5531 561 this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Pt");
62e36168 562 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Eta");}
1268c371 563 } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 564
1268c371 565 // h) Call the methods which calculate correlations for 2D differential flow:
566 if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
567 {
403e3389 568 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 569 {
1268c371 570 // Without using particle weights:
571 this->Calculate2DDiffFlowCorrelations("RP");
572 this->Calculate2DDiffFlowCorrelations("POI");
573 // Non-isotropic terms:
574 // ... to be ctd ...
403e3389 575 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 576 {
577 // With using particle weights:
578 // ... to be ctd ...
579 // Non-isotropic terms:
580 // ... to be ctd ...
581 }
582 // Whether or not using particle weights the following is calculated in the same way:
583 // ... to be ctd ...
584 } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
64e500e3 585
586 // i) Call the methods which calculate other differential correlators:
b84464d3 587 if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
64e500e3 588 {
403e3389 589 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 590 {
591 // Without using particle weights:
592 this->CalculateOtherDiffCorrelators("RP","Pt");
62e36168 593 if(fCalculateDiffFlowVsEta){this->CalculateOtherDiffCorrelators("RP","Eta");}
64e500e3 594 this->CalculateOtherDiffCorrelators("POI","Pt");
62e36168 595 if(fCalculateDiffFlowVsEta){this->CalculateOtherDiffCorrelators("POI","Eta");}
403e3389 596 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 597 {
598 // With using particle weights:
599 // ... to be ctd ...
600 }
601 // Whether or not using particle weights the following is calculated in the same way:
602 // ... to be ctd ...
603 } // end of if(!fEvaluateDiffFlowNestedLoops)
604
605 // j) Distributions of correlations:
e5834fcb 606 if(fStoreDistributions){this->StoreDistributionsOfCorrelations();}
607
64e500e3 608 // k) Store phi distribution for one event to illustrate flow:
e5834fcb 609 if(fStorePhiDistributionForOneEvent){this->StorePhiDistributionForOneEvent(anEvent);}
1268c371 610
64e500e3 611 // l) Cross-check with nested loops correlators for reference flow:
1268c371 612 if(fEvaluateIntFlowNestedLoops){this->EvaluateIntFlowNestedLoops(anEvent);}
613
64e500e3 614 // m) Cross-check with nested loops correlators for differential flow:
1268c371 615 if(fEvaluateDiffFlowNestedLoops){this->EvaluateDiffFlowNestedLoops(anEvent);}
489d5531 616
64e500e3 617 // n) Reset all event-by-event quantities (very important !!!!):
489d5531 618 this->ResetEventByEventQuantities();
619
620} // end of AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)
621
489d5531 622//================================================================================================================================
623
489d5531 624void AliFlowAnalysisWithQCumulants::Finish()
625{
626 // Calculate the final results.
489d5531 627
b3dacf6b 628 // a) Check all pointers used in this method;
629 // b) Acces the constants;
630 // c) Access the flags;
b92ea2b9 631 // d) Calculate reference cumulants (not corrected for detector effects);
632 // e) Correct reference cumulants for detector effects;
633 // f) Calculate reference flow;
b77b6434 634 // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen;
b92ea2b9 635 // h) Calculate the final results for differential flow (without/with weights);
636 // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA);
637 // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults;
638 // k) Store results for differential flow in AliFlowCommonHistResults;
639 // l) Print the final results for integrated flow (RP/POI) on the screen;
640 // m) Cross-checking: Results from Q-vectors vs results from nested loops.
b3dacf6b 641
642 // a) Check all pointers used in this method:
643 this->CheckPointersUsedInFinish();
644
645 // b) Acces the constants:
1268c371 646 this->CommonConstants("Finish");
489d5531 647
b3dacf6b 648 if(fCommonHists && fCommonHists->GetHarmonic()) // to be improved (moved somewhere else)
489d5531 649 {
b3dacf6b 650 fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
489d5531 651 }
b3dacf6b 652
1268c371 653 // c) Access the flags: // to be improved (implement a method for this? should I store again the flags becose they can get modified with redoFinish?)
b3dacf6b 654 fUsePhiWeights = (Bool_t)fUseParticleWeights->GetBinContent(1);
655 fUsePtWeights = (Bool_t)fUseParticleWeights->GetBinContent(2);
656 fUseEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(3);
403e3389 657 fUseTrackWeights = (Bool_t)fUseParticleWeights->GetBinContent(4);
b3dacf6b 658 fApplyCorrectionForNUA = (Bool_t)fIntFlowFlags->GetBinContent(3);
659 fPrintFinalResults[0] = (Bool_t)fIntFlowFlags->GetBinContent(4);
660 fPrintFinalResults[1] = (Bool_t)fIntFlowFlags->GetBinContent(5);
661 fPrintFinalResults[2] = (Bool_t)fIntFlowFlags->GetBinContent(6);
662 fPrintFinalResults[3] = (Bool_t)fIntFlowFlags->GetBinContent(7);
663 fApplyCorrectionForNUAVsM = (Bool_t)fIntFlowFlags->GetBinContent(8);
b77b6434 664 fPropagateErrorAlsoFromNIT = (Bool_t)fIntFlowFlags->GetBinContent(9);
0dd3b008 665 fCalculateCumulantsVsM = (Bool_t)fIntFlowFlags->GetBinContent(10);
666 fMinimumBiasReferenceFlow = (Bool_t)fIntFlowFlags->GetBinContent(11);
e5834fcb 667 fForgetAboutCovariances = (Bool_t)fIntFlowFlags->GetBinContent(12);
668 fStorePhiDistributionForOneEvent = (Bool_t)fIntFlowFlags->GetBinContent(13);
3435cacb 669 fFillMultipleControlHistograms = (Bool_t)fIntFlowFlags->GetBinContent(14);
670 fCalculateAllCorrelationsVsM = (Bool_t)fIntFlowFlags->GetBinContent(15);
b3dacf6b 671 fEvaluateIntFlowNestedLoops = (Bool_t)fEvaluateNestedLoops->GetBinContent(1);
672 fEvaluateDiffFlowNestedLoops = (Bool_t)fEvaluateNestedLoops->GetBinContent(2);
489d5531 673 fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);
674 fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4);
1268c371 675
b92ea2b9 676 // d) Calculate reference cumulants (not corrected for detector effects):
489d5531 677 this->FinalizeCorrelationsIntFlow();
678 this->CalculateCovariancesIntFlow();
679 this->CalculateCumulantsIntFlow();
489d5531 680
b92ea2b9 681 // e) Correct reference cumulants for detector effects:
682 this->FinalizeCorrectionTermsForNUAIntFlow();
683 this->CalculateCovariancesNUAIntFlow();
684 this->CalculateQcumulantsCorrectedForNUAIntFlow();
685
686 // f) Calculate reference flow:
687 this->CalculateReferenceFlow();
489d5531 688
b77b6434 689 // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen:
489d5531 690 this->FillCommonHistResultsIntFlow();
b3dacf6b 691 if(fPrintFinalResults[0]){this->PrintFinalResultsForIntegratedFlow("RF");}
692 if(fPrintFinalResults[3] && fCalculateCumulantsVsM){this->PrintFinalResultsForIntegratedFlow("RF, rebinned in M");}
489d5531 693
1268c371 694 // h) Calculate the final results for differential flow (without/with weights):
695 if(fCalculateDiffFlow)
696 {
697 this->FinalizeReducedCorrelations("RP","Pt");
62e36168 698 if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("RP","Eta");}
1268c371 699 this->FinalizeReducedCorrelations("POI","Pt");
62e36168 700 if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("POI","Eta");}
1268c371 701 this->CalculateDiffFlowCovariances("RP","Pt");
62e36168 702 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("RP","Eta");}
1268c371 703 this->CalculateDiffFlowCovariances("POI","Pt");
62e36168 704 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("POI","Eta");}
1268c371 705 this->CalculateDiffFlowCumulants("RP","Pt");
62e36168 706 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("RP","Eta");}
1268c371 707 this->CalculateDiffFlowCumulants("POI","Pt");
62e36168 708 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("POI","Eta");}
1268c371 709 this->CalculateDiffFlow("RP","Pt");
62e36168 710 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("RP","Eta");}
1268c371 711 this->CalculateDiffFlow("POI","Pt");
62e36168 712 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("POI","Eta");}
1268c371 713 } // if(fCalculateDiffFlow)
714
715 // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA):
716 if(fCalculateDiffFlow)
489d5531 717 {
718 this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");
62e36168 719 if(fCalculateDiffFlowVsEta){this->FinalizeCorrectionTermsForNUADiffFlow("RP","Eta");}
489d5531 720 this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");
62e36168 721 if(fCalculateDiffFlowVsEta){this->FinalizeCorrectionTermsForNUADiffFlow("POI","Eta");}
489d5531 722 this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Pt");
62e36168 723 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Eta");}
489d5531 724 this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Pt");
62e36168 725 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Eta");}
1268c371 726 if(fApplyCorrectionForNUA)
727 {
728 this->CalculateDiffFlowCorrectedForNUA("RP","Pt");
62e36168 729 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectedForNUA("RP","Eta");}
1268c371 730 this->CalculateDiffFlowCorrectedForNUA("POI","Pt");
62e36168 731 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectedForNUA("POI","Eta");}
1268c371 732 }
733 } // end of if(fCalculateDiffFlow && fApplyCorrectionForNUA)
734
735 // i) Calcualate final results for 2D differential flow:
736 if(fCalculate2DDiffFlow)
737 {
738 this->Calculate2DDiffFlowCumulants("RP");
739 this->Calculate2DDiffFlowCumulants("POI");
740 this->Calculate2DDiffFlow("RP");
741 this->Calculate2DDiffFlow("POI");
742 } // end of if(fCalculate2DDiffFlow)
743
744 // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults:
745 if(fCalculateDiffFlow)
746 {
747 this->CalculateFinalResultsForRPandPOIIntegratedFlow("RP");
748 this->CalculateFinalResultsForRPandPOIIntegratedFlow("POI");
3b552efe 749 }
489d5531 750
1268c371 751 // k) Store results for differential flow in AliFlowCommonHistResults:
752 if(fCalculateDiffFlow)
753 {
754 this->FillCommonHistResultsDiffFlow("RP");
755 this->FillCommonHistResultsDiffFlow("POI");
756 }
757
758 // l) Print the final results for integrated flow (RP/POI) on the screen:
759 if(fPrintFinalResults[1] && fCalculateDiffFlow){this->PrintFinalResultsForIntegratedFlow("RP");}
760 if(fPrintFinalResults[2] && fCalculateDiffFlow){this->PrintFinalResultsForIntegratedFlow("POI");}
761
762 // m) Cross-checking: Results from Q-vectors vs results from nested loops:
763 // m1) Reference flow:
489d5531 764 if(fEvaluateIntFlowNestedLoops)
765 {
766 this->CrossCheckIntFlowCorrelations();
767 this->CrossCheckIntFlowCorrectionTermsForNUA();
403e3389 768 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights){this->CrossCheckIntFlowExtraCorrelations();}
489d5531 769 } // end of if(fEvaluateIntFlowNestedLoops)
1268c371 770 // m2) Differential flow:
771 if(fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 772 {
b3dacf6b 773 // Correlations:
489d5531 774 this->PrintNumberOfParticlesInSelectedBin();
775 this->CrossCheckDiffFlowCorrelations("RP","Pt");
62e36168 776 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrelations("RP","Eta");}
489d5531 777 this->CrossCheckDiffFlowCorrelations("POI","Pt");
62e36168 778 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrelations("POI","Eta");}
b3dacf6b 779 // Correction terms for non-uniform acceptance:
489d5531 780 this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt");
62e36168 781 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Eta");}
489d5531 782 this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");
62e36168 783 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Eta");}
64e500e3 784 // Other differential correlators:
785 this->CrossCheckOtherDiffCorrelators("RP","Pt");
62e36168 786 if(fCalculateDiffFlowVsEta){this->CrossCheckOtherDiffCorrelators("RP","Eta");}
64e500e3 787 this->CrossCheckOtherDiffCorrelators("POI","Pt");
62e36168 788 if(fCalculateDiffFlowVsEta){this->CrossCheckOtherDiffCorrelators("POI","Eta");}
489d5531 789 } // end of if(fEvaluateDiffFlowNestedLoops)
790
791} // end of AliFlowAnalysisWithQCumulants::Finish()
792
489d5531 793//================================================================================================================================
794
1268c371 795void AliFlowAnalysisWithQCumulants::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
796{
797 // Evalauted all correlators for reference flow with nested loops.
798
799 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = nRP + nPOI
800 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
801 {
802 // Without using particle weights:
403e3389 803 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 804 {
805 // Correlations:
806 this->CalculateIntFlowCorrelations(); // from Q-vectors
807 this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
808 // Correction for non-uniform acceptance:
809 this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)
810 this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)
811 this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)
812 }
813 // Using particle weights:
403e3389 814 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 815 {
816 // Correlations
817 this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors
818 this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
819 // Correction for non-uniform acceptance:
820 this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)
821 this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)
822 this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
823 }
824 } else if(nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)
825 {
826 cout<<endl;
827 cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;
828 } else
829 {
830 cout<<endl;
831 cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;
832 }
833
834} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
835
836//================================================================================================================================
837
838void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
839{
840 // Evalauted all correlators for differential flow with nested loops.
841
842 if(!fCalculateDiffFlow){return;}
843
844 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = nRP + nPOI
845 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
846 {
847 // Without using particle weights:
403e3389 848 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 849 {
64e500e3 850 // 1.) Reduced correlations:
1268c371 851 // Q-vectors:
852 this->CalculateDiffFlowCorrelations("RP","Pt");
853 this->CalculateDiffFlowCorrelations("RP","Eta");
854 this->CalculateDiffFlowCorrelations("POI","Pt");
855 this->CalculateDiffFlowCorrelations("POI","Eta");
856 // Nested loops:
857 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt");
858 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta");
859 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt");
860 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta");
64e500e3 861 // 2.) Reduced corrections for non-uniform acceptance:
1268c371 862 // Q-vectors:
863 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");
864 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");
865 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");
866 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");
867 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");
868 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");
869 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");
870 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
871 // Nested loops:
872 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Pt");
873 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta");
874 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt");
875 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta");
64e500e3 876 // 3.) Other differential correlators:
877 // Q-vectors:
878 this->CalculateOtherDiffCorrelators("RP","Pt");
879 this->CalculateOtherDiffCorrelators("RP","Eta");
880 this->CalculateOtherDiffCorrelators("POI","Pt");
881 this->CalculateOtherDiffCorrelators("POI","Eta");
882 // Nested loops:
883 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Pt");
884 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Eta");
885 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Pt");
886 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Eta");
403e3389 887 } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 888 // Using particle weights:
403e3389 889 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 890 {
891 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt");
892 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta");
893 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt");
894 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta");
895 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");
896 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");
897 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");
898 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");
899 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");
900 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");
901 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");
902 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");
903 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt");
904 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta");
905 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt");
906 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta");
907 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt");
908 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta");
909 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt");
910 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta");
403e3389 911 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 912 } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
913
914} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
915
916//================================================================================================================================
917
489d5531 918void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()
919{
b92ea2b9 920 // Calculate correction terms for non-uniform acceptance of the detector for reference flow (cos terms).
489d5531 921
922 // multiplicity:
1268c371 923 Double_t dMult = (*fSpk)(0,0);
489d5531 924
925 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
926 Double_t dReQ1n = (*fReQ)(0,0);
927 Double_t dReQ2n = (*fReQ)(1,0);
928 //Double_t dReQ3n = (*fReQ)(2,0);
929 //Double_t dReQ4n = (*fReQ)(3,0);
930 Double_t dImQ1n = (*fImQ)(0,0);
931 Double_t dImQ2n = (*fImQ)(1,0);
932 //Double_t dImQ3n = (*fImQ)(2,0);
933 //Double_t dImQ4n = (*fImQ)(3,0);
934
935 // *************************************************************
936 // **** corrections for non-uniform acceptance (cos terms): ****
937 // *************************************************************
938 //
939 // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors
940 // are stored in 1D profile fQCorrectionsCos.
941 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
942 // --------------------------------------------------------------------------------------------------------------------
943 // 1st bin: <<cos(n*(phi1))>> = cosP1n
944 // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n
945 // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n
946 // 4th bin: <<cos(n*(2phi1-phi2))>> = cosP2nM1n
947 // --------------------------------------------------------------------------------------------------------------------
948
949 // 1-particle:
950 Double_t cosP1n = 0.; // <<cos(n*(phi1))>>
951
952 if(dMult>0)
953 {
954 cosP1n = dReQ1n/dMult;
955
956 // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
957 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);
0328db2d 958 // event weights for NUA terms:
959 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(1,dMult);
489d5531 960
961 // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
962 fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);
b3dacf6b 963 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][0]->Fill(dMult+0.5,cosP1n,dMult);}
489d5531 964 }
965
966 // 2-particle:
3b552efe 967 Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>
489d5531 968 Double_t cosP2nM1n = 0.; // <<cos(n*(2phi1-phi2))>>
969
970 if(dMult>1)
971 {
972 cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1));
973 cosP2nM1n = (dReQ2n*dReQ1n+dImQ2n*dImQ1n-dReQ1n)/(dMult*(dMult-1));
974
975 // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
3b552efe 976 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);
489d5531 977 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(4,cosP2nM1n);
0328db2d 978 // event weights for NUA terms:
979 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(2,dMult*(dMult-1));
980 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(4,dMult*(dMult-1));
981
489d5531 982 // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
3b552efe 983 fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));
489d5531 984 fIntFlowCorrectionTermsForNUAPro[1]->Fill(3.5,cosP2nM1n,dMult*(dMult-1));
b3dacf6b 985 if(fCalculateCumulantsVsM)
986 {
987 fIntFlowCorrectionTermsForNUAVsMPro[1][1]->Fill(dMult+0.5,cosP1nP1n,dMult*(dMult-1));
988 fIntFlowCorrectionTermsForNUAVsMPro[1][3]->Fill(dMult+0.5,cosP2nM1n,dMult*(dMult-1));
989 }
489d5531 990 }
991
992 // 3-particle:
993 Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>
994
995 if(dMult>2)
996 {
997 cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)
998 / (dMult*(dMult-1)*(dMult-2));
999
1000 // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
1001 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);
0328db2d 1002 // event weights for NUA terms:
1003 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
489d5531 1004
1005 // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
2001bc3a 1006 fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
b3dacf6b 1007 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][2]->Fill(dMult+0.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
489d5531 1008 }
1009
1010} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()
1011
1012
1013//================================================================================================================================
1014
1015
1016void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()
1017{
1018 // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
1019
1020 // multiplicity:
1268c371 1021 Double_t dMult = (*fSpk)(0,0);
489d5531 1022
1023 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1024 Double_t dReQ1n = (*fReQ)(0,0);
1025 Double_t dReQ2n = (*fReQ)(1,0);
1026 //Double_t dReQ3n = (*fReQ)(2,0);
1027 //Double_t dReQ4n = (*fReQ)(3,0);
1028 Double_t dImQ1n = (*fImQ)(0,0);
1029 Double_t dImQ2n = (*fImQ)(1,0);
1030 //Double_t dImQ3n = (*fImQ)(2,0);
1031 //Double_t dImQ4n = (*fImQ)(3,0);
1032
1033 // *************************************************************
1034 // **** corrections for non-uniform acceptance (sin terms): ****
1035 // *************************************************************
1036 //
1037 // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors
1038 // are stored in 1D profile fQCorrectionsSin.
1039 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
1040 // --------------------------------------------------------------------------------------------------------------------
1041 // 1st bin: <<sin(n*(phi1))>> = sinP1n
1042 // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n
1043 // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n
1044 // 4th bin: <<sin(n*(2phi1-phi2))>> = sinP2nM1n
1045 // --------------------------------------------------------------------------------------------------------------------
1046
1047 // 1-particle:
1048 Double_t sinP1n = 0.; // <sin(n*(phi1))>
1049
1050 if(dMult>0)
1051 {
1052 sinP1n = dImQ1n/dMult;
1053
1054 // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
0328db2d 1055 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);
1056 // event weights for NUA terms:
1057 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(1,dMult);
489d5531 1058
1059 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1060 fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);
b3dacf6b 1061 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][0]->Fill(dMult+0.5,sinP1n,dMult);}
489d5531 1062 }
1063
1064 // 2-particle:
1065 Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>
1066 Double_t sinP2nM1n = 0.; // <<sin(n*(2phi1-phi2))>>
1067 if(dMult>1)
1068 {
3b552efe 1069 sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1));
489d5531 1070 sinP2nM1n = (dImQ2n*dReQ1n-dReQ2n*dImQ1n-dImQ1n)/(dMult*(dMult-1));
1071
1072 // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
1073 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);
3b552efe 1074 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(4,sinP2nM1n);
0328db2d 1075 // event weights for NUA terms:
1076 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(2,dMult*(dMult-1));
1077 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(4,dMult*(dMult-1));
489d5531 1078
1079 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1080 fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));
1081 fIntFlowCorrectionTermsForNUAPro[0]->Fill(3.5,sinP2nM1n,dMult*(dMult-1));
b3dacf6b 1082 if(fCalculateCumulantsVsM)
1083 {
1084 fIntFlowCorrectionTermsForNUAVsMPro[0][1]->Fill(dMult+0.5,sinP1nP1n,dMult*(dMult-1));
1085 fIntFlowCorrectionTermsForNUAVsMPro[0][3]->Fill(dMult+0.5,sinP2nM1n,dMult*(dMult-1));
1086 }
489d5531 1087 }
1088
1089 // 3-particle:
1090 Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>
1091
1092 if(dMult>2)
1093 {
1094 sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)
1095 / (dMult*(dMult-1)*(dMult-2));
1096
1097 // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
1098 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);
0328db2d 1099 // event weights for NUA terms:
1100 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
489d5531 1101
1102 // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
2001bc3a 1103 fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
b3dacf6b 1104 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][2]->Fill(dMult+0.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
489d5531 1105 }
1106
1107} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()
1108
489d5531 1109//================================================================================================================================
1110
489d5531 1111void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)
1112{
1268c371 1113 // a) Get pointers for common control and common result histograms;
1114 // b) Get pointers for histograms holding particle weights;
1115 // c) Get pointers for reference flow histograms;
1116 // d) Get pointers for differential flow histograms;
1117 // e) Get pointers for 2D differential flow histograms;
64e500e3 1118 // f) Get pointers for other differential correlators;
1119 // g) Get pointers for nested loops' histograms.
489d5531 1120
1121 if(outputListHistos)
3b552efe 1122 {
1123 this->SetHistList(outputListHistos);
1124 if(!fHistList)
1125 {
1268c371 1126 printf("\n WARNING (QC): fHistList is NULL in AFAWQC::GOH() !!!!\n\n");
3b552efe 1127 exit(0);
489d5531 1128 }
1129 this->GetPointersForCommonHistograms();
1130 this->GetPointersForParticleWeightsHistograms();
1131 this->GetPointersForIntFlowHistograms();
1132 this->GetPointersForDiffFlowHistograms();
1268c371 1133 this->GetPointersFor2DDiffFlowHistograms();
64e500e3 1134 this->GetPointersForOtherDiffCorrelators();
489d5531 1135 this->GetPointersForNestedLoopsHistograms();
3b552efe 1136 } else
1137 {
1268c371 1138 printf("\n WARNING (QC): outputListHistos is NULL in AFAWQC::GOH() !!!!\n\n");
3b552efe 1139 exit(0);
489d5531 1140 }
1141
1142} // end of void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)
ad87ae62 1143
489d5531 1144//================================================================================================================================
1145
489d5531 1146TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta) const
ad87ae62 1147{
489d5531 1148 // project 2D profile onto pt axis to get 1D profile
1149
1150 Int_t nBinsPt = profilePtEta->GetNbinsX();
1151 Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();
1152 Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();
1153
1154 Int_t nBinsEta = profilePtEta->GetNbinsY();
1155
1156 TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax);
1157
1158 for(Int_t p=1;p<=nBinsPt;p++)
1159 {
1160 Double_t contentPt = 0.;
1161 Double_t entryPt = 0.;
1162 Double_t spreadPt = 0.;
1163 Double_t sum1 = 0.;
1164 Double_t sum2 = 0.;
1165 Double_t sum3 = 0.;
1166 for(Int_t e=1;e<=nBinsEta;e++)
1167 {
1168 contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1169 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1170 entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1171
1172 sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1173 * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)
1174 + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.));
1175 sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1176 sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1177 * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));
1178 }
1179 if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)
1180 {
1181 spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);
1182 }
1183 profilePt->SetBinContent(p,contentPt);
1184 profilePt->SetBinEntries(p,entryPt);
1185 {
1186 profilePt->SetBinError(p,spreadPt);
1187 }
1188
1189 }
1190
1191 return profilePt;
1192
1193} // end of TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta)
1194
1195
1196//================================================================================================================================
1197
1198
1199TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta) const
1200{
1201 // project 2D profile onto eta axis to get 1D profile
1202
1203 Int_t nBinsEta = profilePtEta->GetNbinsY();
1204 Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();
1205 Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();
1206
1207 Int_t nBinsPt = profilePtEta->GetNbinsX();
1208
1209 TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax);
1210
1211 for(Int_t e=1;e<=nBinsEta;e++)
1212 {
1213 Double_t contentEta = 0.;
1214 Double_t entryEta = 0.;
1215 for(Int_t p=1;p<=nBinsPt;p++)
1216 {
1217 contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1218 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1219 entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1220 }
1221 profileEta->SetBinContent(e,contentEta);
1222 profileEta->SetBinEntries(e,entryEta);
1223 }
1224
1225 return profileEta;
1226
1227} // end of TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta)
1228
489d5531 1229//================================================================================================================================
1230
489d5531 1231void AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type)
1232{
2001bc3a 1233 // Printing on the screen the final results for integrated flow (RF, POI and RP).
489d5531 1234
1235 Int_t n = fHarmonic;
1236
489d5531 1237 Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}
1238 Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}
1239
2001bc3a 1240 if(type == "RF")
489d5531 1241 {
0dd3b008 1242 for(Int_t b=0;b<4;b++)
1243 {
b77b6434 1244 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1);
1245 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1);
1246 dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1);
1247 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1);
1248 dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1);
1249 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1);
1250 dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1);
1251 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1);
0dd3b008 1252 }
489d5531 1253 } else if(type == "RP")
1254 {
1255 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1);
1256 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1);
1257 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1);
1258 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1);
1259 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1);
1260 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1);
1261 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1);
1262 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1);
1263 } else if(type == "POI")
1264 {
1265 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1);
1266 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1);
1267 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1);
1268 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1);
1269 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1);
1270 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1);
1271 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1);
1272 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1);
b77b6434 1273 } else if(type == "RF, rebinned in M" && fCalculateCumulantsVsM)
b3dacf6b 1274 {
0dd3b008 1275 for(Int_t b=0;b<4;b++)
1276 {
1277 dVn[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
1278 dVnErr[b] = fIntFlowRebinnedInM->GetBinError(b+1);
1279 }
b3dacf6b 1280 }
489d5531 1281
1282 TString title = " flow estimates from Q-cumulants";
1283 TString subtitle = " (";
b3dacf6b 1284 TString subtitle2 = " (rebinned in M)";
489d5531 1285
b3dacf6b 1286 if(type != "RF, rebinned in M")
489d5531 1287 {
403e3389 1288 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b3dacf6b 1289 {
1290 subtitle.Append(type);
1291 subtitle.Append(", without weights)");
1292 } else
1293 {
1294 subtitle.Append(type);
1295 subtitle.Append(", with weights)");
1296 }
1297 } else
489d5531 1298 {
403e3389 1299 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b3dacf6b 1300 {
1301 subtitle.Append("RF");
1302 subtitle.Append(", without weights)");
1303 } else
1304 {
1305 subtitle.Append("RF");
1306 subtitle.Append(", with weights)");
1307 }
1308 }
1309
489d5531 1310 cout<<endl;
1311 cout<<"*************************************"<<endl;
1312 cout<<"*************************************"<<endl;
1313 cout<<title.Data()<<endl;
1314 cout<<subtitle.Data()<<endl;
b3dacf6b 1315 if(type == "RF, rebinned in M"){cout<<subtitle2.Data()<<endl;}
489d5531 1316 cout<<endl;
1317
1318 for(Int_t i=0;i<4;i++)
1319 {
2001bc3a 1320 cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
489d5531 1321 }
2001bc3a 1322
489d5531 1323 cout<<endl;
b92ea2b9 1324 if(type == "RF")
1325 {
b77b6434 1326 if(fApplyCorrectionForNUA)
1327 {
1328 cout<<" detector bias (corrected for): "<<endl;
1329 } else
1330 {
1331 cout<<" detector bias (not corrected for):"<<endl;
1332 }
b92ea2b9 1333 cout<<" to QC{2}: "<<fIntFlowDetectorBias->GetBinContent(1)<<" +/- "<<fIntFlowDetectorBias->GetBinError(1)<<endl;
1334 cout<<" to QC{4}: "<<fIntFlowDetectorBias->GetBinContent(2)<<" +/- "<<fIntFlowDetectorBias->GetBinError(2)<<endl;
1335 cout<<endl;
1336 }
b3dacf6b 1337 if(type == "RF" || type == "RF, rebinned in M")
489d5531 1338 {
2001bc3a 1339 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
489d5531 1340 }
1341 else if (type == "RP")
1342 {
2001bc3a 1343 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
489d5531 1344 }
1345 else if (type == "POI")
1346 {
2001bc3a 1347 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
1348 }
1349
489d5531 1350 cout<<"*************************************"<<endl;
1351 cout<<"*************************************"<<endl;
1352 cout<<endl;
1353
2001bc3a 1354}// end of AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type="RF");
489d5531 1355
1356//================================================================================================================================
1357
489d5531 1358void AliFlowAnalysisWithQCumulants::WriteHistograms(TString outputFileName)
1359{
1360 //store the final results in output .root file
1361 TFile *output = new TFile(outputFileName.Data(),"RECREATE");
1362 //output->WriteObject(fHistList, "cobjQC","SingleKey");
1363 fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
1364 delete output;
1365}
1366
1367
1368//================================================================================================================================
1369
1370
1371void AliFlowAnalysisWithQCumulants::WriteHistograms(TDirectoryFile *outputFileName)
1372{
1373 //store the final results in output .root file
1374 fHistList->SetName("cobjQC");
1375 fHistList->SetOwner(kTRUE);
1376 outputFileName->Add(fHistList);
1377 outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
1378}
1379
489d5531 1380//================================================================================================================================
1381
489d5531 1382void AliFlowAnalysisWithQCumulants::BookCommonHistograms()
1383{
1384 // Book common control histograms and common histograms for final results.
1268c371 1385 // a) Book common control histograms;
1386 // b) Book common result histograms.
1387
1388 // a) Book common control histograms:
1389 // Common control histograms (all events):
489d5531 1390 TString commonHistsName = "AliFlowCommonHistQC";
1391 commonHistsName += fAnalysisLabel->Data();
62d19320 1392 fCommonHists = new AliFlowCommonHist(commonHistsName.Data(),commonHistsName.Data(),fBookOnlyBasicCCH);
489d5531 1393 fHistList->Add(fCommonHists);
1268c371 1394 // Common control histograms (selected events):
dd442cd2 1395 if(fFillMultipleControlHistograms)
1396 {
1268c371 1397 // Common control histogram filled for events with 2 and more reference particles:
dd442cd2 1398 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
1399 commonHists2ndOrderName += fAnalysisLabel->Data();
62d19320 1400 fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data(),commonHists2ndOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1401 fHistList->Add(fCommonHists2nd);
1268c371 1402 // Common control histogram filled for events with 2 and more reference particles:
dd442cd2 1403 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
1404 commonHists4thOrderName += fAnalysisLabel->Data();
62d19320 1405 fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data(),commonHists4thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1406 fHistList->Add(fCommonHists4th);
1268c371 1407 // Common control histogram filled for events with 6 and more reference particles:
dd442cd2 1408 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
1409 commonHists6thOrderName += fAnalysisLabel->Data();
62d19320 1410 fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data(),commonHists6thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1411 fHistList->Add(fCommonHists6th);
1268c371 1412 // Common control histogram filled for events with 8 and more reference particles:
dd442cd2 1413 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
1414 commonHists8thOrderName += fAnalysisLabel->Data();
62d19320 1415 fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data(),commonHists8thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1416 fHistList->Add(fCommonHists8th);
1417 } // end of if(fFillMultipleControlHistograms)
1418
1268c371 1419 // b) Book common result histograms:
1420 // Common result histograms for QC{2}:
489d5531 1421 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
1422 commonHistResults2ndOrderName += fAnalysisLabel->Data();
62e36168 1423 fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
489d5531 1424 fHistList->Add(fCommonHistsResults2nd);
1268c371 1425 // Common result histograms for QC{4}:
489d5531 1426 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
1427 commonHistResults4thOrderName += fAnalysisLabel->Data();
62e36168 1428 fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
489d5531 1429 fHistList->Add(fCommonHistsResults4th);
1268c371 1430 // Common result histograms for QC{6}:
489d5531 1431 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
1432 commonHistResults6thOrderName += fAnalysisLabel->Data();
62e36168 1433 fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
489d5531 1434 fHistList->Add(fCommonHistsResults6th);
1268c371 1435 // Common result histograms for QC{8}:
489d5531 1436 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
1437 commonHistResults8thOrderName += fAnalysisLabel->Data();
62e36168 1438 fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
489d5531 1439 fHistList->Add(fCommonHistsResults8th);
1440
1441} // end of void AliFlowAnalysisWithQCumulants::BookCommonHistograms()
1442
489d5531 1443//================================================================================================================================
1444
489d5531 1445void AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()
1446{
1268c371 1447 // Book and fill histograms which hold phi, pt and eta weights.
489d5531 1448
1449 if(!fWeightsList)
1450 {
1268c371 1451 printf("\n WARNING (QC): fWeightsList is NULL in AFAWQC::BAFWH() !!!! \n\n");
489d5531 1452 exit(0);
1453 }
1454
1455 TString fUseParticleWeightsName = "fUseParticleWeightsQC";
1456 fUseParticleWeightsName += fAnalysisLabel->Data();
403e3389 1457 fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",4,0,4);
489d5531 1458 fUseParticleWeights->SetLabelSize(0.06);
1459 (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");
1460 (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");
1461 (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");
403e3389 1462 (fUseParticleWeights->GetXaxis())->SetBinLabel(4,"w_{track}");
489d5531 1463 fUseParticleWeights->Fill(0.5,(Int_t)fUsePhiWeights);
1464 fUseParticleWeights->Fill(1.5,(Int_t)fUsePtWeights);
1465 fUseParticleWeights->Fill(2.5,(Int_t)fUseEtaWeights);
403e3389 1466 fUseParticleWeights->Fill(3.5,(Int_t)fUseTrackWeights);
489d5531 1467 fWeightsList->Add(fUseParticleWeights);
1468
1469 if(fUsePhiWeights)
1470 {
1471 if(fWeightsList->FindObject("phi_weights"))
1472 {
1473 fPhiWeights = dynamic_cast<TH1F*>(fWeightsList->FindObject("phi_weights"));
1268c371 1474 if(!fPhiWeights)
1475 {
1476 printf("\n WARNING (QC): fPhiWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1477 exit(0);
1478 }
489d5531 1479 if(TMath::Abs(fPhiWeights->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
1480 {
1481 cout<<endl;
1482 cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
1483 cout<<endl;
6fbbbbf1 1484 //exit(0);
489d5531 1485 }
1486 } else
1487 {
1488 cout<<"WARNING: fWeightsList->FindObject(\"phi_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1489 exit(0);
1490 }
1491 } // end of if(fUsePhiWeights)
1492
1493 if(fUsePtWeights)
1494 {
1495 if(fWeightsList->FindObject("pt_weights"))
1496 {
1497 fPtWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("pt_weights"));
1268c371 1498 if(!fPtWeights)
1499 {
1500 printf("\n WARNING (QC): fPtWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1501 exit(0);
1502 }
489d5531 1503 if(TMath::Abs(fPtWeights->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
1504 {
1505 cout<<endl;
1506 cout<<"WARNING (QC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
1507 cout<<endl;
6fbbbbf1 1508 //exit(0);
489d5531 1509 }
1510 } else
1511 {
1512 cout<<"WARNING: fWeightsList->FindObject(\"pt_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1513 exit(0);
1514 }
1515 } // end of if(fUsePtWeights)
1516
1517 if(fUseEtaWeights)
1518 {
1519 if(fWeightsList->FindObject("eta_weights"))
1520 {
1521 fEtaWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("eta_weights"));
1268c371 1522 if(!fEtaWeights)
1523 {
1524 printf("\n WARNING (QC): fEtaWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1525 exit(0);
1526 }
489d5531 1527 if(TMath::Abs(fEtaWeights->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
1528 {
1529 cout<<endl;
1530 cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
1531 cout<<endl;
6fbbbbf1 1532 //exit(0);
489d5531 1533 }
1534 } else
1535 {
1536 cout<<"WARNING: fUseEtaWeights && fWeightsList->FindObject(\"eta_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1537 exit(0);
1538 }
1539 } // end of if(fUseEtaWeights)
1540
1541} // end of AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()
1542
489d5531 1543//================================================================================================================================
1544
489d5531 1545void AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()
1546{
1547 // Book all objects for integrated flow:
e5834fcb 1548 // a) Book profile to hold all flags for integrated flow;
1549 // b) Book event-by-event quantities;
1550 // c) Book profiles; // to be improved (comment)
489d5531 1551 // d) Book histograms holding the final results.
1552
1553 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
1554 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)
1555
1556 // a) Book profile to hold all flags for integrated flow:
1557 TString intFlowFlagsName = "fIntFlowFlags";
1558 intFlowFlagsName += fAnalysisLabel->Data();
3435cacb 1559 fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",15,0,15);
489d5531 1560 fIntFlowFlags->SetTickLength(-0.01,"Y");
1561 fIntFlowFlags->SetMarkerStyle(25);
403e3389 1562 fIntFlowFlags->SetLabelSize(0.04);
489d5531 1563 fIntFlowFlags->SetLabelOffset(0.02,"Y");
1564 fIntFlowFlags->GetXaxis()->SetBinLabel(1,"Particle Weights");
1565 fIntFlowFlags->GetXaxis()->SetBinLabel(2,"Event Weights");
1566 fIntFlowFlags->GetXaxis()->SetBinLabel(3,"Corrected for NUA?");
b3dacf6b 1567 fIntFlowFlags->GetXaxis()->SetBinLabel(4,"Print RF results");
489d5531 1568 fIntFlowFlags->GetXaxis()->SetBinLabel(5,"Print RP results");
3b552efe 1569 fIntFlowFlags->GetXaxis()->SetBinLabel(6,"Print POI results");
b3dacf6b 1570 fIntFlowFlags->GetXaxis()->SetBinLabel(7,"Print RF (rebinned in M) results");
1571 fIntFlowFlags->GetXaxis()->SetBinLabel(8,"Corrected for NUA vs M?");
1572 fIntFlowFlags->GetXaxis()->SetBinLabel(9,"Propagate errors to v_{n} from correlations?");
1573 fIntFlowFlags->GetXaxis()->SetBinLabel(10,"Calculate cumulants vs M");
0dd3b008 1574 fIntFlowFlags->GetXaxis()->SetBinLabel(11,"fMinimumBiasReferenceFlow");
8e1cefdd 1575 fIntFlowFlags->GetXaxis()->SetBinLabel(12,"fForgetAboutCovariances");
e5834fcb 1576 fIntFlowFlags->GetXaxis()->SetBinLabel(13,"fStorePhiDistributionForOneEvent");
dd442cd2 1577 fIntFlowFlags->GetXaxis()->SetBinLabel(14,"fFillMultipleControlHistograms");
3435cacb 1578 fIntFlowFlags->GetXaxis()->SetBinLabel(15,"Calculate all correlations vs M");
489d5531 1579 fIntFlowList->Add(fIntFlowFlags);
1580
1581 // b) Book event-by-event quantities:
1582 // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M:
8ed4edc7 1583 fReQ = new TMatrixD(6,9);
1584 fImQ = new TMatrixD(6,9);
1268c371 1585 fSpk = new TMatrixD(8,9);
489d5531 1586 // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):
1587 TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";
1588 intFlowCorrelationsEBEName += fAnalysisLabel->Data();
1589 fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);
1590 // weights for average correlations <2>, <4>, <6> and <8> for single event:
1591 TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";
1592 intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
1593 fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);
1594 // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):
1595 TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";
1596 intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();
403e3389 1597 fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),64,0,64);
489d5531 1598 // average correction terms for non-uniform acceptance for single event
1599 // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):
1600 TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";
1601 fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
1602 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
1603 {
b92ea2b9 1604 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()),4,0,4);
489d5531 1605 }
0328db2d 1606 // event weights for terms for non-uniform acceptance:
1607 TString fIntFlowEventWeightForCorrectionTermsForNUAEBEName = "fIntFlowEventWeightForCorrectionTermsForNUAEBE";
1608 fIntFlowEventWeightForCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
1609 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
1610 {
b92ea2b9 1611 fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc] = new TH1D(Form("%s: %s terms",fIntFlowEventWeightForCorrectionTermsForNUAEBEName.Data(),sinCosFlag[sc].Data()),Form("Event weights for terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),4,0,4); // to be improved - 4
0328db2d 1612 }
489d5531 1613 // c) Book profiles: // to be improved (comment)
1614 // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:
1615 TString avMultiplicityName = "fAvMultiplicity";
1616 avMultiplicityName += fAnalysisLabel->Data();
403e3389 1617 fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average multiplicities of reference particles (RPs)",9,0,9);
489d5531 1618 fAvMultiplicity->SetTickLength(-0.01,"Y");
1619 fAvMultiplicity->SetMarkerStyle(25);
1620 fAvMultiplicity->SetLabelSize(0.05);
1621 fAvMultiplicity->SetLabelOffset(0.02,"Y");
403e3389 1622 fAvMultiplicity->SetYTitle("Average multiplicity");
489d5531 1623 (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");
1624 (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");
1625 (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");
1626 (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");
1627 (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");
1628 (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");
1629 (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");
1630 (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");
1631 (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");
1632 fIntFlowProfiles->Add(fAvMultiplicity);
b40a910e 1633 // Average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):
1634 TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
489d5531 1635 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
1636 intFlowCorrelationsProName += fAnalysisLabel->Data();
1637 fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");
b40a910e 1638 fIntFlowCorrelationsPro->Sumw2();
489d5531 1639 fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");
1640 fIntFlowCorrelationsPro->SetMarkerStyle(25);
1641 fIntFlowCorrelationsPro->SetLabelSize(0.06);
1642 fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");
68a3b4b1 1643 for(Int_t b=0;b<4;b++)
b3dacf6b 1644 {
68a3b4b1 1645 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(b+1,correlationFlag[b].Data());
b3dacf6b 1646 }
489d5531 1647 fIntFlowProfiles->Add(fIntFlowCorrelationsPro);
b40a910e 1648 // Average correlations squared <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> for all events:
1649 TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"};
1650 TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
1651 intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
1652 fIntFlowSquaredCorrelationsPro = new TProfile(intFlowSquaredCorrelationsProName.Data(),"Average squared correlations for all events",4,0,4,"s");
1653 fIntFlowSquaredCorrelationsPro->Sumw2();
1654 fIntFlowSquaredCorrelationsPro->SetTickLength(-0.01,"Y");
1655 fIntFlowSquaredCorrelationsPro->SetMarkerStyle(25);
1656 fIntFlowSquaredCorrelationsPro->SetLabelSize(0.06);
1657 fIntFlowSquaredCorrelationsPro->SetLabelOffset(0.01,"Y");
1658 for(Int_t b=0;b<4;b++)
1659 {
1660 (fIntFlowSquaredCorrelationsPro->GetXaxis())->SetBinLabel(b+1,squaredCorrelationFlag[b].Data());
1661 }
1662 fIntFlowProfiles->Add(fIntFlowSquaredCorrelationsPro);
b3dacf6b 1663 if(fCalculateCumulantsVsM)
1664 {
1665 for(Int_t ci=0;ci<4;ci++) // correlation index
1666 {
b40a910e 1667 // average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (with wrong errors):
b3dacf6b 1668 TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
1669 intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
1670 fIntFlowCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data()),
1671 Form("%s vs multiplicity",correlationFlag[ci].Data()),
b40a910e 1672 fnBinsMult,fMinMult,fMaxMult,"s");
1673 fIntFlowCorrelationsVsMPro[ci]->Sumw2();
b3dacf6b 1674 fIntFlowCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
1675 fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("M");
1676 fIntFlowProfiles->Add(fIntFlowCorrelationsVsMPro[ci]);
b40a910e 1677 // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
1678 TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
1679 intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
1680 fIntFlowSquaredCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data()),
1681 Form("%s vs multiplicity",squaredCorrelationFlag[ci].Data()),
1682 fnBinsMult,fMinMult,fMaxMult,"s");
1683 fIntFlowSquaredCorrelationsVsMPro[ci]->Sumw2();
1684 fIntFlowSquaredCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(squaredCorrelationFlag[ci].Data());
1685 fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("M");
1686 fIntFlowProfiles->Add(fIntFlowSquaredCorrelationsVsMPro[ci]);
b3dacf6b 1687 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
1688 } // end of if(fCalculateCumulantsVsM)
489d5531 1689 // averaged all correlations for all events (with wrong errors!):
1690 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
1691 intFlowCorrelationsAllProName += fAnalysisLabel->Data();
403e3389 1692 fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average all correlations for all events",64,0,64);
b84464d3 1693 fIntFlowCorrelationsAllPro->Sumw2();
489d5531 1694 fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");
1695 fIntFlowCorrelationsAllPro->SetMarkerStyle(25);
1696 fIntFlowCorrelationsAllPro->SetLabelSize(0.03);
1697 fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");
1698 // 2-p correlations:
403e3389 1699 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT_{n|n}");
1700 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"#LT#LT2#GT#GT_{2n|2n}");
1701 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"#LT#LT2#GT#GT_{3n|3n}");
1702 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"#LT#LT2#GT#GT_{4n|4n}");
489d5531 1703 // 3-p correlations:
403e3389 1704 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"#LT#LT3#GT#GT_{2n|n,n}");
1705 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"#LT#LT3#GT#GT_{3n|2n,n}");
1706 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"#LT#LT3#GT#GT_{4n|2n,2n}");
1707 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"#LT#LT3#GT#GT_{4n|3n,n}");
489d5531 1708 // 4-p correlations:
403e3389 1709 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"#LT#LT4#GT#GT_{n,n|n,n}");
1710 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"#LT#LT4#GT#GT_{2n,n|2n,n}");
1711 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"#LT#LT4#GT#GT_{2n,2n|2n,2n}");
1712 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"#LT#LT4#GT#GT_{3n|n,n,n}");
1713 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"#LT#LT4#GT#GT_{3n,n|3n,n}");
1714 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"#LT#LT4#GT#GT_{3n,n|2n,2n}");
1715 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"#LT#LT4#GT#GT_{4n|2n,n,n}");
489d5531 1716 // 5-p correlations:
403e3389 1717 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"#LT#LT5#GT#GT_{2n,n|n,n,n}");
1718 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"#LT#LT5#GT#GT_{2n,2n|2n,n,n}");
1719 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"#LT#LT5#GT#GT_{3n,n|2n,n,n}");
1720 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"#LT#LT5#GT#GT_{4n|n,n,n,n}");
489d5531 1721 // 6-p correlations:
403e3389 1722 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"#LT#LT6#GT#GT_{n,n,n|n,n,n}");
1723 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"#LT#LT6#GT#GT_{2n,n,n|2n,n,n}");
1724 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"#LT#LT6#GT#GT_{2n,2n|n,n,n,n}");
1725 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"#LT#LT6#GT#GT_{3n,n|n,n,n,n}");
489d5531 1726 // 7-p correlations:
403e3389 1727 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}");
489d5531 1728 // 8-p correlations:
403e3389 1729 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}");
b84464d3 1730 // EXTRA correlations for v3{5} study:
403e3389 1731 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(33,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
1732 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(34,"#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}");
b84464d3 1733 // EXTRA correlations for Teaney-Yan study:
403e3389 1734 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(35,"#LT#LT2#GT#GT_{5n|5n}");
1735 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(36,"#LT#LT2#GT#GT_{6n|6n}");
1736 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(37,"#LT#LT3#GT#GT_{5n|3n,2n}");
1737 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(38,"#LT#LT3#GT#GT_{5n|4n,1n}");
1738 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(39,"#LT#LT3#GT#GT_{6n|3n,3n}");
1739 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(40,"#LT#LT3#GT#GT_{6n|4n,2n}");
1740 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(41,"#LT#LT3#GT#GT_{6n|5n,1n}");
1741 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(42,"#LT#LT4#GT#GT_{6n|3n,2n,1n}");
1742 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(43,"#LT#LT4#GT#GT_{3n,2n|3n,2n}");
1743 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(44,"#LT#LT4#GT#GT_{4n,1n|3n,2n}");
1744 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(45,"#LT#LT4#GT#GT_{3n,3n|3n,3n}");
1745 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(46,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
1746 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(47,"#LT#LT4#GT#GT_{5n,1n|3n,3n}");
1747 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(48,"#LT#LT4#GT#GT_{4n,2n|4n,2n}");
1748 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(49,"#LT#LT4#GT#GT_{5n,1n|4n,2n}");
1749 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(50,"#LT#LT4#GT#GT_{5n|3n,1n,1n}");
1750 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(51,"#LT#LT4#GT#GT_{5n|2n,2n,1n}");
1751 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(52,"#LT#LT4#GT#GT_{5n,1n|5n,1n}");
1752 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(53,"#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}");
1753 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(54,"#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}");
1754 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(55,"#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}");
1755 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(56,"#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}");
1756 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(57,"#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}");
1757 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(58,"#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}");
1758 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(59,"#LT#LT4#GT#GT_{6n|4n,1n,1n}");
1759 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(60,"#LT#LT4#GT#GT_{6n|2n,2n,2n}");
1760 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(61,"#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}");
1761 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(62,"#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}");
1762 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(63,"#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}");
489d5531 1763 fIntFlowProfiles->Add(fIntFlowCorrelationsAllPro);
3435cacb 1764 // average all correlations versus multiplicity (errors via Sumw2 - to be improved):
1765 if(fCalculateAllCorrelationsVsM)
1766 {
1767 // 2-p correlations vs M:
1768 fIntFlowCorrelationsAllVsMPro[0] = new TProfile("two1n1n","#LT#LT2#GT#GT_{n|n}",fnBinsMult,fMinMult,fMaxMult);
1769 fIntFlowCorrelationsAllVsMPro[0]->Sumw2();
1770 fIntFlowCorrelationsAllVsMPro[0]->GetXaxis()->SetTitle("M");
1771 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[0]);
1772 fIntFlowCorrelationsAllVsMPro[1] = new TProfile("two2n2n","#LT#LT2#GT#GT_{2n|2n}",fnBinsMult,fMinMult,fMaxMult);
1773 fIntFlowCorrelationsAllVsMPro[1]->Sumw2();
1774 fIntFlowCorrelationsAllVsMPro[1]->GetXaxis()->SetTitle("M");
1775 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[1]);
1776 fIntFlowCorrelationsAllVsMPro[2] = new TProfile("two3n3n","#LT#LT2#GT#GT_{3n|3n}",fnBinsMult,fMinMult,fMaxMult);
1777 fIntFlowCorrelationsAllVsMPro[2]->Sumw2();
1778 fIntFlowCorrelationsAllVsMPro[2]->GetXaxis()->SetTitle("M");
1779 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[2]);
1780 fIntFlowCorrelationsAllVsMPro[3] = new TProfile("two4n4n","#LT#LT2#GT#GT_{4n|4n}",fnBinsMult,fMinMult,fMaxMult);
1781 fIntFlowCorrelationsAllVsMPro[3]->Sumw2();
1782 fIntFlowCorrelationsAllVsMPro[3]->GetXaxis()->SetTitle("M");
1783 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[3]);
1784 // 3-p correlations vs M:
1785 fIntFlowCorrelationsAllVsMPro[5] = new TProfile("three2n1n1n","#LT#LT3#GT#GT_{2n|n,n}",fnBinsMult,fMinMult,fMaxMult);
1786 fIntFlowCorrelationsAllVsMPro[5]->Sumw2();
1787 fIntFlowCorrelationsAllVsMPro[5]->GetXaxis()->SetTitle("M");
1788 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[5]);
1789 fIntFlowCorrelationsAllVsMPro[6] = new TProfile("three3n2n1n","#LT#LT3#GT#GT_{3n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
1790 fIntFlowCorrelationsAllVsMPro[6]->Sumw2();
1791 fIntFlowCorrelationsAllVsMPro[6]->GetXaxis()->SetTitle("M");
1792 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[6]);
1793 fIntFlowCorrelationsAllVsMPro[7] = new TProfile("three4n2n2n","#LT#LT3#GT#GT_{4n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1794 fIntFlowCorrelationsAllVsMPro[7]->Sumw2();
1795 fIntFlowCorrelationsAllVsMPro[7]->GetXaxis()->SetTitle("M");
1796 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[7]);
1797 fIntFlowCorrelationsAllVsMPro[8] = new TProfile("three4n3n1n","#LT#LT3#GT#GT_{4n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
1798 fIntFlowCorrelationsAllVsMPro[8]->Sumw2();
1799 fIntFlowCorrelationsAllVsMPro[8]->GetXaxis()->SetTitle("M");
1800 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[8]);
1801 // 4-p correlations vs M:
1802 fIntFlowCorrelationsAllVsMPro[10] = new TProfile("four1n1n1n1n","#LT#LT4#GT#GT_{n,n|n,n}",fnBinsMult,fMinMult,fMaxMult);
1803 fIntFlowCorrelationsAllVsMPro[10]->Sumw2();
1804 fIntFlowCorrelationsAllVsMPro[10]->GetXaxis()->SetTitle("M");
1805 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[10]);
1806 fIntFlowCorrelationsAllVsMPro[11] = new TProfile("four2n1n2n1n","#LT#LT4#GT#GT_{2n,n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
1807 fIntFlowCorrelationsAllVsMPro[11]->Sumw2();
1808 fIntFlowCorrelationsAllVsMPro[11]->GetXaxis()->SetTitle("M");
1809 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[11]);
1810 fIntFlowCorrelationsAllVsMPro[12] = new TProfile("four2n2n2n2n","#LT#LT4#GT#GT_{2n,2n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1811 fIntFlowCorrelationsAllVsMPro[12]->Sumw2();
1812 fIntFlowCorrelationsAllVsMPro[12]->GetXaxis()->SetTitle("M");
1813 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[12]);
1814 fIntFlowCorrelationsAllVsMPro[13] = new TProfile("four3n1n1n1n","#LT#LT4#GT#GT_{3n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1815 fIntFlowCorrelationsAllVsMPro[13]->Sumw2();
1816 fIntFlowCorrelationsAllVsMPro[13]->GetXaxis()->SetTitle("M");
1817 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[13]);
1818 fIntFlowCorrelationsAllVsMPro[14] = new TProfile("four3n1n3n1n","#LT#LT4#GT#GT_{3n,n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
1819 fIntFlowCorrelationsAllVsMPro[14]->Sumw2();
1820 fIntFlowCorrelationsAllVsMPro[14]->GetXaxis()->SetTitle("M");
1821 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[14]);
1822 fIntFlowCorrelationsAllVsMPro[15] = new TProfile("four3n1n2n2n","#LT#LT4#GT#GT_{3n,n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1823 fIntFlowCorrelationsAllVsMPro[15]->Sumw2();
1824 fIntFlowCorrelationsAllVsMPro[15]->GetXaxis()->SetTitle("M");
1825 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[15]);
1826 fIntFlowCorrelationsAllVsMPro[16] = new TProfile("four4n2n1n1n","#LT#LT4#GT#GT_{4n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1827 fIntFlowCorrelationsAllVsMPro[16]->Sumw2();
1828 fIntFlowCorrelationsAllVsMPro[16]->GetXaxis()->SetTitle("M");
1829 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[16]);
1830 // 5-p correlations vs M:
403e3389 1831 fIntFlowCorrelationsAllVsMPro[18] = new TProfile("five2n1n1n1n1n","#LT#LT5#GT#GT_{2n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
3435cacb 1832 fIntFlowCorrelationsAllVsMPro[18]->Sumw2();
1833 fIntFlowCorrelationsAllVsMPro[18]->GetXaxis()->SetTitle("M");
1834 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[18]);
1835 fIntFlowCorrelationsAllVsMPro[19] = new TProfile("five2n2n2n1n1n","#LT#LT5#GT#GT_{2n,2n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1836 fIntFlowCorrelationsAllVsMPro[19]->Sumw2();
1837 fIntFlowCorrelationsAllVsMPro[19]->GetXaxis()->SetTitle("M");
1838 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[19]);
1839 fIntFlowCorrelationsAllVsMPro[20] = new TProfile("five3n1n2n1n1n","#LT#LT5#GT#GT_{3n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1840 fIntFlowCorrelationsAllVsMPro[20]->Sumw2();
1841 fIntFlowCorrelationsAllVsMPro[20]->GetXaxis()->SetTitle("M");
1842 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[20]);
1843 fIntFlowCorrelationsAllVsMPro[21] = new TProfile("five4n1n1n1n1n","#LT#LT5#GT#GT_{4n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1844 fIntFlowCorrelationsAllVsMPro[21]->Sumw2();
1845 fIntFlowCorrelationsAllVsMPro[21]->GetXaxis()->SetTitle("M");
1846 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[21]);
1847 // 6-p correlations vs M:
1848 fIntFlowCorrelationsAllVsMPro[23] = new TProfile("six1n1n1n1n1n1n","#LT#LT6#GT#GT_{n,n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1849 fIntFlowCorrelationsAllVsMPro[23]->Sumw2();
1850 fIntFlowCorrelationsAllVsMPro[23]->GetXaxis()->SetTitle("M");
1851 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[23]);
1852 fIntFlowCorrelationsAllVsMPro[24] = new TProfile("six2n1n1n2n1n1n","#LT#LT6#GT#GT_{2n,n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1853 fIntFlowCorrelationsAllVsMPro[24]->Sumw2();
1854 fIntFlowCorrelationsAllVsMPro[24]->GetXaxis()->SetTitle("M");
1855 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[24]);
1856 fIntFlowCorrelationsAllVsMPro[25] = new TProfile("six2n2n1n1n1n1n","#LT#LT6#GT#GT_{2n,2n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1857 fIntFlowCorrelationsAllVsMPro[25]->Sumw2();
1858 fIntFlowCorrelationsAllVsMPro[25]->GetXaxis()->SetTitle("M");
1859 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[25]);
1860 fIntFlowCorrelationsAllVsMPro[26] = new TProfile("six3n1n1n1n1n1n","#LT#LT6#GT#GT_{3n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1861 fIntFlowCorrelationsAllVsMPro[26]->Sumw2();
1862 fIntFlowCorrelationsAllVsMPro[26]->GetXaxis()->SetTitle("M");
1863 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[26]);
1864 // 7-p correlations vs M:
1865 fIntFlowCorrelationsAllVsMPro[28] = new TProfile("seven2n1n1n1n1n1n1n","#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1866 fIntFlowCorrelationsAllVsMPro[28]->Sumw2();
1867 fIntFlowCorrelationsAllVsMPro[28]->GetXaxis()->SetTitle("M");
1868 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[28]);
1869 // 8-p correlations vs M:
1870 fIntFlowCorrelationsAllVsMPro[30] = new TProfile("eight1n1n1n1n1n1n1n1n","#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1871 fIntFlowCorrelationsAllVsMPro[30]->Sumw2();
1872 fIntFlowCorrelationsAllVsMPro[30]->GetXaxis()->SetTitle("M");
1873 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[30]);
b84464d3 1874 // EXTRA correlations vs M for v3{5} study (to be improved - put them in a right order somewhere):
3435cacb 1875 fIntFlowCorrelationsAllVsMPro[32] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1876 fIntFlowCorrelationsAllVsMPro[32]->Sumw2();
1877 fIntFlowCorrelationsAllVsMPro[32]->GetXaxis()->SetTitle("M");
1878 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[32]);
b84464d3 1879 fIntFlowCorrelationsAllVsMPro[33] = new TProfile("five3n3n2n2n2n","#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
3435cacb 1880 fIntFlowCorrelationsAllVsMPro[33]->Sumw2();
1881 fIntFlowCorrelationsAllVsMPro[33]->GetXaxis()->SetTitle("M");
1882 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[33]);
b84464d3 1883 // EXTRA correlations vs M for Teaney-Yan study (to be improved - put them in a right order somewhere):
1884 fIntFlowCorrelationsAllVsMPro[34] = new TProfile("two5n5n","#LT#LT2#GT#GT_{5n|5n}",fnBinsMult,fMinMult,fMaxMult);
1885 fIntFlowCorrelationsAllVsMPro[34]->Sumw2();
1886 fIntFlowCorrelationsAllVsMPro[34]->GetXaxis()->SetTitle("M");
1887 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[34]);
1888 fIntFlowCorrelationsAllVsMPro[35] = new TProfile("two6n6n","#LT#LT2#GT#GT_{6n|6n}",fnBinsMult,fMinMult,fMaxMult);
1889 fIntFlowCorrelationsAllVsMPro[35]->Sumw2();
1890 fIntFlowCorrelationsAllVsMPro[35]->GetXaxis()->SetTitle("M");
1891 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[35]);
1892 fIntFlowCorrelationsAllVsMPro[36] = new TProfile("three5n3n2n","#LT#LT3#GT#GT_{5n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1893 fIntFlowCorrelationsAllVsMPro[36]->Sumw2();
1894 fIntFlowCorrelationsAllVsMPro[36]->GetXaxis()->SetTitle("M");
1895 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[36]);
1896 fIntFlowCorrelationsAllVsMPro[37] = new TProfile("three5n4n1n","#LT#LT3#GT#GT_{5n|4n,1n}",fnBinsMult,fMinMult,fMaxMult);
1897 fIntFlowCorrelationsAllVsMPro[37]->Sumw2();
1898 fIntFlowCorrelationsAllVsMPro[37]->GetXaxis()->SetTitle("M");
1899 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[37]);
1900 fIntFlowCorrelationsAllVsMPro[38] = new TProfile("three6n3n3n","#LT#LT3#GT#GT_{6n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1901 fIntFlowCorrelationsAllVsMPro[38]->Sumw2();
1902 fIntFlowCorrelationsAllVsMPro[38]->GetXaxis()->SetTitle("M");
1903 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[38]);
1904 fIntFlowCorrelationsAllVsMPro[39] = new TProfile("three6n4n2n","#LT#LT3#GT#GT_{6n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1905 fIntFlowCorrelationsAllVsMPro[39]->Sumw2();
1906 fIntFlowCorrelationsAllVsMPro[39]->GetXaxis()->SetTitle("M");
1907 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[39]);
1908 fIntFlowCorrelationsAllVsMPro[40] = new TProfile("three6n5n1n","#LT#LT3#GT#GT_{6n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
1909 fIntFlowCorrelationsAllVsMPro[40]->Sumw2();
1910 fIntFlowCorrelationsAllVsMPro[40]->GetXaxis()->SetTitle("M");
1911 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[40]);
1912 fIntFlowCorrelationsAllVsMPro[41] = new TProfile("four6n3n2n1n","#LT#LT4#GT#GT_{6n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1913 fIntFlowCorrelationsAllVsMPro[41]->Sumw2();
1914 fIntFlowCorrelationsAllVsMPro[41]->GetXaxis()->SetTitle("M");
1915 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[41]);
1916 fIntFlowCorrelationsAllVsMPro[42] = new TProfile("four3n2n3n2n","#LT#LT4#GT#GT_{3n,2n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1917 fIntFlowCorrelationsAllVsMPro[42]->Sumw2();
1918 fIntFlowCorrelationsAllVsMPro[42]->GetXaxis()->SetTitle("M");
1919 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[42]);
1920 fIntFlowCorrelationsAllVsMPro[43] = new TProfile("four4n1n3n2n","#LT#LT4#GT#GT_{4n,1n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1921 fIntFlowCorrelationsAllVsMPro[43]->Sumw2();
1922 fIntFlowCorrelationsAllVsMPro[43]->GetXaxis()->SetTitle("M");
1923 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[43]);
1924 fIntFlowCorrelationsAllVsMPro[44] = new TProfile("four3n3n3n3n","#LT#LT4#GT#GT_{3n,3n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1925 fIntFlowCorrelationsAllVsMPro[44]->Sumw2();
1926 fIntFlowCorrelationsAllVsMPro[44]->GetXaxis()->SetTitle("M");
1927 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[44]);
1928 fIntFlowCorrelationsAllVsMPro[45] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1929 fIntFlowCorrelationsAllVsMPro[45]->Sumw2();
1930 fIntFlowCorrelationsAllVsMPro[45]->GetXaxis()->SetTitle("M");
1931 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[45]);
1932 fIntFlowCorrelationsAllVsMPro[46] = new TProfile("four5n1n3n3n","#LT#LT4#GT#GT_{5n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1933 fIntFlowCorrelationsAllVsMPro[46]->Sumw2();
1934 fIntFlowCorrelationsAllVsMPro[46]->GetXaxis()->SetTitle("M");
1935 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[46]);
1936 fIntFlowCorrelationsAllVsMPro[47] = new TProfile("four4n2n4n2n","#LT#LT4#GT#GT_{4n,2n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1937 fIntFlowCorrelationsAllVsMPro[47]->Sumw2();
1938 fIntFlowCorrelationsAllVsMPro[47]->GetXaxis()->SetTitle("M");
1939 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[47]);
1940 fIntFlowCorrelationsAllVsMPro[48] = new TProfile("four5n1n4n2n","#LT#LT4#GT#GT_{5n,1n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1941 fIntFlowCorrelationsAllVsMPro[48]->Sumw2();
1942 fIntFlowCorrelationsAllVsMPro[48]->GetXaxis()->SetTitle("M");
1943 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[48]);
1944 fIntFlowCorrelationsAllVsMPro[49] = new TProfile("four5n3n1n1n","#LT#LT4#GT#GT_{5n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1945 fIntFlowCorrelationsAllVsMPro[49]->Sumw2();
1946 fIntFlowCorrelationsAllVsMPro[49]->GetXaxis()->SetTitle("M");
1947 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[49]);
1948 fIntFlowCorrelationsAllVsMPro[50] = new TProfile("four5n2n2n1n","#LT#LT4#GT#GT_{5n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1949 fIntFlowCorrelationsAllVsMPro[50]->Sumw2();
1950 fIntFlowCorrelationsAllVsMPro[50]->GetXaxis()->SetTitle("M");
1951 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[50]);
1952 fIntFlowCorrelationsAllVsMPro[51] = new TProfile("four5n1n5n1n","#LT#LT4#GT#GT_{5n,1n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
1953 fIntFlowCorrelationsAllVsMPro[51]->Sumw2();
1954 fIntFlowCorrelationsAllVsMPro[51]->GetXaxis()->SetTitle("M");
1955 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[51]);
1956 fIntFlowCorrelationsAllVsMPro[52] = new TProfile("five3n3n3n2n1n","#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1957 fIntFlowCorrelationsAllVsMPro[52]->Sumw2();
1958 fIntFlowCorrelationsAllVsMPro[52]->GetXaxis()->SetTitle("M");
1959 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[52]);
1960 fIntFlowCorrelationsAllVsMPro[53] = new TProfile("five4n2n3n2n1n","#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1961 fIntFlowCorrelationsAllVsMPro[53]->Sumw2();
1962 fIntFlowCorrelationsAllVsMPro[53]->GetXaxis()->SetTitle("M");
1963 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[53]);
1964 fIntFlowCorrelationsAllVsMPro[54] = new TProfile("five3n2n3n1n1n","#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1965 fIntFlowCorrelationsAllVsMPro[54]->Sumw2();
1966 fIntFlowCorrelationsAllVsMPro[54]->GetXaxis()->SetTitle("M");
1967 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[54]);
1968 fIntFlowCorrelationsAllVsMPro[55] = new TProfile("five3n2n2n2n1n","#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1969 fIntFlowCorrelationsAllVsMPro[55]->Sumw2();
1970 fIntFlowCorrelationsAllVsMPro[55]->GetXaxis()->SetTitle("M");
1971 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[55]);
1972 fIntFlowCorrelationsAllVsMPro[56] = new TProfile("five5n1n3n2n1n","#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1973 fIntFlowCorrelationsAllVsMPro[56]->Sumw2();
1974 fIntFlowCorrelationsAllVsMPro[56]->GetXaxis()->SetTitle("M");
1975 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[56]);
1976 fIntFlowCorrelationsAllVsMPro[57] = new TProfile("six3n2n1n3n2n1n","#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1977 fIntFlowCorrelationsAllVsMPro[57]->Sumw2();
1978 fIntFlowCorrelationsAllVsMPro[57]->GetXaxis()->SetTitle("M");
403e3389 1979 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[57]);
1980 fIntFlowCorrelationsAllVsMPro[58] = new TProfile("four6n4n1n1n","#LT#LT4#GT#GT_{6n|4n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1981 fIntFlowCorrelationsAllVsMPro[58]->Sumw2();
1982 fIntFlowCorrelationsAllVsMPro[58]->GetXaxis()->SetTitle("M");
1983 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[58]);
1984 fIntFlowCorrelationsAllVsMPro[59] = new TProfile("four6n2n2n2n","#LT#LT4#GT#GT_{6n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1985 fIntFlowCorrelationsAllVsMPro[59]->Sumw2();
1986 fIntFlowCorrelationsAllVsMPro[59]->GetXaxis()->SetTitle("M");
1987 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[59]);
1988 fIntFlowCorrelationsAllVsMPro[60] = new TProfile("five6n2n2n1n1n","#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1989 fIntFlowCorrelationsAllVsMPro[60]->Sumw2();
1990 fIntFlowCorrelationsAllVsMPro[60]->GetXaxis()->SetTitle("M");
1991 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[60]);
1992 fIntFlowCorrelationsAllVsMPro[61] = new TProfile("five4n1n1n3n3n","#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1993 fIntFlowCorrelationsAllVsMPro[61]->Sumw2();
1994 fIntFlowCorrelationsAllVsMPro[61]->GetXaxis()->SetTitle("M");
1995 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[61]);
1996 fIntFlowCorrelationsAllVsMPro[62] = new TProfile("six3n3n2n2n1n1n","#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1997 fIntFlowCorrelationsAllVsMPro[62]->Sumw2();
1998 fIntFlowCorrelationsAllVsMPro[62]->GetXaxis()->SetTitle("M");
1999 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[62]);
3435cacb 2000 } // end of if(fCalculateAllCorrelationsVsM)
489d5531 2001 // when particle weights are used some extra correlations appear:
403e3389 2002 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2003 {
2004 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
2005 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
2006 fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");
2007 fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");
2008 fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);
2009 fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);
2010 fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");
2011 // extra 2-p correlations:
2012 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");
2013 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");
2014 fIntFlowProfiles->Add(fIntFlowExtraCorrelationsPro);
403e3389 2015 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2016 // average product of correlations <2>, <4>, <6> and <8>:
403e3389 2017 TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
2018 "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
489d5531 2019 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
2020 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
2021 fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);
2022 fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");
2023 fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25);
2024 fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);
2025 fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");
68a3b4b1 2026 for(Int_t b=0;b<6;b++)
b3dacf6b 2027 {
68a3b4b1 2028 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(b+1,productFlag[b].Data());
b3dacf6b 2029 }
2030 fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsPro);
ff70ca91 2031 // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
2032 // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 2033 if(fCalculateCumulantsVsM)
2034 {
2035 TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
2036 intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
2037 for(Int_t pi=0;pi<6;pi++)
2038 {
2039 fIntFlowProductOfCorrelationsVsMPro[pi] = new TProfile(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data()),
2040 Form("%s versus multiplicity",productFlag[pi].Data()),
2041 fnBinsMult,fMinMult,fMaxMult);
2042 fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("M");
2043 fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsVsMPro[pi]);
2044 } // end of for(Int_t pi=0;pi<6;pi++)
2045 } // end of if(fCalculateCumulantsVsM)
0328db2d 2046 // average product of correction terms for NUA:
2047 TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
2048 intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2049 fIntFlowProductOfCorrectionTermsForNUAPro = new TProfile(intFlowProductOfCorrectionTermsForNUAProName.Data(),"Average products of correction terms for NUA",27,0,27);
2050 fIntFlowProductOfCorrectionTermsForNUAPro->SetTickLength(-0.01,"Y");
2051 fIntFlowProductOfCorrectionTermsForNUAPro->SetMarkerStyle(25);
403e3389 2052 fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelSize(0.03);
0328db2d 2053 fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelOffset(0.01,"Y");
2054 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(1,"<<2><cos(#phi)>>");
2055 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(2,"<<2><sin(#phi)>>");
2056 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(3,"<<cos(#phi)><sin(#phi)>>");
2057 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2058 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2059 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2060 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2061 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2062 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2063 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2064 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2065 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2066 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2067 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2068 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2069 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2070 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2071 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2072 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2073 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2074 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2075 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2076 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2077 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2078 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2079 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2080 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2081 fIntFlowProfiles->Add(fIntFlowProductOfCorrectionTermsForNUAPro);
489d5531 2082 // average correction terms for non-uniform acceptance (with wrong errors!):
2083 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2084 {
2085 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
2086 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
b92ea2b9 2087 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()),4,0,4,"s");
489d5531 2088 fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");
2089 fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);
403e3389 2090 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.05);
489d5531 2091 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");
403e3389 2092 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2093 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2094 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2095 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
489d5531 2096 fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAPro[sc]);
2001bc3a 2097 // versus multiplicity:
b3dacf6b 2098 if(fCalculateCumulantsVsM)
2099 {
2100 TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
2101 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2102 {
2103 TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
2104 intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
2105 fIntFlowCorrectionTermsForNUAVsMPro[sc][ci] = new TProfile(Form("%s: #LT#LT%s%s#GT#GT",intFlowCorrectionTermsForNUAVsMProName.Data(),sinCosFlag[sc].Data(),correctionTermFlag[ci].Data()),Form("#LT#LT%s%s#GT#GT vs M",sinCosFlag[sc].Data(),correctionTermFlag[ci].Data()),fnBinsMult,fMinMult,fMaxMult,"s");
2106 fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAVsMPro[sc][ci]);
2107 }
2108 } // end of if(fCalculateCumulantsVsM)
489d5531 2109 } // end of for(Int_t sc=0;sc<2;sc++)
2110
2111 // d) Book histograms holding the final results:
2112 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):
2113 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
2114 intFlowCorrelationsHistName += fAnalysisLabel->Data();
2115 fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);
2116 fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");
2117 fIntFlowCorrelationsHist->SetMarkerStyle(25);
2118 fIntFlowCorrelationsHist->SetLabelSize(0.06);
2119 fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");
403e3389 2120 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT");
2121 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"#LT#LT4#GT#GT");
2122 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"#LT#LT6#GT#GT");
2123 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"#LT#LT8#GT#GT");
489d5531 2124 fIntFlowResults->Add(fIntFlowCorrelationsHist);
ff70ca91 2125 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!) vs M:
b3dacf6b 2126 if(fCalculateCumulantsVsM)
2127 {
2128 for(Int_t ci=0;ci<4;ci++) // correlation index
2129 {
2130 TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
2131 intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
2132 fIntFlowCorrelationsVsMHist[ci] = new TH1D(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data()),
2133 Form("%s vs multiplicity",correlationFlag[ci].Data()),
2134 fnBinsMult,fMinMult,fMaxMult);
2135 fIntFlowCorrelationsVsMHist[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2136 fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("M");
2137 fIntFlowResults->Add(fIntFlowCorrelationsVsMHist[ci]);
2138 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2139 } // end of if(fCalculateCumulantsVsM)
489d5531 2140 // average all correlations for all events (with correct errors!):
2141 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
2142 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
8ed4edc7 2143 fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",34,0,34);
489d5531 2144 fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");
2145 fIntFlowCorrelationsAllHist->SetMarkerStyle(25);
2146 fIntFlowCorrelationsAllHist->SetLabelSize(0.03);
2147 fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");
2148 // 2-p correlations:
2149 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");
2150 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");
2151 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");
2152 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");
2153 // 3-p correlations:
2154 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");
2155 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");
2156 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");
2157 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");
2158 // 4-p correlations:
2159 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}");
2160 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");
2161 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");
2162 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");
2163 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");
2164 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}");
2165 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");
2166 // 5-p correlations:
2167 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}");
2168 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");
2169 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");
2170 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");
2171 // 6-p correlations:
2172 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");
2173 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");
2174 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");
2175 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");
2176 // 7-p correlations:
2177 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");
2178 // 8-p correlations:
2179 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");
2180 fIntFlowResults->Add(fIntFlowCorrelationsAllHist);
2181 // average correction terms for non-uniform acceptance (with correct errors!):
2182 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2183 {
2184 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
2185 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
b92ea2b9 2186 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()),4,0,4);
489d5531 2187 fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");
2188 fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);
403e3389 2189 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.05);
489d5531 2190 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");
b92ea2b9 2191 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
403e3389 2192 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2193 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2194 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
489d5531 2195 fIntFlowResults->Add(fIntFlowCorrectionTermsForNUAHist[sc]);
2196 } // end of for(Int_t sc=0;sc<2;sc++)
2197 // covariances (multiplied with weight dependent prefactor):
2198 TString intFlowCovariancesName = "fIntFlowCovariances";
2199 intFlowCovariancesName += fAnalysisLabel->Data();
2200 fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);
2201 fIntFlowCovariances->SetLabelSize(0.04);
2202 fIntFlowCovariances->SetMarkerStyle(25);
403e3389 2203 (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(#LT2#GT,#LT4#GT)");
2204 (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(#LT2#GT,#LT6#GT)");
2205 (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(#LT2#GT,#LT8#GT)");
2206 (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(#LT4#GT,#LT6#GT)");
2207 (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(#LT4#GT,#LT8#GT)");
2208 (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(#LT6#GT,#LT8#GT)");
489d5531 2209 fIntFlowResults->Add(fIntFlowCovariances);
2210 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
2211 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
2212 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
2213 for(Int_t power=0;power<2;power++)
2214 {
2215 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);
403e3389 2216 fIntFlowSumOfEventWeights[power]->SetLabelSize(0.04);
489d5531 2217 fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);
2218 if(power == 0)
2219 {
403e3389 2220 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}");
2221 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}");
2222 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}");
2223 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}");
489d5531 2224 } else if (power == 1)
2225 {
403e3389 2226 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}^{2}");
2227 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}^{2}");
2228 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}^{2}");
2229 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}^{2}");
489d5531 2230 }
2231 fIntFlowResults->Add(fIntFlowSumOfEventWeights[power]);
2232 }
2233 // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
2234 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
2235 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
2236 fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);
403e3389 2237 fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.04);
489d5531 2238 fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);
403e3389 2239 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT4#GT}");
2240 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT6#GT}");
2241 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT8#GT}");
2242 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT6#GT}");
2243 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT8#GT}");
2244 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT6#GT} w_{#LT8#GT}");
489d5531 2245 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeights);
ff70ca91 2246 // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
2247 // [0=Cov(2,4),1=Cov(2,6),2=Cov(2,8),3=Cov(4,6),4=Cov(4,8),5=Cov(6,8)]:
b3dacf6b 2248 if(fCalculateCumulantsVsM)
ff70ca91 2249 {
b3dacf6b 2250 TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
2251 intFlowCovariancesVsMName += fAnalysisLabel->Data();
2252 TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
2253 for(Int_t ci=0;ci<6;ci++)
2254 {
2255 fIntFlowCovariancesVsM[ci] = new TH1D(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data()),
2256 Form("%s vs multiplicity",covarianceFlag[ci].Data()),
2257 fnBinsMult,fMinMult,fMaxMult);
2258 fIntFlowCovariancesVsM[ci]->GetYaxis()->SetTitle(covarianceFlag[ci].Data());
2259 fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("M");
2260 fIntFlowResults->Add(fIntFlowCovariancesVsM[ci]);
2261 }
2262 } // end of if(fCalculateCumulantsVsM)
ff70ca91 2263 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
2264 // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
b3dacf6b 2265 if(fCalculateCumulantsVsM)
ff70ca91 2266 {
b3dacf6b 2267 TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
2268 intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
2269 TString sumFlag[2][4] = {{"#sum_{i=1}^{N} w_{<2>}","#sum_{i=1}^{N} w_{<4>}","#sum_{i=1}^{N} w_{<6>}","#sum_{i=1}^{N} w_{<8>}"},
2270 {"#sum_{i=1}^{N} w_{<2>}^{2}","#sum_{i=1}^{N} w_{<4>}^{2}","#sum_{i=1}^{N} w_{<6>}^{2}","#sum_{i=1}^{N} w_{<8>}^{2}"}};
2271 for(Int_t si=0;si<4;si++)
ff70ca91 2272 {
b3dacf6b 2273 for(Int_t power=0;power<2;power++)
2274 {
2275 fIntFlowSumOfEventWeightsVsM[si][power] = new TH1D(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data()),
2276 Form("%s vs multiplicity",sumFlag[power][si].Data()),
2277 fnBinsMult,fMinMult,fMaxMult);
2278 fIntFlowSumOfEventWeightsVsM[si][power]->GetYaxis()->SetTitle(sumFlag[power][si].Data());
2279 fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("M");
2280 fIntFlowResults->Add(fIntFlowSumOfEventWeightsVsM[si][power]);
2281 } // end of for(Int_t power=0;power<2;power++)
2282 } // end of for(Int_t si=0;si<4;si++)
2283 } // end of if(fCalculateCumulantsVsM)
ff70ca91 2284 // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
2285 // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
2286 // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
b3dacf6b 2287 if(fCalculateCumulantsVsM)
2288 {
2289 TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
2290 intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
2291 TString sopowFlag[6] = {"#sum_{i=1}^{N} w_{<2>} w_{<4>}","#sum_{i=1}^{N} w_{<2>} w_{<6>}","#sum_{i=1}^{N} w_{<2>} w_{<8>}",
2292 "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
2293 for(Int_t pi=0;pi<6;pi++)
2294 {
2295 fIntFlowSumOfProductOfEventWeightsVsM[pi] = new TH1D(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data()),
2296 Form("%s versus multiplicity",sopowFlag[pi].Data()),
2297 fnBinsMult,fMinMult,fMaxMult);
2298 fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("M");
2299 fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetYaxis()->SetTitle(sopowFlag[pi].Data());
2300 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeightsVsM[pi]);
2301 } // end of for(Int_t pi=0;pi<6;pi++)
2302 } // end of if(fCalculateCumulantsVsM)
0328db2d 2303 // covariances of NUA terms (multiplied with weight dependent prefactor):
2304 TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
2305 intFlowCovariancesNUAName += fAnalysisLabel->Data();
2306 fIntFlowCovariancesNUA = new TH1D(intFlowCovariancesNUAName.Data(),"Covariances for NUA (multiplied with weight dependent prefactor)",27,0,27);
2307 fIntFlowCovariancesNUA->SetLabelSize(0.04);
2308 fIntFlowCovariancesNUA->SetMarkerStyle(25);
2309 fIntFlowCovariancesNUA->GetXaxis()->SetLabelSize(0.02);
2310 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(1,"Cov(<2>,<cos(#phi)>");
2311 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(2,"Cov(<2>,<sin(#phi)>)");
2312 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(3,"Cov(<cos(#phi)>,<sin(#phi)>)");
2313 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2314 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2315 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2316 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2317 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2318 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2319 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2320 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2321 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2322 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2323 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2324 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2325 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2326 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2327 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2328 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2329 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2330 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2331 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2332 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2333 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2334 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2335 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2336 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2337 fIntFlowResults->Add(fIntFlowCovariancesNUA);
2338 // sum of linear and quadratic event weights for NUA terms:
2339 TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
2340 intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
2341 for(Int_t sc=0;sc<2;sc++)
2342 {
2343 for(Int_t power=0;power<2;power++)
2344 {
b92ea2b9 2345 fIntFlowSumOfEventWeightsNUA[sc][power] = new TH1D(Form("%s: %s, %s",intFlowSumOfEventWeightsNUAName.Data(),powerFlag[power].Data(),sinCosFlag[sc].Data()),Form("Sum of %s event weights for NUA %s terms",powerFlag[power].Data(),sinCosFlag[sc].Data()),4,0,4); // to be improved - 4
0328db2d 2346 fIntFlowSumOfEventWeightsNUA[sc][power]->SetLabelSize(0.05);
2347 fIntFlowSumOfEventWeightsNUA[sc][power]->SetMarkerStyle(25);
2348 if(power == 0)
2349 {
2350 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}",sinCosFlag[sc].Data()));
2351 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}",sinCosFlag[sc].Data()));
b92ea2b9 2352 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}",sinCosFlag[sc].Data()));
2353 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}",sinCosFlag[sc].Data()));
0328db2d 2354 } else if(power == 1)
2355 {
2356 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}^{2}",sinCosFlag[sc].Data()));
2357 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
2358 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}^{2}",sinCosFlag[sc].Data()));
b92ea2b9 2359 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
0328db2d 2360 }
2361 fIntFlowResults->Add(fIntFlowSumOfEventWeightsNUA[sc][power]);
2362 }
2363 }
2364 // sum of products of event weights for NUA terms:
2365 TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
2366 intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
2367 fIntFlowSumOfProductOfEventWeightsNUA = new TH1D(intFlowSumOfProductOfEventWeightsNUAName.Data(),"Sum of product of event weights for NUA terms",27,0,27);
403e3389 2368 fIntFlowSumOfProductOfEventWeightsNUA->SetLabelSize(0.02);
0328db2d 2369 fIntFlowSumOfProductOfEventWeightsNUA->SetMarkerStyle(25);
62e36168 2370 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi)#GT}");
2371 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi)#GT}");
2372 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi)#GT}");
2373 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2374 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2375 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2376 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(7,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2377 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(8,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi)#GT}");
2378 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(9,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi)#GT}");
2379 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(10,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2380 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(11,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2381 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(12,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2382 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(13,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2383 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(14,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2384 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(15,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2385 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(16,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2386 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(17,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2387 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(18,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2388 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(19,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2389 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(20,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2390 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(21,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2391 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(22,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2392 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(23,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2393 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(24,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2394 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(25,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2395 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(26,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2396 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(27,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
0328db2d 2397 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeightsNUA);
b3dacf6b 2398 // Final results for reference Q-cumulants:
2399 TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
489d5531 2400 TString intFlowQcumulantsName = "fIntFlowQcumulants";
2401 intFlowQcumulantsName += fAnalysisLabel->Data();
b92ea2b9 2402 fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Reference Q-cumulants",4,0,4);
b77b6434 2403 if(fPropagateErrorAlsoFromNIT)
b92ea2b9 2404 {
b77b6434 2405 fIntFlowQcumulants->SetTitle("Reference Q-cumulants (error from non-isotropic terms also propagated)");
b92ea2b9 2406 }
489d5531 2407 fIntFlowQcumulants->SetLabelSize(0.05);
2408 fIntFlowQcumulants->SetMarkerStyle(25);
68a3b4b1 2409 for(Int_t b=0;b<4;b++)
b3dacf6b 2410 {
68a3b4b1 2411 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
b3dacf6b 2412 }
489d5531 2413 fIntFlowResults->Add(fIntFlowQcumulants);
b3dacf6b 2414 // Final results for reference Q-cumulants rebinned in M:
2415 if(fCalculateCumulantsVsM)
2416 {
2417 TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
2418 intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
2419 fIntFlowQcumulantsRebinnedInM = new TH1D(intFlowQcumulantsRebinnedInMName.Data(),"Reference Q-cumulants rebinned in M",4,0,4);
2420 fIntFlowQcumulantsRebinnedInM->SetLabelSize(0.05);
2421 fIntFlowQcumulantsRebinnedInM->SetMarkerStyle(25);
68a3b4b1 2422 for(Int_t b=0;b<4;b++)
b3dacf6b 2423 {
68a3b4b1 2424 (fIntFlowQcumulantsRebinnedInM->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
b3dacf6b 2425 }
2426 fIntFlowResults->Add(fIntFlowQcumulantsRebinnedInM);
2427 } // end of if(fCalculateCumulantsVsM)
b92ea2b9 2428 // Ratio between error squared: with/without non-isotropic terms:
2429 TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
2430 intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
2431 fIntFlowQcumulantsErrorSquaredRatio = new TH1D(intFlowQcumulantsErrorSquaredRatioName.Data(),"Error squared of reference Q-cumulants: #frac{with NUA terms}{without NUA terms}",4,0,4);
2432 fIntFlowQcumulantsErrorSquaredRatio->SetLabelSize(0.05);
2433 fIntFlowQcumulantsErrorSquaredRatio->SetMarkerStyle(25);
2434 for(Int_t b=0;b<4;b++)
2435 {
2436 (fIntFlowQcumulantsErrorSquaredRatio->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
2437 }
2438 fIntFlowResults->Add(fIntFlowQcumulantsErrorSquaredRatio);
ff70ca91 2439 // final results for integrated Q-cumulants versus multiplicity:
b3dacf6b 2440 if(fCalculateCumulantsVsM)
2441 {
2442 TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
2443 intFlowQcumulantsVsMName += fAnalysisLabel->Data();
2444 for(Int_t co=0;co<4;co++) // cumulant order
2445 {
2446 fIntFlowQcumulantsVsM[co] = new TH1D(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data()),
2447 Form("%s vs multipicity",cumulantFlag[co].Data()),
2448 fnBinsMult,fMinMult,fMaxMult);
2449 fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("M");
2450 fIntFlowQcumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());
2451 fIntFlowResults->Add(fIntFlowQcumulantsVsM[co]);
2452 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2453 } // end of if(fCalculateCumulantsVsM)
489d5531 2454 // final integrated flow estimates from Q-cumulants:
b3dacf6b 2455 TString flowFlag[4] = {Form("v_{%d}{2,QC}",fHarmonic),Form("v_{%d}{4,QC}",fHarmonic),Form("v_{%d}{6,QC}",fHarmonic),Form("v_{%d}{8,QC}",fHarmonic)};
489d5531 2456 TString intFlowName = "fIntFlow";
2457 intFlowName += fAnalysisLabel->Data();
2458 // integrated flow from Q-cumulants:
b3dacf6b 2459 fIntFlow = new TH1D(intFlowName.Data(),"Reference flow estimates from Q-cumulants",4,0,4);
489d5531 2460 fIntFlow->SetLabelSize(0.05);
2461 fIntFlow->SetMarkerStyle(25);
68a3b4b1 2462 for(Int_t b=0;b<4;b++)
b3dacf6b 2463 {
68a3b4b1 2464 (fIntFlow->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
b3dacf6b 2465 }
ff70ca91 2466 fIntFlowResults->Add(fIntFlow);
b3dacf6b 2467 // Reference flow vs M rebinned in one huge bin:
2468 if(fCalculateCumulantsVsM)
2469 {
2470 TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
2471 intFlowRebinnedInMName += fAnalysisLabel->Data();
2472 fIntFlowRebinnedInM = new TH1D(intFlowRebinnedInMName.Data(),"Reference flow estimates from Q-cumulants (rebinned in M)",4,0,4);
2473 fIntFlowRebinnedInM->SetLabelSize(0.05);
2474 fIntFlowRebinnedInM->SetMarkerStyle(25);
68a3b4b1 2475 for(Int_t b=0;b<4;b++)
b3dacf6b 2476 {
68a3b4b1 2477 (fIntFlowRebinnedInM->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
b3dacf6b 2478 }
2479 fIntFlowResults->Add(fIntFlowRebinnedInM);
2480 }
ff70ca91 2481 // integrated flow from Q-cumulants: versus multiplicity:
b3dacf6b 2482 if(fCalculateCumulantsVsM)
2483 {
2484 TString intFlowVsMName = "fIntFlowVsM";
2485 intFlowVsMName += fAnalysisLabel->Data();
2486 for(Int_t co=0;co<4;co++) // cumulant order
2487 {
2488 fIntFlowVsM[co] = new TH1D(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data()),
2489 Form("%s vs multipicity",flowFlag[co].Data()),
2490 fnBinsMult,fMinMult,fMaxMult);
2491 fIntFlowVsM[co]->GetXaxis()->SetTitle("M");
2492 fIntFlowVsM[co]->GetYaxis()->SetTitle(flowFlag[co].Data());
2493 fIntFlowResults->Add(fIntFlowVsM[co]);
2494 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2495 } // end of if(fCalculateCumulantsVsM)
2001bc3a 2496 // quantifying detector effects effects to correlations:
2497 TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
2498 intFlowDetectorBiasName += fAnalysisLabel->Data();
2499 fIntFlowDetectorBias = new TH1D(intFlowDetectorBiasName.Data(),"Quantifying detector bias",4,0,4);
2500 fIntFlowDetectorBias->SetLabelSize(0.05);
2501 fIntFlowDetectorBias->SetMarkerStyle(25);
2502 for(Int_t ci=0;ci<4;ci++)
2503 {
2504 (fIntFlowDetectorBias->GetXaxis())->SetBinLabel(ci+1,Form("#frac{corrected}{measured} %s",cumulantFlag[ci].Data()));
2505 }
2506 fIntFlowResults->Add(fIntFlowDetectorBias);
2507 // quantifying detector effects to correlations versus multiplicity:
b3dacf6b 2508 if(fCalculateCumulantsVsM)
2001bc3a 2509 {
b3dacf6b 2510 TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
2511 intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
2512 for(Int_t ci=0;ci<4;ci++) // correlation index
2513 {
2514 fIntFlowDetectorBiasVsM[ci] = new TH1D(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data()),
2515 Form("Quantifying detector bias for %s vs multipicity",cumulantFlag[ci].Data()),
2516 fnBinsMult,fMinMult,fMaxMult);
2517 fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("M");
2518 fIntFlowDetectorBiasVsM[ci]->GetYaxis()->SetTitle("#frac{corrected}{measured}");
b77b6434 2519 fIntFlowResults->Add(fIntFlowDetectorBiasVsM[ci]);
b3dacf6b 2520 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2521 } // end of if(fCalculateCumulantsVsM)
1268c371 2522
489d5531 2523} // end of AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()
2524
489d5531 2525//================================================================================================================================
2526
489d5531 2527void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()
2528{
2529 // Initialize arrays of all objects relevant for calculations with nested loops.
2530
2531 // integrated flow:
2532 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2533 {
2534 fIntFlowDirectCorrectionTermsForNUA[sc] = NULL;
2535 }
2536
2537 // differential flow:
2538 // correlations:
2539 for(Int_t t=0;t<2;t++) // type: RP or POI
2540 {
2541 for(Int_t pe=0;pe<2;pe++) // pt or eta
2542 {
2543 for(Int_t ci=0;ci<4;ci++) // correlation index
2544 {
2545 fDiffFlowDirectCorrelations[t][pe][ci] = NULL;
2546 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2547 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2548 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
2549 // correction terms for non-uniform acceptance:
2550 for(Int_t t=0;t<2;t++) // type: RP or POI
2551 {
2552 for(Int_t pe=0;pe<2;pe++) // pt or eta
2553 {
2554 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2555 {
2556 for(Int_t cti=0;cti<9;cti++) // correction term index
2557 {
2558 fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = NULL;
2559 }
2560 }
2561 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2562 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
2563
64e500e3 2564 // other differential correlators:
2565 for(Int_t t=0;t<2;t++) // type: RP or POI
2566 {
2567 for(Int_t pe=0;pe<2;pe++) // pt or eta
2568 {
2569 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2570 {
2571 for(Int_t ci=0;ci<1;ci++) // correlator index
2572 {
2573 fOtherDirectDiffCorrelators[t][pe][sc][ci] = NULL;
2574 }
2575 }
2576 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2577 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
489d5531 2578
2579} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()
2580
489d5531 2581//================================================================================================================================
2582
489d5531 2583void AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()
2584{
2585 // Book all objects relevant for calculations with nested loops.
2586
2587 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
2588 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)
2589 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)
2590 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)
2591 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
2592 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
2593
2594 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";
2595 evaluateNestedLoopsName += fAnalysisLabel->Data();
2596 fEvaluateNestedLoops = new TProfile(evaluateNestedLoopsName.Data(),"Flags for nested loops",4,0,4);
2597 fEvaluateNestedLoops->SetLabelSize(0.03);
2598 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(1,"fEvaluateIntFlowNestedLoops");
2599 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(2,"fEvaluateDiffFlowNestedLoops");
2600 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(3,"fCrossCheckInPtBinNo");
2601 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(4,"fCrossCheckInEtaBinNo");
2602 fEvaluateNestedLoops->Fill(0.5,(Int_t)fEvaluateIntFlowNestedLoops);
2603 fEvaluateNestedLoops->Fill(1.5,(Int_t)fEvaluateDiffFlowNestedLoops);
2604 fEvaluateNestedLoops->Fill(2.5,fCrossCheckInPtBinNo);
2605 fEvaluateNestedLoops->Fill(3.5,fCrossCheckInEtaBinNo);
2606 fNestedLoopsList->Add(fEvaluateNestedLoops);
2607 // nested loops for integrated flow:
2608 if(fEvaluateIntFlowNestedLoops)
2609 {
2610 // correlations:
2611 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";
2612 intFlowDirectCorrelationsName += fAnalysisLabel->Data();
403e3389 2613 fIntFlowDirectCorrelations = new TProfile(intFlowDirectCorrelationsName.Data(),"Multiparticle correlations calculated with nested loops (for int. flow)",64,0,64,"s");
489d5531 2614 fNestedLoopsList->Add(fIntFlowDirectCorrelations);
403e3389 2615 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2616 {
2617 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";
2618 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();
2619 fIntFlowExtraDirectCorrelations = new TProfile(intFlowExtraDirectCorrelationsName.Data(),"Extra multiparticle correlations calculated with nested loops (for int. flow)",100,0,100,"s");
2620 fNestedLoopsList->Add(fIntFlowExtraDirectCorrelations);
403e3389 2621 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2622 // correction terms for non-uniform acceptance:
2623 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2624 {
2625 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";
2626 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
2627 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");
2628 fNestedLoopsList->Add(fIntFlowDirectCorrectionTermsForNUA[sc]);
2629 } // end of for(Int_t sc=0;sc<2;sc++)
2630 } // end of if(fEvaluateIntFlowNestedLoops)
2631
2632 // nested loops for differential flow:
2633 if(fEvaluateDiffFlowNestedLoops)
2634 {
2635 // reduced correlations:
2636 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";
2637 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();
2638 for(Int_t t=0;t<2;t++) // type: RP or POI
2639 {
62e36168 2640 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 2641 {
2642 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
2643 {
2644 // reduced correlations:
2645 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");
2646 fDiffFlowDirectCorrelations[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
2647 fNestedLoopsList->Add(fDiffFlowDirectCorrelations[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
2648 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
2649 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2650 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
64e500e3 2651
2652
489d5531 2653 // correction terms for non-uniform acceptance:
2654 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";
2655 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
2656 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
2657 {
62e36168 2658 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 2659 {
2660 for(Int_t sc=0;sc<2;sc++) // sin or cos
2661 {
2662 for(Int_t cti=0;cti<9;cti++) // correction term index
2663 {
2664 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");
2665 fNestedLoopsList->Add(fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]);
2666 }
2667 }
2668 }
64e500e3 2669 }
2670 // other differential correlators:
2671 TString otherDirectDiffCorrelatorsName = "fOtherDirectDiffCorrelators";
2672 otherDirectDiffCorrelatorsName += fAnalysisLabel->Data();
2673 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
2674 {
62e36168 2675 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 2676 {
2677 for(Int_t sc=0;sc<2;sc++) // sin or cos
2678 {
2679 for(Int_t ci=0;ci<1;ci++) // correlator index
2680 {
2681 fOtherDirectDiffCorrelators[t][pe][sc][ci] = new TProfile(Form("%s, %s, %s, %s, ci = %d",otherDirectDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1),Form("%s, %s, %s, %s, ci = %d",otherDirectDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1),1,lowerPtEtaEdge[pe],upperPtEtaEdge[pe]);
2682 fNestedLoopsList->Add(fOtherDirectDiffCorrelators[t][pe][sc][ci]);
2683 }
2684 }
2685 }
2686 }
3b552efe 2687 // number of RPs and POIs in selected pt and eta bins for cross-checkings:
2688 TString noOfParticlesInBinName = "fNoOfParticlesInBin";
2689 fNoOfParticlesInBin = new TH1D(noOfParticlesInBinName.Data(),"Number of RPs and POIs in selected p_{T} and #eta bin",4,0,4);
489d5531 2690 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(1,"# of RPs in p_{T} bin");
2691 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(2,"# of RPs in #eta bin");
2692 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(3,"# of POIs in p_{T} bin");
3b552efe 2693 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(4,"# of POIs in #eta bin");
489d5531 2694 fNestedLoopsList->Add(fNoOfParticlesInBin);
2695 } // end of if(fEvaluateDiffFlowNestedLoops)
2696
2697} // end of AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()
2698
489d5531 2699//================================================================================================================================
2700
489d5531 2701void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()
2702{
b84464d3 2703 // Calculate in this method all multiparticle azimuthal correlations.
2704 //
2705 // Remark 1: All multiparticle correlations are stored in TProfile fIntFlowCorrelationsAllPro;
2706 // Remark 2: There is a special TProfile fIntFlowCorrelationsPro holding results
2707 // only for same harmonic's correlations <<2>>, <<4>>, <<6>> and <<8>>;
2708 // Remark 3: Binning of fIntFlowCorrelationsAllPro is organized as follows:
2709 // --------------------------------------------------------------------------------------------------------------------
2710 // 1st bin: <2>_{1n|1n} = two1n1n = cos(1n(phi1-phi2))>
2711 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n(phi1-phi2))>
2712 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n(phi1-phi2))>
2713 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n(phi1-phi2))>
2714 // 5th bin: ---- EMPTY ----
2715 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n(2*phi1-phi2-phi3))>
2716 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n(3*phi1-2*phi2-phi3))>
2717 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n(4*phi1-2*phi2-2*phi3))>
2718 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n(4*phi1-3*phi2-phi3))>
2719 // 10th bin: ---- EMPTY ----
2720 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n(phi1+phi2-phi3-phi4))>
2721 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(n(2*phi1+phi2-2*phi3-phi4))>
2722 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(2n(phi1+phi2-phi3-phi4))>
2723 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n(3*phi1-phi2-phi3-phi4))>
2724 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n(3*phi1+phi2-3*phi3-phi4))>
2725 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n(3*phi1+phi2-2*phi3-2*phi4))>
2726 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n(4*phi1-2*phi2-phi3-phi4))>
2727 // 18th bin: ---- EMPTY ----
2728 // 19th bin: <5>_{2n,1n|1n,1n,1n} = five2n1n1n1n1n = <cos(n(2*phi1+phi2-phi3-phi4-phi5))>
2729 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n(2*phi1+2*phi2-2*phi3-phi4-phi5))>
2730 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n(3*phi1+phi2-2*phi3-phi4-phi5))>
2731 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n(4*phi1-phi2-phi3-phi4-phi5))>
2732 // 23rd bin: ---- EMPTY ----
2733 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n(phi1+phi2+phi3-phi4-phi5-phi6))>
2734 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n(2*phi1+phi2+phi3-2*phi4-phi5-phi6))>
2735 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n(2*phi1+2*phi2-phi3-phi4-phi5-phi6))>
2736 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n(3*phi1+phi2-phi3-phi4-phi5-phi6))>
2737 // 28th bin: ---- EMPTY ----
2738 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n(2*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
2739 // 30th bin: ---- EMPTY ----
2740 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
2741 // 32nd bin: ---- EMPTY ----
2742 // Extra correlations for v3{5} study:
2743 // 33rd bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n(4*phi1+2*phi2-3*phi3-3*phi4))>
2744 // 34th bin: <5>_{3n,3n|2n,2n,2n} = five3n3n2n2n2n = <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
2745 // Extra correlations for Teaney-Yan study:
2746 // 35th bin: <2>_{5n|5n} = two5n5n = <cos(5n(phi1-phi2)>
2747 // 36th bin: <2>_{6n|6n} = two6n6n = <cos(6n(phi1-phi2)>
2748 // 37th bin: <3>_{5n|3n,2n} = three5n3n2n = <cos(n(5*phi1-3*phi2-2*phi3)>
2749 // 38th bin: <3>_{5n|4n,1n} = three5n4n1n = <cos(n(5*phi1-4*phi2-1*phi3)>
2750 // 39th bin: <3>_{6n|3n,3n} = three6n3n3n = <cos(n(6*phi1-3*phi2-3*phi3)>
2751 // 40th bin: <3>_{6n|4n,2n} = three6n4n2n = <cos(n(6*phi1-4*phi2-2*phi3)>
2752 // 41st bin: <3>_{6n|5n,1n} = three6n5n1n = <cos(n(6*phi1-5*phi2-1*phi3)>
2753 // 42nd bin: <4>_{6n|3n,2n,1n} = four6n3n2n1n = <cos(n(6*phi1-3*phi2-2*phi3-1*phi4)>
2754 // 43rd bin: <4>_{3n,2n|3n,2n} = four3n2n3n2n = <cos(n(3*phi1+2*phi2-3*phi3-2*phi4)>
2755 // 44th bin: <4>_{4n,1n|3n,2n} = four4n1n3n2n = <cos(n(4*phi1+1*phi2-3*phi3-2*phi4)>
2756 // 45th bin: <4>_{3n,3n|3n,3n} = four3n3n3n3n = <cos(3n*(phi1+phi2-phi3-phi4))>
2757 // 46th bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n(4*phi1+2*phi2-3*phi3-3*phi4)>
2758 // 47th bin: <4>_{5n,1n|3n,3n} = four5n1n3n3n = <cos(n(5*phi1+1*phi2-3*phi3-3*phi4)>
2759 // 48th bin: <4>_{4n,2n|4n,2n} = four4n2n4n2n = <cos(n(4*phi1+2*phi2-4*phi3-2*phi4)>
2760 // 49th bin: <4>_{5n,1n|4n,2n} = four5n1n4n2n = <cos(n(5*phi1+1*phi2-4*phi3-2*phi4)>
2761 // 50th bin: <4>_{5n|3n,1n,1n} = four5n3n1n1n = <cos(n(5*phi1-3*phi2-1*phi3-1*phi4)>
2762 // 51st bin: <4>_{5n|2n,2n,1n} = four5n2n2n1n = <cos(n(5*phi1-2*phi2-2*phi3-1*phi4)>
2763 // 52nd bin: <4>_{5n,1n|5n,1n} = four5n1n5n1n = <cos(n(5*phi1+1*phi2-5*phi3-1*phi4)>
2764 // 53rd bin: <5>_{3n,3n|3n,2n,1n} = five3n3n3n2n1n = <cos(n(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
2765 // 54th bin: <5>_{4n,2n|3n,2n,1n} = five4n2n3n2n1n = <cos(n(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
2766 // 55th bin: <5>_{3n,2n|3n,1n,1n} = five3n2n3n1n1n = <cos(n(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
2767 // 56th bin: <5>_{3n,2n|2n,2n,1n} = five3n2n2n2n1n = <cos(n(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
2768 // 57th bin: <5>_{5n,1n|3n,2n,1n} = five5n1n3n2n1n = <cos(n(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
2769 // 58th bin: <6>_{3n,2n,1n|3n,2n,1n} = six3n2n1n3n2n1n = <cos(n(3*phi1+2*phi2+1*phi3-3*phi4-2*phi5-1*phi6)>
403e3389 2770 // Extra correlations for Teaney-Yan study (B):
2771 // 59th bin: <4>_{6n|4n,1n,1n} = four6n4n1n1n = <cos(n(6*phi1-4*phi2-1*phi3-1*phi4)>
2772 // 60th bin: <4>_{6n|2n,2n,2n} = four6n2n2n2n = <cos(n(6*phi1-2*phi2-2*phi3-2*phi4)>
2773 // 61st bin: <5>_{6n|2n,2n,1n,1n} = five6n2n2n1n1n = <cos(n(6*phi1-2*phi2-2*phi3-1*phi4-1*phi5)>
2774 // 62nd bin: <5>_{4n,1n,1n|3n,3n} = five4n1n1n3n3n = <cos(n(4*phi1+1*phi2+1*phi3-3*phi4-3*phi5)>
2775 // 63rd bin: <6>_{3n,3n|2n,2n,1n,1n} = six3n3n2n2n1n1n = <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-1*phi5-1*phi6)>
b84464d3 2776 // --------------------------------------------------------------------------------------------------------------------
403e3389 2777
2778 // Multiplicity of an event:
1268c371 2779 Double_t dMult = (*fSpk)(0,0);
b84464d3 2780 // Real parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n, 4n, 5n and 6n:
489d5531 2781 Double_t dReQ1n = (*fReQ)(0,0);
2782 Double_t dReQ2n = (*fReQ)(1,0);
2783 Double_t dReQ3n = (*fReQ)(2,0);
2784 Double_t dReQ4n = (*fReQ)(3,0);
b84464d3 2785 Double_t dReQ5n = (*fReQ)(4,0);
8ed4edc7 2786 Double_t dReQ6n = (*fReQ)(5,0);
b84464d3 2787 // Imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n, 4n, 5n and 6n:
489d5531 2788 Double_t dImQ1n = (*fImQ)(0,0);
2789 Double_t dImQ2n = (*fImQ)(1,0);
2790 Double_t dImQ3n = (*fImQ)(2,0);
2791 Double_t dImQ4n = (*fImQ)(3,0);
b84464d3 2792 Double_t dImQ5n = (*fImQ)(4,0);
8ed4edc7 2793 Double_t dImQ6n = (*fImQ)(5,0);
489d5531 2794
b84464d3 2795 // Real parts of expressions involving various combinations of Q-vectors which appears
2796 // simultaneously in several equations for multiparticle correlations bellow:
2797 // Re[Q_{2n}Q_{n}^*Q_{n}^*]
2798 Double_t reQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dReQ2n;
2799 // Re[Q_{6n}Q_{3n}^*Q_{3n}^*]
2800 Double_t reQ6nQ3nstarQ3nstar = pow(dReQ3n,2.)*dReQ6n+2.*dReQ3n*dImQ3n*dImQ6n-pow(dImQ3n,2.)*dReQ6n;
2801 // Re[Q_{4n}Q_{2n}^*Q_{2n}^*]
489d5531 2802 Double_t reQ4nQ2nstarQ2nstar = pow(dReQ2n,2.)*dReQ4n+2.*dReQ2n*dImQ2n*dImQ4n-pow(dImQ2n,2.)*dReQ4n;
b84464d3 2803 // Re[Q_{4n}Q_{3n}^*Q_{n}^*]
489d5531 2804 Double_t reQ4nQ3nstarQ1nstar = dReQ4n*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)+dImQ4n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);
b84464d3 2805 // Re[Q_{3n}Q_{2n}^*Q_{n}^*]
489d5531 2806 Double_t reQ3nQ2nstarQ1nstar = dReQ3n*dReQ2n*dReQ1n-dReQ3n*dImQ2n*dImQ1n+dImQ3n*dReQ2n*dImQ1n
b84464d3 2807 + dImQ3n*dImQ2n*dReQ1n;
2808 // Re[Q_{5n}Q_{3n}^*Q_{2n}^*]
2809 Double_t reQ5nQ3nstarQ2nstar = dReQ5n*dReQ2n*dReQ3n-dReQ5n*dImQ2n*dImQ3n+dImQ5n*dReQ2n*dImQ3n
2810 + dImQ5n*dImQ2n*dReQ3n;
2811 // Re[Q_{5n}Q_{4n}^*Q_{1n}^*]
2812 Double_t reQ5nQ4nstarQ1nstar = dReQ5n*dReQ4n*dReQ1n-dReQ5n*dImQ4n*dImQ1n+dImQ5n*dReQ4n*dImQ1n
2813 + dImQ5n*dImQ4n*dReQ1n;
2814 // Re[Q_{6n}Q_{5n}^*Q_{1n}^*]
2815 Double_t reQ6nQ5nstarQ1nstar = dReQ6n*dReQ5n*dReQ1n-dReQ6n*dImQ5n*dImQ1n+dImQ6n*dReQ5n*dImQ1n
2816 + dImQ6n*dImQ5n*dReQ1n;
2817 // Re[Q_{6n}Q_{4n}^*Q_{2n}^*]
2818 Double_t reQ6nQ4nstarQ2nstar = dReQ6n*dReQ4n*dReQ2n-dReQ6n*dImQ4n*dImQ2n+dImQ6n*dReQ4n*dImQ2n
2819 + dImQ6n*dImQ4n*dReQ2n;
2820 // Re[Q_{3n}Q_{n}Q_{2n}^*Q_{2n}^*]
2821 Double_t reQ3nQ1nQ2nstarQ2nstar = (pow(dReQ2n,2.)-pow(dImQ2n,2.))*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)
2822 + 2.*dReQ2n*dImQ2n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);
2823 // Re[Q_{3n}Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2824 Double_t reQ3nQ1nstarQ1nstarQ1nstar = dReQ3n*pow(dReQ1n,3)-3.*dReQ1n*dReQ3n*pow(dImQ1n,2)
2825 + 3.*dImQ1n*dImQ3n*pow(dReQ1n,2)-dImQ3n*pow(dImQ1n,3);
403e3389 2826 // Re[Q_{6n}Q_{2n}^*Q_{2n}^*Q_{2n}^*]
2827 Double_t reQ6nQ2nstarQ2nstarQ2nstar = dReQ6n*pow(dReQ2n,3)-3.*dReQ2n*dReQ6n*pow(dImQ2n,2)
2828 + 3.*dImQ2n*dImQ6n*pow(dReQ2n,2)-dImQ6n*pow(dImQ2n,3);
b84464d3 2829 // Re[Q_{4n}Q_{2n}^*Q_{n}^*Q_{n}^*]
2830 Double_t reQ4nQ2nstarQ1nstarQ1nstar = (dReQ4n*dReQ2n+dImQ4n*dImQ2n)*(pow(dReQ1n,2)-pow(dImQ1n,2))
2831 + 2.*dReQ1n*dImQ1n*(dImQ4n*dReQ2n-dReQ4n*dImQ2n);
2832 // Re[Q_{4n}Q_{2n}^*Q_{3n}^*Q_{3n}^*]
2833 Double_t reQ4nQ2nQ3nstarQ3nstar = (dReQ4n*dReQ2n-dImQ4n*dImQ2n)*(dReQ3n*dReQ3n-dImQ3n*dImQ3n)
2834 + 2.*(dReQ4n*dImQ2n+dImQ4n*dReQ2n)*dReQ3n*dImQ3n;
2835 // Re[Q_{4n}Q_{n}Q_{3n}^*Q_{2n}^*]
2836 Double_t reQ4nQ1nQ3nstarQ2nstar = dImQ1n*dImQ2n*dImQ3n*dImQ4n+dImQ3n*dImQ4n*dReQ1n*dReQ2n
2837 + dImQ2n*dImQ4n*dReQ1n*dReQ3n-dImQ1n*dImQ4n*dReQ2n*dReQ3n
2838 - dImQ2n*dImQ3n*dReQ1n*dReQ4n+dImQ1n*dImQ3n*dReQ2n*dReQ4n
2839 + dImQ1n*dImQ2n*dReQ3n*dReQ4n+dReQ1n*dReQ2n*dReQ3n*dReQ4n;
2840 // Re[Q_{5n}Q_{n}Q_{4n}^*Q_{2n}^*]
2841 Double_t reQ5nQ1nQ4nstarQ2nstar = dImQ1n*dImQ2n*dImQ4n*dImQ5n+dImQ4n*dImQ5n*dReQ1n*dReQ2n
2842 + dImQ2n*dImQ5n*dReQ1n*dReQ4n-dImQ1n*dImQ5n*dReQ2n*dReQ4n
2843 - dImQ2n*dImQ4n*dReQ1n*dReQ5n+dImQ1n*dImQ4n*dReQ2n*dReQ5n
2844 + dImQ1n*dImQ2n*dReQ4n*dReQ5n+dReQ1n*dReQ2n*dReQ4n*dReQ5n;
2845 // Re[Q_{5n}Q_{n}Q_{3n}^*Q_{3n}^*]
2846 Double_t reQ5nQ1nQ3nstarQ3nstar = dImQ1n*pow(dImQ3n,2.)*dImQ5n+2.*dImQ3n*dImQ5n*dReQ1n*dReQ3n
2847 - dImQ1n*dImQ5n*pow(dReQ3n,2.)-pow(dImQ3n,2.)*dReQ1n*dReQ5n
2848 + 2.*dImQ1n*dImQ3n*dReQ3n*dReQ5n+dReQ1n*pow(dReQ3n,2.)*dReQ5n;
2849 // Re[Q_{5n}Q_{3n}^*Q_{n}^*Q_{n}^*]
2850 Double_t reQ5nQ3nstarQ1nstarQ1nstar = -pow(dImQ1n,2.)*dImQ3n*dImQ5n+dImQ3n*dImQ5n*pow(dReQ1n,2.)
2851 + 2.*dImQ1n*dImQ5n*dReQ1n*dReQ3n-2.*dImQ1n*dImQ3n*dReQ1n*dReQ5n
2852 - pow(dImQ1n,2.)*dReQ3n*dReQ5n+pow(dReQ1n,2.)*dReQ3n*dReQ5n;
2853 // Re[Q_{5n}Q_{2n}^*Q_{2n}^*Q_{n}^*]
2854 Double_t reQ5nQ2nstarQ2nstarQ1nstar = -pow(dImQ2n,2.)*dImQ1n*dImQ5n+dImQ1n*dImQ5n*pow(dReQ2n,2.)
2855 + 2.*dImQ2n*dImQ5n*dReQ2n*dReQ1n-2.*dImQ2n*dImQ1n*dReQ2n*dReQ5n
403e3389 2856 - pow(dImQ2n,2.)*dReQ1n*dReQ5n+pow(dReQ2n,2.)*dReQ1n*dReQ5n;
2857 // Re[Q_{6n}Q_{4n}^*Q_{n}^*Q_{n}^*]
2858 Double_t reQ6nQ4nstarQ1nstarQ1nstar = -pow(dImQ1n,2.)*dImQ4n*dImQ6n+dImQ4n*dImQ6n*pow(dReQ1n,2.)
2859 + 2.*dImQ1n*dImQ6n*dReQ1n*dReQ4n-2.*dImQ1n*dImQ4n*dReQ1n*dReQ6n
2860 - pow(dImQ1n,2.)*dReQ4n*dReQ6n+pow(dReQ1n,2.)*dReQ4n*dReQ6n;
489d5531 2861 // |Q_{2n}|^2 |Q_{n}|^2
2862 Double_t dQ2nQ1nQ2nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));
b84464d3 2863 // |Q_{4n}|^2 |Q_{2n}|^2
2864 Double_t dQ4nQ2nQ4nstarQ2nstar = (pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.));
2865 // |Q_{3n}|^2 |Q_{2n}|^2
2866 Double_t dQ3nQ2nQ3nstarQ2nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.));
2867 // |Q_{5n}|^2 |Q_{n}|^2
2868 Double_t dQ5nQ1nQ5nstarQ1nstar = (pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));
2869 // Re[Q_{2n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2870 Double_t reQ2nQ1nQ1nstarQ1nstarQ1nstar = (dReQ2n*dReQ1n-dImQ2n*dImQ1n)*(pow(dReQ1n,3)-3.*dReQ1n*pow(dImQ1n,2))
b84464d3 2871 + (dReQ2n*dImQ1n+dReQ1n*dImQ2n)*(3.*dImQ1n*pow(dReQ1n,2)-pow(dImQ1n,3));
2872 // Re[Q_{2n}Q_{2n}Q_{2n}^*Q_{n}^*Q_{n}^*]
489d5531 2873 Double_t reQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))
2874 * (dReQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) + 2.*dImQ2n*dReQ1n*dImQ1n);
b84464d3 2875 // Re[Q_{4n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2876 Double_t reQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dReQ4n-6.*pow(dReQ1n,2.)*dReQ4n*pow(dImQ1n,2.)
2877 + pow(dImQ1n,4.)*dReQ4n+4.*pow(dReQ1n,3.)*dImQ1n*dImQ4n
2878 - 4.*pow(dImQ1n,3.)*dReQ1n*dImQ4n;
b84464d3 2879 // Re[Q_{3n}Q_{n}Q_{2n}^*Q_{n}^*Q_{n}^*]
489d5531 2880 Double_t reQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))
b84464d3 2881 * (dReQ1n*dReQ2n*dReQ3n-dReQ3n*dImQ1n*dImQ2n
2882 + dReQ2n*dImQ1n*dImQ3n+dReQ1n*dImQ2n*dImQ3n);
2883 // Re[Q_{6n}Q_{n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2884 Double_t reQ6nQ3nstarQ2nstarQ1nstar = dReQ1n*dReQ2n*dReQ3n*dReQ6n-dReQ3n*dReQ6n*dImQ1n*dImQ2n
2885 - dReQ2n*dReQ6n*dImQ1n*dImQ3n-dReQ1n*dReQ6n*dImQ2n*dImQ3n
2886 + dReQ2n*dReQ3n*dImQ1n*dImQ6n+dReQ1n*dReQ3n*dImQ2n*dImQ6n
2887 + dReQ1n*dReQ2n*dImQ3n*dImQ6n-dImQ1n*dImQ2n*dImQ3n*dImQ6n;
2888 // Re[Q_{3n}Q_{3n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2889 Double_t reQ3nQ3nQ3nstarQ2nstarQ1nstar = (pow(dImQ3n,2.)+pow(dReQ3n,2.))
2890 * (dImQ2n*dImQ3n*dReQ1n+dImQ1n*dImQ3n*dReQ2n
2891 - dImQ1n*dImQ2n*dReQ3n+dReQ1n*dReQ2n*dReQ3n);
2892 // Re[Q_{3n}Q_{3n}Q_{2n}^*Q_{2n}^*Q_{2n}^*]
2893 Double_t reQ3nQ3nQ2nstarQ2nstarQ2nstar = pow(dReQ2n,3.)*pow(dReQ3n,2.)
2894 - 3.*dReQ2n*pow(dReQ3n,2.)*pow(dImQ2n,2.)
2895 + 6.*pow(dReQ2n,2.)*dReQ3n*dImQ2n*dImQ3n
2896 - 2.*dReQ3n*pow(dImQ2n,3.)*dImQ3n-pow(dReQ2n,3.)*pow(dImQ3n,2.)
2897 + 3.*dReQ2n*pow(dImQ2n,2.)*pow(dImQ3n,2.);
2898 // Re[Q_{4n}Q_{2n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2899 Double_t reQ4nQ2nQ3nstarQ2nstarQ1nstar = (pow(dImQ2n,2.)+pow(dReQ2n,2.))
2900 * (dImQ3n*dImQ4n*dReQ1n+dImQ1n*dImQ4n*dReQ3n
2901 - dImQ1n*dImQ3n*dReQ4n+dReQ1n*dReQ3n*dReQ4n);
2902 // Re[Q_{3n}Q_{2n}Q_{3n}^*Q_{n}^*Q_{n}^*]
2903 Double_t reQ3nQ2nQ3nstarQ1nstarQ1nstar = -(pow(dImQ3n,2.)+pow(dReQ3n,2.))
2904 * (-2.*dImQ1n*dImQ2n*dReQ1n+pow(dImQ1n,2.)*dReQ2n-pow(dReQ1n,2.)*dReQ2n);
2905 // Re[Q_{3n}Q_{2n}Q_{2n}^*Q_{2n}^*Q_{n}^*]
2906 Double_t reQ3nQ2nQ2nstarQ2nstarQ1nstar = (pow(dImQ2n,2.)+pow(dReQ2n,2.))
2907 * (dImQ2n*dImQ3n*dReQ1n+dImQ1n*dImQ3n*dReQ2n
2908 - dImQ1n*dImQ2n*dReQ3n+dReQ1n*dReQ2n*dReQ3n);
2909 // Re[Q_{5n}Q_{n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2910 Double_t reQ5nQ1nQ3nstarQ2nstarQ1nstar = (pow(dImQ1n,2.)+pow(dReQ1n,2.))
2911 * (dImQ3n*dImQ5n*dReQ2n+dImQ2n*dImQ5n*dReQ3n
2912 - dImQ2n*dImQ3n*dReQ5n+dReQ2n*dReQ3n*dReQ5n);
2913 // Re[Q_{2n}Q_{2n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2914 Double_t reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)*dReQ2n-2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)
2915 + dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dImQ2n)
2916 * (pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)
b84464d3 2917 - dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n+pow(dImQ1n,2.)*dImQ2n);
2918 // Re[Q_{3n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2919 Double_t reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))
2920 * (pow(dReQ1n,3.)*dReQ3n-3.*dReQ1n*dReQ3n*pow(dImQ1n,2.)
2921 + 3.*pow(dReQ1n,2.)*dImQ1n*dImQ3n-pow(dImQ1n,3.)*dImQ3n);
489d5531 2922 // |Q_{2n}|^2 |Q_{n}|^4
b84464d3 2923 Double_t dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.);
2924 // |Q_{3n}|^2 |Q_{2n}|^2 |Q_{n}|^2
2925 Double_t dQ3nQ2nQ1nQ3nstarQ2nstarQ1nstar = (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
2926 * (pow(dReQ1n,2.)+pow(dImQ1n,2.));
2927 // Re[Q_{2n}Q_{n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2928 Double_t reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
2929 * (pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)
2930 + 2.*dReQ1n*dImQ1n*dImQ2n);
489d5531 2931
b84464d3 2932 // Results for multiparticle azimuthal correlations:
489d5531 2933 // 2-particle:
b84464d3 2934 Double_t two1n1n = 0.; // <cos(n(phi1-phi2))>
2935 Double_t two2n2n = 0.; // <cos(2n(phi1-phi2))>
2936 Double_t two3n3n = 0.; // <cos(3n(phi1-phi2))>
2937 Double_t two4n4n = 0.; // <cos(4n(phi1-phi2))>
489d5531 2938 if(dMult>1)
2939 {
2940 two1n1n = (pow(dReQ1n,2.)+pow(dImQ1n,2.)-dMult)/(dMult*(dMult-1.));
2941 two2n2n = (pow(dReQ2n,2.)+pow(dImQ2n,2.)-dMult)/(dMult*(dMult-1.));
2942 two3n3n = (pow(dReQ3n,2.)+pow(dImQ3n,2.)-dMult)/(dMult*(dMult-1.));
2943 two4n4n = (pow(dReQ4n,2.)+pow(dImQ4n,2.)-dMult)/(dMult*(dMult-1.));
b84464d3 2944 // Average 2-particle correlations for single event:
489d5531 2945 fIntFlowCorrelationsAllEBE->SetBinContent(1,two1n1n);
2946 fIntFlowCorrelationsAllEBE->SetBinContent(2,two2n2n);
2947 fIntFlowCorrelationsAllEBE->SetBinContent(3,two3n3n);
b84464d3 2948 fIntFlowCorrelationsAllEBE->SetBinContent(4,two4n4n);
2949 // Average 2-particle correlations for all events:
2950 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1n,dMult*(dMult-1.));
2951 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2n,dMult*(dMult-1.));
2952 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3n,dMult*(dMult-1.));
2953 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4n,dMult*(dMult-1.));
2954 // Store separetately <2>:
2955 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1n); // <2>
2956 // Testing other multiplicity weights:
489d5531 2957 Double_t mWeight2p = 0.;
2958 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
2959 {
2960 mWeight2p = dMult*(dMult-1.);
2961 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
2962 {
2963 mWeight2p = 1.;
2964 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
2965 {
2966 mWeight2p = dMult;
b84464d3 2967 }
489d5531 2968 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,mWeight2p); // eW_<2>
2969 fIntFlowCorrelationsPro->Fill(0.5,two1n1n,mWeight2p);
b40a910e 2970 fIntFlowSquaredCorrelationsPro->Fill(0.5,two1n1n*two1n1n,mWeight2p);
2971 if(fCalculateCumulantsVsM)
2972 {
2973 fIntFlowCorrelationsVsMPro[0]->Fill(dMult+0.5,two1n1n,mWeight2p);
2974 fIntFlowSquaredCorrelationsVsMPro[0]->Fill(dMult+0.5,two1n1n*two1n1n,mWeight2p);
2975 }
3435cacb 2976 if(fCalculateAllCorrelationsVsM)
2977 {
2978 fIntFlowCorrelationsAllVsMPro[0]->Fill(dMult+0.5,two1n1n,mWeight2p);
2979 fIntFlowCorrelationsAllVsMPro[1]->Fill(dMult+0.5,two2n2n,mWeight2p);
2980 fIntFlowCorrelationsAllVsMPro[2]->Fill(dMult+0.5,two3n3n,mWeight2p);
2981 fIntFlowCorrelationsAllVsMPro[3]->Fill(dMult+0.5,two4n4n,mWeight2p);
2982 }
489d5531 2983 } // end of if(dMult>1)
2984
2985 // 3-particle:
b84464d3 2986 Double_t three2n1n1n = 0.; // <cos(n(2*phi1-phi2-phi3))>
2987 Double_t three3n2n1n = 0.; // <cos(n(3*phi1-2*phi2-phi3))>
2988 Double_t three4n2n2n = 0.; // <cos(n(4*phi1-2*phi2-2*phi3))>
2989 Double_t three4n3n1n = 0.; // <cos(n(4*phi1-3*phi2-phi3))>
489d5531 2990 if(dMult>2)
2991 {
2992 three2n1n1n = (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
2993 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
2994 / (dMult*(dMult-1.)*(dMult-2.));
2995 three3n2n1n = (reQ3nQ2nstarQ1nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))
2996 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))
2997 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
2998 / (dMult*(dMult-1.)*(dMult-2.));
2999 three4n2n2n = (reQ4nQ2nstarQ2nstar-2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3000 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*dMult)
3001 / (dMult*(dMult-1.)*(dMult-2.));
3002 three4n3n1n = (reQ4nQ3nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3003 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))
3004 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
b84464d3 3005 / (dMult*(dMult-1.)*(dMult-2.));
3006 // Average 3-particle correlations for single event:
489d5531 3007 fIntFlowCorrelationsAllEBE->SetBinContent(6,three2n1n1n);
3008 fIntFlowCorrelationsAllEBE->SetBinContent(7,three3n2n1n);
3009 fIntFlowCorrelationsAllEBE->SetBinContent(8,three4n2n2n);
3010 fIntFlowCorrelationsAllEBE->SetBinContent(9,three4n3n1n);
b84464d3 3011 // Average 3-particle correlations for all events:
489d5531 3012 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.));
3013 fIntFlowCorrelationsAllPro->Fill(6.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));
3014 fIntFlowCorrelationsAllPro->Fill(7.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.));
3435cacb 3015 fIntFlowCorrelationsAllPro->Fill(8.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.));
b84464d3 3016 // Average 3-particle correlations vs M for all events:
3435cacb 3017 if(fCalculateAllCorrelationsVsM)
3018 {
3019 fIntFlowCorrelationsAllVsMPro[5]->Fill(dMult+0.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.));
3020 fIntFlowCorrelationsAllVsMPro[6]->Fill(dMult+0.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));
3021 fIntFlowCorrelationsAllVsMPro[7]->Fill(dMult+0.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.));
3022 fIntFlowCorrelationsAllVsMPro[8]->Fill(dMult+0.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.));
3023 }
489d5531 3024 } // end of if(dMult>2)
3025
3026 // 4-particle:
b84464d3 3027 Double_t four1n1n1n1n = 0.; // <cos(n(phi1+phi2-phi3-phi4))>
3028 Double_t four2n2n2n2n = 0.; // <cos(2n(phi1+phi2-phi3-phi4))>
3029 Double_t four2n1n2n1n = 0.; // <cos(n(2*phi1+phi2-2*phi3-phi4))>
3030 Double_t four3n1n1n1n = 0.; // <cos(n(3*phi1-phi2-phi3-phi4))>
3031 Double_t four4n2n1n1n = 0.; // <cos(n(4*phi1-2*phi2-phi3-phi4))>
3032 Double_t four3n1n2n2n = 0.; // <cos(n(3*phi1+phi2-2*phi3-2*phi4))>
3033 Double_t four3n1n3n1n = 0.; // <cos(n(3*phi1+phi2-3*phi3-phi4))>
489d5531 3034 if(dMult>3)
3035 {
3036 four1n1n1n1n = (2.*dMult*(dMult-3.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ1n,2.)
3037 + pow(dImQ1n,2.))-2.*reQ2nQ1nstarQ1nstar+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))
3038 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3039 four2n2n2n2n = (2.*dMult*(dMult-3.)+pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ2n,2.)
3040 + pow(dImQ2n,2.))-2.*reQ4nQ2nstarQ2nstar+(pow(dReQ4n,2.)+pow(dImQ4n,2.)))
3041 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3042 four2n1n2n1n = (dQ2nQ1nQ2nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar-2.*reQ2nQ1nstarQ1nstar)
3043 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3044 - ((dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3045 + (dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-(pow(dReQ3n,2.)+pow(dImQ3n,2.)))
3046 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3047 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3048 four3n1n1n1n = (reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar-3.*reQ2nQ1nstarQ1nstar
3049 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
489d5531 3050 + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3051 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3052 four4n2n1n1n = (reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar)
3053 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3054 - (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3055 - 3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))
3056 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3057 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3058 four3n1n2n2n = (reQ3nQ1nQ2nstarQ2nstar-reQ4nQ2nstarQ2nstar-reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar)
489d5531 3059 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
b84464d3 3060 - (2.*reQ2nQ1nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
489d5531 3061 - 4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))
3062 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3063 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));
3064 four3n1n3n1n = ((pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
b84464d3 3065 - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar
3066 + pow(dReQ4n,2.)+pow(dImQ4n,2.)-(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3067 + pow(dReQ2n,2.)+pow(dImQ2n,2.)-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3068 + dMult*(dMult-6.))
3069 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3070 // Average 4-particle correlations for single event:
489d5531 3071 fIntFlowCorrelationsAllEBE->SetBinContent(11,four1n1n1n1n);
3072 fIntFlowCorrelationsAllEBE->SetBinContent(12,four2n1n2n1n);
3073 fIntFlowCorrelationsAllEBE->SetBinContent(13,four2n2n2n2n);
3074 fIntFlowCorrelationsAllEBE->SetBinContent(14,four3n1n1n1n);
3075 fIntFlowCorrelationsAllEBE->SetBinContent(15,four3n1n3n1n);
3076 fIntFlowCorrelationsAllEBE->SetBinContent(16,four3n1n2n2n);
b84464d3 3077 fIntFlowCorrelationsAllEBE->SetBinContent(17,four4n2n1n1n);
3078 // Average 4-particle correlations for all events:
489d5531 3079 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3080 fIntFlowCorrelationsAllPro->Fill(11.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3081 fIntFlowCorrelationsAllPro->Fill(12.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3082 fIntFlowCorrelationsAllPro->Fill(13.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3083 fIntFlowCorrelationsAllPro->Fill(14.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3084 fIntFlowCorrelationsAllPro->Fill(15.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3085 fIntFlowCorrelationsAllPro->Fill(16.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3086 // Average 4-particle correlations vs M for all events:
3435cacb 3087 if(fCalculateAllCorrelationsVsM)
3088 {
3089 fIntFlowCorrelationsAllVsMPro[10]->Fill(dMult+0.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3090 fIntFlowCorrelationsAllVsMPro[11]->Fill(dMult+0.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3091 fIntFlowCorrelationsAllVsMPro[12]->Fill(dMult+0.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3092 fIntFlowCorrelationsAllVsMPro[13]->Fill(dMult+0.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3093 fIntFlowCorrelationsAllVsMPro[14]->Fill(dMult+0.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3094 fIntFlowCorrelationsAllVsMPro[15]->Fill(dMult+0.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3095 fIntFlowCorrelationsAllVsMPro[16]->Fill(dMult+0.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3096 }
3097 // Store separetately <4>:
489d5531 3098 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1n); // <4>
b84464d3 3099 // Testing other multiplicity weights:
489d5531 3100 Double_t mWeight4p = 0.;
3101 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3102 {
3103 mWeight4p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.);
3104 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3105 {
3106 mWeight4p = 1.;
3107 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3108 {
3109 mWeight4p = dMult;
b84464d3 3110 }
489d5531 3111 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,mWeight4p); // eW_<4>
3112 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1n,mWeight4p);
b40a910e 3113 fIntFlowSquaredCorrelationsPro->Fill(1.5,four1n1n1n1n*four1n1n1n1n,mWeight4p);
3114 if(fCalculateCumulantsVsM)
3115 {
3116 fIntFlowCorrelationsVsMPro[1]->Fill(dMult+0.5,four1n1n1n1n,mWeight4p);
3117 fIntFlowSquaredCorrelationsVsMPro[1]->Fill(dMult+0.5,four1n1n1n1n*four1n1n1n1n,mWeight4p);
3118 }
489d5531 3119 } // end of if(dMult>3)
3120
3121 // 5-particle:
b84464d3 3122 Double_t five2n1n1n1n1n = 0.; // <cos(n(2*phi1+phi2-phi3-phi4-phi5))>
3123 Double_t five2n2n2n1n1n = 0.; // <cos(n(2*phi1+2*phi2-2*phi3-phi4-phi5))>
3124 Double_t five3n1n2n1n1n = 0.; // <cos(n(3*phi1+phi2-2*phi3-phi4-phi5))>
3125 Double_t five4n1n1n1n1n = 0.; // <cos(n(4*phi1-phi2-phi3-phi4-phi5))>
489d5531 3126 if(dMult>4)
b84464d3 3127 {
3128 five2n1n1n1n1n = (reQ2nQ1nQ1nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar+5.*reQ3nQ2nstarQ1nstar
3129 - 3.*(dMult-5.)*reQ2nQ1nstarQ1nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3130 - 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3131 + 3.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3132 - 3.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3133 + 6.*(2.*dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult*(dMult-4.))
489d5531 3134 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3135 five2n2n2n1n1n = (reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ3nQ1nQ2nstarQ2nstar
3136 + 3.*reQ4nQ2nstarQ2nstar+8.*reQ3nQ2nstarQ1nstar+2.*reQ4nQ3nstarQ1nstar
3137 - 2.*(dMult-6.)*reQ2nQ1nstarQ1nstar
3138 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3139 - pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)
3140 + 2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3141 - 4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3142 + 4.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
489d5531 3143 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3144 five4n1n1n1n1n = (reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ4nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nstarQ1nstarQ1nstar
3145 + 8.*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+12.*reQ3nQ2nstarQ1nstar+12.*reQ2nQ1nstarQ1nstar
3146 - 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-8.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3147 - 12.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+24.*dMult)
3148 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3149 five3n1n2n1n1n = (reQ3nQ1nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar
3150 - reQ3nQ1nQ2nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar+reQ4nQ2nstarQ2nstar
3151 - (2.*dMult-13.)*reQ3nQ2nstarQ1nstar+7.*reQ2nQ1nstarQ1nstar
3152 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3153 + 2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3154 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3155 + 2.*(dMult-6.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
489d5531 3156 - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3157 - pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
b84464d3 3158 + 2.*(3.*dMult-11.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3159 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3160 // Average 5-particle correlations for single event:
489d5531 3161 fIntFlowCorrelationsAllEBE->SetBinContent(19,five2n1n1n1n1n);
3162 fIntFlowCorrelationsAllEBE->SetBinContent(20,five2n2n2n1n1n);
3163 fIntFlowCorrelationsAllEBE->SetBinContent(21,five3n1n2n1n1n);
b84464d3 3164 fIntFlowCorrelationsAllEBE->SetBinContent(22,five4n1n1n1n1n);
3165 // Average 5-particle correlations for all events:
489d5531 3166 fIntFlowCorrelationsAllPro->Fill(18.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3167 fIntFlowCorrelationsAllPro->Fill(19.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3168 fIntFlowCorrelationsAllPro->Fill(20.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3169 fIntFlowCorrelationsAllPro->Fill(21.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3170 // Average 5-particle correlations vs M for all events:
3435cacb 3171 if(fCalculateAllCorrelationsVsM)
3172 {
3173 fIntFlowCorrelationsAllVsMPro[18]->Fill(dMult+0.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3174 fIntFlowCorrelationsAllVsMPro[19]->Fill(dMult+0.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3175 fIntFlowCorrelationsAllVsMPro[20]->Fill(dMult+0.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3176 fIntFlowCorrelationsAllVsMPro[21]->Fill(dMult+0.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3177 }
489d5531 3178 } // end of if(dMult>4)
3179
3180 // 6-particle:
b84464d3 3181 Double_t six1n1n1n1n1n1n = 0.; // <cos(n(phi1+phi2+phi3-phi4-phi5-phi6))>
3182 Double_t six2n2n1n1n1n1n = 0.; // <cos(n(2*phi1+2*phi2-phi3-phi4-phi5-phi6))>
3183 Double_t six3n1n1n1n1n1n = 0.; // <cos(n(3*phi1+phi2-phi3-phi4-phi5-phi6))>
3184 Double_t six2n1n1n2n1n1n = 0.; // <cos(n(2*phi1+phi2+phi3-2*phi4-phi5-phi6))>
489d5531 3185 if(dMult>5)
3186 {
b84464d3 3187 six1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)-6.*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3188 + 4.*reQ3nQ1nstarQ1nstarQ1nstar-12.*reQ3nQ2nstarQ1nstar+18.*(dMult-4.)*reQ2nQ1nstarQ1nstar
3189 + 9.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3190 + 4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))-9.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3191 - 9.*(dMult-4.)*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3192 + 18.*(dMult*dMult-7.*dMult+10.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3193 - 6.*dMult*(dMult*dMult-9.*dMult+20.))
3194 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3195 six2n1n1n2n1n1n = (dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3196 - 4.*reQ2nQ1nQ1nstarQ1nstarQ1nstar-2.*reQ2nQ2nQ2nstarQ1nstarQ1nstar
3197 + 4.*reQ4nQ2nstarQ1nstarQ1nstar+4.*reQ3nQ1nQ2nstarQ2nstar+4.*reQ3nQ1nstarQ1nstarQ1nstar
3198 - 8.*reQ4nQ3nstarQ1nstar-4.*reQ4nQ2nstarQ2nstar+4.*(2.*dMult-13.)*reQ3nQ2nstarQ1nstar
3199 + 2.*(7.*dMult-34.)*reQ2nQ1nstarQ1nstar+4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3200 - 4.*(dMult-7.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3201 + 4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-4.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3202 + pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+(2.*dMult*dMult-27.*dMult+76.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3203 - (dMult-12.)*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3204 + 4.*(dMult*dMult-15.*dMult+34.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3205 - 2.*dMult*(dMult*dMult-17.*dMult+60.))
3206 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3207 six2n2n1n1n1n1n = (reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ1nstarQ1nstarQ1nstarQ1nstar
3208 - 8.*reQ2nQ1nQ1nstarQ1nstarQ1nstar+8.*reQ3nQ1nstarQ1nstarQ1nstar+6.*reQ4nQ2nstarQ1nstarQ1nstar
3209 + 8.*reQ3nQ1nQ2nstarQ2nstar-40.*reQ3nQ2nstarQ1nstar-8.*reQ4nQ3nstarQ1nstar-9.*reQ4nQ2nstarQ2nstar
3210 + 24.*(dMult-4.)*reQ2nQ1nstarQ1nstar+24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3211 + 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+16.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3212 + 3.*pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-12.*(2.*dMult-7.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3213 + 12.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-48.*(dMult-3.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3214 + 24.*dMult*(dMult-5.))
3215 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3216 six3n1n1n1n1n1n = (reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ3nQ1nQ2nstarQ1nstarQ1nstar+6.*reQ4nQ2nstarQ1nstarQ1nstar
3217 - reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-4.*reQ2nQ1nQ1nstarQ1nstarQ1nstar+3.*reQ3nQ1nQ2nstarQ2nstar
3218 - 4.*(dMult-5.)*reQ3nQ1nstarQ1nstarQ1nstar-14.*reQ4nQ3nstarQ1nstar
3219 - 3.*reQ4nQ2nstarQ2nstar+4.*(3.*dMult-17.)*reQ3nQ2nstarQ1nstar+12.*(dMult-6.)*reQ2nQ1nstarQ1nstar
3220 + 12.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3221 + 8.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3222 + 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-8.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3223 - 12.*(dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-48.*(dMult-3.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3224 + 12.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)+24.*dMult*(dMult-5.))
3225 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3226 // Average 6-particle correlations for single event:
489d5531 3227 fIntFlowCorrelationsAllEBE->SetBinContent(24,six1n1n1n1n1n1n);
3228 fIntFlowCorrelationsAllEBE->SetBinContent(25,six2n1n1n2n1n1n);
3229 fIntFlowCorrelationsAllEBE->SetBinContent(26,six2n2n1n1n1n1n);
3230 fIntFlowCorrelationsAllEBE->SetBinContent(27,six3n1n1n1n1n1n);
b84464d3 3231 // Average 6-particle correlations for all events:
489d5531 3232 fIntFlowCorrelationsAllPro->Fill(23.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3233 fIntFlowCorrelationsAllPro->Fill(24.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3234 fIntFlowCorrelationsAllPro->Fill(25.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3235 fIntFlowCorrelationsAllPro->Fill(26.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3236 // Average 6-particle correlations vs M for all events:
3435cacb 3237 if(fCalculateAllCorrelationsVsM)
3238 {
3239 fIntFlowCorrelationsAllVsMPro[23]->Fill(dMult+0.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3240 fIntFlowCorrelationsAllVsMPro[24]->Fill(dMult+0.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3241 fIntFlowCorrelationsAllVsMPro[25]->Fill(dMult+0.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3242 fIntFlowCorrelationsAllVsMPro[26]->Fill(dMult+0.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3243 }
b84464d3 3244 // Store separetately <6>:
489d5531 3245 fIntFlowCorrelationsEBE->SetBinContent(3,six1n1n1n1n1n1n); // <6>
b84464d3 3246 // Testing other multiplicity weights:
489d5531 3247 Double_t mWeight6p = 0.;
3248 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3249 {
3250 mWeight6p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.);
3251 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3252 {
3253 mWeight6p = 1.;
3254 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3255 {
3256 mWeight6p = dMult;
3257 }
489d5531 3258 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(3,mWeight6p); // eW_<6>
3259 fIntFlowCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n,mWeight6p);
b40a910e 3260 fIntFlowSquaredCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n*six1n1n1n1n1n1n,mWeight6p);
3261 if(fCalculateCumulantsVsM)
3262 {
3263 fIntFlowCorrelationsVsMPro[2]->Fill(dMult+0.5,six1n1n1n1n1n1n,mWeight6p);
3264 fIntFlowSquaredCorrelationsVsMPro[2]->Fill(dMult+0.5,six1n1n1n1n1n1n*six1n1n1n1n1n1n,mWeight6p);
3265 }
489d5531 3266 } // end of if(dMult>5)
3267
3268 // 7-particle:
b84464d3 3269 Double_t seven2n1n1n1n1n1n1n = 0.; // <cos(n(2*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
489d5531 3270 if(dMult>6)
3271 {
b84464d3 3272 seven2n1n1n1n1n1n1n = (reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-4.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)
3273 - reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-2.*reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar
3274 + 9.*reQ2nQ2nQ2nstarQ1nstarQ1nstar+20.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3275 + 2.*reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-8.*(dMult-8.)*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3276 - 18.*reQ4nQ2nstarQ1nstarQ1nstar-14.*reQ3nQ1nQ2nstarQ2nstar
3277 + 8.*(dMult-7.)*reQ3nQ1nstarQ1nstarQ1nstar+28.*reQ4nQ3nstarQ1nstar
3278 + 12.*reQ4nQ2nstarQ2nstar-8.*(5.*dMult-31.)*reQ3nQ2nstarQ1nstar
3279 + 12.*(dMult*dMult-15.*dMult+46.)*reQ2nQ1nstarQ1nstar
3280 - 16.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3281 - 6.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3282 - 3.*pow(pow(dReQ2n,2.)+pow(dImQ2n,2.),2.)
3283 + 12.*(2.*dMult-13.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3284 - 12.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+16.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3285 - 12.*(dMult-8.)*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3286 + 12.*(3.*dMult-14.)*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)
3287 - 24.*(3.*dMult-7.)*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3288 + 24.*dMult*(dMult-5.)*(dMult-6.))
3289 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.));
3290 // Average 7-particle correlations for single event:
3291 fIntFlowCorrelationsAllEBE->SetBinContent(29,seven2n1n1n1n1n1n1n);
3292 // Average 7-particle correlations for all events:
3293 fIntFlowCorrelationsAllPro->Fill(28.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3294 *(dMult-4.)*(dMult-5.)*(dMult-6.));
3295 // Average 7-particle correlations vs M for all events:
3435cacb 3296 if(fCalculateAllCorrelationsVsM)
3297 {
b84464d3 3298 fIntFlowCorrelationsAllVsMPro[28]->Fill(dMult+0.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3299 *(dMult-4.)*(dMult-5.)*(dMult-6.));
3435cacb 3300 }
489d5531 3301 } // end of if(dMult>6)
3302
3303 // 8-particle:
b84464d3 3304 Double_t eight1n1n1n1n1n1n1n1n = 0.; // <cos(n(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
489d5531 3305 if(dMult>7)
b84464d3 3306 {
3307 eight1n1n1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),4.)-12.*reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar
3308 + 16.*reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar+6.*reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar
3309 - 12.*reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-36.*reQ2nQ2nQ2nstarQ1nstarQ1nstar
3310 - 96.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3311 + 72.*reQ4nQ2nstarQ1nstarQ1nstar+48.*reQ3nQ1nQ2nstarQ2nstar
3312 - 64.*(dMult-6.)*reQ3nQ1nstarQ1nstarQ1nstar
3313 + 96.*(dMult-6.)*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3314 - 96.*reQ4nQ3nstarQ1nstar-36.*reQ4nQ2nstarQ2nstar
3315 + 192.*(dMult-6.)*reQ3nQ2nstarQ1nstar
3316 - 144.*(dMult-7.)*(dMult-4.)*reQ2nQ1nstarQ1nstar
3317 + 64.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3318 - 144.*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3319 + 72.*(dMult-7.)*(dMult-4.)*(pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)+pow(dReQ2n,2.)+pow(dImQ2n,2.))
3320 - 96.*(dMult-7.)*(dMult-6.)*(dMult-2.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3321 + 36.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3322 + 9.*pow(pow(dReQ2n,2.)+pow(dImQ2n,2.),2.)
3323 - 64.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3324 + 36.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3325 - 16.*(dMult-6.)*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)
3326 + 24.*dMult*(dMult-7.)*(dMult-6.)*(dMult-5.))
3327 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3328 // Average 8-particle correlations for single event:
3329 fIntFlowCorrelationsAllEBE->SetBinContent(31,eight1n1n1n1n1n1n1n1n);
3330 // Average 8-particle correlations for all events:
3331 fIntFlowCorrelationsAllPro->Fill(30.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3332 *(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3333 // Average 8-particle correlations vs M for all events:
3435cacb 3334 if(fCalculateAllCorrelationsVsM)
3335 {
b84464d3 3336 fIntFlowCorrelationsAllVsMPro[30]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3337 *(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3338 }
3339 // Store separetately <8>:
489d5531 3340 fIntFlowCorrelationsEBE->SetBinContent(4,eight1n1n1n1n1n1n1n1n); // <8>
b84464d3 3341 // Testing other multiplicity weights:
489d5531 3342 Double_t mWeight8p = 0.;
3343 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3344 {
3345 mWeight8p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.);
3346 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3347 {
3348 mWeight8p = 1.;
3349 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3350 {
3351 mWeight8p = dMult;
b84464d3 3352 }
489d5531 3353 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(4,mWeight8p); // eW_<8>
b40a910e 3354 fIntFlowCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n,mWeight8p);
3355 fIntFlowSquaredCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n*eight1n1n1n1n1n1n1n1n,mWeight8p);
3356 if(fCalculateCumulantsVsM)
3357 {
3358 fIntFlowCorrelationsVsMPro[3]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n,mWeight8p);
3359 fIntFlowSquaredCorrelationsVsMPro[3]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n*eight1n1n1n1n1n1n1n1n,mWeight8p);
3360 }
489d5531 3361 } // end of if(dMult>7)
3362
b84464d3 3363 // EXTRA correlations for v3{5} study:
8ed4edc7 3364 // 4-particle:
b84464d3 3365 Double_t four4n2n3n3n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-3*phi4))>
8ed4edc7 3366 if(dMult>3.)
3367 {
11d3e40e 3368 four4n2n3n3n = (reQ4nQ2nQ3nstarQ3nstar-reQ6nQ4nstarQ2nstar-reQ6nQ3nstarQ3nstar
3369 - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar
3370 + (pow(dReQ6n,2.)+pow(dImQ6n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3371 + 2.*(2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3372 + (pow(dReQ1n,2.)+pow(dImQ1n,2.))-3.*dMult))
b84464d3 3373 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
8ed4edc7 3374 fIntFlowCorrelationsAllPro->Fill(32.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3375 // Average 4-particle correlations vs M for all events:
3435cacb 3376 if(fCalculateAllCorrelationsVsM)
3377 {
3378 fIntFlowCorrelationsAllVsMPro[32]->Fill(dMult+0.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3379 }
11d3e40e 3380 } // end of if(dMult>3.)
8ed4edc7 3381
3382 // 5-particle:
b84464d3 3383 Double_t five3n3n2n2n2n = 0.; // <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
8ed4edc7 3384 if(dMult>4.)
3385 {
b84464d3 3386 five3n3n2n2n2n = (reQ3nQ3nQ2nstarQ2nstarQ2nstar-reQ6nQ2nstarQ2nstarQ2nstar-3.*reQ4nQ2nQ3nstarQ3nstar
3387 - 6.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ6nQ3nstarQ3nstar+3.*reQ6nQ4nstarQ2nstar
3388 + 6.*reQ4nQ3nstarQ1nstar+6.*reQ4nQ2nstarQ2nstar
3389 + 12.*reQ3nQ2nstarQ1nstar+6.*reQ2nQ1nstarQ1nstar
11d3e40e 3390 - 2.*((pow(dReQ6n,2.)+pow(dImQ6n,2.))
3391 + 3.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3392 + 6.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3393 + 9.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3394 + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-12.*dMult))
b84464d3 3395 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3396 fIntFlowCorrelationsAllPro->Fill(33.5,five3n3n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3435cacb 3397 if(fCalculateAllCorrelationsVsM)
3398 {
b84464d3 3399 fIntFlowCorrelationsAllVsMPro[33]->Fill(dMult+0.5,five3n3n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3435cacb 3400 }
11d3e40e 3401 } // end of if(dMult>4.)
8ed4edc7 3402
b84464d3 3403 // EXTRA correlations for Teaney-Yan study:
3404 // 2-particle:
3405 Double_t two5n5n = 0.; // <cos(5n(phi1-phi2))>
3406 Double_t two6n6n = 0.; // <cos(6n(phi1-phi2))>
3407 if(dMult>1)
3408 {
3409 two5n5n = (pow(dReQ5n,2.)+pow(dImQ5n,2.)-dMult)/(dMult*(dMult-1.));
3410 two6n6n = (pow(dReQ6n,2.)+pow(dImQ6n,2.)-dMult)/(dMult*(dMult-1.));
3411 // Average 2-particle correlations for all events:
3412 fIntFlowCorrelationsAllPro->Fill(34.5,two5n5n,dMult*(dMult-1.));
3413 fIntFlowCorrelationsAllPro->Fill(35.5,two6n6n,dMult*(dMult-1.));
3414 if(fCalculateAllCorrelationsVsM)
3415 {
3416 fIntFlowCorrelationsAllVsMPro[34]->Fill(dMult+0.5,two5n5n,dMult*(dMult-1.));
3417 fIntFlowCorrelationsAllVsMPro[35]->Fill(dMult+0.5,two6n6n,dMult*(dMult-1.));
3418 }
3419 } // end of if(dMult>1)
3420
3421 // 3-particle:
3422 Double_t three5n3n2n = 0.; // <cos(n(5*phi1-3*phi2-2*phi3)>
3423 Double_t three5n4n1n = 0.; // <cos(n(5*phi1-4*phi2-1*phi3)>
3424 Double_t three6n3n3n = 0.; // <cos(n(6*phi1-3*phi2-3*phi3)>
3425 Double_t three6n4n2n = 0.; // <cos(n(6*phi1-4*phi2-2*phi3)>
3426 Double_t three6n5n1n = 0.; // <cos(n(6*phi1-5*phi2-1*phi3)>
3427 if(dMult>2)
3428 {
3429 three5n3n2n = (reQ5nQ3nstarQ2nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3430 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))
3431 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
3432 / (dMult*(dMult-1.)*(dMult-2.));
3433 three5n4n1n = (reQ5nQ4nstarQ1nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3434 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))
3435 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
3436 / (dMult*(dMult-1.)*(dMult-2.));
3437 three6n3n3n = (reQ6nQ3nstarQ3nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3438 - (pow(dReQ6n,2.)+pow(dImQ6n,2.))+2.*dMult)
3439 / (dMult*(dMult-1.)*(dMult-2.));
3440 three6n4n2n = (reQ6nQ4nstarQ2nstar-(pow(dReQ6n,2.)+pow(dImQ6n,2.))
3441 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))
3442 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
3443 / (dMult*(dMult-1.)*(dMult-2.));
3444 three6n5n1n = (reQ6nQ5nstarQ1nstar-(pow(dReQ6n,2.)+pow(dImQ6n,2.))
3445 - (pow(dReQ5n,2.)+pow(dImQ5n,2.))
3446 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
3447 / (dMult*(dMult-1.)*(dMult-2.));
3448 // Average 3-particle correlations for all events:
3449 fIntFlowCorrelationsAllPro->Fill(36.5,three5n3n2n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(5*phi1-3*phi2-2*phi3)>>
3450 fIntFlowCorrelationsAllPro->Fill(37.5,three5n4n1n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(5*phi1-4*phi2-1*phi3)>>
3451 fIntFlowCorrelationsAllPro->Fill(38.5,three6n3n3n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-3*phi2-3*phi3)>>
3452 fIntFlowCorrelationsAllPro->Fill(39.5,three6n4n2n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-4*phi2-2*phi3)>>
3453 fIntFlowCorrelationsAllPro->Fill(40.5,three6n5n1n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-5*phi2-1*phi3)>>
3454 if(fCalculateAllCorrelationsVsM)
3455 {
3456 fIntFlowCorrelationsAllVsMPro[36]->Fill(dMult+0.5,three5n3n2n,dMult*(dMult-1.)*(dMult-2.));
3457 fIntFlowCorrelationsAllVsMPro[37]->Fill(dMult+0.5,three5n4n1n,dMult*(dMult-1.)*(dMult-2.));
3458 fIntFlowCorrelationsAllVsMPro[38]->Fill(dMult+0.5,three6n3n3n,dMult*(dMult-1.)*(dMult-2.));
3459 fIntFlowCorrelationsAllVsMPro[39]->Fill(dMult+0.5,three6n4n2n,dMult*(dMult-1.)*(dMult-2.));
3460 fIntFlowCorrelationsAllVsMPro[40]->Fill(dMult+0.5,three6n5n1n,dMult*(dMult-1.)*(dMult-2.));
3461 }
3462 } // end of if(dMult>2)
3463
3464 // 4-particle:
3465 Double_t four6n3n2n1n = 0.; // <cos(n(6*phi1-3*phi2-2*phi3-1*phi4)>
3466 Double_t four3n2n3n2n = 0.; // <cos(n(3*phi1+2*phi2-3*phi3-2*phi4)>
3467 Double_t four4n1n3n2n = 0.; // <cos(n(4*phi1+1*phi2-3*phi3-2*phi4)>
3468 Double_t four3n3n3n3n = 0.; // <cos(3n(phi1+phi2-phi3-phi4))>
3469 //Double_t four4n2n3n3n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-3*phi4)> // I already have this one above
3470 Double_t four5n1n3n3n = 0.; // <cos(n(5*phi1+1*phi2-3*phi3-3*phi4)>
3471 Double_t four4n2n4n2n = 0.; // <cos(n(4*phi1+2*phi2-4*phi3-2*phi4)>
3472 Double_t four5n1n4n2n = 0.; // <cos(n(5*phi1+1*phi2-4*phi3-2*phi4)>
3473 Double_t four5n3n1n1n = 0.; // <cos(n(5*phi1-3*phi2-1*phi3-1*phi4)>
3474 Double_t four5n2n2n1n = 0.; // <cos(n(5*phi1-2*phi2-2*phi3-1*phi4)>
403e3389 3475 Double_t four5n1n5n1n = 0.; // <cos(n(5*phi1+1*phi2-5*phi3-1*phi4)>
3476 Double_t four6n4n1n1n = 0.; // <cos(n(6*phi1-4*phi2-1*phi3-1*phi4)>
3477 Double_t four6n2n2n2n = 0.; // <cos(n(6*phi1-2*phi2-2*phi3-2*phi4)>
b84464d3 3478 if(dMult>3)
3479 {
3480 four6n3n2n1n = (reQ6nQ3nstarQ2nstarQ1nstar-reQ6nQ4nstarQ2nstar-reQ6nQ3nstarQ3nstar-reQ6nQ5nstarQ1nstar
3481 - reQ5nQ3nstarQ2nstar-reQ4nQ3nstarQ1nstar-reQ3nQ2nstarQ1nstar
3482 + 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+pow(dReQ5n,2.)+pow(dImQ5n,2.)
3483 + pow(dReQ4n,2.)+pow(dImQ4n,2.)+3.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3484 + 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3485 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3486 four3n2n3n2n = (dQ3nQ2nQ3nstarQ2nstar-2.*reQ5nQ3nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar
3487 + pow(dReQ5n,2.)+pow(dImQ5n,2.)+pow(dReQ1n,2.)+pow(dImQ1n,2.)
3488 -(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.)+pow(dReQ2n,2.)+pow(dImQ2n,2.))
3489 + dMult*(dMult-6.))
3490 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3491 four4n1n3n2n = (reQ4nQ1nQ3nstarQ2nstar-reQ5nQ3nstarQ2nstar-reQ5nQ4nstarQ1nstar-reQ4nQ3nstarQ1nstar
3492 - reQ4nQ2nstarQ2nstar-reQ3nQ2nstarQ1nstar-reQ2nQ1nstarQ1nstar
3493 + pow(dReQ5n,2.)+pow(dImQ5n,2.)+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3494 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3495 + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3496 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3497 four3n3n3n3n = (2.*dMult*(dMult-3.)+pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ3n,2.)
3498 + pow(dImQ3n,2.))-2.*reQ6nQ3nstarQ3nstar+(pow(dReQ6n,2.)+pow(dImQ6n,2.)))
3499 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3500 //four4n2n3n3n = ; // I already have this one above
3501 four5n1n3n3n = (reQ5nQ1nQ3nstarQ3nstar-reQ6nQ5nstarQ1nstar-reQ6nQ3nstarQ3nstar-2.*reQ5nQ3nstarQ2nstar
3502 - 2.*reQ3nQ2nstarQ1nstar+pow(dReQ6n,2.)+pow(dImQ6n,2.)+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3503 + 4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3504 + 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3505 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3506 four4n2n4n2n = (dQ4nQ2nQ4nstarQ2nstar-2.*reQ6nQ4nstarQ2nstar-2.*reQ4nQ2nstarQ2nstar)
3507 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3508 - ((dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3509 + (dMult-4.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-(pow(dReQ6n,2.)+pow(dImQ6n,2.)))
3510 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3511 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));
3512 four5n1n4n2n = (reQ5nQ1nQ4nstarQ2nstar-reQ6nQ5nstarQ1nstar-reQ6nQ4nstarQ2nstar-reQ5nQ4nstarQ1nstar
3513 - reQ5nQ3nstarQ2nstar-reQ4nQ3nstarQ1nstar-reQ2nQ1nstarQ1nstar+pow(dReQ6n,2.)+pow(dImQ6n,2.)
3514 + 2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3515 + pow(dReQ3n,2.)+pow(dImQ3n,2.)+2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3516 + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3517 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3518 four5n3n1n1n = (reQ5nQ3nstarQ1nstarQ1nstar-2.*reQ5nQ4nstarQ1nstar-reQ5nQ3nstarQ2nstar-2.*reQ4nQ3nstarQ1nstar
3519 - reQ2nQ1nstarQ1nstar+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3520 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+pow(dReQ2n,2.)+pow(dImQ2n,2.)
3521 + 4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3522 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3523 four5n2n2n1n = (reQ5nQ2nstarQ2nstarQ1nstar-reQ5nQ4nstarQ1nstar-2.*reQ5nQ3nstarQ2nstar-reQ4nQ2nstarQ2nstar
3524 - 2.*reQ3nQ2nstarQ1nstar+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+pow(dReQ4n,2.)+pow(dImQ4n,2.)
3525 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3526 + 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3527 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3528 four5n1n5n1n = (dQ5nQ1nQ5nstarQ1nstar-2.*reQ6nQ5nstarQ1nstar-2.*reQ5nQ4nstarQ1nstar
3529 + pow(dReQ6n,2.)+pow(dImQ6n,2.)-(dMult-4.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3530 + pow(dReQ4n,2.)+pow(dImQ4n,2.)-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+dMult*(dMult-6.))
3531 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
403e3389 3532
3533 four6n4n1n1n = (reQ6nQ4nstarQ1nstarQ1nstar
3534 - dMult*(dMult-1.)*(dMult-2.)*(three2n1n1n+2.*three5n4n1n+2.*three6n5n1n+three6n4n2n)
3535 - dMult*(dMult-1.)*(2.*two1n1n+1.*two4n4n+1.*two6n6n+1.*two2n2n+2.*two5n5n)
3536 - 1.*dMult)
3537 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3538
3539 four6n2n2n2n = (reQ6nQ2nstarQ2nstarQ2nstar-3.*reQ6nQ4nstarQ2nstar-3.*reQ4nQ2nstarQ2nstar
3540 + 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+3.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3541 + 6.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-6.*dMult)
3542 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3543 // Average 4-particle correlations for all events:
3544 fIntFlowCorrelationsAllPro->Fill(41.5,four6n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3545 fIntFlowCorrelationsAllPro->Fill(42.5,four3n2n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3546 fIntFlowCorrelationsAllPro->Fill(43.5,four4n1n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3547 fIntFlowCorrelationsAllPro->Fill(44.5,four3n3n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3548 //fIntFlowCorrelationsAllPro->Fill(45.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)); // I already have this one above
3549 fIntFlowCorrelationsAllPro->Fill(46.5,four5n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3550 fIntFlowCorrelationsAllPro->Fill(47.5,four4n2n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3551 fIntFlowCorrelationsAllPro->Fill(48.5,four5n1n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3552 fIntFlowCorrelationsAllPro->Fill(49.5,four5n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3553 fIntFlowCorrelationsAllPro->Fill(50.5,four5n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3554 fIntFlowCorrelationsAllPro->Fill(51.5,four5n1n5n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
403e3389 3555 fIntFlowCorrelationsAllPro->Fill(58.5,four6n4n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3556 fIntFlowCorrelationsAllPro->Fill(59.5,four6n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3557 if(fCalculateAllCorrelationsVsM)
3558 {
3559 fIntFlowCorrelationsAllVsMPro[41]->Fill(dMult+0.5,four6n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3560 fIntFlowCorrelationsAllVsMPro[42]->Fill(dMult+0.5,four3n2n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3561 fIntFlowCorrelationsAllVsMPro[43]->Fill(dMult+0.5,four4n1n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3562 fIntFlowCorrelationsAllVsMPro[44]->Fill(dMult+0.5,four3n3n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3563 //fIntFlowCorrelationsAllVsMPro[45]->Fill(dMult+0.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3564 fIntFlowCorrelationsAllVsMPro[46]->Fill(dMult+0.5,four5n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3565 fIntFlowCorrelationsAllVsMPro[47]->Fill(dMult+0.5,four4n2n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3566 fIntFlowCorrelationsAllVsMPro[48]->Fill(dMult+0.5,four5n1n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3567 fIntFlowCorrelationsAllVsMPro[49]->Fill(dMult+0.5,four5n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3568 fIntFlowCorrelationsAllVsMPro[50]->Fill(dMult+0.5,four5n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3569 fIntFlowCorrelationsAllVsMPro[51]->Fill(dMult+0.5,four5n1n5n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
403e3389 3570 fIntFlowCorrelationsAllVsMPro[58]->Fill(dMult+0.5,four6n4n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3571 fIntFlowCorrelationsAllVsMPro[59]->Fill(dMult+0.5,four6n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3572 }
3573 } // end of if(dMult>3)
3574
3575 // 5-particle:
3576 Double_t five3n3n3n2n1n = 0.; // <cos(n(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
3577 Double_t five4n2n3n2n1n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
3578 Double_t five3n2n3n1n1n = 0.; // <cos(n(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
3579 Double_t five3n2n2n2n1n = 0.; // <cos(n(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
3580 Double_t five5n1n3n2n1n = 0.; // <cos(n(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
403e3389 3581 Double_t five6n2n2n1n1n = 0.; // <cos(n(6*phi1-2*phi2-2*phi3-1*phi4-1*phi5)>
3582 Double_t five4n1n1n3n3n = 0.; // <cos(n(4*phi1+1*phi2+1*phi3-3*phi4-3*phi5)>
b84464d3 3583 if(dMult>4)
3584 {
3585 five3n3n3n2n1n = (reQ3nQ3nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ3nstarQ3nstar-reQ4nQ2nQ3nstarQ3nstar
3586 + reQ6nQ5nstarQ1nstar+reQ6nQ4nstarQ2nstar+3.*reQ6nQ3nstarQ3nstar+4.*reQ5nQ3nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar
3587 - 2.*(dMult-6.)*reQ3nQ2nstarQ1nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3588 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3589 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3590 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*(3.*dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3591 - pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)+2.*(dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3592 + 2.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3593 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3594 five4n2n3n2n1n = (reQ4nQ2nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ4nstarQ2nstar
3595 - reQ4nQ2nQ3nstarQ3nstar-reQ4nQ1nQ3nstarQ2nstar-reQ4nQ2nstarQ1nstarQ1nstar
3596 - reQ3nQ1nQ2nstarQ2nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3597 + 3.*reQ6nQ4nstarQ2nstar+reQ6nQ5nstarQ1nstar+reQ6nQ3nstarQ3nstar+reQ5nQ4nstarQ1nstar
3598 + 3.*reQ5nQ3nstarQ2nstar-(dMult-7.)*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+7.*reQ3nQ2nstarQ1nstar
3599 + 4.*reQ2nQ1nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3600 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3601 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3602 + (dMult-8.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+(dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3603 + 2.*(dMult-7.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+(dMult-12.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3604 - 2.*dMult*(dMult-12.))
3605 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3606 five3n2n3n1n1n = (reQ3nQ2nQ3nstarQ1nstarQ1nstar-reQ5nQ3nstarQ1nstarQ1nstar-2.*reQ4nQ1nQ3nstarQ2nstar-reQ3nQ1nstarQ1nstarQ1nstar
3607 - 2.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ5nQ4nstarQ1nstar+3.*reQ5nQ3nstarQ2nstar+6.*reQ4nQ3nstarQ1nstar
3608 + 2.*reQ4nQ2nstarQ2nstar+9.*reQ3nQ2nstarQ1nstar-(dMult-8.)*reQ2nQ1nstarQ1nstar
3609 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3610 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3611 - 2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))-4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3612 + 2.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+(dMult-12.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3613 + 2.*(dMult-9.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-2.*dMult*(dMult-12.))
3614 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3615 five3n2n2n2n1n = (reQ3nQ2nQ2nstarQ2nstarQ1nstar-reQ5nQ2nstarQ2nstarQ1nstar-reQ4nQ1nQ3nstarQ2nstar-reQ3nQ1nQ2nstarQ2nstar
3616 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+reQ5nQ4nstarQ1nstar
3617 + 4.*reQ5nQ3nstarQ2nstar+reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar-2.*(dMult-6.)*reQ3nQ2nstarQ1nstar
3618 + 4.*reQ2nQ1nstarQ1nstar-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3619 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3620 - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3621 - pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3622 + 2.*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3623 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3624 five5n1n3n2n1n = (reQ5nQ1nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ4nstarQ2nstar-reQ5nQ1nQ3nstarQ3nstar
3625 - reQ4nQ1nQ3nstarQ2nstar-reQ5nQ3nstarQ1nstarQ1nstar-reQ5nQ2nstarQ2nstarQ1nstar
3626 + 3.*reQ6nQ5nstarQ1nstar+reQ6nQ4nstarQ2nstar+reQ6nQ3nstarQ3nstar+4.*reQ5nQ4nstarQ1nstar
3627 - (dMult-7.)*reQ5nQ3nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar+reQ4nQ2nstarQ2nstar+6.*reQ3nQ2nstarQ1nstar
3628 + 3.*reQ2nQ1nstarQ1nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3629 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3630 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3631 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+(dMult-8.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3632 - 4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+(dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3633 + (dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*(dMult-7.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3634 - 2.*dMult*(dMult-12.))
3635 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3636
3637 // five6n2n2n1n1n = ;
3638 // five4n1n1n3n3n = ;
3639
b84464d3 3640 // Average 5-particle correlations for all events:
3641 fIntFlowCorrelationsAllPro->Fill(52.5,five3n3n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3642 fIntFlowCorrelationsAllPro->Fill(53.5,five4n2n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3643 fIntFlowCorrelationsAllPro->Fill(54.5,five3n2n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3644 fIntFlowCorrelationsAllPro->Fill(55.5,five3n2n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3645 fIntFlowCorrelationsAllPro->Fill(56.5,five5n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3646 fIntFlowCorrelationsAllPro->Fill(60.5,five6n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3647 fIntFlowCorrelationsAllPro->Fill(61.5,five4n1n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3648 if(fCalculateAllCorrelationsVsM)
3649 {
3650 fIntFlowCorrelationsAllVsMPro[52]->Fill(dMult+0.5,five3n3n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3651 fIntFlowCorrelationsAllVsMPro[53]->Fill(dMult+0.5,five4n2n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3652 fIntFlowCorrelationsAllVsMPro[54]->Fill(dMult+0.5,five3n2n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3653 fIntFlowCorrelationsAllVsMPro[55]->Fill(dMult+0.5,five3n2n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3654 fIntFlowCorrelationsAllVsMPro[56]->Fill(dMult+0.5,five5n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3655 fIntFlowCorrelationsAllVsMPro[60]->Fill(dMult+0.5,five6n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3656 fIntFlowCorrelationsAllVsMPro[61]->Fill(dMult+0.5,five4n1n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3657 }
3658 } // end of if(dMult>4)
3659
3660 // 6-particle:
3661 Double_t six3n2n1n3n2n1n = 0.; // <cos(n(3*phi1+2*phi2+1*phi3-3*phi4-2*phi5-1*phi6)>
403e3389 3662 Double_t six3n3n2n2n1n1n = 0.; // <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-1*phi5-1*phi6)>
b84464d3 3663 if(dMult>5.)
3664 {
3665 six3n2n1n3n2n1n = (dQ3nQ2nQ1nQ3nstarQ2nstarQ1nstar-2.*reQ3nQ3nQ3nstarQ2nstarQ1nstar
3666 - 2.*reQ3nQ2nQ2nstarQ2nstarQ1nstar-2.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3667 - 2.*reQ3nQ2nQ3nstarQ1nstarQ1nstar-2.*reQ4nQ2nQ3nstarQ2nstarQ1nstar
3668 - 2.*reQ5nQ1nQ3nstarQ2nstarQ1nstar+4.*reQ6nQ3nstarQ2nstarQ1nstar
3669 + 2.*reQ5nQ1nQ4nstarQ2nstar+2.*reQ5nQ1nQ3nstarQ3nstar
3670 + 2.*reQ4nQ2nQ3nstarQ3nstar+6.*reQ4nQ1nQ3nstarQ2nstar
3671 + 2.*reQ5nQ3nstarQ1nstarQ1nstar+2.*reQ5nQ2nstarQ2nstarQ1nstar
3672 + 6.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ4nQ2nstarQ1nstarQ1nstar
3673 - 4.*reQ6nQ5nstarQ1nstar-4.*reQ6nQ4nstarQ2nstar-6.*reQ5nQ4nstarQ1nstar
3674 - 4.*reQ6nQ3nstarQ3nstar+2.*(dMult-11.)*reQ5nQ3nstarQ2nstar
3675 + 2.*(dMult-13.)*reQ4nQ3nstarQ1nstar-8.*reQ4nQ2nstarQ2nstar
3676 + 2.*(5.*dMult-32.)*reQ3nQ2nstarQ1nstar+2.*reQ3nQ1nstarQ1nstarQ1nstar
3677 + 2.*(dMult-13.)*reQ2nQ1nstarQ1nstar
3678 - (dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3679 + (pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3680 + (pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3681 - (dMult-11.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3682 - (dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3683 + 4.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-(dMult-12.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3684 - (dMult-16.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)
3685 + (dMult*dMult-19.*dMult+68.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3686 + (dMult*dMult-19.*dMult+72.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3687 + pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3688 + (dMult*dMult-20.*dMult+80.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3689 - dMult*(dMult-12.)*(dMult-10.))
3690 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3691
3692 // six3n3n2n2n1n1n = ;
3693
b84464d3 3694 // Average 6-particle correlations for all events:
3695 fIntFlowCorrelationsAllPro->Fill(57.5,six3n2n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3696 fIntFlowCorrelationsAllPro->Fill(62.5,six3n3n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3697 if(fCalculateAllCorrelationsVsM)
3698 {
3699 fIntFlowCorrelationsAllVsMPro[57]->Fill(dMult+0.5,six3n2n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3700 fIntFlowCorrelationsAllVsMPro[62]->Fill(dMult+0.5,six3n3n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3701 }
3702 } // end of if(dMult>5.)
3703
489d5531 3704} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()
3705
489d5531 3706//================================================================================================================================
3707
e5834fcb 3708void AliFlowAnalysisWithQCumulants::StorePhiDistributionForOneEvent(AliFlowEventSimple *anEvent)
3709{
3710 // Store phi distribution for one event to illustrate flow.
3711
3712 if(fPhiDistributionForOneEvent->GetEntries()>0){return;} // store only phi distribution for one event
3713
3714 Double_t vMin = fPhiDistributionForOneEventSettings[0];
3715 Double_t vMax = fPhiDistributionForOneEventSettings[1];
3716 Double_t refMultMin = fPhiDistributionForOneEventSettings[2];
3717 Double_t refMultMax = fPhiDistributionForOneEventSettings[3];
3718
3719 Double_t vEBE = 0.;
3720 Double_t cumulant4thEBE = fIntFlowCorrelationsEBE->GetBinContent(2)-2.*pow(fIntFlowCorrelationsEBE->GetBinContent(1),2.);
3721 if(cumulant4thEBE<0.)
3722 {
3723 vEBE = pow(-1.*cumulant4thEBE,0.25);
3724 if((vEBE>vMin && vEBE<vMax) && (fReferenceMultiplicityEBE>refMultMin && fReferenceMultiplicityEBE<refMultMax))
3725 {
3958eee6 3726 fPhiDistributionForOneEvent->SetTitle(Form("v_{%i} = %f",fHarmonic,vEBE));
e5834fcb 3727 for(Int_t p=0;p<anEvent->NumberOfTracks();p++)
3728 {
3729 if(anEvent->GetTrack(p)->InRPSelection())
3730 {
3731 fPhiDistributionForOneEvent->Fill(anEvent->GetTrack(p)->Phi());
3732 }
3733 } // end of for(Int_t p=0;p<anEvent->NumberOfTracks();p++)
3958eee6 3734 } else
3735 {
3736 fPhiDistributionForOneEvent->SetTitle(Form("v_{%i} = %f, out of specified boundaries",fHarmonic,vEBE));
3737 }
3738
e5834fcb 3739 } // end of if(cumulant4thEBE<0.)
3740
3741} // end of void AliFlowAnalysisWithQCumulants::StorePhiDistributionForOneEvent(AliFlowEventSimple *anEvent)
3742
3743//================================================================================================================================
489d5531 3744
3745void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()
3746{
0328db2d 3747 // Calculate averages of products of correlations for integrated flow.
489d5531 3748
2001bc3a 3749 // multiplicity:
1268c371 3750 Double_t dMult = (*fSpk)(0,0);
2001bc3a 3751
489d5531 3752 Int_t counter = 0;
3753
3754 for(Int_t ci1=1;ci1<4;ci1++)
3755 {
3756 for(Int_t ci2=ci1+1;ci2<=4;ci2++)
3757 {
ff70ca91 3758 fIntFlowProductOfCorrelationsPro->Fill(0.5+counter,
3759 fIntFlowCorrelationsEBE->GetBinContent(ci1)*
3760 fIntFlowCorrelationsEBE->GetBinContent(ci2),
3761 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
3762 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
3763 // products versus multiplicity: // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 3764 if(fCalculateCumulantsVsM)
3765 {
3766 fIntFlowProductOfCorrelationsVsMPro[counter]->Fill(dMult+0.5, // to be improved: dMult => sum of weights ?
3767 fIntFlowCorrelationsEBE->GetBinContent(ci1)*
3768 fIntFlowCorrelationsEBE->GetBinContent(ci2),
3769 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
3770 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
3771 } // end of if(fCalculateCumulantsVsM)
ff70ca91 3772 counter++;
489d5531 3773 }
3774 }
3775
3776} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()
3777
3778
3779//================================================================================================================================
3780
3781
0328db2d 3782void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrectionTermsForNUA()
3783{
3784 // Calculate averages of products of correction terms for NUA.
3785
3786 // a) Binning of fIntFlowProductOfCorrectionTermsForNUAPro is organized as follows:
3787 // 1st bin: <<2><cos(phi)>>
3788 // 2nd bin: <<2><sin(phi)>>
3789 // 3rd bin: <<cos(phi)><sin(phi)>>
3790 // 4th bin: <<2><cos(phi1+phi2)>>
3791 // 5th bin: <<2><sin(phi1+phi2)>>
3792 // 6th bin: <<2><cos(phi1-phi2-phi3)>>
3793 // 7th bin: <<2><sin(phi1-phi2-phi3)>>
3794 // 8th bin: <<4><cos(phi1)>>
3795 // 9th bin: <<4><sin(phi1)>>
3796 // 10th bin: <<4><cos(phi1+phi2)>>
3797 // 11th bin: <<4><sin(phi1+phi2)>>
3798 // 12th bin: <<4><cos(phi1-phi2-phi3)>>
3799 // 13th bin: <<4><sin(phi1-phi2-phi3)>>
3800 // 14th bin: <<cos(phi1)><cos(phi1+phi2)>>
3801 // 15th bin: <<cos(phi1)><sin(phi1+phi2)>>
3802 // 16th bin: <<cos(phi1)><cos(phi1-phi2-phi3)>>
3803 // 17th bin: <<cos(phi1)><sin(phi1-phi2-phi3)>>
3804 // 18th bin: <<sin(phi1)><cos(phi1+phi2)>>
3805 // 19th bin: <<sin(phi1)><sin(phi1+phi2)>>
3806 // 20th bin: <<sin(phi1)><cos(phi1-phi2-phi3)>>
3807 // 21st bin: <<sin(phi1)><sin(phi1-phi2-phi3)>>
3808 // 22nd bin: <<cos(phi1+phi2)><sin(phi1+phi2)>>
3809 // 23rd bin: <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>
3810 // 24th bin: <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>
3811 // 25th bin: <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>
3812 // 26th bin: <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>
3813 // 27th bin: <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>
3814
3815 // <<2><cos(phi)>>:
3816 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(0.5,
3817 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1),
3818 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3819 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
3820 // <<2><sin(phi)>>:
3821 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(1.5,
3822 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3823 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3824 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3825 // <<cos(phi)><sin(phi)>>:
3826 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(2.5,
3827 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3828 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3829 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3830 // <<2><cos(phi1+phi2)>>:
3831 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(3.5,
3832 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3833 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3834 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3835 // <<2><sin(phi1+phi2)>>:
3836 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(4.5,
3837 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3838 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3839 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3840 // <<2><cos(phi1-phi2-phi3)>>:
3841 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(5.5,
3842 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3843 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3844 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3845 // <<2><sin(phi1-phi2-phi3)>>:
3846 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(6.5,
3847 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3848 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3849 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3850 // <<4><cos(phi1)>>:
3851 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(7.5,
3852 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1),
3853 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3854 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
3855 // <<4><sin(phi1)>>:
3856 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(8.5,
3857 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3858 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3859 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3860 // <<4><cos(phi1+phi2)>>:
3861 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(9.5,
3862 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3863 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3864 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3865 // <<4><sin(phi1+phi2)>>:
3866 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(10.5,
3867 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3868 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3869 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3870 // <<4><cos(phi1-phi2-phi3)>>:
3871 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(11.5,
3872 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3873 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3874 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3875 // <<4><sin(phi1-phi2-phi3)>>:
3876 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(12.5,
3877 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3878 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3879 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3880 // <<cos(phi1)><cos(phi1+phi2)>>:
3881 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(13.5,
3882 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3883 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3884 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3885 // <<cos(phi1)><sin(phi1+phi2)>>:
3886 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(14.5,
3887 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3888 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3889 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3890 // <<cos(phi1)><cos(phi1-phi2-phi3)>>:
3891 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(15.5,
3892 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3893 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3894 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3895 // <<cos(phi1)><sin(phi1-phi2-phi3)>>:
3896 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(16.5,
3897 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3898 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3899 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3900 // <<sin(phi1)><cos(phi1+phi2)>>:
3901 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(17.5,
3902 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3903 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3904 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3905 // <<sin(phi1)><sin(phi1+phi2)>>:
3906 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(18.5,
3907 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3908 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3909 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3910 // <<sin(phi1)><cos(phi1-phi2-phi3)>>:
3911 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(19.5,
3912 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3913 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3914 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3915 // <<sin(phi1)><sin(phi1-phi2-phi3)>>:
3916 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(20.5,
3917 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3918 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3919 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3920 // <<cos(phi1+phi2)><sin(phi1+phi2)>>:
3921 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(21.5,
3922 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3923 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
3924 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3925 // <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>:
3926 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(22.5,
3927 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3928 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
3929 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3930 // <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>:
3931 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(23.5,
3932 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3933 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
3934 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3935 // <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>:
3936 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(24.5,
3937 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3938 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)
3939 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3940 // <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>:
3941 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(25.5,
3942 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3943 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)
3944 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3945 // <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>:
3946 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(26.5,
3947 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3948 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3)
3949 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3950
3951} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrectionTermsForNUA()
3952
0328db2d 3953//================================================================================================================================
3954
489d5531 3955void AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()
3956{
3957 // a) Calculate unbiased estimators Cov(<2>,<4>), Cov(<2>,<6>), Cov(<2>,<8>), Cov(<4>,<6>), Cov(<4>,<8>) and Cov(<6>,<8>)
3958 // for covariances V_(<2>,<4>), V_(<2>,<6>), V_(<2>,<8>), V_(<4>,<6>), V_(<4>,<8>) and V_(<6>,<8>).
3959 // b) Store in histogram fIntFlowCovariances for instance the following:
3960 //
3961 // 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)]
3962 //
3963 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<4>} is event weight for <4>.
3964 // c) Binning of fIntFlowCovariances is organized as follows:
3965 //
3966 // 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)]
3967 // 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)]
3968 // 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)]
3969 // 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)]
3970 // 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)]
3971 // 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)]
b3dacf6b 3972 //
489d5531 3973
b3dacf6b 3974 // Average 2-, 4-, 6- and 8-particle correlations for all events:
489d5531 3975 Double_t correlation[4] = {0.};
3976 for(Int_t ci=0;ci<4;ci++)
3977 {
3978 correlation[ci] = fIntFlowCorrelationsPro->GetBinContent(ci+1);
3979 }
b3dacf6b 3980 // Average products of 2-, 4-, 6- and 8-particle correlations:
489d5531 3981 Double_t productOfCorrelations[4][4] = {{0.}};
3982 Int_t productOfCorrelationsLabel = 1;
b3dacf6b 3983 // Denominators in the expressions for the unbiased estimator for covariance:
489d5531 3984 Double_t denominator[4][4] = {{0.}};
3985 Int_t sumOfProductOfEventWeightsLabel1 = 1;
b3dacf6b 3986 // Weight dependent prefactor which multiply unbiased estimators for covariances:
489d5531 3987 Double_t wPrefactor[4][4] = {{0.}};
3988 Int_t sumOfProductOfEventWeightsLabel2 = 1;
3989 for(Int_t c1=0;c1<4;c1++)
3990 {
3991 for(Int_t c2=c1+1;c2<4;c2++)
3992 {
3993 productOfCorrelations[c1][c2] = fIntFlowProductOfCorrelationsPro->GetBinContent(productOfCorrelationsLabel);
b3dacf6b 3994 if(TMath::Abs(fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)) > 1.e-44 && TMath::Abs(fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1)) > 1.e-44)
3995 {
3996 denominator[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel1))
3997 / (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)
3998 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));
3999 wPrefactor[c1][c2] = fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel2)
4000 / (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)
4001 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));
489d5531 4002 }
b3dacf6b 4003 productOfCorrelationsLabel++; // to be improved - do I need here all 3 counters?
489d5531 4004 sumOfProductOfEventWeightsLabel1++;
4005 sumOfProductOfEventWeightsLabel2++;
b3dacf6b 4006 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4007 } // end of for(Int_t c1=0;c1<4;c1++)
489d5531 4008
489d5531 4009 Int_t covarianceLabel = 1;
4010 for(Int_t c1=0;c1<4;c1++)
4011 {
4012 for(Int_t c2=c1+1;c2<4;c2++)
4013 {
b3dacf6b 4014 if(TMath::Abs(denominator[c1][c2]) > 1.e-44)
489d5531 4015 {
b3dacf6b 4016 // Covariances:
489d5531 4017 Double_t cov = (productOfCorrelations[c1][c2]-correlation[c1]*correlation[c2])/denominator[c1][c2];
b3dacf6b 4018 // Covariances multiplied with weight dependent prefactor:
489d5531 4019 Double_t wCov = cov * wPrefactor[c1][c2];
4020 fIntFlowCovariances->SetBinContent(covarianceLabel,wCov);
4021 }
4022 covarianceLabel++;
b3dacf6b 4023 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4024 } // end of for(Int_t c1=0;c1<4;c1++)
489d5531 4025
b3dacf6b 4026 // Versus multiplicity:
4027 if(!fCalculateCumulantsVsM){return;}
9da1a4f3 4028 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
4029 for(Int_t b=1;b<=nBins;b++)
4030 {
b3dacf6b 4031 // Average 2-, 4-, 6- and 8-particle correlations for all events:
9da1a4f3 4032 Double_t correlationVsM[4] = {0.};
4033 for(Int_t ci=0;ci<4;ci++)
4034 {
4035 correlationVsM[ci] = fIntFlowCorrelationsVsMPro[ci]->GetBinContent(b);
4036 } // end of for(Int_t ci=0;ci<4;ci++)
b3dacf6b 4037 // Average products of 2-, 4-, 6- and 8-particle correlations:
9da1a4f3 4038 Double_t productOfCorrelationsVsM[4][4] = {{0.}};
4039 Int_t productOfCorrelationsLabelVsM = 1;
b3dacf6b 4040 // Denominators in the expressions for the unbiased estimator for covariance:
9da1a4f3 4041 Double_t denominatorVsM[4][4] = {{0.}};
4042 Int_t sumOfProductOfEventWeightsLabel1VsM = 1;
b3dacf6b 4043 // Weight dependent prefactor which multiply unbiased estimators for covariances:
9da1a4f3 4044 Double_t wPrefactorVsM[4][4] = {{0.}};
4045 Int_t sumOfProductOfEventWeightsLabel2VsM = 1;
4046 for(Int_t c1=0;c1<4;c1++)
4047 {
4048 for(Int_t c2=c1+1;c2<4;c2++)
4049 {
4050 productOfCorrelationsVsM[c1][c2] = fIntFlowProductOfCorrelationsVsMPro[productOfCorrelationsLabelVsM-1]->GetBinContent(b);
b3dacf6b 4051 if(TMath::Abs(fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)) > 1.e-44 && TMath::Abs(fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b)) > 1.e-44)
4052 {
4053 denominatorVsM[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeightsVsM[sumOfProductOfEventWeightsLabel1VsM-1]->GetBinContent(b))
4054 / (fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)
4055 * fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b));
4056 wPrefactorVsM[c1][c2] = fIntFlowSumOfProductOfEventWeightsVsM[sumOfProductOfEventWeightsLabel2VsM-1]->GetBinContent(b)
4057 / (fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)
4058 * fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b));
9da1a4f3 4059 }
4060 productOfCorrelationsLabelVsM++;
4061 sumOfProductOfEventWeightsLabel1VsM++;
4062 sumOfProductOfEventWeightsLabel2VsM++;
4063 } // end of for(Int_t c1=0;c1<4;c1++)
4064 } // end of for(Int_t c2=c1+1;c2<4;c2++)
b3dacf6b 4065
9da1a4f3 4066 Int_t covarianceLabelVsM = 1;
4067 for(Int_t c1=0;c1<4;c1++)
4068 {
4069 for(Int_t c2=c1+1;c2<4;c2++)
4070 {
b3dacf6b 4071 if(TMath::Abs(denominatorVsM[c1][c2]) > 1.e-44)
9da1a4f3 4072 {
b3dacf6b 4073 // Covariances:
9da1a4f3 4074 Double_t covVsM = (productOfCorrelationsVsM[c1][c2]-correlationVsM[c1]*correlationVsM[c2])/denominatorVsM[c1][c2];
b3dacf6b 4075 // Covariances multiplied with weight dependent prefactor:
9da1a4f3 4076 Double_t wCovVsM = covVsM * wPrefactorVsM[c1][c2];
4077 fIntFlowCovariancesVsM[covarianceLabelVsM-1]->SetBinContent(b,wCovVsM);
4078 }
4079 covarianceLabelVsM++;
b3dacf6b 4080 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4081 } // end of for(Int_t c1=0;c1<4;c1++)
9da1a4f3 4082 } // end of for(Int_t b=1;b<=nBins;b++)
4083
489d5531 4084} // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()
4085
489d5531 4086//================================================================================================================================
4087
0328db2d 4088void AliFlowAnalysisWithQCumulants::CalculateCovariancesNUAIntFlow()
4089{
4090 // a) Calculate unbiased estimators Cov(*,*) for true covariances V_(*,*) for NUA terms.
4091 // b) Store in histogram fIntFlowCovariancesNUA for instance the following:
4092 //
4093 // Cov(<2>,<cos(phi)>) * (sum_{i=1}^{N} w_{<2>}_i w_{<cos(phi)>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<cos(phi)>}_j)]
4094 //
4095 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<cos(phi)>} is event weight for <cos(phi)>.
4096 // c) Binning of fIntFlowCovariancesNUA is organized as follows:
4097 //
4098 // 1st bin: Cov(<2>,<cos(phi)>) * (sum_{i=1}^{N} w_{<2>}_i w_{<cos(phi)>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<cos(phi)>}_j)]
4099 // 2nd bin: Cov(<2>,<sin(phi)>) * (sum_{i=1}^{N} w_{<2>}_i w_{<sin(phi)>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<sin(phi)>}_j)]
4100 // 3rd bin: Cov(<cos(phi)>,<sin(phi)>) * (sum_{i=1}^{N} w_{<cos(phi)>}_i w_{<sin(phi)>}_i )/[(sum_{i=1}^{N} w_{<cos(phi)>}_i) * (sum_{j=1}^{N} w_{<sin(phi)>}_j)]
4101 // ...
4102
4103 // Cov(<2>,<cos(phi)>):
4104 Double_t product1 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(1); // <<2><cos(phi)>>
4105 Double_t term1st1 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4106 Double_t term2nd1 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi)>>
4107 Double_t sumOfW1st1 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4108 Double_t sumOfW2nd1 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi)>}
4109 Double_t sumOfWW1 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(1); // W_{<2>} * W_{<cos(phi)>}
4110 // numerator in the expression for the the unbiased estimator for covariance:
4111 Double_t numerator1 = product1 - term1st1*term2nd1;
4112 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4113 Double_t denominator1 = 0.;
4114 if(TMath::Abs(sumOfW1st1*sumOfW2nd1)>0.)
4115 {
4116 denominator1 = 1.-sumOfWW1/(sumOfW1st1*sumOfW2nd1);
4117 if(TMath::Abs(denominator1)>0.)
4118 {
4119 // covariance:
4120 Double_t covariance1 = numerator1/denominator1;
4121 // weight dependent prefactor for covariance:
4122 Double_t wPrefactor1 = sumOfWW1/(sumOfW1st1*sumOfW2nd1);
4123 // finally, store "weighted" covariance:
4124 fIntFlowCovariancesNUA->SetBinContent(1,wPrefactor1*covariance1);
4125 } // end of if(TMath::Abs(denominator)>0.)
4126 } // end of if(TMath::Abs(sumOfW1st1*sumOfW2nd1)>0.)
4127
0328db2d 4128 // Cov(<2>,<sin(phi)>):
4129 Double_t product2 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(2); // <<2><sin(phi)>>
4130 Double_t term1st2 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4131 Double_t term2nd2 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi)>>
4132 Double_t sumOfW1st2 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4133 Double_t sumOfW2nd2 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi)>}
4134 Double_t sumOfWW2 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(2); // W_{<2>} * W_{<sin(phi)>}
4135 // numerator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4136 Double_t numerator2 = product2 - term1st2*term2nd2;
0328db2d 4137 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4138 Double_t denominator2 = 0.;
4139 if(TMath::Abs(sumOfW1st2*sumOfW2nd2)>0.)
4140 {
4141 denominator2 = 1.-sumOfWW2/(sumOfW1st2*sumOfW2nd2);
4142 if(TMath::Abs(denominator2)>0.)
4143 {
4144 // covariance:
4145 Double_t covariance2 = numerator2/denominator2;
4146 // weight dependent prefactor for covariance:
4147 Double_t wPrefactor2 = sumOfWW2/(sumOfW1st2*sumOfW2nd2);
4148 // finally, store "weighted" covariance:
4149 fIntFlowCovariancesNUA->SetBinContent(2,wPrefactor2*covariance2);
4150 } // end of if(TMath::Abs(denominator2)>0.)
4151 } // end of if(TMath::Abs(sumOfW1st2*sumOfW2nd2)>0.)
0328db2d 4152
4153 // Cov(<cos(phi)>,<sin(phi)>):
4154 Double_t product3 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(3); // <<cos(phi)><sin(phi)>>
4155 Double_t term1st3 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi)>>
4156 Double_t term2nd3 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi)>>
4157 Double_t sumOfW1st3 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi)>}
4158 Double_t sumOfW2nd3 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi)>}
4159 Double_t sumOfWW3 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(3); // W_{<cos(phi)>} * W_{<sin(phi)>}
4160 // numerator in the expression for the the unbiased estimator for covariance:
4161 Double_t numerator3 = product3 - term1st3*term2nd3;
4162 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4163 Double_t denominator3 = 0;
4164 if(TMath::Abs(sumOfW1st3*sumOfW2nd3)>0.)
4165 {
4166 denominator3 = 1.-sumOfWW3/(sumOfW1st3*sumOfW2nd3);
4167 if(TMath::Abs(denominator3)>0.)
4168 {
4169 // covariance:
4170 Double_t covariance3 = numerator3/denominator3;
4171 // weight dependent prefactor for covariance:
4172 Double_t wPrefactor3 = sumOfWW3/(sumOfW1st3*sumOfW2nd3);
4173 // finally, store "weighted" covariance:
4174 fIntFlowCovariancesNUA->SetBinContent(3,wPrefactor3*covariance3);
4175 } // end of if(TMath::Abs(denominator3)>0.)
4176 } // end of if(TMath::Abs(sumOfW1st3*sumOfW2nd3)>0.)
0328db2d 4177
4178 // Cov(<2>,<cos(phi1+phi2)>):
4179 Double_t product4 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(4); // <<2><cos(phi1+phi2)>>
4180 Double_t term1st4 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4181 Double_t term2nd4 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4182 Double_t sumOfW1st4 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4183 Double_t sumOfW2nd4 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4184 Double_t sumOfWW4 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(4); // W_{<2>} * W_{<cos(phi1+phi2)>}
4185 // numerator in the expression for the the unbiased estimator for covariance:
4186 Double_t numerator4 = product4 - term1st4*term2nd4;
4187 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4188 Double_t denominator4 = 0.;
4189 if(TMath::Abs(sumOfW1st4*sumOfW2nd4)>0.)
4190 {
4191 denominator4 = 1.-sumOfWW4/(sumOfW1st4*sumOfW2nd4);
4192 if(TMath::Abs(denominator4)>0.)
4193 {
4194 // covariance:
4195 Double_t covariance4 = numerator4/denominator4;
4196 // weight dependent prefactor for covariance:
4197 Double_t wPrefactor4 = sumOfWW4/(sumOfW1st4*sumOfW2nd4);
4198 // finally, store "weighted" covariance:
4199 fIntFlowCovariancesNUA->SetBinContent(4,wPrefactor4*covariance4);
4200 } // end of if(TMath::Abs(denominator4)>0.)
4201 } // end of if(TMath::Abs(sumOfW1st4*sumOfW2nd4)>0.)
4202
0328db2d 4203 // Cov(<2>,<sin(phi1+phi2)>):
4204 Double_t product5 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(5); // <<2><sin(phi1+phi2)>>
4205 Double_t term1st5 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4206 Double_t term2nd5 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4207 Double_t sumOfW1st5 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4208 Double_t sumOfW2nd5 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4209 Double_t sumOfWW5 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(5); // W_{<2>} * W_{<sin(phi1+phi2)>}
4210 // numerator in the expression for the the unbiased estimator for covariance:
4211 Double_t numerator5 = product5 - term1st5*term2nd5;
4212 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4213 Double_t denominator5 = 0.;
4214 if(TMath::Abs(sumOfW1st5*sumOfW2nd5)>0.)
4215 {
4216 denominator5 = 1.-sumOfWW5/(sumOfW1st5*sumOfW2nd5);
4217 if(TMath::Abs(denominator5)>0.)
4218 {
4219 // covariance:
4220 Double_t covariance5 = numerator5/denominator5;
4221 // weight dependent prefactor for covariance:
4222 Double_t wPrefactor5 = sumOfWW5/(sumOfW1st5*sumOfW2nd5);
4223 // finally, store "weighted" covariance:
4224 fIntFlowCovariancesNUA->SetBinContent(5,wPrefactor5*covariance5);
4225 } // end of if(TMath::Abs(denominator5)>0.)
4226 } // end of if(TMath::Abs(sumOfW1st5*sumOfW2nd5)>0.)
4227
0328db2d 4228 // Cov(<2>,<cos(phi1-phi2-phi3)>):
4229 Double_t product6 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(6); // <<2><cos(phi1-phi2-phi3)>>
4230 Double_t term1st6 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4231 Double_t term2nd6 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4232 Double_t sumOfW1st6 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4233 Double_t sumOfW2nd6 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4234 Double_t sumOfWW6 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(6); // W_{<2>} * W_{<cos(phi1-phi2-phi3)>}
4235 // numerator in the expression for the the unbiased estimator for covariance:
4236 Double_t numerator6 = product6 - term1st6*term2nd6;
4237 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4238 Double_t denominator6 = 0.;
4239 if(TMath::Abs(sumOfW1st6*sumOfW2nd6)>0.)
4240 {
4241 denominator6 = 1.-sumOfWW6/(sumOfW1st6*sumOfW2nd6);
4242 if(TMath::Abs(denominator6)>0.)
4243 {
4244 // covariance:
4245 Double_t covariance6 = numerator6/denominator6;
4246 // weight dependent prefactor for covariance:
4247 Double_t wPrefactor6 = sumOfWW6/(sumOfW1st6*sumOfW2nd6);
4248 // finally, store "weighted" covariance:
4249 fIntFlowCovariancesNUA->SetBinContent(6,wPrefactor6*covariance6);
4250 } // end of if(TMath::Abs(denominator6)>0.)
4251 } // end of if(TMath::Abs(sumOfW1st6*sumOfW2nd6)>0.)
4252
0328db2d 4253 // Cov(<2>,<sin(phi1-phi2-phi3)>):
4254 Double_t product7 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(7); // <<2><sin(phi1-phi2-phi3)>>
4255 Double_t term1st7 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4256 Double_t term2nd7 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4257 Double_t sumOfW1st7 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4258 Double_t sumOfW2nd7 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4259 Double_t sumOfWW7 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(7); // W_{<2>} * W_{<sin(phi1-phi2-phi3)>}
4260 // numerator in the expression for the the unbiased estimator for covariance:
4261 Double_t numerator7 = product7 - term1st7*term2nd7;
4262 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4263 Double_t denominator7 = 0.;
4264 if(TMath::Abs(sumOfW1st7*sumOfW2nd7)>0.)
4265 {
4266 denominator7 = 1.-sumOfWW7/(sumOfW1st7*sumOfW2nd7);
4267 if(TMath::Abs(denominator7)>0.)
4268 {
4269 // covariance:
4270 Double_t covariance7 = numerator7/denominator7;
4271 // weight dependent prefactor for covariance:
4272 Double_t wPrefactor7 = sumOfWW7/(sumOfW1st7*sumOfW2nd7);
4273 // finally, store "weighted" covariance:
4274 fIntFlowCovariancesNUA->SetBinContent(7,wPrefactor7*covariance7);
4275 } // end of if(TMath::Abs(denominator7)>0.)
4276 } // end of if(TMath::Abs(sumOfW1st7*sumOfW2nd7)>0.)
4277
0328db2d 4278 // Cov(<4>,<cos(phi1>):
4279 Double_t product8 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(8); // <<4><cos(phi1)>>
4280 Double_t term1st8 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4281 Double_t term2nd8 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4282 Double_t sumOfW1st8 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4283 Double_t sumOfW2nd8 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4284 Double_t sumOfWW8 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(8); // W_{<4>} * W_{<cos(phi1)>}
4285 // numerator in the expression for the the unbiased estimator for covariance:
4286 Double_t numerator8 = product8 - term1st8*term2nd8;
4287 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4288 Double_t denominator8 = 0.;
4289 if(TMath::Abs(sumOfW1st8*sumOfW2nd8)>0.)
4290 {
4291 denominator8 = 1.-sumOfWW8/(sumOfW1st8*sumOfW2nd8);
4292 if(TMath::Abs(denominator8)>0.)
4293 {
4294 // covariance:
4295 Double_t covariance8 = numerator8/denominator8;
4296 // weight dependent prefactor for covariance:
4297 Double_t wPrefactor8 = sumOfWW8/(sumOfW1st8*sumOfW2nd8);
4298 // finally, store "weighted" covariance:
4299 fIntFlowCovariancesNUA->SetBinContent(8,wPrefactor8*covariance8);
4300 } // end of if(TMath::Abs(denominator8)>0.)
4301 } // end of if(TMath::Abs(sumOfW1st8*sumOfW2nd8)>0.)
4302
0328db2d 4303 // Cov(<4>,<sin(phi1)>):
4304 Double_t product9 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(9); // <<4><sin(phi1)>>
4305 Double_t term1st9 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4306 Double_t term2nd9 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4307 Double_t sumOfW1st9 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4308 Double_t sumOfW2nd9 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4309 Double_t sumOfWW9 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(9); // W_{<4>} * W_{<sin(phi1)>}
4310 // numerator in the expression for the the unbiased estimator for covariance:
4311 Double_t numerator9 = product9 - term1st9*term2nd9;
4312 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4313 Double_t denominator9 = 0.;
4314 if(TMath::Abs(sumOfW1st9*sumOfW2nd9)>0.)
4315 {
4316 denominator9 = 1.-sumOfWW9/(sumOfW1st9*sumOfW2nd9);
4317 if(TMath::Abs(denominator9)>0.)
4318 {
4319 // covariance:
4320 Double_t covariance9 = numerator9/denominator9;
4321 // weight dependent prefactor for covariance:
4322 Double_t wPrefactor9 = sumOfWW9/(sumOfW1st9*sumOfW2nd9);
4323 // finally, store "weighted" covariance:
4324 fIntFlowCovariancesNUA->SetBinContent(9,wPrefactor9*covariance9);
4325 }
4326 } // end of if(TMath::Abs(sumOfW1st9*sumOfW2nd9)>0.)
4327
0328db2d 4328 // Cov(<4>,<cos(phi1+phi2)>):
4329 Double_t product10 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(10); // <<4><cos(phi1+phi2)>>
4330 Double_t term1st10 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4331 Double_t term2nd10 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4332 Double_t sumOfW1st10 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4333 Double_t sumOfW2nd10 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4334 Double_t sumOfWW10 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(10); // W_{<4>} * W_{<cos(phi1+phi2)>}
4335 // numerator in the expression for the the unbiased estimator for covariance:
4336 Double_t numerator10 = product10 - term1st10*term2nd10;
4337 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4338 Double_t denominator10 = 0.;
4339 if(TMath::Abs(sumOfW1st10*sumOfW2nd10)>0.)
4340 {
4341 denominator10 = 1.-sumOfWW10/(sumOfW1st10*sumOfW2nd10);
4342 if(TMath::Abs(denominator10)>0.)
4343 {
4344 // covariance:
4345 Double_t covariance10 = numerator10/denominator10;
4346 // weight dependent prefactor for covariance:
4347 Double_t wPrefactor10 = sumOfWW10/(sumOfW1st10*sumOfW2nd10);
4348 // finally, store "weighted" covariance:
4349 fIntFlowCovariancesNUA->SetBinContent(10,wPrefactor10*covariance10);
4350 } // end of if(TMath::Abs(denominator10)>0.)
4351 } // end of if(TMath::Abs(sumOfW1st10*sumOfW2nd10)>0.)
4352
0328db2d 4353 // Cov(<4>,<sin(phi1+phi2)>):
4354 Double_t product11 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(11); // <<4><sin(phi1+phi2)>>
4355 Double_t term1st11 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4356 Double_t term2nd11 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4357 Double_t sumOfW1st11 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4358 Double_t sumOfW2nd11 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4359 Double_t sumOfWW11 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(11); // W_{<4>} * W_{<sin(phi1+phi2)>}
4360 // numerator in the expression for the the unbiased estimator for covariance:
4361 Double_t numerator11 = product11 - term1st11*term2nd11;
4362 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4363 Double_t denominator11 = 0.;
4364 if(TMath::Abs(sumOfW1st11*sumOfW2nd11)>0.)
4365 {
4366 denominator11 = 1.-sumOfWW11/(sumOfW1st11*sumOfW2nd11);
4367 if(TMath::Abs(denominator11)>0.)
4368 {
4369 // covariance:
4370 Double_t covariance11 = numerator11/denominator11;
4371 // weight dependent prefactor for covariance:
4372 Double_t wPrefactor11 = sumOfWW11/(sumOfW1st11*sumOfW2nd11);
4373 // finally, store "weighted" covariance:
4374 fIntFlowCovariancesNUA->SetBinContent(11,wPrefactor11*covariance11);
4375 } // end of if(TMath::Abs(denominator11)>0.)
4376 } // end of if(TMath::Abs(sumOfW1st11*sumOfW2nd11)>0.)
0328db2d 4377
4378 // Cov(<4>,<cos(phi1-phi2-phi3)>):
4379 Double_t product12 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(12); // <<4><cos(phi1-phi2-phi3)>>
4380 Double_t term1st12 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4381 Double_t term2nd12 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4382 Double_t sumOfW1st12 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4383 Double_t sumOfW2nd12 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4384 Double_t sumOfWW12 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(12); // W_{<4>} * W_{<cos(phi1-phi2-phi3)>}
4385 // numerator in the expression for the the unbiased estimator for covariance:
4386 Double_t numerator12 = product12 - term1st12*term2nd12;
4387 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4388 Double_t denominator12 = 0.;
4389 if(TMath::Abs(sumOfW1st12*sumOfW2nd12)>0.)
4390 {
4391 denominator12 = 1.-sumOfWW12/(sumOfW1st12*sumOfW2nd12);
4392 if(TMath::Abs(denominator12)>0.)
4393 {
4394 // covariance:
4395 Double_t covariance12 = numerator12/denominator12;
4396 // weight dependent prefactor for covariance:
4397 Double_t wPrefactor12 = sumOfWW12/(sumOfW1st12*sumOfW2nd12);
4398 // finally, store "weighted" covariance:
4399 fIntFlowCovariancesNUA->SetBinContent(12,wPrefactor12*covariance12);
4400 } // end of if(TMath::Abs(denominator12)>0.)
4401 } // end of if(TMath::Abs(sumOfW1st12*sumOfW2nd12)>0.)
0328db2d 4402
4403 // Cov(<4>,<sin(phi1-phi2-phi3)>):
4404 Double_t product13 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(13); // <<4><sin(phi1-phi2-phi3)>>
4405 Double_t term1st13 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4406 Double_t term2nd13 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4407 Double_t sumOfW1st13 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4408 Double_t sumOfW2nd13 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4409 Double_t sumOfWW13 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(13); // W_{<4>} * W_{<sin(phi1-phi2-phi3)>}
4410 // numerator in the expression for the the unbiased estimator for covariance:
4411 Double_t numerator13 = product13 - term1st13*term2nd13;
4412 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4413 Double_t denominator13 = 0.;
4414 if(TMath::Abs(sumOfW1st13*sumOfW2nd13)>0.)
4415 {
4416 denominator13 = 1.-sumOfWW13/(sumOfW1st13*sumOfW2nd13);
4417 if(TMath::Abs(denominator13)>0.)
4418 {
4419 // covariance:
4420 Double_t covariance13 = numerator13/denominator13;
4421 // weight dependent prefactor for covariance:
4422 Double_t wPrefactor13 = sumOfWW13/(sumOfW1st13*sumOfW2nd13);
4423 // finally, store "weighted" covariance:
4424 fIntFlowCovariancesNUA->SetBinContent(13,wPrefactor13*covariance13);
4425 } // end of if(TMath::Abs(denominator13)>0.)
4426 } // end of if(TMath::Abs(sumOfW1st13*sumOfW2nd13)>0.)
0328db2d 4427
4428 // Cov(<cos(phi1)>,<cos(phi1+phi2)>):
4429 Double_t product14 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(14); // <<cos(phi1)><cos(phi1+phi2)>>
4430 Double_t term1st14 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4431 Double_t term2nd14 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4432 Double_t sumOfW1st14 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4433 Double_t sumOfW2nd14 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4434 Double_t sumOfWW14 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(14); // W_{<cos(phi1)>} * W_{<cos(phi1+phi2)>}
4435 // numerator in the expression for the the unbiased estimator for covariance:
4436 Double_t numerator14 = product14 - term1st14*term2nd14;
4437 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4438 Double_t denominator14 = 0.;
4439 if(TMath::Abs(sumOfW1st14*sumOfW2nd14)>0.)
4440 {
4441 denominator14 = 1.-sumOfWW14/(sumOfW1st14*sumOfW2nd14);
4442 if(TMath::Abs(denominator14)>0.)
4443 {
4444 // covariance:
4445 Double_t covariance14 = numerator14/denominator14;
4446 // weight dependent prefactor for covariance:
4447 Double_t wPrefactor14 = sumOfWW14/(sumOfW1st14*sumOfW2nd14);
4448 // finally, store "weighted" covariance:
4449 fIntFlowCovariancesNUA->SetBinContent(14,wPrefactor14*covariance14);
4450 } // end of if(TMath::Abs(denominator14)>0.)
4451 } // end of if(TMath::Abs(sumOfW1st14*sumOfW2nd14)>0.)
0328db2d 4452
4453 // Cov(<cos(phi1)>,<sin(phi1+phi2)>):
4454 Double_t product15 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(15); // <<cos(phi1)><sin(phi1+phi2)>>
4455 Double_t term1st15 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4456 Double_t term2nd15 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4457 Double_t sumOfW1st15 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4458 Double_t sumOfW2nd15 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4459 Double_t sumOfWW15 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(15); // W_{<cos(phi1)>} * W_{<sin(phi1+phi2)>}
4460 // numerator in the expression for the the unbiased estimator for covariance:
4461 Double_t numerator15 = product15 - term1st15*term2nd15;
4462 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4463 Double_t denominator15 = 0.;
4464 if(TMath::Abs(sumOfW1st15*sumOfW2nd15)>0.)
4465 {
4466 denominator15 = 1.-sumOfWW15/(sumOfW1st15*sumOfW2nd15);
4467 if(TMath::Abs(denominator15)>0.)
4468 {
4469 // covariance:
4470 Double_t covariance15 = numerator15/denominator15;
4471 // weight dependent prefactor for covariance:
4472 Double_t wPrefactor15 = sumOfWW15/(sumOfW1st15*sumOfW2nd15);
4473 // finally, store "weighted" covariance:
4474 fIntFlowCovariancesNUA->SetBinContent(15,wPrefactor15*covariance15);
4475 } // end of if(TMath::Abs(denominator15)>0.)
4476 } // end of if(TMath::Abs(sumOfW1st15*sumOfW2nd15)>0.)
4477
0328db2d 4478 // Cov(<cos(phi1)>,<cos(phi1-phi2-phi3)>):
4479 Double_t product16 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(16); // <<cos(phi1)><cos(phi1-phi2-phi3)>>
4480 Double_t term1st16 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4481 Double_t term2nd16 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4482 Double_t sumOfW1st16 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4483 Double_t sumOfW2nd16 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4484 Double_t sumOfWW16 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(16); // W_{<cos(phi1)>} * W_{<cos(phi1-phi2-phi3)>}
4485 // numerator in the expression for the the unbiased estimator for covariance:
4486 Double_t numerator16 = product16 - term1st16*term2nd16;
4487 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4488 Double_t denominator16 = 0.;
4489 if(TMath::Abs(sumOfW1st16*sumOfW2nd16)>0.)
4490 {
4491 denominator16 = 1.-sumOfWW16/(sumOfW1st16*sumOfW2nd16);
4492 if(TMath::Abs(denominator16)>0.)
4493 {
4494 // covariance:
4495 Double_t covariance16 = numerator16/denominator16;
4496 // weight dependent prefactor for covariance:
4497 Double_t wPrefactor16 = sumOfWW16/(sumOfW1st16*sumOfW2nd16);
4498 // finally, store "weighted" covariance:
4499 fIntFlowCovariancesNUA->SetBinContent(16,wPrefactor16*covariance16);
4500 } // end of if(TMath::Abs(denominator16)>0.)
4501 } // end ofif(TMath::Abs(sumOfW1st16*sumOfW2nd16)>0.)
4502
0328db2d 4503 // Cov(<cos(phi1)>,<sin(phi1-phi2-phi3)>):
4504 Double_t product17 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(17); // <<cos(phi1)><sin(phi1-phi2-phi3)>>
4505 Double_t term1st17 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4506 Double_t term2nd17 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4507 Double_t sumOfW1st17 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4508 Double_t sumOfW2nd17 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4509 Double_t sumOfWW17 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(17); // W_{<cos(phi1)>} * W_{<sin(phi1-phi2-phi3)>}
4510 // numerator in the expression for the the unbiased estimator for covariance:
4511 Double_t numerator17 = product17 - term1st17*term2nd17;
4512 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4513 Double_t denominator17 = 0.;
4514 if(TMath::Abs(sumOfW1st17*sumOfW2nd17)>0.)
4515 {
4516 denominator17 = 1.-sumOfWW17/(sumOfW1st17*sumOfW2nd17);
4517 if(TMath::Abs(denominator17)>0.)
4518 {
4519 // covariance:
4520 Double_t covariance17 = numerator17/denominator17;
4521 // weight dependent prefactor for covariance:
4522 Double_t wPrefactor17 = sumOfWW17/(sumOfW1st17*sumOfW2nd17);
4523 // finally, store "weighted" covariance:
4524 fIntFlowCovariancesNUA->SetBinContent(17,wPrefactor17*covariance17);
4525 } // end of if(TMath::Abs(denominator17)>0.)
4526 } // end of if(TMath::Abs(sumOfW1st17*sumOfW2nd17)>0.)
0328db2d 4527
4528 // Cov(<sin(phi1)>,<cos(phi1+phi2)>):
4529 Double_t product18 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(18); // <<sin(phi1)><cos(phi1+phi2)>>
4530 Double_t term1st18 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4531 Double_t term2nd18 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4532 Double_t sumOfW1st18 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4533 Double_t sumOfW2nd18 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4534 Double_t sumOfWW18 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(18); // W_{<sin(phi1)>} * W_{<cos(phi1+phi2)>}
4535 // numerator in the expression for the the unbiased estimator for covariance:
4536 Double_t numerator18 = product18 - term1st18*term2nd18;
4537 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4538 Double_t denominator18 = 0.;
4539 if(TMath::Abs(sumOfW1st18*sumOfW2nd18)>0.)
4540 {
4541 denominator18 = 1.-sumOfWW18/(sumOfW1st18*sumOfW2nd18);
4542 if(TMath::Abs(denominator18)>0.)
4543 {
4544 // covariance:
4545 Double_t covariance18 = numerator18/denominator18;
4546 // weight dependent prefactor for covariance:
4547 Double_t wPrefactor18 = sumOfWW18/(sumOfW1st18*sumOfW2nd18);
4548 // finally, store "weighted" covariance:
4549 fIntFlowCovariancesNUA->SetBinContent(18,wPrefactor18*covariance18);
4550 } // end of if(TMath::Abs(denominator18)>0.)
4551 } // end of if(TMath::Abs(sumOfW1st18*sumOfW2nd18)>0.)
0328db2d 4552
4553 // Cov(<sin(phi1)>,<sin(phi1+phi2)>):
4554 Double_t product19 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(19); // <<sin(phi1)><sin(phi1+phi2)>>
4555 Double_t term1st19 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4556 Double_t term2nd19 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4557 Double_t sumOfW1st19 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4558 Double_t sumOfW2nd19 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4559 Double_t sumOfWW19 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(19); // W_{<sin(phi1)>} * W_{<sin(phi1+phi2)>}
4560 // numerator in the expression for the the unbiased estimator for covariance:
4561 Double_t numerator19 = product19 - term1st19*term2nd19;
4562 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4563 Double_t denominator19 = 0.;
4564 if(TMath::Abs(sumOfW1st19*sumOfW2nd19)>0.)
4565 {
4566 denominator19 = 1.-sumOfWW19/(sumOfW1st19*sumOfW2nd19);
4567 if(TMath::Abs(denominator19)>0.)
4568 {
4569 // covariance:
4570 Double_t covariance19 = numerator19/denominator19;
4571 // weight dependent prefactor for covariance:
4572 Double_t wPrefactor19 = sumOfWW19/(sumOfW1st19*sumOfW2nd19);
4573 // finally, store "weighted" covariance:
4574 fIntFlowCovariancesNUA->SetBinContent(19,wPrefactor19*covariance19);
4575 } // end of if(TMath::Abs(denominator19)>0.)
4576 } // end of if(TMath::Abs(sumOfW1st19*sumOfW2nd19)>0.)
4577
0328db2d 4578 // Cov(<sin(phi1)>,<cos(phi1-phi2-phi3)>):
4579 Double_t product20 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(20); // <<sin(phi1)><cos(phi1-phi2-phi3)>>
4580 Double_t term1st20 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4581 Double_t term2nd20 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4582 Double_t sumOfW1st20 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4583 Double_t sumOfW2nd20 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4584 Double_t sumOfWW20 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(20); // W_{<sin(phi1)>} * W_{<cos(phi1-phi2-phi3)>}
4585 // numerator in the expression for the the unbiased estimator for covariance:
4586 Double_t numerator20 = product20 - term1st20*term2nd20;
4587 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4588 Double_t denominator20 = 0.;
4589 if(TMath::Abs(sumOfW1st20*sumOfW2nd20)>0.)
4590 {
4591 denominator20 = 1.-sumOfWW20/(sumOfW1st20*sumOfW2nd20);
4592 if(TMath::Abs(denominator20)>0.)
4593 {
4594 // covariance:
4595 Double_t covariance20 = numerator20/denominator20;
4596 // weight dependent prefactor for covariance:
4597 Double_t wPrefactor20 = sumOfWW20/(sumOfW1st20*sumOfW2nd20);
4598 // finally, store "weighted" covariance:
4599 fIntFlowCovariancesNUA->SetBinContent(20,wPrefactor20*covariance20);
4600 } // end of if(TMath::Abs(denominator20)>0.)
4601 } // end of if(TMath::Abs(sumOfW1st20*sumOfW2nd20)>0.)
0328db2d 4602
4603 // Cov(<sin(phi1)>,<sin(phi1-phi2-phi3)>):
4604 Double_t product21 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(21); // <<sin(phi1)><sin(phi1-phi2-phi3)>>
4605 Double_t term1st21 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4606 Double_t term2nd21 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4607 Double_t sumOfW1st21 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4608 Double_t sumOfW2nd21 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4609 Double_t sumOfWW21 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(21); // W_{<sin(phi1)>} * W_{<sin(phi1-phi2-phi3)>}
4610 // numerator in the expression for the the unbiased estimator for covariance:
4611 Double_t numerator21 = product21 - term1st21*term2nd21;
4612 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4613 Double_t denominator21 = 0.;
4614 if(TMath::Abs(sumOfW1st21*sumOfW2nd21)>0.)
4615 {
4616 denominator21 = 1.-sumOfWW21/(sumOfW1st21*sumOfW2nd21);
4617 if(TMath::Abs(denominator21)>0.)
4618 {
4619 // covariance:
4620 Double_t covariance21 = numerator21/denominator21;
4621 // weight dependent prefactor for covariance:
4622 Double_t wPrefactor21 = sumOfWW21/(sumOfW1st21*sumOfW2nd21);
4623 // finally, store "weighted" covariance:
4624 fIntFlowCovariancesNUA->SetBinContent(21,wPrefactor21*covariance21);
4625 } // end of if(TMath::Abs(denominator21)>0.)
4626 } // end of if(TMath::Abs(sumOfW1st21*sumOfW2nd21)>0.)
0328db2d 4627
4628 // Cov(<cos(phi1+phi2)>,<sin(phi1+phi2)>):
4629 Double_t product22 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(22); // <<cos(phi1+phi2)><sin(phi1+phi2)>>
4630 Double_t term1st22 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4631 Double_t term2nd22 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4632 Double_t sumOfW1st22 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4633 Double_t sumOfW2nd22 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4634 Double_t sumOfWW22 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(22); // W_{<cos(phi1+phi2)>} * W_{<sin(phi1+phi2)>}
4635 // numerator in the expression for the the unbiased estimator for covariance:
4636 Double_t numerator22 = product22 - term1st22*term2nd22;
4637 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4638 Double_t denominator22 = 0.;
4639 if(TMath::Abs(sumOfW1st22*sumOfW2nd22)>0.)
4640 {
4641 denominator22 = 1.-sumOfWW22/(sumOfW1st22*sumOfW2nd22);
4642 if(TMath::Abs(denominator22)>0.)
4643 {
4644 // covariance:
4645 Double_t covariance22 = numerator22/denominator22;
4646 // weight dependent prefactor for covariance:
4647 Double_t wPrefactor22 = sumOfWW22/(sumOfW1st22*sumOfW2nd22);
4648 // finally, store "weighted" covariance:
4649 fIntFlowCovariancesNUA->SetBinContent(22,wPrefactor22*covariance22);
4650 } // end of if(TMath::Abs(denominator22)>0.)
4651 } // end of if(TMath::Abs(sumOfW1st22*sumOfW2nd22)>0.)
0328db2d 4652
4653 // Cov(<cos(phi1+phi2)>,<cos(phi1-phi2-phi3)>):
4654 Double_t product23 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(23); // <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>
4655 Double_t term1st23 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4656 Double_t term2nd23 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4657 Double_t sumOfW1st23 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4658 Double_t sumOfW2nd23 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4659 Double_t sumOfWW23 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(23); // W_{<cos(phi1+phi2)>} * W_{<cos(phi1-phi2-phi3)>}
4660 // numerator in the expression for the the unbiased estimator for covariance:
4661 Double_t numerator23 = product23 - term1st23*term2nd23;
4662 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4663 Double_t denominator23 = 0.;
4664 if(TMath::Abs(sumOfW1st23*sumOfW2nd23)>0.)
4665 {
4666 denominator23 = 1.-sumOfWW23/(sumOfW1st23*sumOfW2nd23);
4667 if(TMath::Abs(denominator23)>0.)
4668 {
4669 // covariance:
4670 Double_t covariance23 = numerator23/denominator23;
4671 // weight dependent prefactor for covariance:
4672 Double_t wPrefactor23 = sumOfWW23/(sumOfW1st23*sumOfW2nd23);
4673 // finally, store "weighted" covariance:
4674 fIntFlowCovariancesNUA->SetBinContent(23,wPrefactor23*covariance23);
4675 } // end of if(TMath::Abs(denominator23)>0.)
4676 } // end of if(TMath::Abs(sumOfW1st23*sumOfW2nd23)>0.)
4677
0328db2d 4678 // Cov(<cos(phi1+phi2)>,<sin(phi1-phi2-phi3)>):
4679 Double_t product24 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(24); // <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>
4680 Double_t term1st24 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4681 Double_t term2nd24 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4682 Double_t sumOfW1st24 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4683 Double_t sumOfW2nd24 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4684 Double_t sumOfWW24 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(24); // W_{<cos(phi1+phi2)>} * W_{<sin(phi1-phi2-phi3)>}
4685 // numerator in the expression for the the unbiased estimator for covariance:
4686 Double_t numerator24 = product24 - term1st24*term2nd24;
4687 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4688 Double_t denominator24 = 0.;
4689 if(TMath::Abs(sumOfW1st24*sumOfW2nd24)>0.)
4690 {
4691 denominator24 = 1.-sumOfWW24/(sumOfW1st24*sumOfW2nd24);
4692 if(TMath::Abs(denominator24)>0.)
4693 {
4694 // covariance:
4695 Double_t covariance24 = numerator24/denominator24;
4696 // weight dependent prefactor for covariance:
4697 Double_t wPrefactor24 = sumOfWW24/(sumOfW1st24*sumOfW2nd24);
4698 // finally, store "weighted" covariance:
4699 fIntFlowCovariancesNUA->SetBinContent(24,wPrefactor24*covariance24);
4700 } // end of if(TMath::Abs(denominator24)>0.)
4701 } // end of if(TMath::Abs(sumOfW1st24*sumOfW2nd24)>0.)
0328db2d 4702
4703 // Cov(<sin(phi1+phi2)>,<cos(phi1-phi2-phi3)>):
4704 Double_t product25 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(25); // <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>
4705 Double_t term1st25 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4706 Double_t term2nd25 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4707 Double_t sumOfW1st25 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4708 Double_t sumOfW2nd25 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4709 Double_t sumOfWW25 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(25); // W_{<sin(phi1+phi2)>} * W_{<cos(phi1-phi2-phi3)>}
4710 // numerator in the expression for the the unbiased estimator for covariance:
4711 Double_t numerator25 = product25 - term1st25*term2nd25;
4712 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4713 Double_t denominator25 = 0.;
4714 if(TMath::Abs(sumOfW1st25*sumOfW2nd25)>0.)
4715 {
4716 denominator25 = 1.-sumOfWW25/(sumOfW1st25*sumOfW2nd25);
4717 if(TMath::Abs(denominator25)>0.)
4718 {
4719 // covariance:
4720 Double_t covariance25 = numerator25/denominator25;
4721 // weight dependent prefactor for covariance:
4722 Double_t wPrefactor25 = sumOfWW25/(sumOfW1st25*sumOfW2nd25);
4723 // finally, store "weighted" covariance:
4724 fIntFlowCovariancesNUA->SetBinContent(25,wPrefactor25*covariance25);
4725 } // end of if(TMath::Abs(denominator25)>0.)
4726 } // end of if(TMath::Abs(sumOfW1st25*sumOfW2nd25)>0.)
4727
0328db2d 4728 // Cov(<sin(phi1+phi2)>,<sin(phi1-phi2-phi3)>):
4729 Double_t product26 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(26); // <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>
4730 Double_t term1st26 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4731 Double_t term2nd26 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4732 Double_t sumOfW1st26 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4733 Double_t sumOfW2nd26 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4734 Double_t sumOfWW26 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(26); // W_{<sin(phi1+phi2)>} * W_{<sin(phi1-phi2-phi3)>}
4735 // numerator in the expression for the the unbiased estimator for covariance:
4736 Double_t numerator26 = product26 - term1st26*term2nd26;
4737 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4738 Double_t denominator26 = 0.;
4739 if(TMath::Abs(sumOfW1st26*sumOfW2nd26)>0.)
4740 {
4741 denominator26 = 1.-sumOfWW26/(sumOfW1st26*sumOfW2nd26);
4742 if(TMath::Abs(denominator26)>0.)
4743 {
4744 // covariance:
4745 Double_t covariance26 = numerator26/denominator26;
4746 // weight dependent prefactor for covariance:
4747 Double_t wPrefactor26 = sumOfWW26/(sumOfW1st26*sumOfW2nd26);
4748 // finally, store "weighted" covariance:
4749 fIntFlowCovariancesNUA->SetBinContent(26,wPrefactor26*covariance26);
4750 } // end of if(TMath::Abs(denominator26)>0.)
4751 } // end of if(TMath::Abs(sumOfW1st26*sumOfW2nd26)>0.)
4752
0328db2d 4753 // Cov(<cos(phi1-phi2-phi3)>,<sin(phi1-phi2-phi3)>):
4754 Double_t product27 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(27); // <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>
b92ea2b9 4755 Double_t term1st27 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
0328db2d 4756 Double_t term2nd27 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
b92ea2b9 4757 Double_t sumOfW1st27 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
0328db2d 4758 Double_t sumOfW2nd27 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4759 Double_t sumOfWW27 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(27); // W_{<cos(phi1-phi2-phi3)>} * W_{<sin(phi1-phi2-phi3)>}
4760 // numerator in the expression for the the unbiased estimator for covariance:
4761 Double_t numerator27 = product27 - term1st27*term2nd27;
4762 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4763 Double_t denominator27 = 0.;
4764 if(TMath::Abs(sumOfW1st27*sumOfW2nd27)>0.)
4765 {
4766 denominator27 = 1.-sumOfWW27/(sumOfW1st27*sumOfW2nd27);
4767 if(TMath::Abs(denominator27)>0.)
4768 {
4769 // covariance:
4770 Double_t covariance27 = numerator27/denominator27;
4771 // weight dependent prefactor for covariance:
4772 Double_t wPrefactor27 = sumOfWW27/(sumOfW1st27*sumOfW2nd27);
4773 // finally, store "weighted" covariance:
4774 fIntFlowCovariancesNUA->SetBinContent(27,wPrefactor27*covariance27);
4775 } // end of if(TMath::Abs(denominator27)>0.)
4776 } // end of if(TMath::Abs(sumOfW1st27*sumOfW2nd27)>0.)
4777
0328db2d 4778} // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesNUAIntFlow()
4779
0328db2d 4780//================================================================================================================================
4781
489d5531 4782void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()
4783{
4784 // From profile fIntFlowCorrelationsPro access measured correlations and spread,
4785 // correctly calculate the statistical errors and store the final results and
4786 // statistical errors for correlations in histogram fIntFlowCorrelationsHist.
4787 //
4788 // Remark: Statistical error of correlation is calculated as:
4789 //
4790 // statistical error = termA * spread * termB:
4791 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)
4792 // termB = 1/sqrt(1-termA^2)
b3dacf6b 4793 //
4794
489d5531 4795 for(Int_t ci=1;ci<=4;ci++) // correlation index
4796 {
b40a910e 4797 if(fIntFlowCorrelationsPro->GetBinEffectiveEntries(ci) < 2 || fIntFlowSquaredCorrelationsPro->GetBinEffectiveEntries(ci) < 2)
4798 {
4799 fIntFlowCorrelationsPro->SetBinError(ci,0.);
4800 fIntFlowSquaredCorrelationsPro->SetBinError(ci,0.);
4801 continue;
4802 }
489d5531 4803 Double_t correlation = fIntFlowCorrelationsPro->GetBinContent(ci);
b40a910e 4804 Double_t squaredCorrelation = fIntFlowSquaredCorrelationsPro->GetBinContent(ci);
4805 Double_t spread = 0.;
4806 if(squaredCorrelation-correlation*correlation >= 0.)
4807 {
4808 spread = pow(squaredCorrelation-correlation*correlation,0.5);
4809 } else
4810 {
4811 cout<<endl;
4812 cout<<Form(" WARNING: Imaginary 'spread' for %d-particle correlation!!!! ",2*ci)<<endl;
4813 cout<<endl;
4814 }
489d5531 4815 Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);
4816 Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);
4817 Double_t termA = 0.;
4818 Double_t termB = 0.;
b3dacf6b 4819 if(TMath::Abs(sumOfLinearEventWeights) > 0.) // to be improved - shall I omitt here Abs() ?
489d5531 4820 {
4821 termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;
4822 } else
4823 {
b3dacf6b 4824 cout<<endl;
4825 cout<<" WARNING (QC): sumOfLinearEventWeights == 0 in method FinalizeCorrelationsIntFlow() !!!!"<<endl;
4826 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;
4827 cout<<endl;
489d5531 4828 }
4829 if(1.-pow(termA,2.) > 0.)
4830 {
4831 termB = 1./pow(1-pow(termA,2.),0.5);
4832 } else
4833 {
b3dacf6b 4834 cout<<endl;
4835 cout<<" WARNING (QC): 1.-pow(termA,2.) <= 0 in method FinalizeCorrelationsIntFlow() !!!!"<<endl;
4836 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;
4837 cout<<endl;
489d5531 4838 }
4839 Double_t statisticalError = termA * spread * termB;
4840 fIntFlowCorrelationsHist->SetBinContent(ci,correlation);
4841 fIntFlowCorrelationsHist->SetBinError(ci,statisticalError);
ff70ca91 4842 } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index
4843
b3dacf6b 4844 // Versus multiplicity:
4845 if(!fCalculateCumulantsVsM){return;}
ff70ca91 4846 for(Int_t ci=0;ci<=3;ci++) // correlation index
4847 {
4848 Int_t nBins = fIntFlowCorrelationsVsMPro[ci]->GetNbinsX();
4849 for(Int_t b=1;b<=nBins;b++) // looping over multiplicity bins
4850 {
b40a910e 4851 if(fIntFlowCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b) < 2 || fIntFlowSquaredCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b) < 2)
4852 {
4853 fIntFlowCorrelationsVsMPro[ci]->SetBinError(b,0.);
4854 fIntFlowSquaredCorrelationsVsMPro[ci]->SetBinError(b,0.);
4855 continue;
4856 }
ff70ca91 4857 Double_t correlationVsM = fIntFlowCorrelationsVsMPro[ci]->GetBinContent(b);
b40a910e 4858 Double_t squaredCorrelationVsM = fIntFlowSquaredCorrelationsVsMPro[ci]->GetBinContent(b);
4859 Double_t spreadVsM = 0.;
4860 if(squaredCorrelationVsM-correlationVsM*correlationVsM >= 0.)
4861 {
4862 spreadVsM = pow(squaredCorrelationVsM-correlationVsM*correlationVsM,0.5);
4863 } else
4864 {
4865 cout<<endl;
4866 cout<<Form(" WARNING (QC): Imaginary 'spreadVsM' for ci = %d, bin = %d, entries = %f !!!!",
4867 ci,b,fIntFlowCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b))<<endl;
4868 cout<<endl;
4869 }
ff70ca91 4870 Double_t sumOfLinearEventWeightsVsM = fIntFlowSumOfEventWeightsVsM[ci][0]->GetBinContent(b);
4871 Double_t sumOfQuadraticEventWeightsVsM = fIntFlowSumOfEventWeightsVsM[ci][1]->GetBinContent(b);
4872 Double_t termAVsM = 0.;
4873 Double_t termBVsM = 0.;
b40a910e 4874 if(sumOfLinearEventWeightsVsM > 0.)
ff70ca91 4875 {
4876 termAVsM = pow(sumOfQuadraticEventWeightsVsM,0.5)/sumOfLinearEventWeightsVsM;
b3dacf6b 4877 }
ff70ca91 4878 if(1.-pow(termAVsM,2.) > 0.)
4879 {
4880 termBVsM = 1./pow(1-pow(termAVsM,2.),0.5);
b3dacf6b 4881 }
ff70ca91 4882 Double_t statisticalErrorVsM = termAVsM * spreadVsM * termBVsM;
4883 fIntFlowCorrelationsVsMHist[ci]->SetBinContent(b,correlationVsM);
4884 fIntFlowCorrelationsVsMHist[ci]->SetBinError(b,statisticalErrorVsM);
4885 } // end of for(Int_t b=1;b<=nBins;b++)
4886 } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index
4887
489d5531 4888} // end of AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()
4889
489d5531 4890//================================================================================================================================
4891
489d5531 4892void AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(Int_t nRP)
4893{
b77b6434 4894 // Fill profile fAverageMultiplicity to hold average multiplicities and
4895 // number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8
489d5531 4896
4897 // Binning of fAverageMultiplicity is organized as follows:
4898 // 1st bin: all events (including the empty ones)
4899 // 2nd bin: event with # of RPs greater or equal to 1
4900 // 3rd bin: event with # of RPs greater or equal to 2
4901 // 4th bin: event with # of RPs greater or equal to 3
4902 // 5th bin: event with # of RPs greater or equal to 4
4903 // 6th bin: event with # of RPs greater or equal to 5
4904 // 7th bin: event with # of RPs greater or equal to 6
4905 // 8th bin: event with # of RPs greater or equal to 7
4906 // 9th bin: event with # of RPs greater or equal to 8
4907
489d5531 4908 if(nRP<0)
4909 {
b77b6434 4910 cout<<endl;
4911 cout<<" WARNING (QC): nRP<0 in in AFAWQC::FAM() !!!!"<<endl;
4912 cout<<endl;
489d5531 4913 exit(0);
4914 }
4915
4916 for(Int_t i=0;i<9;i++)
4917 {
b77b6434 4918 if(nRP>=i){fAvMultiplicity->Fill(i+0.5,nRP,1);}
489d5531 4919 }
4920
4921} // end of AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(nRP)
4922
489d5531 4923//================================================================================================================================
4924
489d5531 4925void AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()
b3dacf6b 4926{
b92ea2b9 4927 // a) Calculate Q-cumulants from the measured multiparticle correlations;
4928 // b) Propagate the statistical errors from measured multiparticle correlations to statistical errors of Q-cumulants;
4929 // c) Remark: Q-cumulants calculated in this method are biased by non-uniform acceptance of detector !!!!
4930 // Method CalculateQcumulantsCorrectedForNUAIntFlow() is called afterwards to correct for this bias;
4931 // d) Store the results and statistical error of Q-cumulants in histogram fIntFlowQcumulants.
4932 // Binning of fIntFlowQcumulants is organized as follows:
489d5531 4933 //
b3dacf6b 4934 // 1st bin: QC{2}
4935 // 2nd bin: QC{4}
4936 // 3rd bin: QC{6}
4937 // 4th bin: QC{8}
4938 //
489d5531 4939
b3dacf6b 4940 // Correlations:
489d5531 4941 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
4942 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
4943 Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
4944 Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
b3dacf6b 4945 // Statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:
489d5531 4946 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2>
4947 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4>
4948 Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6>
4949 Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8>
b3dacf6b 4950 // Covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):
8e1cefdd 4951 Double_t wCov24 = 0.; // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
4952 Double_t wCov26 = 0.; // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
4953 Double_t wCov28 = 0.; // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
4954 Double_t wCov46 = 0.; // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
4955 Double_t wCov48 = 0.; // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
4956 Double_t wCov68 = 0.; // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
4957 if(!fForgetAboutCovariances)
4958 {
4959 wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
4960 wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
4961 wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
4962 wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
4963 wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
4964 wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
4965 }
489d5531 4966 // Q-cumulants:
4967 Double_t qc2 = 0.; // QC{2}
4968 Double_t qc4 = 0.; // QC{4}
4969 Double_t qc6 = 0.; // QC{6}
4970 Double_t qc8 = 0.; // QC{8}
b3dacf6b 4971 if(TMath::Abs(two) > 0.){qc2 = two;}
4972 if(TMath::Abs(four) > 0.){qc4 = four-2.*pow(two,2.);}
4973 if(TMath::Abs(six) > 0.){qc6 = six-9.*two*four+12.*pow(two,3.);}
4974 if(TMath::Abs(eight) > 0.){qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.);}
4975 // Statistical errors of Q-cumulants:
489d5531 4976 Double_t qc2Error = 0.;
4977 Double_t qc4Error = 0.;
4978 Double_t qc6Error = 0.;
b3dacf6b 4979 Double_t qc8Error = 0.;
4980 // Squared statistical errors of Q-cumulants:
489d5531 4981 //Double_t qc2ErrorSquared = 0.;
4982 Double_t qc4ErrorSquared = 0.;
4983 Double_t qc6ErrorSquared = 0.;
b3dacf6b 4984 Double_t qc8ErrorSquared = 0.;
4985 // Statistical error of QC{2}:
4986 qc2Error = twoError;
4987 // Statistical error of QC{4}:
489d5531 4988 qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)
4989 - 8.*two*wCov24;
4990 if(qc4ErrorSquared>0.)
4991 {
4992 qc4Error = pow(qc4ErrorSquared,0.5);
4993 } else
4994 {
b3dacf6b 4995 cout<<" WARNING (QC): Statistical error of QC{4} is imaginary !!!!"<<endl;
4996 }
4997 // Statistical error of QC{6}:
489d5531 4998 qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)
4999 + 81.*pow(two,2.)*pow(fourError,2.)
5000 + pow(sixError,2.)
5001 - 162.*two*(4.*pow(two,2.)-four)*wCov24
5002 + 18.*(4.*pow(two,2.)-four)*wCov26
b3dacf6b 5003 - 18.*two*wCov46;
489d5531 5004 if(qc6ErrorSquared>0.)
5005 {
5006 qc6Error = pow(qc6ErrorSquared,0.5);
5007 } else
5008 {
b3dacf6b 5009 cout<<" WARNING (QC): Statistical error of QC{6} is imaginary !!!!"<<endl;
5010 }
5011 // Statistical error of QC{8}:
489d5531 5012 qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)
5013 + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)
5014 + 256.*pow(two,2.)*pow(sixError,2.)
5015 + pow(eightError,2.)
5016 - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24
5017 + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26
5018 - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28
5019 - 1152.*two*(4.*pow(two,2.)-four)*wCov46
5020 + 72.*(4.*pow(two,2.)-four)*wCov48
5021 - 32.*two*wCov68;
5022 if(qc8ErrorSquared>0.)
5023 {
5024 qc8Error = pow(qc8ErrorSquared,0.5);
5025 } else
5026 {
b3dacf6b 5027 cout<<"WARNING (QC): Statistical error of QC{8} is imaginary !!!!"<<endl;
489d5531 5028 }
b3dacf6b 5029 // Store the results and statistical errors for Q-cumulants:
5030 if(TMath::Abs(qc2)>0.)
5031 {
5032 fIntFlowQcumulants->SetBinContent(1,qc2);
5033 fIntFlowQcumulants->SetBinError(1,qc2Error);
5034 }
5035 if(TMath::Abs(qc4)>0.)
5036 {
5037 fIntFlowQcumulants->SetBinContent(2,qc4);
5038 fIntFlowQcumulants->SetBinError(2,qc4Error);
5039 }
5040 if(TMath::Abs(qc6)>0.)
5041 {
5042 fIntFlowQcumulants->SetBinContent(3,qc6);
5043 fIntFlowQcumulants->SetBinError(3,qc6Error);
5044 }
5045 if(TMath::Abs(qc8)>0.)
5046 {
5047 fIntFlowQcumulants->SetBinContent(4,qc8);
5048 fIntFlowQcumulants->SetBinError(4,qc8Error);
5049 }
5050
5051 // Versus multiplicity:
5052 if(!fCalculateCumulantsVsM){return;}
9da1a4f3 5053 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
b3dacf6b 5054 Double_t value[4] = {0.}; // QCs vs M
5055 Double_t error[4] = {0.}; // error of QCs vs M
5056 Double_t dSum1[4] = {0.}; // sum value_i/(error_i)^2
5057 Double_t dSum2[4] = {0.}; // sum 1/(error_i)^2
9da1a4f3 5058 for(Int_t b=1;b<=nBins;b++)
5059 {
b3dacf6b 5060 // Correlations:
9da1a4f3 5061 two = fIntFlowCorrelationsVsMHist[0]->GetBinContent(b); // <<2>>
5062 four = fIntFlowCorrelationsVsMHist[1]->GetBinContent(b); // <<4>>
5063 six = fIntFlowCorrelationsVsMHist[2]->GetBinContent(b); // <<6>>
5064 eight = fIntFlowCorrelationsVsMHist[3]->GetBinContent(b); // <<8>>
b3dacf6b 5065 // Statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:
9da1a4f3 5066 twoError = fIntFlowCorrelationsVsMHist[0]->GetBinError(b); // statistical error of <2>
5067 fourError = fIntFlowCorrelationsVsMHist[1]->GetBinError(b); // statistical error of <4>
5068 sixError = fIntFlowCorrelationsVsMHist[2]->GetBinError(b); // statistical error of <6>
5069 eightError = fIntFlowCorrelationsVsMHist[3]->GetBinError(b); // statistical error of <8>
b3dacf6b 5070 // Covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):
8e1cefdd 5071 if(!fForgetAboutCovariances)
5072 {
5073 wCov24 = fIntFlowCovariancesVsM[0]->GetBinContent(b); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
5074 wCov26 = fIntFlowCovariancesVsM[1]->GetBinContent(b); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
5075 wCov28 = fIntFlowCovariancesVsM[2]->GetBinContent(b); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
5076 wCov46 = fIntFlowCovariancesVsM[3]->GetBinContent(b); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
5077 wCov48 = fIntFlowCovariancesVsM[4]->GetBinContent(b); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
5078 wCov68 = fIntFlowCovariancesVsM[5]->GetBinContent(b); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
5079 }
9da1a4f3 5080 // Q-cumulants:
5081 qc2 = 0.; // QC{2}
5082 qc4 = 0.; // QC{4}
5083 qc6 = 0.; // QC{6}
5084 qc8 = 0.; // QC{8}
b3dacf6b 5085 if(TMath::Abs(two) > 0.){qc2 = two;}
5086 if(TMath::Abs(four) > 0.){qc4 = four-2.*pow(two,2.);}
5087 if(TMath::Abs(six) > 0.){qc6 = six-9.*two*four+12.*pow(two,3.);}
5088 if(TMath::Abs(eight) > 0.){qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.);}
5089 // Statistical errors of Q-cumulants:
9da1a4f3 5090 qc2Error = 0.;
5091 qc4Error = 0.;
5092 qc6Error = 0.;
b3dacf6b 5093 qc8Error = 0.;
5094 // Squared statistical errors of Q-cumulants:
9da1a4f3 5095 //Double_t qc2ErrorSquared = 0.;
5096 qc4ErrorSquared = 0.;
5097 qc6ErrorSquared = 0.;
b3dacf6b 5098 qc8ErrorSquared = 0.;
5099 // Statistical error of QC{2}:
5100 qc2Error = twoError;
5101 // Statistical error of QC{4}:
9da1a4f3 5102 qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)
5103 - 8.*two*wCov24;
5104 if(qc4ErrorSquared>0.)
5105 {
5106 qc4Error = pow(qc4ErrorSquared,0.5);
5107 } else
5108 {
5109 // cout<<"WARNING: Statistical error of QC{4} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
b3dacf6b 5110 }
5111 // Statistical error of QC{6}:
9da1a4f3 5112 qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)
5113 + 81.*pow(two,2.)*pow(fourError,2.)
5114 + pow(sixError,2.)
5115 - 162.*two*(4.*pow(two,2.)-four)*wCov24
5116 + 18.*(4.*pow(two,2.)-four)*wCov26
b3dacf6b 5117 - 18.*two*wCov46;
9da1a4f3 5118 if(qc6ErrorSquared>0.)
5119 {
5120 qc6Error = pow(qc6ErrorSquared,0.5);
5121 } else
5122 {
5123 // cout<<"WARNING: Statistical error of QC{6} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
b3dacf6b 5124 }
5125 // Statistical error of QC{8}:
9da1a4f3 5126 qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)
5127 + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)
5128 + 256.*pow(two,2.)*pow(sixError,2.)
5129 + pow(eightError,2.)
5130 - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24
5131 + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26
5132 - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28
5133 - 1152.*two*(4.*pow(two,2.)-four)*wCov46
5134 + 72.*(4.*pow(two,2.)-four)*wCov48
5135 - 32.*two*wCov68;
5136 if(qc8ErrorSquared>0.)
5137 {
5138 qc8Error = pow(qc8ErrorSquared,0.5);
5139 } else
5140 {
5141 // cout<<"WARNING: Statistical error of QC{8} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
5142 }
b3dacf6b 5143 // Store the results and statistical errors for Q-cumulants:
5144 if(TMath::Abs(qc2)>0.)
5145 {
5146 fIntFlowQcumulantsVsM[0]->SetBinContent(b,qc2);
5147 fIntFlowQcumulantsVsM[0]->SetBinError(b,qc2Error);
5148 }
5149 if(TMath::Abs(qc4)>0.)
5150 {
5151 fIntFlowQcumulantsVsM[1]->SetBinContent(b,qc4);
5152 fIntFlowQcumulantsVsM[1]->SetBinError(b,qc4Error);
5153 }
5154 if(TMath::Abs(qc6)>0.)
5155 {
5156 fIntFlowQcumulantsVsM[2]->SetBinContent(b,qc6);
5157 fIntFlowQcumulantsVsM[2]->SetBinError(b,qc6Error);
5158 }
5159 if(TMath::Abs(qc8)>0.)
5160 {
5161 fIntFlowQcumulantsVsM[3]->SetBinContent(b,qc8);
5162 fIntFlowQcumulantsVsM[3]->SetBinError(b,qc8Error);
5163 }
5164 // Rebin in M:
5165 for(Int_t co=0;co<4;co++)
5166 {
b40a910e 5167 if(fIntFlowCorrelationsVsMPro[co]->GetBinEffectiveEntries(b)<2){continue;}
b3dacf6b 5168 value[co] = fIntFlowQcumulantsVsM[co]->GetBinContent(b);
5169 error[co] = fIntFlowQcumulantsVsM[co]->GetBinError(b);
5170 if(error[co]>0.)
5171 {
5172 dSum1[co]+=value[co]/(error[co]*error[co]);
5173 dSum2[co]+=1./(error[co]*error[co]);
5174 }
5175 } // end of for(Int_t co=0;co<4;co++)
9da1a4f3 5176 } // end of for(Int_t b=1;b<=nBins;b++)
b3dacf6b 5177 // Store rebinned Q-cumulants:
5178 for(Int_t co=0;co<4;co++)
5179 {
5180 if(dSum2[co]>0.)
5181 {
5182 fIntFlowQcumulantsRebinnedInM->SetBinContent(co+1,dSum1[co]/dSum2[co]);
5183 fIntFlowQcumulantsRebinnedInM->SetBinError(co+1,pow(1./dSum2[co],0.5));
5184 }
5185 } // end of for(Int_t co=0;co<4;co++)
5186
489d5531 5187} // end of AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()
5188
489d5531 5189//================================================================================================================================
5190
b92ea2b9 5191void AliFlowAnalysisWithQCumulants::CalculateReferenceFlow()
489d5531 5192{
b92ea2b9 5193 // a) Calculate the final results for reference flow estimates from Q-cumulants;
5194 // b) Propagate the statistical errors to reference flow estimates from statistical error of Q-cumulants;
0328db2d 5195 // c) Store the results and statistical errors of reference flow estimates in histogram fIntFlow.
489d5531 5196 // Binning of fIntFlow is organized as follows:
5197 //
b3dacf6b 5198 // 1st bin: v{2,QC}
5199 // 2nd bin: v{4,QC}
5200 // 3rd bin: v{6,QC}
5201 // 4th bin: v{8,QC}
5202 //
489d5531 5203
b3dacf6b 5204 // Reference flow estimates:
489d5531 5205 Double_t v2 = 0.; // v{2,QC}
5206 Double_t v4 = 0.; // v{4,QC}
5207 Double_t v6 = 0.; // v{6,QC}
5208 Double_t v8 = 0.; // v{8,QC}
b3dacf6b 5209 // Reference flow's statistical errors:
5210 Double_t v2Error = 0.; // v{2,QC} stat. error
5211 Double_t v4Error = 0.; // v{4,QC} stat. error
5212 Double_t v6Error = 0.; // v{6,QC} stat. error
5213 Double_t v8Error = 0.; // v{8,QC} stat. error
5214
b92ea2b9 5215 // Q-cumulants:
5216 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}
5217 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}
5218 Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6}
5219 Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}
5220 // Q-cumulants's statistical errors:
5221 Double_t qc2Error = fIntFlowQcumulants->GetBinError(1); // QC{2} stat. error
5222 Double_t qc4Error = fIntFlowQcumulants->GetBinError(2); // QC{4} stat. error
5223 Double_t qc6Error = fIntFlowQcumulants->GetBinError(3); // QC{6} stat. error
5224 Double_t qc8Error = fIntFlowQcumulants->GetBinError(4); // QC{8} stat. error
5225 // Calculate reference flow estimates from Q-cumulants:
1268c371 5226 if(qc2>=0.){v2 = pow(qc2,0.5);}
b92ea2b9 5227 if(qc4<=0.){v4 = pow(-1.*qc4,1./4.);}
5228 if(qc6>=0.){v6 = pow((1./4.)*qc6,1./6.);}
5229 if(qc8<=0.){v8 = pow((-1./33.)*qc8,1./8.);}
5230 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5231 if(qc2>0.){v2Error = (1./2.)*pow(qc2,-0.5)*qc2Error;}
b92ea2b9 5232 if(qc4<0.){v4Error = (1./4.)*pow(-qc4,-3./4.)*qc4Error;}
5233 if(qc6>0.){v6Error = (1./6.)*pow(2.,-1./3.)*pow(qc6,-5./6.)*qc6Error;}
5234 if(qc8<0.){v8Error = (1./8.)*pow(33.,-1./8.)*pow(-qc8,-7./8.)*qc8Error;}
5235 // Print warnings for the 'wrong sign' cumulants:
5236 if(TMath::Abs(v2) < 1.e-44)
5237 {
5238 cout<<" WARNING: Wrong sign QC{2}, couldn't calculate v{2,QC} !!!!"<<endl;
5239 }
5240 if(TMath::Abs(v4) < 1.e-44)
5241 {
5242 cout<<" WARNING: Wrong sign QC{4}, couldn't calculate v{4,QC} !!!!"<<endl;
5243 }
5244 if(TMath::Abs(v6) < 1.e-44)
5245 {
5246 cout<<" WARNING: Wrong sign QC{6}, couldn't calculate v{6,QC} !!!!"<<endl;
5247 }
5248 if(TMath::Abs(v8) < 1.e-44)
5249 {
5250 cout<<" WARNING: Wrong sign QC{8}, couldn't calculate v{8,QC} !!!!"<<endl;
5251 }
5252 // Store the results and statistical errors of integrated flow estimates:
5253 fIntFlow->SetBinContent(1,v2);
5254 fIntFlow->SetBinError(1,v2Error);
5255 fIntFlow->SetBinContent(2,v4);
5256 fIntFlow->SetBinError(2,v4Error);
5257 fIntFlow->SetBinContent(3,v6);
5258 fIntFlow->SetBinError(3,v6Error);
5259 fIntFlow->SetBinContent(4,v8);
5260 fIntFlow->SetBinError(4,v8Error);
5261
5262 // Versus multiplicity:
5263 if(!fCalculateCumulantsVsM){return;}
5264 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
5265 for(Int_t b=1;b<=nBins;b++)
9da1a4f3 5266 {
5267 // Q-cumulants:
b92ea2b9 5268 Double_t qc2VsM = fIntFlowQcumulantsVsM[0]->GetBinContent(b); // QC{2}
5269 Double_t qc4VsM = fIntFlowQcumulantsVsM[1]->GetBinContent(b); // QC{4}
5270 Double_t qc6VsM = fIntFlowQcumulantsVsM[2]->GetBinContent(b); // QC{6}
5271 Double_t qc8VsM = fIntFlowQcumulantsVsM[3]->GetBinContent(b); // QC{8}
b3dacf6b 5272 // Q-cumulants's statistical errors:
b92ea2b9 5273 Double_t qc2ErrorVsM = fIntFlowQcumulantsVsM[0]->GetBinError(b); // QC{2} stat. error
5274 Double_t qc4ErrorVsM = fIntFlowQcumulantsVsM[1]->GetBinError(b); // QC{4} stat. error
5275 Double_t qc6ErrorVsM = fIntFlowQcumulantsVsM[2]->GetBinError(b); // QC{6} stat. error
5276 Double_t qc8ErrorVsM = fIntFlowQcumulantsVsM[3]->GetBinError(b); // QC{8} stat. error
b3dacf6b 5277 // Reference flow estimates:
b92ea2b9 5278 Double_t v2VsM = 0.; // v{2,QC}
5279 Double_t v4VsM = 0.; // v{4,QC}
5280 Double_t v6VsM = 0.; // v{6,QC}
5281 Double_t v8VsM = 0.; // v{8,QC}
5282 // Reference flow estimates errors:
5283 Double_t v2ErrorVsM = 0.; // v{2,QC} stat. error
5284 Double_t v4ErrorVsM = 0.; // v{4,QC} stat. error
5285 Double_t v6ErrorVsM = 0.; // v{6,QC} stat. error
5286 Double_t v8ErrorVsM = 0.; // v{8,QC} stat. error
b3dacf6b 5287 // Calculate reference flow estimates from Q-cumulants:
1268c371 5288 if(qc2VsM>=0.){v2VsM = pow(qc2VsM,0.5);}
b92ea2b9 5289 if(qc4VsM<=0.){v4VsM = pow(-1.*qc4VsM,1./4.);}
5290 if(qc6VsM>=0.){v6VsM = pow((1./4.)*qc6VsM,1./6.);}
5291 if(qc8VsM<=0.){v8VsM = pow((-1./33.)*qc8VsM,1./8.);}
b3dacf6b 5292 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5293 if(qc2VsM>0.){v2ErrorVsM = (1./2.)*pow(qc2VsM,-0.5)*qc2ErrorVsM;}
b92ea2b9 5294 if(qc4VsM<0.){v4ErrorVsM = (1./4.)*pow(-qc4VsM,-3./4.)*qc4ErrorVsM;}
5295 if(qc6VsM>0.){v6ErrorVsM = (1./6.)*pow(2.,-1./3.)*pow(qc6VsM,-5./6.)*qc6ErrorVsM;}
5296 if(qc8VsM<0.){v8ErrorVsM = (1./8.)*pow(33.,-1./8.)*pow(-qc8VsM,-7./8.)*qc8ErrorVsM;}
b3dacf6b 5297 // Store the results and statistical errors of integrated flow estimates:
b92ea2b9 5298 fIntFlowVsM[0]->SetBinContent(b,v2VsM);
5299 fIntFlowVsM[0]->SetBinError(b,v2ErrorVsM);
5300 fIntFlowVsM[1]->SetBinContent(b,v4VsM);
5301 fIntFlowVsM[1]->SetBinError(b,v4ErrorVsM);
5302 fIntFlowVsM[2]->SetBinContent(b,v6VsM);
5303 fIntFlowVsM[2]->SetBinError(b,v6ErrorVsM);
5304 fIntFlowVsM[3]->SetBinContent(b,v8VsM);
5305 fIntFlowVsM[3]->SetBinError(b,v8ErrorVsM);
5306 } // end of for(Int_t b=1;b<=nBins;b++)
5307
5308 // 'Rebinned in M' calculation: // to be improved - this can be implemented better:
5309 // Reference flow estimates:
5310 Double_t v2RebinnedInM = 0.; // v{2,QC}
5311 Double_t v4RebinnedInM = 0.; // v{4,QC}
5312 Double_t v6RebinnedInM = 0.; // v{6,QC}
5313 Double_t v8RebinnedInM = 0.; // v{8,QC}
5314 // Reference flow's statistical errors:
5315 Double_t v2ErrorRebinnedInM = 0.; // v{2,QC} stat. error
5316 Double_t v4ErrorRebinnedInM = 0.; // v{4,QC} stat. error
5317 Double_t v6ErrorRebinnedInM = 0.; // v{6,QC} stat. error
5318 Double_t v8ErrorRebinnedInM = 0.; // v{8,QC} stat. error
5319 // Q-cumulants:
5320 Double_t qc2RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(1); // QC{2}
5321 Double_t qc4RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(2); // QC{4}
5322 Double_t qc6RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(3); // QC{6}
5323 Double_t qc8RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(4); // QC{8}
5324 // Q-cumulants's statistical errors:
5325 Double_t qc2ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(1); // QC{2} stat. error
5326 Double_t qc4ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(2); // QC{4} stat. error
5327 Double_t qc6ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(3); // QC{6} stat. error
5328 Double_t qc8ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(4); // QC{8} stat. error
5329 // Calculate reference flow estimates from Q-cumulants:
1268c371 5330 if(qc2RebinnedInM>=0.){v2RebinnedInM = pow(qc2RebinnedInM,0.5);}
b92ea2b9 5331 if(qc4RebinnedInM<=0.){v4RebinnedInM = pow(-1.*qc4RebinnedInM,1./4.);}
5332 if(qc6RebinnedInM>=0.){v6RebinnedInM = pow((1./4.)*qc6RebinnedInM,1./6.);}
5333 if(qc8RebinnedInM<=0.){v8RebinnedInM = pow((-1./33.)*qc8RebinnedInM,1./8.);}
5334 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5335 if(qc2RebinnedInM>0.){v2ErrorRebinnedInM = (1./2.)*pow(qc2RebinnedInM,-0.5)*qc2ErrorRebinnedInM;}
b92ea2b9 5336 if(qc4RebinnedInM<0.){v4ErrorRebinnedInM = (1./4.)*pow(-qc4RebinnedInM,-3./4.)*qc4ErrorRebinnedInM;}
5337 if(qc6RebinnedInM>0.){v6ErrorRebinnedInM = (1./6.)*pow(2.,-1./3.)*pow(qc6RebinnedInM,-5./6.)*qc6ErrorRebinnedInM;}
5338 if(qc8RebinnedInM<0.){v8ErrorRebinnedInM = (1./8.)*pow(33.,-1./8.)*pow(-qc8RebinnedInM,-7./8.)*qc8ErrorRebinnedInM;}
5339 // Print warnings for the 'wrong sign' cumulants:
5340 if(TMath::Abs(v2RebinnedInM) < 1.e-44)
5341 {
5342 cout<<" WARNING: Wrong sign QC{2} rebinned in M, couldn't calculate v{2,QC} !!!!"<<endl;
5343 }
5344 if(TMath::Abs(v4RebinnedInM) < 1.e-44)
5345 {
5346 cout<<" WARNING: Wrong sign QC{4} rebinned in M, couldn't calculate v{4,QC} !!!!"<<endl;
5347 }
5348 if(TMath::Abs(v6RebinnedInM) < 1.e-44)
5349 {
5350 cout<<" WARNING: Wrong sign QC{6} rebinned in M, couldn't calculate v{6,QC} !!!!"<<endl;
5351 }
5352 if(TMath::Abs(v8RebinnedInM) < 1.e-44)
5353 {
5354 cout<<" WARNING: Wrong sign QC{8} rebinned in M, couldn't calculate v{8,QC} !!!!"<<endl;
5355 }
5356 // Store the results and statistical errors of integrated flow estimates:
5357 fIntFlowRebinnedInM->SetBinContent(1,v2RebinnedInM);
5358 fIntFlowRebinnedInM->SetBinError(1,v2ErrorRebinnedInM);
5359 fIntFlowRebinnedInM->SetBinContent(2,v4RebinnedInM);
5360 fIntFlowRebinnedInM->SetBinError(2,v4ErrorRebinnedInM);
5361 fIntFlowRebinnedInM->SetBinContent(3,v6RebinnedInM);
5362 fIntFlowRebinnedInM->SetBinError(3,v6ErrorRebinnedInM);
5363 fIntFlowRebinnedInM->SetBinContent(4,v8RebinnedInM);
5364 fIntFlowRebinnedInM->SetBinError(4,v8ErrorRebinnedInM);
5365
5366} // end of AliFlowAnalysisWithQCumulants::CalculateReferenceFlow()
489d5531 5367
489d5531 5368//================================================================================================================================
5369
489d5531 5370void AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()
5371{
0dd3b008 5372 // Fill in AliFlowCommonHistResults histograms relevant for reference flow.
489d5531 5373
0dd3b008 5374 // There are two possibilities here:
5375 // a) Store minimum bias reference flow - use SetMinimumBiasReferenceFlow(kTRUE). This result is
5376 // biased by the interplay between nonflow correlations and multiplicity fluctuations and is
5377 // also stored in local histogram fIntFlow;
5378 // b) Store reference flow obtained from flow analysis performed at fixed multiplicity and
5379 // rebinned only at the end of the day - use SetMinimumBiasReferenceFlow(kFALSE). This result
5380 // is also stored in local histogram fIntFlowRebinnedInM.
489d5531 5381
0dd3b008 5382 // Reference flow estimates:
5383 Double_t v[4] = {0.};
5384 // Statistical errors of reference flow estimates:
5385 Double_t vError[4] = {0.};
489d5531 5386
0dd3b008 5387 for(Int_t b=0;b<4;b++)
5388 {
5389 if(fMinimumBiasReferenceFlow)
5390 {
5391 v[b] = fIntFlow->GetBinContent(b+1);
5392 vError[b] = fIntFlow->GetBinError(b+1);
5393 } else
5394 {
5395 v[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
5396 vError[b] = fIntFlowRebinnedInM->GetBinError(b+1);
5397 }
5398 } // end of for(Int_t b=0;b<4;b++)
5399
5400 // Fill AliFlowCommonHistResults histogram:
5401 fCommonHistsResults2nd->FillIntegratedFlow(v[0],vError[0]); // to be improved (hardwired 2nd in the name)
5402 fCommonHistsResults4th->FillIntegratedFlow(v[1],vError[1]); // to be improved (hardwired 4th in the name)
403e3389 5403 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)) // to be improved (calculate also 6th and 8th order)
489d5531 5404 {
0dd3b008 5405 fCommonHistsResults6th->FillIntegratedFlow(v[2],vError[2]); // to be improved (hardwired 6th in the name)
5406 fCommonHistsResults8th->FillIntegratedFlow(v[3],vError[3]); // to be improved (hardwired 8th in the name)
489d5531 5407 }
5408
5409} // end of AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()
5410
489d5531 5411//================================================================================================================================
5412
489d5531 5413void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()
5414{
5415 // Calculate all correlations needed for integrated flow using particle weights.
5416
5417 // Remark 1: When particle weights are used the binning of fIntFlowCorrelationAllPro is organized as follows:
5418 //
5419 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>
5420 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>
5421 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))>
5422 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>
5423 // 5th bin: ---- EMPTY ----
5424 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
5425 // 7th bin: <3>_{3n|2n,1n} = ...
5426 // 8th bin: <3>_{4n|2n,2n} = ...
5427 // 9th bin: <3>_{4n|3n,1n} = ...
5428 // 10th bin: ---- EMPTY ----
5429 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
5430 // 12th bin: <4>_{2n,1n|2n,1n} = ...
5431 // 13th bin: <4>_{2n,2n|2n,2n} = ...
5432 // 14th bin: <4>_{3n|1n,1n,1n} = ...
5433 // 15th bin: <4>_{3n,1n|3n,1n} = ...
5434 // 16th bin: <4>_{3n,1n|2n,2n} = ...
5435 // 17th bin: <4>_{4n|2n,1n,1n} = ...
5436 // 18th bin: ---- EMPTY ----
5437 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...
5438 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...
5439 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...
5440 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...
5441 // 23rd bin: ---- EMPTY ----
5442 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...
5443 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...
5444 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...
5445 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...
5446 // 28th bin: ---- EMPTY ----
5447 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...
5448 // 30th bin: ---- EMPTY ----
5449 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...
5450
5451 // Remark 2: When particle weights are used there are some extra correlations. They are stored in
5452 // fIntFlowExtraCorrelationsPro binning of which is organized as follows:
5453
5454 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>
5455 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>
5456
5457 // multiplicity (number of particles used to determine the reaction plane)
1268c371 5458 Double_t dMult = (*fSpk)(0,0);
489d5531 5459
5460 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
5461 Double_t dReQ1n1k = (*fReQ)(0,1);
5462 Double_t dReQ2n2k = (*fReQ)(1,2);
5463 Double_t dReQ3n3k = (*fReQ)(2,3);
5464 Double_t dReQ4n4k = (*fReQ)(3,4);
5465 Double_t dReQ1n3k = (*fReQ)(0,3);
5466 Double_t dImQ1n1k = (*fImQ)(0,1);
5467 Double_t dImQ2n2k = (*fImQ)(1,2);
5468 Double_t dImQ3n3k = (*fImQ)(2,3);
5469 Double_t dImQ4n4k = (*fImQ)(3,4);
5470 Double_t dImQ1n3k = (*fImQ)(0,3);
5471
5472 // dMs are variables introduced in order to simplify some Eqs. bellow:
5473 //..............................................................................................
1268c371 5474 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
5475 Double_t dM22 = (*fSpk)(1,2)-(*fSpk)(0,4); // dM22 = sum_{i,j=1,i!=j}^M w_i^2 w_j^2
5476 Double_t dM33 = (*fSpk)(1,3)-(*fSpk)(0,6); // dM33 = sum_{i,j=1,i!=j}^M w_i^3 w_j^3
5477 Double_t dM44 = (*fSpk)(1,4)-(*fSpk)(0,8); // dM44 = sum_{i,j=1,i!=j}^M w_i^4 w_j^4
5478 Double_t dM31 = (*fSpk)(0,3)*(*fSpk)(0,1)-(*fSpk)(0,4); // dM31 = sum_{i,j=1,i!=j}^M w_i^3 w_j
5479 Double_t dM211 = (*fSpk)(0,2)*(*fSpk)(1,1)-2.*(*fSpk)(0,3)*(*fSpk)(0,1)
5480 - (*fSpk)(1,2)+2.*(*fSpk)(0,4); // dM211 = sum_{i,j,k=1,i!=j!=k}^M w_i^2 w_j w_k
5481 Double_t dM1111 = (*fSpk)(3,1)-6.*(*fSpk)(0,2)*(*fSpk)(1,1)
5482 + 8.*(*fSpk)(0,3)*(*fSpk)(0,1)
5483 + 3.*(*fSpk)(1,2)-6.*(*fSpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l
489d5531 5484 //..............................................................................................
5485
5486 // 2-particle correlations:
5487 Double_t two1n1nW1W1 = 0.; // <w1 w2 cos(n*(phi1-phi2))>
5488 Double_t two2n2nW2W2 = 0.; // <w1^2 w2^2 cos(2n*(phi1-phi2))>
5489 Double_t two3n3nW3W3 = 0.; // <w1^3 w2^3 cos(3n*(phi1-phi2))>
5490 Double_t two4n4nW4W4 = 0.; // <w1^4 w2^4 cos(4n*(phi1-phi2))>
5491 if(dMult>1)
5492 {
5493 if(dM11)
5494 {
1268c371 5495 two1n1nW1W1 = (pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSpk)(0,2))/dM11;
489d5531 5496 // average correlation <w1 w2 cos(n*(phi1-phi2))> for single event:
5497 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1nW1W1);
5498 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,dM11);
5499 // average correlation <w1 w2 cos(n*(phi1-phi2))> for all events:
b40a910e 5500 fIntFlowCorrelationsPro->Fill(0.5,two1n1nW1W1,dM11);
5501 // average squared correlation <w1 w2 cos(n*(phi1-phi2))> for all events:
5502 fIntFlowSquaredCorrelationsPro->Fill(0.5,two1n1nW1W1*two1n1nW1W1,dM11);
489d5531 5503 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1nW1W1,dM11);
5504 }
5505 if(dM22)
5506 {
1268c371 5507 two2n2nW2W2 = (pow(dReQ2n2k,2)+pow(dImQ2n2k,2)-(*fSpk)(0,4))/dM22;
489d5531 5508 // ...
5509 // average correlation <w1^2 w2^2 cos(2n*(phi1-phi2))> for all events:
5510 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2nW2W2,dM22);
5511 }
5512 if(dM33)
5513 {
1268c371 5514 two3n3nW3W3 = (pow(dReQ3n3k,2)+pow(dImQ3n3k,2)-(*fSpk)(0,6))/dM33;
489d5531 5515 // ...
5516 // average correlation <w1^3 w2^3 cos(3n*(phi1-phi2))> for all events:
5517 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3nW3W3,dM33);
5518 }
5519 if(dM44)
5520 {
1268c371 5521 two4n4nW4W4 = (pow(dReQ4n4k,2)+pow(dImQ4n4k,2)-(*fSpk)(0,8))/dM44;
489d5531 5522 // ...
5523 // average correlation <w1^4 w2^4 cos(4n*(phi1-phi2))> for all events:
5524 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4nW4W4,dM44);
5525 }
5526 } // end of if(dMult>1)
5527
5528 // extra 2-particle correlations:
5529 Double_t two1n1nW3W1 = 0.; // <w1^3 w2 cos(n*(phi1-phi2))>
5530 Double_t two1n1nW1W1W2 = 0.; // <w1 w2 w3^2 cos(n*(phi1-phi2))>
5531 if(dMult>1)
5532 {
5533 if(dM31)
5534 {
1268c371 5535 two1n1nW3W1 = (dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k-(*fSpk)(0,4))/dM31;
489d5531 5536 fIntFlowExtraCorrelationsPro->Fill(0.5,two1n1nW3W1,dM31);
5537 }
5538 if(dM211)
5539 {
1268c371 5540 two1n1nW1W1W2 = ((*fSpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSpk)(0,2))
489d5531 5541 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k
1268c371 5542 - (*fSpk)(0,4)))/dM211;
489d5531 5543 fIntFlowExtraCorrelationsPro->Fill(1.5,two1n1nW1W1W2,dM211);
5544 }
5545 } // end of if(dMult>1)
5546 //..............................................................................................
5547
5548 //..............................................................................................
5549 // 3-particle correlations:
5550 Double_t three2n1n1nW2W1W1 = 0.; // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
5551
5552 if(dMult>2)
5553 {
5554 if(dM211)
5555 {
5556 three2n1n1nW2W1W1 = (pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k
5557 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)
5558 - pow(dReQ2n2k,2)-pow(dImQ2n2k,2)
1268c371 5559 + 2.*(*fSpk)(0,4))/dM211;
489d5531 5560 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1nW2W1W1,dM211);
5561 }
5562 } // end of if(dMult>2)
5563 //..............................................................................................
5564
5565 //..............................................................................................
5566 // 4-particle correlations:
5567 Double_t four1n1n1n1nW1W1W1W1 = 0.; // <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
5568 if(dMult>3)
5569 {
5570 if(dM1111)
5571 {
5572 four1n1n1n1nW1W1W1W1 = (pow(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.),2)
5573 - 2.*(pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k)
5574 + 8.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)
5575 + (pow(dReQ2n2k,2)+pow(dImQ2n2k,2))
1268c371 5576 - 4.*(*fSpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
5577 - 6.*(*fSpk)(0,4)+2.*(*fSpk)(1,2))/dM1111;
489d5531 5578
5579 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for single event:
5580 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1nW1W1W1W1);
5581 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,dM1111);
5582 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:
5583 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1,dM1111);
b40a910e 5584 // average squared correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:
5585 fIntFlowSquaredCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1*four1n1n1n1nW1W1W1W1,dM1111);
489d5531 5586 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1nW1W1W1W1,dM1111);
5587 }
5588 } // end of if(dMult>3)
5589 //..............................................................................................
5590
5591} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()
5592
489d5531 5593//================================================================================================================================
5594
489d5531 5595void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()
5596{
5597 // Initialize all arrays used to calculate integrated flow.
5598
5599 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5600 {
5601 fIntFlowCorrectionTermsForNUAEBE[sc] = NULL;
0328db2d 5602 fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc] = NULL;
489d5531 5603 fIntFlowCorrectionTermsForNUAPro[sc] = NULL;
5604 fIntFlowCorrectionTermsForNUAHist[sc] = NULL;
b92ea2b9 5605 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2001bc3a 5606 {
5607 fIntFlowCorrectionTermsForNUAVsMPro[sc][ci] = NULL;
5608 }
0328db2d 5609 for(Int_t power=0;power<2;power++) // linear or quadratic
5610 {
5611 fIntFlowSumOfEventWeightsNUA[sc][power] = NULL;
5612 }
489d5531 5613 }
5614 for(Int_t power=0;power<2;power++) // linear or quadratic
5615 {
5616 fIntFlowSumOfEventWeights[power] = NULL;
5617 }
b3dacf6b 5618 for(Int_t i=0;i<4;i++) // print on the screen the final results (0=RF, 1=RP, 2=POI, 3=RF (rebbined in M))
489d5531 5619 {
5620 fPrintFinalResults[i] = kTRUE;
5621 }
ff70ca91 5622 for(Int_t ci=0;ci<4;ci++) // correlation index or cumulant order
5623 {
5624 fIntFlowCorrelationsVsMPro[ci] = NULL;
b40a910e 5625 fIntFlowSquaredCorrelationsVsMPro[ci] = NULL;
ff70ca91 5626 fIntFlowCorrelationsVsMHist[ci] = NULL;
5627 fIntFlowQcumulantsVsM[ci] = NULL;
5628 fIntFlowVsM[ci] = NULL;
2001bc3a 5629 fIntFlowDetectorBiasVsM[ci] = NULL;
ff70ca91 5630 for(Int_t lc=0;lc<2;lc++)
5631 {
5632 fIntFlowSumOfEventWeightsVsM[ci][lc] = NULL;
5633 }
5634 }
5635 for(Int_t pi=0;pi<6;pi++) // product or covariance index
5636 {
5637 fIntFlowProductOfCorrelationsVsMPro[pi] = NULL;
5638 fIntFlowCovariancesVsM[pi] = NULL;
5639 fIntFlowSumOfProductOfEventWeightsVsM[pi] = NULL;
5640 }
403e3389 5641 for(Int_t ci=0;ci<64;ci++) // correlation index for all correlations vs M profiles (to be improved - hardwired 64)
3435cacb 5642 {
5643 fIntFlowCorrelationsAllVsMPro[ci] = NULL;
5644 }
5645
489d5531 5646} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()
5647
489d5531 5648//================================================================================================================================
5649
489d5531 5650void AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()
5651{
5652 // Initialize all arrays needed to calculate differential flow.
5653 // a) Initialize lists holding profiles;
5654 // b) Initialize lists holding histograms;
5655 // c) Initialize event-by-event quantities;
5656 // d) Initialize profiles;
5657 // e) Initialize histograms holding final results.
5658
5659 // a) Initialize lists holding profiles;
5660 for(Int_t t=0;t<2;t++) // type (RP, POI)
5661 {
5662 for(Int_t pe=0;pe<2;pe++) // pt or eta
5663 {
5664 fDiffFlowCorrelationsProList[t][pe] = NULL;
5665 fDiffFlowProductOfCorrelationsProList[t][pe] = NULL;
5666 fDiffFlowCorrectionsProList[t][pe] = NULL;
5667 }
1268c371 5668 // 2D:
5669 f2DDiffFlowCorrelationsProList[t] = NULL;
489d5531 5670 }
5671
5672 // b) Initialize lists holding histograms;
5673 for(Int_t t=0;t<2;t++) // type (RP, POI)
5674 {
5675 for(Int_t pe=0;pe<2;pe++) // pt or eta
5676 {
5677 fDiffFlowCorrelationsHistList[t][pe] = NULL;
5678 for(Int_t power=0;power<2;power++)
5679 {
5680 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = NULL;
5681 } // end of for(Int_t power=0;power<2;power++)
5682 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = NULL;
5683 fDiffFlowCorrectionsHistList[t][pe] = NULL;
5684 fDiffFlowCovariancesHistList[t][pe] = NULL;
5685 fDiffFlowCumulantsHistList[t][pe] = NULL;
1268c371 5686 fDiffFlowDetectorBiasHistList[t][pe] = NULL;
489d5531 5687 fDiffFlowHistList[t][pe] = NULL;
5688 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
5689 } // enf of for(Int_t t=0;t<2;t++) // type (RP, POI)
5690
5691 // c) Initialize event-by-event quantities:
5692 // 1D:
5693 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
5694 {
5695 for(Int_t pe=0;pe<2;pe++) // pt or eta
5696 {
5697 for(Int_t m=0;m<4;m++) // multiple of harmonic
5698 {
5699 for(Int_t k=0;k<9;k++) // power of weight
5700 {
5701 fReRPQ1dEBE[t][pe][m][k] = NULL;
5702 fImRPQ1dEBE[t][pe][m][k] = NULL;
5703 fs1dEBE[t][pe][k] = NULL; // to be improved (this doesn't need to be within loop over m)
5704 }
5705 }
5706 }
5707 }
5708 // 1D:
5709 for(Int_t t=0;t<2;t++) // type (RP or POI)
5710 {
5711 for(Int_t pe=0;pe<2;pe++) // pt or eta
5712 {
5713 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5714 {
5715 for(Int_t cti=0;cti<9;cti++) // correction term index
5716 {
5717 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = NULL;
5718 }
5719 }
5720 }
5721 }
5722 // 2D:
5723 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
5724 {
5725 for(Int_t m=0;m<4;m++) // multiple of harmonic
5726 {
5727 for(Int_t k=0;k<9;k++) // power of weight
5728 {
5729 fReRPQ2dEBE[t][m][k] = NULL;
5730 fImRPQ2dEBE[t][m][k] = NULL;
5731 fs2dEBE[t][k] = NULL; // to be improved (this doesn't need to be within loop over m)
5732 }
5733 }
5734 }
5735
5736 // d) Initialize profiles:
5737 for(Int_t t=0;t<2;t++) // type: RP or POI
5738 {
5739 for(Int_t pe=0;pe<2;pe++) // pt or eta
5740 {
5741 for(Int_t ci=0;ci<4;ci++) // correlation index
5742 {
5743 fDiffFlowCorrelationsPro[t][pe][ci] = NULL;
b40a910e 5744 fDiffFlowSquaredCorrelationsPro[t][pe][ci] = NULL;
489d5531 5745 } // end of for(Int_t ci=0;ci<4;ci++)
5746 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5747 {
5748 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5749 {
5750 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = NULL;
5751 } // end of for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5752 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5753 // correction terms for nua:
5754 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5755 {
5756 for(Int_t cti=0;cti<9;cti++) // correction term index
5757 {
5758 fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = NULL;
5759 }
5760 }
64e500e3 5761 // other differential correlators:
5762 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5763 {
5764 for(Int_t ci=0;ci<1;ci++) // correction term index
5765 {
5766 fOtherDiffCorrelators[t][pe][sc][ci] = NULL;
5767 }
5768 }
489d5531 5769 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
1268c371 5770 for(Int_t ci=0;ci<4;ci++) // correlation index
5771 {
5772 f2DDiffFlowCorrelationsPro[t][ci] = NULL;
5773 }
489d5531 5774 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
5775
5776 // e) Initialize histograms holding final results.
5777 for(Int_t t=0;t<2;t++) // type: RP or POI
5778 {
5779 for(Int_t pe=0;pe<2;pe++) // pt or eta
5780 {
5781 for(Int_t ci=0;ci<4;ci++) // correlation index
5782 {
5783 fDiffFlowCorrelationsHist[t][pe][ci] = NULL;
5784 fDiffFlowCumulants[t][pe][ci] = NULL;
1268c371 5785 fDiffFlowDetectorBias[t][pe][ci] = NULL;
489d5531 5786 fDiffFlow[t][pe][ci] = NULL;
5787 } // end of for(Int_t ci=0;ci<4;ci++)
5788 for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++)
5789 {
5790 fDiffFlowCovariances[t][pe][covarianceIndex] = NULL;
5791 } // end of for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++)
5792 // correction terms for nua:
5793 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5794 {
5795 for(Int_t cti=0;cti<9;cti++) // correction term index
5796 {
5797 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = NULL;
5798 }
5799 }
5800 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
1268c371 5801 for(Int_t ci=0;ci<4;ci++) // correlation index
5802 {
5803 f2DDiffFlowCumulants[t][ci] = NULL;
5804 f2DDiffFlow[t][ci] = NULL;
5805 }
489d5531 5806 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
5807
5808 // sum of event weights for reduced correlations:
5809 for(Int_t t=0;t<2;t++) // type = RP or POI
5810 {
5811 for(Int_t pe=0;pe<2;pe++) // pt or eta
5812 {
5813 for(Int_t p=0;p<2;p++) // power of weight is 1 or 2
5814 {
5815 for(Int_t ew=0;ew<4;ew++) // event weight index for reduced correlations
5816 {
5817 fDiffFlowSumOfEventWeights[t][pe][p][ew] = NULL;
5818 }
5819 }
5820 }
5821 }
5822 // product of event weights for both types of correlations:
5823 for(Int_t t=0;t<2;t++) // type = RP or POI
5824 {
5825 for(Int_t pe=0;pe<2;pe++) // pt or eta
5826 {
5827 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5828 {
5829 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5830 {
5831 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = NULL;
5832 }
5833 }
5834 }
5835 }
1268c371 5836
5837} // end of AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()
5838
5839//================================================================================================================================
489d5531 5840
1268c371 5841void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, TString ptOrEta)
5842{
5843 // Calculate differential flow cumulants from measured multiparticle correlations.
489d5531 5844
1268c371 5845 // REMARK: Cumulants calculated in this method are NOT corrected for non-uniform acceptance.
5846 // This correction, if enabled via setter SetApplyCorrectionForNUA(Bool_t), is applied
5847 // in the method CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
489d5531 5848
1268c371 5849 Int_t t = 0;
5850 Int_t pe = 0;
5851
5852 if(type == "RP")
5853 {
5854 t = 0;
5855 } else if(type == "POI")
5856 {
5857 t = 1;
5858 }
5859
5860 if(ptOrEta == "Pt")
5861 {
5862 pe = 0;
5863 } else if(ptOrEta == "Eta")
5864 {
5865 pe = 1;
5866 }
5867
5868 // Common:
5869 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 5870
1268c371 5871 // Correlation <<2>>:
5872 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);
5873 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);
489d5531 5874
1268c371 5875 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
489d5531 5876 {
1268c371 5877 // Reduced correlations:
5878 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>
5879 Double_t twoPrimeError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b); // stat. error of <<2'>>
5880 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>
5881 Double_t fourPrimeError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b); // stat. error of <<4'>>
5882 // Covariances:
5883 Double_t wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b); // Cov(<2>,<2'>) * prefactor(<2>,<2'>)
5884 Double_t wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b); // Cov(<2>,<4'>) * prefactor(<2>,<4'>)
5885 Double_t wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b); // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)
5886 // QC{2'}:
5887 Double_t qc2Prime = twoPrime; // QC{2'}
5888 Double_t qc2PrimeError = twoPrimeError; // stat. error of QC{2'}
5889 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);
5890 fDiffFlowCumulants[t][pe][0]->SetBinError(b,qc2PrimeError);
5891 // QC{4'}:
5892 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>
5893 Double_t qc4PrimeError = 0.; // stat. error of QC{4'}
5894 Double_t qc4PrimeErrorSquared = 4.*pow(twoPrime,2.)*pow(twoError,2.)
5895 + 4.*pow(two,2.)*pow(twoPrimeError,2.)
5896 + pow(fourPrimeError,2.)
5897 + 8.*two*twoPrime*wCovTwoTwoReduced
5898 - 4.*twoPrime*wCovTwoFourReduced
5899 - 4.*two*wCovTwoReducedFourReduced;
5900 if(qc4PrimeErrorSquared>0.)
5901 {
5902 qc4PrimeError = pow(qc4PrimeErrorSquared,0.5);
489d5531 5903 }
1268c371 5904 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime);
5905 fDiffFlowCumulants[t][pe][1]->SetBinError(b,qc4PrimeError);
489d5531 5906 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 5907
1268c371 5908} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, Bool_t useParticleWeights, TString eventWeights);
489d5531 5909
5910//================================================================================================================================
5911
1268c371 5912void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCumulants(TString type)
489d5531 5913{
1268c371 5914 // Calculate 2D differential cumulants.
489d5531 5915
1268c371 5916 // Remark: correction for detector effects and error propagation not implemented yet for 2D differential cumulants.
489d5531 5917
1268c371 5918 Int_t t = 0;
489d5531 5919
5920 if(type == "RP")
5921 {
1268c371 5922 t = 0;
489d5531 5923 } else if(type == "POI")
5924 {
1268c371 5925 t = 1;
5926 }
5927
5928 // Reference correlation <<2>>:
5929 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);
489d5531 5930
1268c371 5931 // Looping over all (pt,eta) bins and calculating differential flow cumulants:
5932 for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 5933 {
5934 for(Int_t e=1;e<=fnBinsEta;e++)
5935 {
1268c371 5936 // Reduced correlations:
5937 Double_t twoPrime = f2DDiffFlowCorrelationsPro[t][0]->GetBinContent(f2DDiffFlowCorrelationsPro[t][0]->GetBin(p,e)); // <<2'>>(pt,eta)
5938 Double_t fourPrime = f2DDiffFlowCorrelationsPro[t][1]->GetBinContent(f2DDiffFlowCorrelationsPro[t][1]->GetBin(p,e)); // <<4'>>(pt,eta)
5939 // Cumulants:
5940 Double_t qc2Prime = twoPrime; // QC{2'} = <<2'>>
5941 f2DDiffFlowCumulants[t][0]->SetBinContent(f2DDiffFlowCumulants[t][0]->GetBin(p,e),qc2Prime);
5942 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>
5943 f2DDiffFlowCumulants[t][1]->SetBinContent(f2DDiffFlowCumulants[t][1]->GetBin(p,e),qc4Prime);
489d5531 5944 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
489d5531 5945 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
5946
1268c371 5947} // end of void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCumulants(TString type)
489d5531 5948
489d5531 5949//================================================================================================================================
5950
489d5531 5951void AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)
5952{
1268c371 5953 // Calculate final results for integrated flow of RPs and POIs.
489d5531 5954
1268c371 5955 // to be improved - check if the integrated flow calculation here is actually correct
5956
5957 Int_t t = 0; // RP = 0, POI = 1
489d5531 5958
5959 if(type == "RP")
5960 {
1268c371 5961 t = 0;
489d5531 5962 } else if(type == "POI")
5963 {
1268c371 5964 t = 1;
5965 }
489d5531 5966
489d5531 5967 // pt yield:
5968 TH1F *yield2ndPt = NULL;
5969 TH1F *yield4thPt = NULL;
5970 TH1F *yield6thPt = NULL;
5971 TH1F *yield8thPt = NULL;
5972
5973 if(type == "POI")
5974 {
dd442cd2 5975 if(fFillMultipleControlHistograms)
5976 {
5977 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtPOI())->Clone();
5978 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtPOI())->Clone();
5979 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtPOI())->Clone();
5980 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtPOI())->Clone();
5981 } else
5982 {
5983 yield2ndPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
5984 yield4thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
5985 yield6thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
5986 yield8thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
5987 }
489d5531 5988 }
5989 else if(type == "RP")
5990 {
dd442cd2 5991 if(fFillMultipleControlHistograms)
5992 {
5993 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtRP())->Clone();
5994 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtRP())->Clone();
5995 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtRP())->Clone();
5996 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtRP())->Clone();
5997 } else
5998 {
5999 yield2ndPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6000 yield4thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6001 yield6thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6002 yield8thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6003 }
489d5531 6004 }
6005
0d11c335 6006 if(!yield2ndPt){return;}
6007 if(!yield4thPt){return;}
6008 if(!yield6thPt){return;}
6009 if(!yield8thPt){return;}
6010
489d5531 6011 Int_t nBinsPt = yield2ndPt->GetNbinsX();
6012
6013 TH1D *flow2ndPt = NULL;
6014 TH1D *flow4thPt = NULL;
6015 TH1D *flow6thPt = NULL;
6016 TH1D *flow8thPt = NULL;
6017
6018 // to be improved (hardwired pt index)
6019 flow2ndPt = (TH1D*)fDiffFlow[t][0][0]->Clone();
6020 flow4thPt = (TH1D*)fDiffFlow[t][0][1]->Clone();
6021 flow6thPt = (TH1D*)fDiffFlow[t][0][2]->Clone();
6022 flow8thPt = (TH1D*)fDiffFlow[t][0][3]->Clone();
0d11c335 6023
6024 if(!flow2ndPt){return;}
6025 if(!flow4thPt){return;}
6026 if(!flow6thPt){return;}
6027 if(!flow8thPt){return;}
489d5531 6028
6029 Double_t dvn2nd = 0., dvn4th = 0., dvn6th = 0., dvn8th = 0.; // differential flow
6030 Double_t dErrvn2nd = 0., dErrvn4th = 0., dErrvn6th = 0., dErrvn8th = 0.; // error on differential flow
6031
6032 Double_t dVn2nd = 0., dVn4th = 0., dVn6th = 0., dVn8th = 0.; // integrated flow
6033 Double_t dErrVn2nd = 0., dErrVn4th = 0., dErrVn6th = 0., dErrVn8th = 0.; // error on integrated flow
6034
6035 Double_t dYield2nd = 0., dYield4th = 0., dYield6th = 0., dYield8th = 0.; // pt yield
6036 Double_t dSum2nd = 0., dSum4th = 0., dSum6th = 0., dSum8th = 0.; // needed for normalizing integrated flow
6037
6038 // looping over pt bins:
6039 for(Int_t p=1;p<nBinsPt+1;p++)
6040 {
6041 dvn2nd = flow2ndPt->GetBinContent(p);
6042 dvn4th = flow4thPt->GetBinContent(p);
6043 dvn6th = flow6thPt->GetBinContent(p);
6044 dvn8th = flow8thPt->GetBinContent(p);
6045
6046 dErrvn2nd = flow2ndPt->GetBinError(p);
6047 dErrvn4th = flow4thPt->GetBinError(p);
6048 dErrvn6th = flow6thPt->GetBinError(p);
6049 dErrvn8th = flow8thPt->GetBinError(p);
6050
6051 dYield2nd = yield2ndPt->GetBinContent(p);
6052 dYield4th = yield4thPt->GetBinContent(p);
6053 dYield6th = yield6thPt->GetBinContent(p);
6054 dYield8th = yield8thPt->GetBinContent(p);
6055
6056 dVn2nd += dvn2nd*dYield2nd;
6057 dVn4th += dvn4th*dYield4th;
6058 dVn6th += dvn6th*dYield6th;
6059 dVn8th += dvn8th*dYield8th;
6060
6061 dSum2nd += dYield2nd;
6062 dSum4th += dYield4th;
6063 dSum6th += dYield6th;
6064 dSum8th += dYield8th;
6065
6066 dErrVn2nd += dYield2nd*dYield2nd*dErrvn2nd*dErrvn2nd; // ro be improved (check this relation)
6067 dErrVn4th += dYield4th*dYield4th*dErrvn4th*dErrvn4th;
6068 dErrVn6th += dYield6th*dYield6th*dErrvn6th*dErrvn6th;
6069 dErrVn8th += dYield8th*dYield8th*dErrvn8th*dErrvn8th;
6070
6071 } // end of for(Int_t p=1;p<nBinsPt+1;p++)
6072
6073 // normalizing the results for integrated flow:
6074 if(dSum2nd)
6075 {
6076 dVn2nd /= dSum2nd;
6077 dErrVn2nd /= (dSum2nd*dSum2nd);
6078 dErrVn2nd = TMath::Sqrt(dErrVn2nd);
6079 }
6080 if(dSum4th)
6081 {
6082 dVn4th /= dSum4th;
6083 dErrVn4th /= (dSum4th*dSum4th);
6084 dErrVn4th = TMath::Sqrt(dErrVn4th);
6085 }
6086 //if(dSum6th) dVn6th/=dSum6th;
6087 //if(dSum8th) dVn8th/=dSum8th;
6088
6089 // storing the results for integrated flow in common histos: (to be improved: new method for this?)
6090 if(type == "POI")
6091 {
6092 fCommonHistsResults2nd->FillIntegratedFlowPOI(dVn2nd,dErrVn2nd);
6093 fCommonHistsResults4th->FillIntegratedFlowPOI(dVn4th,dErrVn4th);
6094 fCommonHistsResults6th->FillIntegratedFlowPOI(dVn6th,0.); // to be improved (errors)
6095 fCommonHistsResults8th->FillIntegratedFlowPOI(dVn8th,0.); // to be improved (errors)
6096 }
6097 else if (type == "RP")
6098 {
6099 fCommonHistsResults2nd->FillIntegratedFlowRP(dVn2nd,dErrVn2nd);
6100 fCommonHistsResults4th->FillIntegratedFlowRP(dVn4th,dErrVn4th);
6101 fCommonHistsResults6th->FillIntegratedFlowRP(dVn6th,0.); // to be improved (errors)
6102 fCommonHistsResults8th->FillIntegratedFlowRP(dVn8th,0.); // to be improved (errors)
6103 }
6104
6105 delete flow2ndPt;
6106 delete flow4thPt;
6107 //delete flow6thPt;
6108 //delete flow8thPt;
6109
6110 delete yield2ndPt;
6111 delete yield4thPt;
6112 delete yield6thPt;
6113 delete yield8thPt;
6114
6115} // end of AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)
6116
489d5531 6117//================================================================================================================================
6118
489d5531 6119void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()
6120{
6121 // Initialize all arrays used for distributions.
6122
6123 // a) Initialize arrays of histograms used to hold distributions of correlations;
6124 // b) Initialize array to hold min and max values of correlations.
6125
6126 // a) Initialize arrays of histograms used to hold distributions of correlations:
6127 for(Int_t di=0;di<4;di++) // distribution index
6128 {
6129 fDistributions[di] = NULL;
6130 }
6131
6132 // b) Initialize default min and max values of correlations:
6133 // (Remark: The default values bellow were chosen for v2=5% and M=500)
6134 fMinValueOfCorrelation[0] = -0.01; // <2>_min
6135 fMaxValueOfCorrelation[0] = 0.04; // <2>_max
6136 fMinValueOfCorrelation[1] = -0.00002; // <4>_min
6137 fMaxValueOfCorrelation[1] = 0.00015; // <4>_max
6138 fMinValueOfCorrelation[2] = -0.0000003; // <6>_min
6139 fMaxValueOfCorrelation[2] = 0.0000006; // <6>_max
6140 fMinValueOfCorrelation[3] = -0.000000006; // <8>_min
6141 fMaxValueOfCorrelation[3] = 0.000000003; // <8>_max
6142
6143} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()
6144
489d5531 6145//================================================================================================================================
6146
e5834fcb 6147void AliFlowAnalysisWithQCumulants::InitializeArraysForVarious()
6148{
6149 // Initialize all arrays used for various unclassified objects.
6150
6151 for(Int_t p=0;p<4;p++) // [v_min,v_max,refMult_min,refMult_max]
6152 {
6153 fPhiDistributionForOneEventSettings[p] = 0.;
6154 }
6155
6156} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForVarious()
6157
6158//================================================================================================================================
489d5531 6159
6160void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()
6161{
6162 // a) Book profile to hold all flags for distributions of correlations;
6163 // b) Book all histograms to hold distributions of correlations.
6164
6165 TString correlationIndex[4] = {"<2>","<4>","<6>","<8>"}; // to be improved (should I promote this to data members?)
6166
6167 // a) Book profile to hold all flags for distributions of correlations:
6168 TString distributionsFlagsName = "fDistributionsFlags";
6169 distributionsFlagsName += fAnalysisLabel->Data();
6170 fDistributionsFlags = new TProfile(distributionsFlagsName.Data(),"Flags for Distributions of Correlations",9,0,9);
6171 fDistributionsFlags->SetTickLength(-0.01,"Y");
6172 fDistributionsFlags->SetMarkerStyle(25);
6173 fDistributionsFlags->SetLabelSize(0.05);
6174 fDistributionsFlags->SetLabelOffset(0.02,"Y");
6175 fDistributionsFlags->GetXaxis()->SetBinLabel(1,"Store or not?");
6176 fDistributionsFlags->GetXaxis()->SetBinLabel(2,"<2>_{min}");
6177 fDistributionsFlags->GetXaxis()->SetBinLabel(3,"<2>_{max}");
6178 fDistributionsFlags->GetXaxis()->SetBinLabel(4,"<4>_{min}");
6179 fDistributionsFlags->GetXaxis()->SetBinLabel(5,"<4>_{max}");
6180 fDistributionsFlags->GetXaxis()->SetBinLabel(6,"<6>_{min}");
6181 fDistributionsFlags->GetXaxis()->SetBinLabel(7,"<6>_{max}");
6182 fDistributionsFlags->GetXaxis()->SetBinLabel(8,"<8>_{min}");
6183 fDistributionsFlags->GetXaxis()->SetBinLabel(9,"<8>_{max}");
6184 fDistributionsList->Add(fDistributionsFlags);
6185
6186 // b) Book all histograms to hold distributions of correlations.
6187 if(fStoreDistributions)
6188 {
6189 TString distributionsName = "fDistributions";
6190 distributionsName += fAnalysisLabel->Data();
6191 for(Int_t di=0;di<4;di++) // distribution index
6192 {
6193 fDistributions[di] = new TH1D(Form("Distribution of %s",correlationIndex[di].Data()),Form("Distribution of %s",correlationIndex[di].Data()),10000,fMinValueOfCorrelation[di],fMaxValueOfCorrelation[di]);
6194 fDistributions[di]->SetXTitle(correlationIndex[di].Data());
6195 fDistributionsList->Add(fDistributions[di]);
6196 } // end of for(Int_t di=0;di<4;di++) // distribution index
6197 } // end of if(fStoreDistributions)
6198
6199} // end of void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()
6200
489d5531 6201//================================================================================================================================
6202
e5834fcb 6203void AliFlowAnalysisWithQCumulants::BookEverythingForVarious()
6204{
6205 // Book all objects for various unclassified quantities.
6206
6207 if(!fStorePhiDistributionForOneEvent){return;}
6208
6209 // a) Book histogram holding phi distribution for single event to illustrate flow.
6210
6211 // a) Book histogram holding phi distribution for single event to illustrate flow:
6212 fPhiDistributionForOneEvent = new TH1D("fPhiDistributionForOneEvent","",360,0.,TMath::TwoPi());
6213 fPhiDistributionForOneEvent->GetXaxis()->SetTitle("#phi");
6214 fVariousList->Add(fPhiDistributionForOneEvent);
6215
6216} // end of void AliFlowAnalysisWithQCumulants::BookEverythingForVarious()
6217
6218//================================================================================================================================
489d5531 6219
6220void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()
6221{
6222 // Store all flags for distributiuons of correlations in profile fDistributionsFlags.
6223
6224 if(!fDistributionsFlags)
6225 {
6226 cout<<"WARNING: fDistributionsFlags is NULL in AFAWQC::SDF() !!!!"<<endl;
6227 exit(0);
6228 }
6229
6230 fDistributionsFlags->Fill(0.5,(Int_t)fStoreDistributions); // histos with distributions of correlations stored or not in the output file
6231 // store min and max values of correlations:
6232 for(Int_t di=0;di<4;di++) // distribution index
6233 {
6234 fDistributionsFlags->Fill(1.5+2.*(Double_t)di,fMinValueOfCorrelation[di]);
6235 fDistributionsFlags->Fill(2.5+2.*(Double_t)di,fMaxValueOfCorrelation[di]);
6236 }
6237
6238} // end of void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()
6239
489d5531 6240//================================================================================================================================
6241
489d5531 6242void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
6243{
6244 // Store distributions of correlations.
6245
6246 if(!(fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE))
6247 {
6248 cout<<"WARNING: fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE"<<endl;
6249 cout<<" is NULL in AFAWQC::SDOC() !!!!"<<endl;
6250 exit(0);
6251 }
6252
6253 for(Int_t di=0;di<4;di++) // distribution index
6254 {
6255 if(!fDistributions[di])
6256 {
6257 cout<<"WARNING: fDistributions[di] is NULL in AFAWQC::SDOC() !!!!"<<endl;
6258 cout<<"di = "<<di<<endl;
6259 exit(0);
6260 } else
6261 {
6262 fDistributions[di]->Fill(fIntFlowCorrelationsEBE->GetBinContent(di+1),fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(di+1));
6263 }
6264 } // end of for(Int_t di=0;di<4;di++) // distribution index
6265
6266} // end of void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
6267
489d5531 6268//================================================================================================================================
6269
489d5531 6270void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()
6271{
6272 // Book and nest all lists nested in the base list fHistList.
6273 // a) Book and nest lists for integrated flow;
6274 // b) Book and nest lists for differential flow;
6275 // c) Book and nest list for particle weights;
6276 // d) Book and nest list for distributions;
e5834fcb 6277 // e) Book and nest list for various unclassified objects;
6278 // f) Book and nest list for nested loops.
489d5531 6279
6280 // a) Book and nest all lists for integrated flow:
1268c371 6281 // Base list for integrated flow:
489d5531 6282 fIntFlowList = new TList();
6283 fIntFlowList->SetName("Integrated Flow");
6284 fIntFlowList->SetOwner(kTRUE);
6285 fHistList->Add(fIntFlowList);
1268c371 6286 // List holding profiles:
489d5531 6287 fIntFlowProfiles = new TList();
6288 fIntFlowProfiles->SetName("Profiles");
6289 fIntFlowProfiles->SetOwner(kTRUE);
6290 fIntFlowList->Add(fIntFlowProfiles);
3435cacb 6291 // List holding all profiles with results for correlations vs M:
6292 if(fCalculateAllCorrelationsVsM)
6293 {
6294 fIntFlowAllCorrelationsVsM = new TList();
6295 fIntFlowAllCorrelationsVsM->SetName("Correlations vs M");
6296 fIntFlowAllCorrelationsVsM->SetOwner(kTRUE);
6297 fIntFlowProfiles->Add(fIntFlowAllCorrelationsVsM);
6298 } // end of if(fCalculateAllCorrelationsVsM)
1268c371 6299 // List holding histograms with results:
489d5531 6300 fIntFlowResults = new TList();
6301 fIntFlowResults->SetName("Results");
6302 fIntFlowResults->SetOwner(kTRUE);
6303 fIntFlowList->Add(fIntFlowResults);
6304
1268c371 6305 // b) Book and nest lists for differential flow:
6306 this->BookAndNestListsForDifferentialFlow();
6307
6308 // c) Book and nest list for particle weights:
6309 fWeightsList->SetName("Weights");
6310 fWeightsList->SetOwner(kTRUE);
6311 fHistList->Add(fWeightsList);
6312
6313 // d) Book and nest list for distributions:
6314 fDistributionsList = new TList();
6315 fDistributionsList->SetName("Distributions");
6316 fDistributionsList->SetOwner(kTRUE);
6317 fHistList->Add(fDistributionsList);
6318
6319 // e) Book and nest list for various unclassified objects:
6320 if(fStorePhiDistributionForOneEvent)
6321 {
6322 fVariousList = new TList();
6323 fVariousList->SetName("Various");
6324 fVariousList->SetOwner(kTRUE);
6325 fHistList->Add(fVariousList);
6326 }
6327
64e500e3 6328 // f) Book and nest list for other differential correlators:
6329 fOtherDiffCorrelatorsList = new TList();
6330 fOtherDiffCorrelatorsList->SetName("Other differential correlators");
6331 fOtherDiffCorrelatorsList->SetOwner(kTRUE);
62e36168 6332 if(fCalculateDiffFlow){fHistList->Add(fOtherDiffCorrelatorsList);} // TBI: Use another flag here instead of fCalculateDiffFlow
64e500e3 6333
6334 // g) Book and nest list for nested loops:
1268c371 6335 fNestedLoopsList = new TList();
6336 fNestedLoopsList->SetName("Nested Loops");
6337 fNestedLoopsList->SetOwner(kTRUE);
6338 fHistList->Add(fNestedLoopsList);
6339
6340} // end of void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()
6341
6342//================================================================================================================================
6343
6344void AliFlowAnalysisWithQCumulants::BookAndNestListsForDifferentialFlow()
6345{
6346 // Book and nest lists for differential flow.
6347
6348 // Base list for differential flow objects:
489d5531 6349 fDiffFlowList = new TList();
6350 fDiffFlowList->SetName("Differential Flow");
6351 fDiffFlowList->SetOwner(kTRUE);
6352 fHistList->Add(fDiffFlowList);
1268c371 6353
6354 // Local flags:
6355 TString typeFlag[2] = {"RP","POI"};
6356 TString ptEtaFlag[2] = {"p_{T}","#eta"};
6357 TString powerFlag[2] = {"linear","quadratic"};
6358
6359 // 2D:
6360 if(fCalculate2DDiffFlow)
6361 {
6362 fDiffFlow2D = new TList();
6363 fDiffFlow2D->SetName("2D");
6364 fDiffFlow2D->SetOwner(kTRUE);
6365 fDiffFlowList->Add(fDiffFlow2D);
6366 for(Int_t t=0;t<2;t++)
6367 {
6368 f2DDiffFlowCorrelationsProList[t] = new TList();
6369 f2DDiffFlowCorrelationsProList[t]->SetOwner(kTRUE);
6370 f2DDiffFlowCorrelationsProList[t]->SetName(Form("Profiles with 2D correlations (%s)",typeFlag[t].Data()));
6371 fDiffFlow2D->Add(f2DDiffFlowCorrelationsProList[t]);
6372 } // end of for(Int_t t=0;t<2;t++)
6373 } // end of if(fCalculate2DDiffFlow)
6374
6375 // What follows bellow in this method is relevant only for 1D differential flow:
6376 if(!fCalculateDiffFlow){return;}
6377
6378 // List holding profiles:
489d5531 6379 fDiffFlowProfiles = new TList();
6380 fDiffFlowProfiles->SetName("Profiles");
6381 fDiffFlowProfiles->SetOwner(kTRUE);
6382 fDiffFlowList->Add(fDiffFlowProfiles);
1268c371 6383 // List holding histograms with results:
489d5531 6384 fDiffFlowResults = new TList();
6385 fDiffFlowResults->SetName("Results");
6386 fDiffFlowResults->SetOwner(kTRUE);
6387 fDiffFlowList->Add(fDiffFlowResults);
1268c371 6388 // Flags used for naming nested lists in list fDiffFlowProfiles and fDiffFlowResults:
489d5531 6389 TList list;
6390 list.SetOwner(kTRUE);
1268c371 6391 // Nested lists in fDiffFlowProfiles (~/Differential Flow/Profiles):
489d5531 6392 for(Int_t t=0;t<2;t++) // type: RP or POI
6393 {
62e36168 6394 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 6395 {
6396 // list holding profiles with correlations:
6397 fDiffFlowCorrelationsProList[t][pe] = (TList*)list.Clone();
6398 fDiffFlowCorrelationsProList[t][pe]->SetName(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6399 fDiffFlowProfiles->Add(fDiffFlowCorrelationsProList[t][pe]);
6400 // list holding profiles with products of correlations:
6401 fDiffFlowProductOfCorrelationsProList[t][pe] = (TList*)list.Clone();
6402 fDiffFlowProductOfCorrelationsProList[t][pe]->SetName(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6403 fDiffFlowProfiles->Add(fDiffFlowProductOfCorrelationsProList[t][pe]);
6404 // list holding profiles with corrections:
6405 fDiffFlowCorrectionsProList[t][pe] = (TList*)list.Clone();
6406 fDiffFlowCorrectionsProList[t][pe]->SetName(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6407 fDiffFlowProfiles->Add(fDiffFlowCorrectionsProList[t][pe]);
6408 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
6409 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
6410 // nested lists in fDiffFlowResults (~/Differential Flow/Results):
6411 for(Int_t t=0;t<2;t++) // type: RP or POI
6412 {
62e36168 6413 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 6414 {
6415 // list holding histograms with correlations:
6416 fDiffFlowCorrelationsHistList[t][pe] = (TList*)list.Clone();
6417 fDiffFlowCorrelationsHistList[t][pe]->SetName(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6418 fDiffFlowResults->Add(fDiffFlowCorrelationsHistList[t][pe]);
6419 // list holding histograms with corrections:
6420 fDiffFlowCorrectionsHistList[t][pe] = (TList*)list.Clone();
6421 fDiffFlowCorrectionsHistList[t][pe]->SetName(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6422 fDiffFlowResults->Add(fDiffFlowCorrectionsHistList[t][pe]);
6423 for(Int_t power=0;power<2;power++)
6424 {
6425 // list holding histograms with sums of event weights:
6426 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = (TList*)list.Clone();
6427 fDiffFlowSumOfEventWeightsHistList[t][pe][power]->SetName(Form("Sum of %s event weights (%s, %s)",powerFlag[power].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6428 fDiffFlowResults->Add(fDiffFlowSumOfEventWeightsHistList[t][pe][power]);
6429 } // end of for(Int_t power=0;power<2;power++)
6430 // list holding histograms with sums of products of event weights:
6431 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = (TList*)list.Clone();
6432 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->SetName(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6433 fDiffFlowResults->Add(fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]);
6434 // list holding histograms with covariances of correlations:
6435 fDiffFlowCovariancesHistList[t][pe] = (TList*)list.Clone();
6436 fDiffFlowCovariancesHistList[t][pe]->SetName(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6437 fDiffFlowResults->Add(fDiffFlowCovariancesHistList[t][pe]);
6438 // list holding histograms with differential Q-cumulants:
6439 fDiffFlowCumulantsHistList[t][pe] = (TList*)list.Clone();
6440 fDiffFlowCumulantsHistList[t][pe]->SetName(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6441 fDiffFlowResults->Add(fDiffFlowCumulantsHistList[t][pe]);
1268c371 6442 // list holding histograms which quantify detector bias to differential Q-cumulants:
6443 fDiffFlowDetectorBiasHistList[t][pe] = (TList*)list.Clone();
6444 fDiffFlowDetectorBiasHistList[t][pe]->SetName(Form("Detector bias (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6445 fDiffFlowResults->Add(fDiffFlowDetectorBiasHistList[t][pe]);
489d5531 6446 // list holding histograms with differential flow estimates from Q-cumulants:
6447 fDiffFlowHistList[t][pe] = (TList*)list.Clone();
6448 fDiffFlowHistList[t][pe]->SetName(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6449 fDiffFlowResults->Add(fDiffFlowHistList[t][pe]);
6450 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
6451 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
6452
1268c371 6453} // end of void AliFlowAnalysisWithQCumulants::BookAndNestListsForDifferentialFlow()
489d5531 6454
6455//================================================================================================================================
6456
489d5531 6457void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type)
6458{
1268c371 6459 // Fill common result histograms for differential flow.
489d5531 6460
1268c371 6461 Int_t t = 0;
489d5531 6462
6463 if(type == "RP")
6464 {
1268c371 6465 t = 0;
489d5531 6466 } else if(type == "POI")
6467 {
1268c371 6468 t = 1;
489d5531 6469 }
1268c371 6470
6471 // to be improved - check all pointers used in this method
489d5531 6472
6473 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))
6474 {
6475 cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl;
6476 cout<<" is NULL in AFAWQC::FCHRIF() !!!!"<<endl;
6477 exit(0);
6478 }
6479
6480 // pt:
6481 for(Int_t p=1;p<=fnBinsPt;p++)
6482 {
6483 Double_t v2 = fDiffFlow[t][0][0]->GetBinContent(p);
6484 Double_t v4 = fDiffFlow[t][0][1]->GetBinContent(p);
6485 Double_t v6 = fDiffFlow[t][0][2]->GetBinContent(p);
6486 Double_t v8 = fDiffFlow[t][0][3]->GetBinContent(p);
6487
6488 Double_t v2Error = fDiffFlow[t][0][0]->GetBinError(p);
6489 Double_t v4Error = fDiffFlow[t][0][1]->GetBinError(p);
6490 //Double_t v6Error = fFinalFlow1D[t][pW][nua][0][2]->GetBinError(p);
6491 //Double_t v8Error = fFinalFlow1D[t][pW][nua][0][3]->GetBinError(p);
6492
6493 if(type == "RP")
6494 {
6495 fCommonHistsResults2nd->FillDifferentialFlowPtRP(p,v2,v2Error);
6496 fCommonHistsResults4th->FillDifferentialFlowPtRP(p,v4,v4Error);
6497 fCommonHistsResults6th->FillDifferentialFlowPtRP(p,v6,0.);
6498 fCommonHistsResults8th->FillDifferentialFlowPtRP(p,v8,0.);
6499 } else if(type == "POI")
6500 {
6501 fCommonHistsResults2nd->FillDifferentialFlowPtPOI(p,v2,v2Error);
6502 fCommonHistsResults4th->FillDifferentialFlowPtPOI(p,v4,v4Error);
6503 fCommonHistsResults6th->FillDifferentialFlowPtPOI(p,v6,0.);
6504 fCommonHistsResults8th->FillDifferentialFlowPtPOI(p,v8,0.);
6505 }
6506 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
6507
6508 // eta:
62e36168 6509 if(!fCalculateDiffFlowVsEta){return;}
489d5531 6510 for(Int_t e=1;e<=fnBinsEta;e++)
6511 {
6512 Double_t v2 = fDiffFlow[t][1][0]->GetBinContent(e);
6513 Double_t v4 = fDiffFlow[t][1][1]->GetBinContent(e);
6514 Double_t v6 = fDiffFlow[t][1][2]->GetBinContent(e);
6515 Double_t v8 = fDiffFlow[t][1][3]->GetBinContent(e);
6516
6517 Double_t v2Error = fDiffFlow[t][1][0]->GetBinError(e);
6518 Double_t v4Error = fDiffFlow[t][1][1]->GetBinError(e);
6519 //Double_t v6Error = fDiffFlow[t][1][2]->GetBinError(e);
6520 //Double_t v8Error = fDiffFlow[t][1][3]->GetBinError(e);
6521
6522 if(type == "RP")
6523 {
6524 fCommonHistsResults2nd->FillDifferentialFlowEtaRP(e,v2,v2Error);
6525 fCommonHistsResults4th->FillDifferentialFlowEtaRP(e,v4,v4Error);
6526 fCommonHistsResults6th->FillDifferentialFlowEtaRP(e,v6,0.);
6527 fCommonHistsResults8th->FillDifferentialFlowEtaRP(e,v8,0.);
6528 } else if(type == "POI")
6529 {
6530 fCommonHistsResults2nd->FillDifferentialFlowEtaPOI(e,v2,v2Error);
6531 fCommonHistsResults4th->FillDifferentialFlowEtaPOI(e,v4,v4Error);
6532 fCommonHistsResults6th->FillDifferentialFlowEtaPOI(e,v6,0.);
6533 fCommonHistsResults8th->FillDifferentialFlowEtaPOI(e,v8,0.);
6534 }
6535 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
6536
6537} // end of void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights, Bool_t correctedForNUA)
6538
489d5531 6539//================================================================================================================================
6540
1268c371 6541void AliFlowAnalysisWithQCumulants::CommonConstants(TString method)
489d5531 6542{
1268c371 6543 // Access and store common constants.
6544
6545 // a) If this method was called in Init() access common constants from AliFlowCommonConstants;
6546 // b) If this method was called in Init() book and fill TProfile to hold constants accessed in a);
6547 // c) If this method was called in Finish() access common constants from TProfile booked and filled in b).
6548
6549 if(method == "Init")
6550 {
6551 // a) If this method was called in Init() access common constants from AliFlowCommonConstants:
6552 fnBinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();
6553 fPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin();
6554 fPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();
6555 if(fnBinsPhi){fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;}
6556 fnBinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();
6557 fPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin();
6558 fPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();
6559 if(fnBinsPt){fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;}
6560 fnBinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();
6561 fEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin();
6562 fEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();
6563 if(fnBinsEta){fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;}
6564
6565 // b) If this method was called in Init() book and fill TProfile to hold constants accessed in a):
6566 TString fCommonConstantsName = "fCommonConstants";
6567 fCommonConstantsName += fAnalysisLabel->Data();
6568 fCommonConstants = new TProfile(fCommonConstantsName.Data(),"Common constants",9,0.,9.);
6569 fCommonConstants->SetLabelSize(0.05);
6570 fCommonConstants->GetXaxis()->SetBinLabel(1,"nBins (#phi)");
6571 fCommonConstants->Fill(0.5,fnBinsPhi);
6572 fCommonConstants->GetXaxis()->SetBinLabel(2,"#phi_{min}");
6573 fCommonConstants->Fill(1.5,fPhiMin);
6574 fCommonConstants->GetXaxis()->SetBinLabel(3,"#phi_{max}");
6575 fCommonConstants->Fill(2.5,fPhiMax);
6576 fCommonConstants->GetXaxis()->SetBinLabel(4,"nBins (p_{t})");
6577 fCommonConstants->Fill(3.5,fnBinsPt);
6578 fCommonConstants->GetXaxis()->SetBinLabel(5,"(p_{t})_{min}");
6579 fCommonConstants->Fill(4.5,fPtMin);
6580 fCommonConstants->GetXaxis()->SetBinLabel(6,"(p_{t})_{max}");
6581 fCommonConstants->Fill(5.5,fPtMax);
6582 fCommonConstants->GetXaxis()->SetBinLabel(7,"nBins (#eta)");
6583 fCommonConstants->Fill(6.5,fnBinsEta);
6584 fCommonConstants->GetXaxis()->SetBinLabel(8,"#eta_{min}");
6585 fCommonConstants->Fill(7.5,fEtaMin);
6586 fCommonConstants->GetXaxis()->SetBinLabel(9,"#eta_{max}");
6587 fCommonConstants->Fill(8.5,fEtaMax);
6588 fHistList->Add(fCommonConstants);
6589 } // end of if(method == "Init")
6590 else if(method == "Finish")
6591 {
6592 // c) If this method was called in Finish() access common constants from TProfile booked and filled in b):
6593 if(!fCommonConstants)
6594 {
6595 printf("\n WARNING (QC): fCommonConstants is NULL in AFAWQC::AC(\"%s\") !!!!\n\n",method.Data());
6596 exit(0);
6597 }
6598 fnBinsPhi = (Int_t)fCommonConstants->GetBinContent(1);
6599 fPhiMin = fCommonConstants->GetBinContent(2);
6600 fPhiMax = fCommonConstants->GetBinContent(3);
6601 if(fnBinsPhi){fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;}
6602 fnBinsPt = (Int_t)fCommonConstants->GetBinContent(4);
6603 fPtMin = fCommonConstants->GetBinContent(5);
6604 fPtMax = fCommonConstants->GetBinContent(6);
6605 if(fnBinsPt){fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;}
6606 fnBinsEta = (Int_t)fCommonConstants->GetBinContent(7);
6607 fEtaMin = fCommonConstants->GetBinContent(8);
6608 fEtaMax = fCommonConstants->GetBinContent(9);
6609 if(fnBinsEta){fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;}
6610 } // end of else if(method == "Finish")
6611
6612} // end of void AliFlowAnalysisWithQCumulants::CommonConstants(TString method)
489d5531 6613
489d5531 6614//================================================================================================================================
6615
489d5531 6616void AliFlowAnalysisWithQCumulants::CrossCheckSettings()
6617{
1268c371 6618 // a) Cross check if the choice for multiplicity weights make sense.
489d5531 6619
6620 // a) Cross check if the choice for multiplicity weights make sense:
6621 if(strcmp(fMultiplicityWeight->Data(),"combinations") &&
6622 strcmp(fMultiplicityWeight->Data(),"unit") &&
6623 strcmp(fMultiplicityWeight->Data(),"multiplicity"))
6624 {
6625 cout<<"WARNING (QC): Multiplicity weight can be either \"combinations\", \"unit\""<<endl;
6626 cout<<" or \"multiplicity\". Certainly not \""<<fMultiplicityWeight->Data()<<"\"."<<endl;
6627 exit(0);
6628 }
6629
6630} // end of void AliFlowAnalysisWithQCumulants::CrossCheckSettings()
6631
489d5531 6632//================================================================================================================================
6633
489d5531 6634void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()
6635{
0328db2d 6636 // Calculate sum of linear and quadratic event weights for correlations.
2001bc3a 6637
6638 // multiplicity:
1268c371 6639 Double_t dMult = (*fSpk)(0,0);
9f33751d 6640
489d5531 6641 for(Int_t p=0;p<2;p++) // power-1
6642 {
6643 for(Int_t ci=0;ci<4;ci++) // correlation index
6644 {
6645 fIntFlowSumOfEventWeights[p]->Fill(ci+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1));
b3dacf6b 6646 if(fCalculateCumulantsVsM)
6647 {
6648 fIntFlowSumOfEventWeightsVsM[ci][p]->Fill(dMult+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1)); // to be improved: dMult => sum of weights?
6649 }
489d5531 6650 }
6651 }
6652
6653} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()
6654
489d5531 6655//================================================================================================================================
6656
0328db2d 6657void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeightsNUA()
489d5531 6658{
0328db2d 6659 // Calculate sum of linear and quadratic event weights for NUA terms.
6660
6661 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
489d5531 6662 {
0328db2d 6663 for(Int_t p=0;p<2;p++) // power-1
6664 {
b92ea2b9 6665 for(Int_t ci=0;ci<4;ci++) // nua term index
0328db2d 6666 {
6667 fIntFlowSumOfEventWeightsNUA[sc][p]->Fill(ci+0.5,pow(fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc]->GetBinContent(ci+1),p+1));
489d5531 6668 }
0328db2d 6669 }
6670 }
6671
6672} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeightsNUA()
489d5531 6673
0328db2d 6674//================================================================================================================================
6675
0328db2d 6676void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()
6677{
ff70ca91 6678 // Calculate sum of product of event weights for correlations.
2001bc3a 6679
6680 // multiplicity:
1268c371 6681 Double_t dMult = (*fSpk)(0,0);
2001bc3a 6682
489d5531 6683 Int_t counter = 0;
6684
6685 for(Int_t ci1=1;ci1<4;ci1++)
6686 {
6687 for(Int_t ci2=ci1+1;ci2<=4;ci2++)
6688 {
ff70ca91 6689 fIntFlowSumOfProductOfEventWeights->Fill(0.5+counter,
6690 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
b3dacf6b 6691 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
6692 if(fCalculateCumulantsVsM)
6693 {
6694 fIntFlowSumOfProductOfEventWeightsVsM[counter]->Fill(dMult+0.5, // to be improved: dMult => sum of weights?
6695 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
6696 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
6697 } // end of if(fCalculateCumulantsVsM)
ff70ca91 6698 counter++;
489d5531 6699 }
6700 }
6701
0328db2d 6702} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()
6703
0328db2d 6704//================================================================================================================================
6705
0328db2d 6706void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeightsNUA()
6707{
6708 // Calculate sum of product of event weights for NUA terms.
6709
6710 // w_{<2>} * w_{<cos(#phi)>}:
6711 fIntFlowSumOfProductOfEventWeightsNUA->Fill(0.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6712 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
6713 // w_{<2>} * w_{<sin(#phi)>}:
6714 fIntFlowSumOfProductOfEventWeightsNUA->Fill(1.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6715 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6716 // w_{<cos(#phi)> * w_{<sin(#phi)>}:
6717 fIntFlowSumOfProductOfEventWeightsNUA->Fill(2.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6718 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6719 // w_{<2>} * w{<cos(phi1+phi2)>}
6720 fIntFlowSumOfProductOfEventWeightsNUA->Fill(3.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6721 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6722 // w_{<2>} * w{<sin(phi1+phi2)>}
6723 fIntFlowSumOfProductOfEventWeightsNUA->Fill(4.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6724 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6725 // w_{<2>} * w{<cos(phi1-phi2-phi3)>}
6726 fIntFlowSumOfProductOfEventWeightsNUA->Fill(5.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6727 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6728 // w_{<2>} * w{<sin(phi1-phi2-phi3)>}
6729 fIntFlowSumOfProductOfEventWeightsNUA->Fill(6.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6730 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6731 // w_{<4>} * w{<cos(phi1)>}
6732 fIntFlowSumOfProductOfEventWeightsNUA->Fill(7.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6733 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
6734 // w_{<4>} * w{<sin(phi1)>}
6735 fIntFlowSumOfProductOfEventWeightsNUA->Fill(8.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6736 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6737 // w_{<4>} * w{<cos(phi1+phi2)>}
6738 fIntFlowSumOfProductOfEventWeightsNUA->Fill(9.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6739 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6740 // w_{<4>} * w{<sin(phi1+phi2)>}
6741 fIntFlowSumOfProductOfEventWeightsNUA->Fill(10.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6742 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6743 // w_{<4>} * w{<cos(phi1-phi2-phi3)>}
6744 fIntFlowSumOfProductOfEventWeightsNUA->Fill(11.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6745 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6746 // w_{<4>} * w{<sin(phi1-phi2-phi3)>}
6747 fIntFlowSumOfProductOfEventWeightsNUA->Fill(12.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6748 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6749 // w_{<cos(phi1)>} * w{<cos(phi1+phi2)>}
6750 fIntFlowSumOfProductOfEventWeightsNUA->Fill(13.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6751 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6752 // w_{<cos(phi1)>} * w{<sin(phi1+phi2)>}
6753 fIntFlowSumOfProductOfEventWeightsNUA->Fill(14.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6754 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6755 // w_{<cos(phi1)>} * w{<cos(phi1-phi2-phi3)>}
6756 fIntFlowSumOfProductOfEventWeightsNUA->Fill(15.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6757 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6758 // w_{<cos(phi1)>} * w{<sin(phi1-phi2-phi3)>}
6759 fIntFlowSumOfProductOfEventWeightsNUA->Fill(16.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6760 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6761 // w_{<sin(phi1)>} * w{<cos(phi1+phi2)>}
6762 fIntFlowSumOfProductOfEventWeightsNUA->Fill(17.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6763 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6764 // w_{<sin(phi1)>} * w{<sin(phi1+phi2)>}
6765 fIntFlowSumOfProductOfEventWeightsNUA->Fill(18.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6766 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6767 // w_{<sin(phi1)>} * w{<cos(phi1-phi2-phi3)>}
6768 fIntFlowSumOfProductOfEventWeightsNUA->Fill(19.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6769 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6770 // w_{<sin(phi1)>} * w{<sin(phi1-phi2-phi3)>}
6771 fIntFlowSumOfProductOfEventWeightsNUA->Fill(20.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6772 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6773 // w_{<cos(phi1+phi2)>} * w{<sin(phi1+phi2))>}
6774 fIntFlowSumOfProductOfEventWeightsNUA->Fill(21.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6775 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6776 // w_{<cos(phi1+phi2)>} * w{<cos(phi1-phi2-phi3)>}
6777 fIntFlowSumOfProductOfEventWeightsNUA->Fill(22.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6778 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6779 // w_{<cos(phi1+phi2)>} * w{<sin(phi1-phi2-phi3)>}
6780 fIntFlowSumOfProductOfEventWeightsNUA->Fill(23.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6781 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6782 // w_{<sin(phi1+phi2)>} * w{<cos(phi1-phi2-phi3)>}
6783 fIntFlowSumOfProductOfEventWeightsNUA->Fill(24.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)*
6784 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6785 // w_{<sin(phi1+phi2)>} * w{<sin(phi1-phi2-phi3)>}
6786 fIntFlowSumOfProductOfEventWeightsNUA->Fill(25.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)*
6787 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6788 // w_{<cos(phi1-phi2-phi3)>} * w{<sin(phi1-phi2-phi3)>}
6789 fIntFlowSumOfProductOfEventWeightsNUA->Fill(26.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3)*
6790 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6791
6792} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowIntFlowSumOfProductOfEventWeightsNUA()
489d5531 6793
489d5531 6794//================================================================================================================================
6795
489d5531 6796void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta)
6797{
1268c371 6798 // Calculate reduced correlations for RPs or POIs for all pt and eta bins.
489d5531 6799
1268c371 6800 // Multiplicity:
6801 Double_t dMult = (*fSpk)(0,0);
489d5531 6802
6803 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
6804 Double_t dReQ1n = (*fReQ)(0,0);
6805 Double_t dReQ2n = (*fReQ)(1,0);
6806 //Double_t dReQ3n = (*fReQ)(2,0);
6807 //Double_t dReQ4n = (*fReQ)(3,0);
6808 Double_t dImQ1n = (*fImQ)(0,0);
6809 Double_t dImQ2n = (*fImQ)(1,0);
6810 //Double_t dImQ3n = (*fImQ)(2,0);
6811 //Double_t dImQ4n = (*fImQ)(3,0);
6812
6813 // reduced correlations are stored in fDiffFlowCorrelationsPro[0=RP,1=POI][0=pt,1=eta][correlation index]. Correlation index runs as follows:
6814 //
6815 // 0: <<2'>>
6816 // 1: <<4'>>
6817 // 2: <<6'>>
6818 // 3: <<8'>>
6819
2a98ceb8 6820 Int_t t = 0; // type flag
6821 Int_t pe = 0; // ptEta flag
489d5531 6822
6823 if(type == "RP")
6824 {
6825 t = 0;
6826 } else if(type == "POI")
6827 {
6828 t = 1;
6829 }
6830
6831 if(ptOrEta == "Pt")
6832 {
6833 pe = 0;
6834 } else if(ptOrEta == "Eta")
6835 {
6836 pe = 1;
6837 }
6838
6839 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
6840 Double_t minPtEta[2] = {fPtMin,fEtaMin};
6841 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
6842 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
6843
6844 // looping over all bins and calculating reduced correlations:
6845 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
6846 {
6847 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
6848 Double_t p1n0kRe = 0.;
6849 Double_t p1n0kIm = 0.;
6850
6851 // number of POIs in particular pt or eta bin:
6852 Double_t mp = 0.;
6853
6854 // 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):
6855 Double_t q1n0kRe = 0.;
6856 Double_t q1n0kIm = 0.;
6857 Double_t q2n0kRe = 0.;
6858 Double_t q2n0kIm = 0.;
6859
6860 // number of particles which are both RPs and POIs in particular pt or eta bin:
6861 Double_t mq = 0.;
6862
6863 if(type == "POI")
6864 {
6865 // q_{m*n,0}:
6866 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
6867 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
6868 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
6869 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
6870 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
6871 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
6872 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
6873 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
6874
6875 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6876 }
6877 else if(type == "RP")
6878 {
6879 // q_{m*n,0}:
6880 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
6881 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
6882 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
6883 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
6884 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
6885 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
6886 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
6887 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
6888
6889 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6890 }
6891
6892 if(type == "POI")
6893 {
6894 // p_{m*n,0}:
6895 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
6896 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
6897 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
6898 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
6899
6900 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6901
6902 t = 1; // typeFlag = RP or POI
6903 }
6904 else if(type == "RP")
6905 {
6906 // p_{m*n,0} = q_{m*n,0}:
6907 p1n0kRe = q1n0kRe;
6908 p1n0kIm = q1n0kIm;
6909
6910 mp = mq;
6911
6912 t = 0; // typeFlag = RP or POI
6913 }
6914
1268c371 6915 // 2'-particle correlation for particular pt or eta bin:
489d5531 6916 Double_t two1n1nPtEta = 0.;
b40a910e 6917 Double_t mWeight2pPrime = 0.; // multiplicity weight for <2'>
489d5531 6918 if(mp*dMult-mq)
6919 {
6920 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)
6921 / (mp*dMult-mq);
b40a910e 6922 // determine multiplicity weight:
6923 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
6924 {
6925 mWeight2pPrime = mp*dMult-mq;
6926 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
6927 {
6928 mWeight2pPrime = 1.;
6929 }
489d5531 6930 if(type == "POI") // to be improved (I do not this if)
6931 {
6932 // fill profile to get <<2'>> for POIs
b40a910e 6933 fDiffFlowCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mWeight2pPrime);
6934 // fill profile to get <<2'>^2> for POIs
6935 fDiffFlowSquaredCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta*two1n1nPtEta,mWeight2pPrime);
489d5531 6936 // histogram to store <2'> for POIs e-b-e (needed in some other methods):
6937 fDiffFlowCorrelationsEBE[1][pe][0]->SetBinContent(b,two1n1nPtEta);
b40a910e 6938 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][0]->SetBinContent(b,mWeight2pPrime);
489d5531 6939 }
6940 else if(type == "RP") // to be improved (I do not this if)
6941 {
6942 // profile to get <<2'>> for RPs:
b40a910e 6943 fDiffFlowCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mWeight2pPrime);
6944 // profile to get <<2'>^2> for RPs:
6945 fDiffFlowSquaredCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta*two1n1nPtEta,mWeight2pPrime);
489d5531 6946 // histogram to store <2'> for RPs e-b-e (needed in some other methods):
6947 fDiffFlowCorrelationsEBE[0][pe][0]->SetBinContent(b,two1n1nPtEta);
b40a910e 6948 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][0]->SetBinContent(b,mWeight2pPrime);
489d5531 6949 }
6950 } // end of if(mp*dMult-mq)
6951
6952 // 4'-particle correlation:
6953 Double_t four1n1n1n1nPtEta = 0.;
b40a910e 6954 Double_t mWeight4pPrime = 0.; // multiplicity weight for <4'>
489d5531 6955 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
6956 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)
6957 {
6958 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
6959 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))
6960 - 2.*q2n0kIm*dReQ1n*dImQ1n
6961 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)
6962 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)
6963 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
6964 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq
6965 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)
6966 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)
6967 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
6968 + 2.*mq*dMult
6969 - 6.*mq)
6970 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
6971 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));
b40a910e 6972 // determine multiplicity weight:
6973 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
6974 {
6975 mWeight4pPrime = (mp-mq)*dMult*(dMult-1.)*(dMult-2.) + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
6976 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
6977 {
6978 mWeight4pPrime = 1.;
6979 }
489d5531 6980 if(type == "POI")
6981 {
6982 // profile to get <<4'>> for POIs:
b40a910e 6983 fDiffFlowCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,mWeight4pPrime);
6984 // profile to get <<4'>^2> for POIs:
6985 fDiffFlowSquaredCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta*four1n1n1n1nPtEta,mWeight4pPrime);
489d5531 6986 // histogram to store <4'> for POIs e-b-e (needed in some other methods):
6987 fDiffFlowCorrelationsEBE[1][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);
b40a910e 6988 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][1]->SetBinContent(b,mWeight4pPrime);
489d5531 6989 }
6990 else if(type == "RP")
6991 {
6992 // profile to get <<4'>> for RPs:
b40a910e 6993 fDiffFlowCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,mWeight4pPrime);
6994 // profile to get <<4'>^2> for RPs:
6995 fDiffFlowSquaredCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta*four1n1n1n1nPtEta,mWeight4pPrime);
489d5531 6996 // histogram to store <4'> for RPs e-b-e (needed in some other methods):
6997 fDiffFlowCorrelationsEBE[0][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);
b40a910e 6998 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][1]->SetBinContent(b,mWeight4pPrime);
489d5531 6999 }
7000 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7001 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))
7002
7003 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7004
7005
7006} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta);
7007
489d5531 7008//================================================================================================================================
7009
64e500e3 7010void AliFlowAnalysisWithQCumulants::CalculateOtherDiffCorrelators(TString type, TString ptOrEta)
7011{
7012 // Calculate other differential correlators for RPs or POIs for all pt and eta bins.
7013
7014 // Multiplicity:
7015 Double_t dMult = (*fSpk)(0,0);
7016
7017 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
7018 Double_t dReQ1n = (*fReQ)(0,0);
7019 Double_t dReQ2n = (*fReQ)(1,0);
7020 Double_t dReQ3n = (*fReQ)(2,0);
7021 //Double_t dReQ4n = (*fReQ)(3,0);
7022 Double_t dImQ1n = (*fImQ)(0,0);
7023 Double_t dImQ2n = (*fImQ)(1,0);
7024 Double_t dImQ3n = (*fImQ)(2,0);
7025 //Double_t dImQ4n = (*fImQ)(3,0);
7026
7027 // Other correlations are stored in fOtherDiffCorrelators[2][2][2][1], [0=RP,1=POI][0=pt,1=eta][0=sin terms,1=cos terms][correlator index]
7028 // Correlation index runs as follows:
7029 //
7030 // 0: <exp[in(psi1-3phi2+2phi3)]>
7031
7032 Int_t t = 0; // type flag
7033 Int_t pe = 0; // ptEta flag
7034
7035 if(type == "RP")
7036 {
7037 t = 0;
7038 } else if(type == "POI")
7039 {
7040 t = 1;
7041 }
7042
7043 if(ptOrEta == "Pt")
7044 {
7045 pe = 0;
7046 } else if(ptOrEta == "Eta")
7047 {
7048 pe = 1;
7049 }
7050
7051 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7052 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7053 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7054 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7055
7056 // looping over all bins and calculating reduced correlations:
7057 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7058 {
7059 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
7060 Double_t p1n0kRe = 0.;
7061 Double_t p1n0kIm = 0.;
7062
7063 // number of POIs in particular pt or eta bin:
7064 Double_t mp = 0.;
7065
7066 // 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):
7067 Double_t q1n0kRe = 0.;
7068 Double_t q1n0kIm = 0.;
7069 Double_t q2n0kRe = 0.;
7070 Double_t q2n0kIm = 0.;
7071 Double_t q3n0kRe = 0.;
7072 Double_t q3n0kIm = 0.;
7073
7074 // number of particles which are both RPs and POIs in particular pt or eta bin:
7075 Double_t mq = 0.;
7076
7077 if(type == "POI")
7078 {
7079 // q_{m*n,0}:
7080 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
7081 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
7082 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
7083 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
7084 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
7085 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
7086 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
7087 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
7088 q3n0kRe = fReRPQ1dEBE[2][pe][2][0]->GetBinContent(fReRPQ1dEBE[2][pe][2][0]->GetBin(b))
7089 * fReRPQ1dEBE[2][pe][2][0]->GetBinEntries(fReRPQ1dEBE[2][pe][2][0]->GetBin(b));
7090 q3n0kIm = fImRPQ1dEBE[2][pe][2][0]->GetBinContent(fImRPQ1dEBE[2][pe][2][0]->GetBin(b))
7091 * fImRPQ1dEBE[2][pe][2][0]->GetBinEntries(fImRPQ1dEBE[2][pe][2][0]->GetBin(b));
7092
7093 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7094 }
7095 else if(type == "RP")
7096 {
7097 // q_{m*n,0}:
7098 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
7099 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
7100 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
7101 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
7102 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
7103 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
7104 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
7105 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
7106 q3n0kRe = fReRPQ1dEBE[0][pe][2][0]->GetBinContent(fReRPQ1dEBE[0][pe][2][0]->GetBin(b))
7107 * fReRPQ1dEBE[0][pe][2][0]->GetBinEntries(fReRPQ1dEBE[0][pe][2][0]->GetBin(b));
7108 q3n0kIm = fImRPQ1dEBE[0][pe][2][0]->GetBinContent(fImRPQ1dEBE[0][pe][2][0]->GetBin(b))
7109 * fImRPQ1dEBE[0][pe][2][0]->GetBinEntries(fImRPQ1dEBE[0][pe][2][0]->GetBin(b));
7110
7111 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7112 }
7113
7114 if(type == "POI")
7115 {
7116 // p_{m*n,0}:
7117 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
7118 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
7119 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
7120 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
7121
7122 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7123
7124 t = 1; // typeFlag = RP or POI
7125 }
7126 else if(type == "RP")
7127 {
7128 // p_{m*n,0} = q_{m*n,0}:
7129 p1n0kRe = q1n0kRe;
7130 p1n0kIm = q1n0kIm;
7131
7132 mp = mq;
7133
7134 t = 0; // typeFlag = RP or POI
7135 }
7136
7137 // 3'-particle correlators:
7138 // Taeney-Yan correlator:
7139 Double_t dTaeneyYan = 0.;
7140 Double_t mWeightTaeneyYan = 0.; // multiplicity weight for Taeney-Yan correlator
7141 if((mp*dMult-2.*mq)*(dMult-1.) > 0.) // to be improved - is this condition fully justified?
7142 {
7143 dTaeneyYan = (dReQ3n*(p1n0kRe*dReQ2n-p1n0kIm*dImQ2n)+dImQ3n*(p1n0kIm*dReQ2n+p1n0kRe*dImQ2n)
7144 - p1n0kRe*dReQ1n - p1n0kIm*dImQ1n
7145 - q2n0kRe*dReQ2n - q2n0kIm*dImQ2n
7146 - q3n0kRe*dReQ3n - q3n0kIm*dImQ3n
7147 + 2.*mq)
7148 / ((mp*dMult-2.*mq)*(dMult-1.));
7149 // determine multiplicity weight:
7150 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7151 {
7152 mWeightTaeneyYan = (mp*dMult-2.*mq)*(dMult-1.);
7153 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7154 {
7155 mWeightTaeneyYan = 1.;
7156 }
7157 // Fill profiles:
7158 fOtherDiffCorrelators[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dTaeneyYan,mWeightTaeneyYan);
7159 } // end of if((mp*dMult-2.*mq)*(dMult-1.) > 0.)
7160
7161 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7162
7163} // end of void AliFlowAnalysisWithQCumulants::CalculateOtherDiffCorrelators(TString type, TString ptOrEta)
7164
7165//================================================================================================================================
7166
1268c371 7167void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCorrelations(TString type)
7168{
7169 // Calculate all reduced correlations needed for 2D differential flow for each (pt,eta) bin.
7170
7171 // Multiplicity:
7172 Double_t dMult = (*fSpk)(0,0);
7173 // Real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
7174 Double_t dReQ1n = (*fReQ)(0,0);
7175 Double_t dReQ2n = (*fReQ)(1,0);
7176 //Double_t dReQ3n = (*fReQ)(2,0);
7177 //Double_t dReQ4n = (*fReQ)(3,0);
7178 Double_t dImQ1n = (*fImQ)(0,0);
7179 Double_t dImQ2n = (*fImQ)(1,0);
7180 //Double_t dImQ3n = (*fImQ)(2,0);
7181 //Double_t dImQ4n = (*fImQ)(3,0);
7182
7183 // 2D reduced correlations are stored in TProfile2D f2DDiffFlowCorrelationsPro[0=RP,1=POI][correlation index].
7184 // Correlation index runs as follows:
7185 // 0: <<2'>>
7186 // 1: <<4'>>
7187 // 2: <<6'>>
7188 // 3: <<8'>>
7189
7190 Int_t t = 0; // type flag
7191 if(type == "RP")
7192 {
7193 t = 0;
7194 } else if(type == "POI")
7195 {
7196 t = 1;
7197 }
7198
7199 // Looping over all (pt,eta) bins and calculating correlations needed for differential flow:
7200 for(Int_t p=1;p<=fnBinsPt;p++)
7201 {
7202 for(Int_t e=1;e<=fnBinsEta;e++)
7203 {
7204 // Real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):
7205 Double_t p1n0kRe = 0.;
7206 Double_t p1n0kIm = 0.;
7207 // Number of POIs in particular pt or eta bin:
7208 Double_t mp = 0.;
7209 // Real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for 'RP && POI particles' in particular pt or eta bin):
7210 Double_t q1n0kRe = 0.;
7211 Double_t q1n0kIm = 0.;
7212 Double_t q2n0kRe = 0.;
7213 Double_t q2n0kIm = 0.;
7214 // Number of 'RP && POI particles' in particular pt or eta bin:
7215 Double_t mq = 0.;
7216 if(type == "POI")
7217 {
7218 // q_{m*n,0}:
7219 q1n0kRe = fReRPQ2dEBE[2][0][0]->GetBinContent(fReRPQ2dEBE[2][0][0]->GetBin(p,e))
7220 * fReRPQ2dEBE[2][0][0]->GetBinEntries(fReRPQ2dEBE[2][0][0]->GetBin(p,e));
7221 q1n0kIm = fImRPQ2dEBE[2][0][0]->GetBinContent(fImRPQ2dEBE[2][0][0]->GetBin(p,e))
7222 * fImRPQ2dEBE[2][0][0]->GetBinEntries(fImRPQ2dEBE[2][0][0]->GetBin(p,e));
7223 q2n0kRe = fReRPQ2dEBE[2][1][0]->GetBinContent(fReRPQ2dEBE[2][1][0]->GetBin(p,e))
7224 * fReRPQ2dEBE[2][1][0]->GetBinEntries(fReRPQ2dEBE[2][1][0]->GetBin(p,e));
7225 q2n0kIm = fImRPQ2dEBE[2][1][0]->GetBinContent(fImRPQ2dEBE[2][1][0]->GetBin(p,e))
7226 * fImRPQ2dEBE[2][1][0]->GetBinEntries(fImRPQ2dEBE[2][1][0]->GetBin(p,e));
7227 // m_{q}:
7228 mq = fReRPQ2dEBE[2][0][0]->GetBinEntries(fReRPQ2dEBE[2][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7229 } // end of if(type == "POI")
7230 else if(type == "RP")
7231 {
7232 // q_{m*n,0}:
7233 q1n0kRe = fReRPQ2dEBE[0][0][0]->GetBinContent(fReRPQ2dEBE[0][0][0]->GetBin(p,e))
7234 * fReRPQ2dEBE[0][0][0]->GetBinEntries(fReRPQ2dEBE[0][0][0]->GetBin(p,e));
7235 q1n0kIm = fImRPQ2dEBE[0][0][0]->GetBinContent(fImRPQ2dEBE[0][0][0]->GetBin(p,e))
7236 * fImRPQ2dEBE[0][0][0]->GetBinEntries(fImRPQ2dEBE[0][0][0]->GetBin(p,e));
7237 q2n0kRe = fReRPQ2dEBE[0][1][0]->GetBinContent(fReRPQ2dEBE[0][1][0]->GetBin(p,e))
7238 * fReRPQ2dEBE[0][1][0]->GetBinEntries(fReRPQ2dEBE[0][1][0]->GetBin(p,e));
7239 q2n0kIm = fImRPQ2dEBE[0][1][0]->GetBinContent(fImRPQ2dEBE[0][1][0]->GetBin(p,e))
7240 * fImRPQ2dEBE[0][1][0]->GetBinEntries(fImRPQ2dEBE[0][1][0]->GetBin(p,e));
7241 // m_{q}:
7242 mq = fReRPQ2dEBE[0][0][0]->GetBinEntries(fReRPQ2dEBE[0][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7243 } // end of else if(type == "RP")
7244 if(type == "POI")
7245 {
7246 // p_{m*n,0}:
7247 p1n0kRe = fReRPQ2dEBE[1][0][0]->GetBinContent(fReRPQ2dEBE[1][0][0]->GetBin(p,e))
7248 * fReRPQ2dEBE[1][0][0]->GetBinEntries(fReRPQ2dEBE[1][0][0]->GetBin(p,e));
7249 p1n0kIm = fImRPQ2dEBE[1][0][0]->GetBinContent(fImRPQ2dEBE[1][0][0]->GetBin(p,e))
7250 * fImRPQ2dEBE[1][0][0]->GetBinEntries(fImRPQ2dEBE[1][0][0]->GetBin(p,e));
7251 // m_{p}
7252 mp = fReRPQ2dEBE[1][0][0]->GetBinEntries(fReRPQ2dEBE[1][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7253
7254 t = 1; // typeFlag = RP or POI
7255 } // end of if(type == "POI")
7256 else if(type == "RP")
7257 {
7258 // p_{m*n,0} = q_{m*n,0}:
7259 p1n0kRe = q1n0kRe;
7260 p1n0kIm = q1n0kIm;
7261 // m_{p} = m_{q}:
7262 mp = mq;
7263
7264 t = 0; // typeFlag = RP or POI
7265 } // end of if(type == "RP")
7266
7267 // 2'-particle correlation for particular (pt,eta) bin:
7268 Double_t two1n1nPtEta = 0.;
7269 Double_t mWeight2pPrime = 0.; // multiplicity weight for <2'>
7270 if(mp*dMult-mq)
7271 {
7272 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)
7273 / (mp*dMult-mq);
7274 // Determine multiplicity weight:
7275 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7276 {
7277 mWeight2pPrime = mp*dMult-mq;
7278 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7279 {
7280 mWeight2pPrime = 1.;
7281 }
7282 // Fill 2D profile holding <<2'>>:
7283 f2DDiffFlowCorrelationsPro[t][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mWeight2pPrime);
7284 } // end of if(mp*dMult-mq)
7285
7286 // 4'-particle correlation:
7287 Double_t four1n1n1n1nPtEta = 0.;
7288 Double_t mWeight4pPrime = 0.; // multiplicity weight for <4'>
7289 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7290 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)
7291 {
7292 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7293 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))
7294 - 2.*q2n0kIm*dReQ1n*dImQ1n
7295 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)
7296 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)
7297 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7298 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq
7299 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)
7300 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)
7301 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7302 + 2.*mq*dMult
7303 - 6.*mq)
7304 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7305 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));
7306 // Determine multiplicity weight:
7307 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7308 {
7309 mWeight4pPrime = (mp-mq)*dMult*(dMult-1.)*(dMult-2.) + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7310 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7311 {
7312 mWeight4pPrime = 1.;
7313 }
7314 // Fill 2D profile holding <<4'>>:
7315 f2DDiffFlowCorrelationsPro[t][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,mWeight4pPrime);
7316 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7317 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))
7318 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
7319 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
7320
7321} // end of AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCorrelations(TString type)
7322
7323//================================================================================================================================
7324
489d5531 7325void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights(TString type, TString ptOrEta)
7326{
7327 // Calculate sums of various event weights for reduced correlations.
7328 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)
7329
2a98ceb8 7330 Int_t typeFlag = 0;
7331 Int_t ptEtaFlag = 0;
489d5531 7332
7333 if(type == "RP")
7334 {
7335 typeFlag = 0;
7336 } else if(type == "POI")
7337 {
7338 typeFlag = 1;
7339 }
7340
7341 if(ptOrEta == "Pt")
7342 {
7343 ptEtaFlag = 0;
7344 } else if(ptOrEta == "Eta")
7345 {
7346 ptEtaFlag = 1;
7347 }
7348
7349 // shortcuts:
7350 Int_t t = typeFlag;
7351 Int_t pe = ptEtaFlag;
7352
7353 // binning:
7354 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7355 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7356 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7357 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7358
7359 for(Int_t rpq=0;rpq<3;rpq++)
7360 {
7361 for(Int_t m=0;m<4;m++)
7362 {
7363 for(Int_t k=0;k<9;k++)
7364 {
7365 if(!fReRPQ1dEBE[rpq][pe][m][k])
7366 {
7367 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;
7368 cout<<"pe = "<<pe<<endl;
7369 cout<<"rpq = "<<rpq<<endl;
7370 cout<<"m = "<<m<<endl;
7371 cout<<"k = "<<k<<endl;
7372 exit(0);
7373 }
7374 }
7375 }
7376 }
7377
7378 // multiplicities:
1268c371 7379 Double_t dMult = (*fSpk)(0,0); // total event multiplicity
489d5531 7380 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7381 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7382 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7383
7384 // event weights for reduced correlations:
7385 Double_t dw2 = 0.; // event weight for <2'>
7386 Double_t dw4 = 0.; // event weight for <4'>
7387 //Double_t dw6 = 0.; // event weight for <6'>
7388 //Double_t dw8 = 0.; // event weight for <8'>
7389
7390 // looping over bins:
7391 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7392 {
7393 if(type == "RP")
7394 {
7395 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7396 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7397 } else if(type == "POI")
7398 {
7399 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7400 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7401 }
7402
7403 // event weight for <2'>:
7404 dw2 = mp*dMult-mq;
7405 fDiffFlowSumOfEventWeights[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2);
7406 fDiffFlowSumOfEventWeights[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw2,2.));
7407
7408 // event weight for <4'>:
7409 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7410 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7411 fDiffFlowSumOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4);
7412 fDiffFlowSumOfEventWeights[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw4,2.));
7413
7414 // event weight for <6'>:
7415 //dw6 = ...;
7416 //fDiffFlowSumOfEventWeights[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6);
7417 //fDiffFlowSumOfEventWeights[t][pe][t][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw6,2.));
7418
7419 // event weight for <8'>:
7420 //dw8 = ...;
7421 //fDiffFlowSumOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw8);
7422 //fDiffFlowSumOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw8,2.));
7423 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7424
7425} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights()
7426
7427
7428//================================================================================================================================
7429
7430
7431void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)
7432{
7433 // Calculate sum of products of various event weights for both types of correlations (the ones for int. and diff. flow).
7434 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)
7435 //
7436 // Important: To fill fDiffFlowSumOfProductOfEventWeights[][][][] use bellow table (i,j) with following constraints:
7437 // 1.) i<j
7438 // 2.) do not store terms which DO NOT include reduced correlations;
7439 // Table:
7440 // [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'>]
7441
2a98ceb8 7442 Int_t typeFlag = 0;
7443 Int_t ptEtaFlag = 0;
489d5531 7444
7445 if(type == "RP")
7446 {
7447 typeFlag = 0;
7448 } else if(type == "POI")
7449 {
7450 typeFlag = 1;
7451 }
7452
7453 if(ptOrEta == "Pt")
7454 {
7455 ptEtaFlag = 0;
7456 } else if(ptOrEta == "Eta")
7457 {
7458 ptEtaFlag = 1;
7459 }
7460
7461 // shortcuts:
7462 Int_t t = typeFlag;
7463 Int_t pe = ptEtaFlag;
7464
7465 // binning:
7466 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7467 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7468 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7469 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7470
7471 // protection:
7472 for(Int_t rpq=0;rpq<3;rpq++)
7473 {
7474 for(Int_t m=0;m<4;m++)
7475 {
7476 for(Int_t k=0;k<9;k++)
7477 {
7478 if(!fReRPQ1dEBE[rpq][pe][m][k])
7479 {
7480 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;
7481 cout<<"pe = "<<pe<<endl;
7482 cout<<"rpq = "<<rpq<<endl;
7483 cout<<"m = "<<m<<endl;
7484 cout<<"k = "<<k<<endl;
7485 exit(0);
7486 }
7487 }
7488 }
7489 }
7490
7491 // multiplicities:
1268c371 7492 Double_t dMult = (*fSpk)(0,0); // total event multiplicity
489d5531 7493 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7494 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7495 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7496
7497 // event weights for correlations:
7498 Double_t dW2 = dMult*(dMult-1); // event weight for <2>
7499 Double_t dW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4>
7500 Double_t dW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6>
7501 Double_t dW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8>
7502
7503 // event weights for reduced correlations:
7504 Double_t dw2 = 0.; // event weight for <2'>
7505 Double_t dw4 = 0.; // event weight for <4'>
7506 //Double_t dw6 = 0.; // event weight for <6'>
7507 //Double_t dw8 = 0.; // event weight for <8'>
7508
7509 // looping over bins:
7510 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7511 {
7512 if(type == "RP")
7513 {
7514 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7515 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7516 } else if(type == "POI")
7517 {
7518 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7519 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7520 }
7521
7522 // event weight for <2'>:
7523 dw2 = mp*dMult-mq;
7524 fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw2); // storing product of even weights for <2> and <2'>
7525 fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW4); // storing product of even weights for <4> and <2'>
7526 fDiffFlowSumOfProductOfEventWeights[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW6); // storing product of even weights for <6> and <2'>
7527 fDiffFlowSumOfProductOfEventWeights[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW8); // storing product of even weights for <8> and <2'>
7528
7529 // event weight for <4'>:
7530 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7531 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7532 fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw4); // storing product of even weights for <2> and <4'>
7533 fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw4); // storing product of even weights for <2'> and <4'>
7534 fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw4); // storing product of even weights for <4> and <4'>
7535 fDiffFlowSumOfProductOfEventWeights[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW6); // storing product of even weights for <6> and <4'>
7536 fDiffFlowSumOfProductOfEventWeights[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW8); // storing product of even weights for <8> and <4'>
7537
7538 // event weight for <6'>:
7539 //dw6 = ...;
7540 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw6); // storing product of even weights for <2> and <6'>
7541 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw6); // storing product of even weights for <2'> and <6'>
7542 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw6); // storing product of even weights for <4> and <6'>
7543 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw6); // storing product of even weights for <4'> and <6'>
7544 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw6); // storing product of even weights for <6> and <6'>
7545 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dW8); // storing product of even weights for <6'> and <8>
7546 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>
7547
7548 // event weight for <8'>:
7549 //dw8 = ...;
7550 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw8); // storing product of even weights for <2> and <8'>
7551 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw8); // storing product of even weights for <2'> and <8'>
7552 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw8); // storing product of even weights for <4> and <8'>
7553 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw8); // storing product of even weights for <4'> and <8'>
7554 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw8); // storing product of even weights for <6> and <8'>
7555 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>
7556 //fDiffFlowSumOfProductOfEventWeights[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW8*dw8); // storing product of even weights for <8> and <8'>
7557
7558 // Table:
7559 // [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'>]
7560
7561 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7562
7563
7564
7565} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)
7566
489d5531 7567//================================================================================================================================
7568
489d5531 7569void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)
7570{
7571 // Transfer profiles into histograms and calculate statistical errors correctly.
7572
1268c371 7573 Int_t t = 0; // RP or POI
7574 Int_t pe = 0; // pt or eta
489d5531 7575
7576 if(type == "RP")
7577 {
1268c371 7578 t = 0;
489d5531 7579 } else if(type == "POI")
7580 {
1268c371 7581 t = 1;
489d5531 7582 }
7583
7584 if(ptOrEta == "Pt")
7585 {
1268c371 7586 pe = 0;
489d5531 7587 } else if(ptOrEta == "Eta")
7588 {
1268c371 7589 pe = 1;
489d5531 7590 }
1268c371 7591
7592 for(Int_t rci=0;rci<4;rci++) // to be improved - moved into the method CheckPointersUsedInFinish()
489d5531 7593 {
7594 if(!fDiffFlowCorrelationsPro[t][pe][rci])
7595 {
7596 cout<<"WARNING: fDiffFlowCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7597 cout<<"t = "<<t<<endl;
7598 cout<<"pe = "<<pe<<endl;
7599 cout<<"rci = "<<rci<<endl;
7600 exit(0);
7601 }
b40a910e 7602 if(!fDiffFlowSquaredCorrelationsPro[t][pe][rci])
7603 {
7604 cout<<"WARNING: fDiffFlowSquaredCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7605 cout<<"t = "<<t<<endl;
7606 cout<<"pe = "<<pe<<endl;
7607 cout<<"rci = "<<rci<<endl;
7608 exit(0);
7609 }
489d5531 7610 for(Int_t power=0;power<2;power++)
7611 {
7612 if(!fDiffFlowSumOfEventWeights[t][pe][power][rci])
7613 {
7614 cout<<"WARNING: fDiffFlowSumOfEventWeights[t][pe][power][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7615 cout<<"t = "<<t<<endl;
7616 cout<<"pe = "<<pe<<endl;
7617 cout<<"power = "<<power<<endl;
7618 cout<<"rci = "<<rci<<endl;
7619 exit(0);
7620 }
7621 } // end of for(Int_t power=0;power<2;power++)
7622 } // end of for(Int_t rci=0;rci<4;rci++)
7623
7624 // common:
b40a910e 7625 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 7626 // transfer 1D profile into 1D histogram:
7627 Double_t correlation = 0.;
b40a910e 7628 Double_t squaredCorrelation = 0.;
489d5531 7629 Double_t spread = 0.;
7630 Double_t sumOfWeights = 0.; // sum of weights for particular reduced correlations for particular pt or eta bin
7631 Double_t sumOfSquaredWeights = 0.; // sum of squared weights for particular reduced correlations for particular pt or eta bin
7632 Double_t error = 0.; // error = termA * spread * termB
7633 // termA = (sqrt(sumOfSquaredWeights)/sumOfWeights)
7634 // termB = 1/pow(1-termA^2,0.5)
7635 Double_t termA = 0.;
7636 Double_t termB = 0.;
7637 for(Int_t rci=0;rci<4;rci++) // index of reduced correlation
7638 {
7639 for(Int_t b=1;b<=nBinsPtEta[pe];b++) // number of pt or eta bins
7640 {
b40a910e 7641 if(fDiffFlowCorrelationsPro[t][pe][rci]->GetBinEffectiveEntries(b) < 2 ||
7642 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->GetBinEffectiveEntries(b) < 2)
7643 {
7644 fDiffFlowCorrelationsPro[t][pe][rci]->SetBinError(b,0.);
7645 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->SetBinError(b,0.);
7646 continue; // to be improved - should I ignore results in pt bins with one entry for reduced correlations or not?
7647 }
489d5531 7648 correlation = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(b);
b40a910e 7649 squaredCorrelation = fDiffFlowSquaredCorrelationsPro[t][pe][rci]->GetBinContent(b);
7650 if(squaredCorrelation-correlation*correlation >= 0.)
7651 {
7652 spread = pow(squaredCorrelation-correlation*correlation,0.5);
7653 } else
7654 {
7655 cout<<endl;
7656 cout<<Form(" WARNING: Imaginary 'spread' for rci = %d, pe = %d, bin = %d !!!!",rci,pe,b)<<endl;
7657 cout<<endl;
7658 }
489d5531 7659 sumOfWeights = fDiffFlowSumOfEventWeights[t][pe][0][rci]->GetBinContent(b);
7660 sumOfSquaredWeights = fDiffFlowSumOfEventWeights[t][pe][1][rci]->GetBinContent(b);
1268c371 7661 if(TMath::Abs(sumOfWeights)>0.){termA = (pow(sumOfSquaredWeights,0.5)/sumOfWeights);}
7662 if(1.-pow(termA,2.)>0.){termB = 1./pow(1.-pow(termA,2.),0.5);}
489d5531 7663 error = termA*spread*termB; // final error (unbiased estimator for standard deviation)
7664 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinContent(b,correlation);
7665 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinError(b,error);
7666 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7667 } // end of for(Int_t rci=0;rci<4;rci++)
7668
7669} // end of void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)
7670
489d5531 7671//================================================================================================================================
7672
489d5531 7673void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)
7674{
7675 // store products: <2><2'>, <2><4'>, <2><6'>, <2><8'>, <2'><4>,
7676 // <2'><4'>, <2'><6>, <2'><6'>, <2'><8>, <2'><8'>,
7677 // <4><4'>, <4><6'>, <4><8'>, <4'><6>, <4'><6'>,
7678 // <4'><8>, <4'><8'>, <6><6'>, <6><8'>, <6'><8>,
7679 // <6'><8'>, <8><8'>.
7680
2a98ceb8 7681 Int_t typeFlag = 0;
7682 Int_t ptEtaFlag = 0;
489d5531 7683
7684 if(type == "RP")
7685 {
7686 typeFlag = 0;
7687 } else if(type == "POI")
7688 {
7689 typeFlag = 1;
7690 }
7691
7692 if(ptOrEta == "Pt")
7693 {
7694 ptEtaFlag = 0;
7695 } else if(ptOrEta == "Eta")
7696 {
7697 ptEtaFlag = 1;
7698 }
7699
7700 // shortcuts:
7701 Int_t t = typeFlag;
7702 Int_t pe = ptEtaFlag;
7703
7704 // common:
7705 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7706 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7707 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7708
7709 // protections // to be improved (add protection for all pointers in this method)
7710 if(!fIntFlowCorrelationsEBE)
7711 {
7712 cout<<"WARNING: fIntFlowCorrelationsEBE is NULL in AFAWQC::CDFPOC() !!!!"<<endl;
7713 exit(0);
7714 }
7715
7716 /*
1268c371 7717 Double_t dMult = (*fSpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)
489d5531 7718 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7719 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7720 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7721 */
7722
7723 // e-b-e correlations:
7724 Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>
7725 Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>
7726 Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>
7727 Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>
7728
7729 // event weights for correlations:
7730 Double_t dW2 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1); // event weight for <2>
7731 Double_t dW4 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2); // event weight for <4>
7732 Double_t dW6 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(3); // event weight for <6>
7733 Double_t dW8 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(4); // event weight for <8>
7734
7735 // e-b-e reduced correlations:
7736 Double_t twoReducedEBE = 0.; // <2'>
7737 Double_t fourReducedEBE = 0.; // <4'>
7738 Double_t sixReducedEBE = 0.; // <6'>
7739 Double_t eightReducedEBE = 0.; // <8'>
7740
7741 // event weights for reduced correlations:
7742 Double_t dw2 = 0.; // event weight for <2'>
7743 Double_t dw4 = 0.; // event weight for <4'>
7744 //Double_t dw6 = 0.; // event weight for <6'>
7745 //Double_t dw8 = 0.; // event weight for <8'>
7746
7747 // looping over bins:
7748 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7749 {
7750 // e-b-e reduced correlations:
7751 twoReducedEBE = fDiffFlowCorrelationsEBE[t][pe][0]->GetBinContent(b);
7752 fourReducedEBE = fDiffFlowCorrelationsEBE[t][pe][1]->GetBinContent(b);
7753 sixReducedEBE = fDiffFlowCorrelationsEBE[t][pe][2]->GetBinContent(b);
7754 eightReducedEBE = fDiffFlowCorrelationsEBE[t][pe][3]->GetBinContent(b);
7755
7756 /*
7757 // to be improved (I should not do this here again)
7758 if(type == "RP")
7759 {
7760 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7761 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7762 } else if(type == "POI")
7763 {
7764 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7765 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7766 }
7767
7768 // event weights for reduced correlations:
7769 dw2 = mp*dMult-mq; // weight for <2'>
7770 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7771 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); // weight for <4'>
7772 //dw6 = ...
7773 //dw8 = ...
7774
7775 */
7776
7777 dw2 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->GetBinContent(b);
7778 dw4 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->GetBinContent(b);
7779
7780 // storing all products:
7781 fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*twoReducedEBE,dW2*dw2); // storing <2><2'>
7782 fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*twoReducedEBE,dW4*dw2); // storing <4><2'>
7783 fDiffFlowProductOfCorrelationsPro[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*twoReducedEBE,dW6*dw2); // storing <6><2'>
7784 fDiffFlowProductOfCorrelationsPro[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*twoReducedEBE,dW8*dw2); // storing <8><2'>
7785
7786 // event weight for <4'>:
7787 fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*fourReducedEBE,dW2*dw4); // storing <2><4'>
7788 fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*fourReducedEBE,dw2*dw4); // storing <2'><4'>
7789 fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*fourReducedEBE,dW4*dw4); // storing <4><4'>
7790 fDiffFlowProductOfCorrelationsPro[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*fourReducedEBE,dW6*dw4); // storing <6><4'>
7791 fDiffFlowProductOfCorrelationsPro[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*fourReducedEBE,dW8*dw4); // storing <8><4'>
7792
7793 // event weight for <6'>:
7794 //dw6 = ...;
7795 //fDiffFlowProductOfCorrelationsPro[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*sixReducedEBE,dW2*dw6); // storing <2><6'>
7796 //fDiffFlowProductOfCorrelationsPro[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*sixReducedEBE,dw2*dw6); // storing <2'><6'>
7797 //fDiffFlowProductOfCorrelationsPro[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*sixReducedEBE,dW4*dw6); // storing <4><6'>
7798 //fDiffFlowProductOfCorrelationsPro[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*sixReducedEBE,dw4*dw6); // storing <4'><6'>
7799 //fDiffFlowProductOfCorrelationsPro[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*sixReducedEBE,dW6*dw6); // storing <6><6'>
7800 //fDiffFlowProductOfCorrelationsPro[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightEBE,dw6*dW8); // storing <6'><8>
7801 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>
7802
7803 // event weight for <8'>:
7804 //dw8 = ...;
7805 //fDiffFlowProductOfCorrelationsPro[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*eightReducedEBE,dW2*dw8); // storing <2><8'>
7806 //fDiffFlowProductOfCorrelationsPro[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*eightReducedEBE,dw2*dw8); // storing <2'><8'>
7807 //fDiffFlowProductOfCorrelationsPro[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*eightReducedEBE,dW4*dw8); // storing <4><8'>
7808 //fDiffFlowProductOfCorrelationsPro[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*eightReducedEBE,dw4*dw8); // storing <4'><8'>
7809 //fDiffFlowProductOfCorrelationsPro[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*eightReducedEBE,dW6*dw8); // storing <6><8'>
7810 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>
7811 //fDiffFlowProductOfCorrelationsPro[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*eightReducedEBE,dW8*dw8); // storing <8><8'>
7812 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++
7813
7814} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)
7815
489d5531 7816//================================================================================================================================
7817
489d5531 7818void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta) // to be improved (reimplemented)
7819{
7820 // a) Calculate unbiased estimators Cov(<2>,<2'>), Cov(<2>,<4'>), Cov(<4>,<2'>), Cov(<4>,<4'>) and Cov(<2'>,<4'>)
7821 // for covariances V(<2>,<2'>), V(<2>,<4'>), V(<4>,<2'>), V(<4>,<4'>) and V(<2'>,<4'>).
7822 // b) Store in histogram fDiffFlowCovariances[t][pe][index] for instance the following:
7823 //
7824 // 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)]
7825 //
7826 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<2'>} is event weight for <2'>.
7827 // c) Binning of fDiffFlowCovariances[t][pe][index] is organized as follows:
7828 //
7829 // 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)]
7830 // 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)]
7831 // 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)]
7832 // 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)]
7833 // 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)]
7834 // ...
7835
2a98ceb8 7836 Int_t typeFlag = 0;
7837 Int_t ptEtaFlag = 0;
489d5531 7838
7839 if(type == "RP")
7840 {
7841 typeFlag = 0;
7842 } else if(type == "POI")
7843 {
7844 typeFlag = 1;
7845 }
7846
7847 if(ptOrEta == "Pt")
7848 {
7849 ptEtaFlag = 0;
7850 } else if(ptOrEta == "Eta")
7851 {
7852 ptEtaFlag = 1;
7853 }
7854
7855 // shortcuts:
7856 Int_t t = typeFlag;
7857 Int_t pe = ptEtaFlag;
7858
7859 // common:
7860 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7861 //Double_t minPtEta[2] = {fPtMin,fEtaMin};
7862 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7863 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7864
7865 // average correlations:
7866 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
7867 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
7868 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
7869 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
7870
7871 // sum of weights for correlation:
7872 Double_t sumOfWeightsForTwo = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // sum_{i=1}^{N} w_{<2>}
7873 Double_t sumOfWeightsForFour = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // sum_{i=1}^{N} w_{<4>}
7874 //Double_t sumOfWeightsForSix = fIntFlowSumOfEventWeights[0]->GetBinContent(3); // sum_{i=1}^{N} w_{<6>}
7875 //Double_t sumOfWeightsForEight = fIntFlowSumOfEventWeights[0]->GetBinContent(4); // sum_{i=1}^{N} w_{<8>}
7876
7877 // average reduced correlations:
7878 Double_t twoReduced = 0.; // <<2'>>
7879 Double_t fourReduced = 0.; // <<4'>>
7880 //Double_t sixReduced = 0.; // <<6'>>
7881 //Double_t eightReduced = 0.; // <<8'>>
7882
7883 // sum of weights for reduced correlation:
7884 Double_t sumOfWeightsForTwoReduced = 0.; // sum_{i=1}^{N} w_{<2'>}
7885 Double_t sumOfWeightsForFourReduced = 0.; // sum_{i=1}^{N} w_{<4'>}
7886 //Double_t sumOfWeightsForSixReduced = 0.; // sum_{i=1}^{N} w_{<6'>}
7887 //Double_t sumOfWeightsForEightReduced = 0.; // sum_{i=1}^{N} w_{<8'>}
7888
7889 // product of weights for reduced correlation:
7890 Double_t productOfWeightsForTwoTwoReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<2'>}
7891 Double_t productOfWeightsForTwoFourReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<4'>}
7892 Double_t productOfWeightsForFourTwoReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<2'>}
7893 Double_t productOfWeightsForFourFourReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<4'>}
7894 Double_t productOfWeightsForTwoReducedFourReduced = 0.; // sum_{i=1}^{N} w_{<2'>}w_{<4'>}
7895 // ...
7896
7897 // products for differential flow:
7898 Double_t twoTwoReduced = 0; // <<2><2'>>
7899 Double_t twoFourReduced = 0; // <<2><4'>>
7900 Double_t fourTwoReduced = 0; // <<4><2'>>
7901 Double_t fourFourReduced = 0; // <<4><4'>>
7902 Double_t twoReducedFourReduced = 0; // <<2'><4'>>
7903
7904 // denominators in the expressions for the unbiased estimators for covariances:
7905 // denominator = 1 - term1/(term2*term3)
7906 // prefactor = term1/(term2*term3)
7907 Double_t denominator = 0.;
7908 Double_t prefactor = 0.;
7909 Double_t term1 = 0.;
7910 Double_t term2 = 0.;
7911 Double_t term3 = 0.;
7912
7913 // unbiased estimators for covariances for differential flow:
7914 Double_t covTwoTwoReduced = 0.; // Cov(<2>,<2'>)
7915 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(w_{<2>},w_{<2'>})
7916 Double_t covTwoFourReduced = 0.; // Cov(<2>,<4'>)
7917 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(w_{<2>},w_{<4'>})
7918 Double_t covFourTwoReduced = 0.; // Cov(<4>,<2'>)
7919 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(w_{<4>},w_{<2'>})
7920 Double_t covFourFourReduced = 0.; // Cov(<4>,<4'>)
7921 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(w_{<4>},w_{<4'>})
7922 Double_t covTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>)
7923 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(w_{<2'>},w_{<4'>})
7924
7925 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7926 {
7927 // average reduced corelations:
7928 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);
7929 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);
7930 // average products:
7931 twoTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->GetBinContent(b);
7932 twoFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->GetBinContent(b);
7933 fourTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->GetBinContent(b);
7934 fourFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->GetBinContent(b);
7935 twoReducedFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->GetBinContent(b);
7936 // sum of weights for reduced correlations:
7937 sumOfWeightsForTwoReduced = fDiffFlowSumOfEventWeights[t][pe][0][0]->GetBinContent(b);
7938 sumOfWeightsForFourReduced = fDiffFlowSumOfEventWeights[t][pe][0][1]->GetBinContent(b);
7939 // products of weights for correlations:
7940 productOfWeightsForTwoTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->GetBinContent(b);
7941 productOfWeightsForTwoFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->GetBinContent(b);
7942 productOfWeightsForFourTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->GetBinContent(b);
7943 productOfWeightsForFourFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->GetBinContent(b);
7944 productOfWeightsForTwoReducedFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->GetBinContent(b);
7945 // denominator for the unbiased estimator for covariances: 1 - term1/(term2*term3)
7946 // prefactor (multiplies Cov's) = term1/(term2*term3)
7947 // <2>,<2'>:
7948 term1 = productOfWeightsForTwoTwoReduced;
7949 term2 = sumOfWeightsForTwo;
7950 term3 = sumOfWeightsForTwoReduced;
7951 if(term2*term3>0.)
7952 {
7953 denominator = 1.-term1/(term2*term3);
7954 prefactor = term1/(term2*term3);
1268c371 7955 if(TMath::Abs(denominator)>1.e-6)
489d5531 7956 {
7957 covTwoTwoReduced = (twoTwoReduced-two*twoReduced)/denominator;
7958 wCovTwoTwoReduced = covTwoTwoReduced*prefactor;
7959 fDiffFlowCovariances[t][pe][0]->SetBinContent(b,wCovTwoTwoReduced);
7960 }
7961 }
7962 // <2>,<4'>:
7963 term1 = productOfWeightsForTwoFourReduced;
7964 term2 = sumOfWeightsForTwo;
7965 term3 = sumOfWeightsForFourReduced;
7966 if(term2*term3>0.)
7967 {
7968 denominator = 1.-term1/(term2*term3);
7969 prefactor = term1/(term2*term3);
1268c371 7970 if(TMath::Abs(denominator)>1.e-6)
489d5531 7971 {
7972 covTwoFourReduced = (twoFourReduced-two*fourReduced)/denominator;
7973 wCovTwoFourReduced = covTwoFourReduced*prefactor;
7974 fDiffFlowCovariances[t][pe][1]->SetBinContent(b,wCovTwoFourReduced);
7975 }
7976 }
7977 // <4>,<2'>:
7978 term1 = productOfWeightsForFourTwoReduced;
7979 term2 = sumOfWeightsForFour;
7980 term3 = sumOfWeightsForTwoReduced;
7981 if(term2*term3>0.)
7982 {
7983 denominator = 1.-term1/(term2*term3);
7984 prefactor = term1/(term2*term3);
1268c371 7985 if(TMath::Abs(denominator)>1.e-6)
489d5531 7986 {
7987 covFourTwoReduced = (fourTwoReduced-four*twoReduced)/denominator;
7988 wCovFourTwoReduced = covFourTwoReduced*prefactor;
7989 fDiffFlowCovariances[t][pe][2]->SetBinContent(b,wCovFourTwoReduced);
7990 }
7991 }
7992 // <4>,<4'>:
7993 term1 = productOfWeightsForFourFourReduced;
7994 term2 = sumOfWeightsForFour;
7995 term3 = sumOfWeightsForFourReduced;
7996 if(term2*term3>0.)
7997 {
7998 denominator = 1.-term1/(term2*term3);
7999 prefactor = term1/(term2*term3);
1268c371 8000 if(TMath::Abs(denominator)>1.e-6)
489d5531 8001 {
8002 covFourFourReduced = (fourFourReduced-four*fourReduced)/denominator;
8003 wCovFourFourReduced = covFourFourReduced*prefactor;
8004 fDiffFlowCovariances[t][pe][3]->SetBinContent(b,wCovFourFourReduced);
8005 }
8006 }
8007 // <2'>,<4'>:
8008 term1 = productOfWeightsForTwoReducedFourReduced;
8009 term2 = sumOfWeightsForTwoReduced;
8010 term3 = sumOfWeightsForFourReduced;
8011 if(term2*term3>0.)
8012 {
8013 denominator = 1.-term1/(term2*term3);
8014 prefactor = term1/(term2*term3);
1268c371 8015 if(TMath::Abs(denominator)>1.e-6)
489d5531 8016 {
8017 covTwoReducedFourReduced = (twoReducedFourReduced-twoReduced*fourReduced)/denominator;
8018 wCovTwoReducedFourReduced = covTwoReducedFourReduced*prefactor;
8019 fDiffFlowCovariances[t][pe][4]->SetBinContent(b,wCovTwoReducedFourReduced);
8020 }
8021 }
8022 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
8023
8024} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta)
8025
489d5531 8026//================================================================================================================================
8027
489d5531 8028void AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, TString ptOrEta)
8029{
1268c371 8030 // Calculate final results for differential flow.
489d5531 8031
1268c371 8032 // REMARK: Differential flow calculated in this method is NOT corrected for non-uniform acceptance.
8033 // This correction, if enabled via setter SetApplyCorrectionForNUA(Bool_t), is applied in the method
8034 // CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)
8035
8036 Int_t t = 0; // RP or POI
8037 Int_t pe = 0; // pt or eta
489d5531 8038
8039 if(type == "RP")
8040 {
1268c371 8041 t = 0;
489d5531 8042 } else if(type == "POI")
8043 {
1268c371 8044 t = 1;
489d5531 8045 }
8046
8047 if(ptOrEta == "Pt")
8048 {
1268c371 8049 pe = 0;
489d5531 8050 } else if(ptOrEta == "Eta")
8051 {
1268c371 8052 pe = 1;
489d5531 8053 }
1268c371 8054
8055 // Common:
489d5531 8056 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
1268c371 8057 // Correlations:
489d5531 8058 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
1268c371 8059 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
8060 // Statistical errors of correlations:
489d5531 8061 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);
8062 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2);
1268c371 8063 // Reduced correlations:
489d5531 8064 Double_t twoReduced = 0.; // <<2'>>
8065 Double_t fourReduced = 0.; // <<4'>>
1268c371 8066 // Statistical errors of reduced correlations:
489d5531 8067 Double_t twoReducedError = 0.;
8068 Double_t fourReducedError = 0.;
1268c371 8069 // Covariances:
8e1cefdd 8070 Double_t wCovTwoFour = 0.; // Cov(<2>,<4>) * prefactor(<2>,<4>)
8071 if(!fForgetAboutCovariances)
8072 {
8073 wCovTwoFour = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(<2>,<4>)
8074 }
489d5531 8075 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(<2>,<2'>)
8076 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(<2>,<4'>)
8077 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(<4>,<2'>)
8078 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(<4>,<4'>)
8079 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)
1268c371 8080 // Differential flow:
489d5531 8081 Double_t v2Prime = 0.; // v'{2}
8082 Double_t v4Prime = 0.; // v'{4}
1268c371 8083 // Statistical error of differential flow:
489d5531 8084 Double_t v2PrimeError = 0.;
8085 Double_t v4PrimeError = 0.;
1268c371 8086 // Squared statistical error of differential flow:
489d5531 8087 Double_t v2PrimeErrorSquared = 0.;
8088 Double_t v4PrimeErrorSquared = 0.;
1268c371 8089 // Loop over pt or eta bins:
489d5531 8090 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
8091 {
1268c371 8092 // Reduced correlations and statistical errors:
489d5531 8093 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);
8094 twoReducedError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b);
8095 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);
8096 fourReducedError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b);
1268c371 8097 // Covariances:
8e1cefdd 8098 if(!fForgetAboutCovariances)
8099 {
8100 wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b);
8101 wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b);
8102 wCovFourTwoReduced = fDiffFlowCovariances[t][pe][2]->GetBinContent(b);
8103 wCovFourFourReduced = fDiffFlowCovariances[t][pe][3]->GetBinContent(b);
8104 wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b);
8105 }
1268c371 8106 // Differential flow:
489d5531 8107 // v'{2}:
8108 if(two>0.)
8109 {
8110 v2Prime = twoReduced/pow(two,0.5);
1268c371 8111 v2PrimeErrorSquared = (1./4.)*pow(two,-3.)*(pow(twoReduced,2.)*pow(twoError,2.)
8112 + 4.*pow(two,2.)*pow(twoReducedError,2.)
8113 - 4.*two*twoReduced*wCovTwoTwoReduced);
8114 if(v2PrimeErrorSquared>0.){v2PrimeError = pow(v2PrimeErrorSquared,0.5);}
8115 if(TMath::Abs(v2Prime)>0.)
8116 {
8117 fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime);
8118 fDiffFlow[t][pe][0]->SetBinError(b,v2PrimeError);
8119 }
8120 } // end of if(two>0.)
489d5531 8121 // differential flow:
8122 // v'{4}
8123 if(2.*pow(two,2.)-four > 0.)
8124 {
8125 v4Prime = (2.*two*twoReduced-fourReduced)/pow(2.*pow(two,2.)-four,3./4.);
1268c371 8126 v4PrimeErrorSquared = pow(2.*pow(two,2.)-four,-7./2.)
8127 * (pow(2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced,2.)*pow(twoError,2.)
8128 + (9./16.)*pow(2.*two*twoReduced-fourReduced,2.)*pow(fourError,2.)
8129 + 4.*pow(two,2.)*pow(2.*pow(two,2.)-four,2.)*pow(twoReducedError,2.)
8130 + pow(2.*pow(two,2.)-four,2.)*pow(fourReducedError,2.)
8131 - (3./2.)*(2.*two*twoReduced-fourReduced)
8132 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFour
8133 - 4.*two*(2.*pow(two,2.)-four)
8134 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoTwoReduced
8135 + 2.*(2.*pow(two,2.)-four)
8136 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFourReduced
8137 + 3.*two*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourTwoReduced
8138 - (3./2.)*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourFourReduced
8139 - 4.*two*pow(2.*pow(two,2.)-four,2.)*wCovTwoReducedFourReduced);
8140 if(v4PrimeErrorSquared>0.){v4PrimeError = pow(v4PrimeErrorSquared,0.5);}
8141 if(TMath::Abs(v4Prime)>0.)
8142 {
8143 fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);
8144 fDiffFlow[t][pe][1]->SetBinError(b,v4PrimeError);
8145 }
8146 } // end of if(2.*pow(two,2.)-four > 0.)
489d5531 8147 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)
1268c371 8148
8149} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, Bool_t useParticleWeights)
8150
8151//================================================================================================================================
8152
8153void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlow(TString type)
8154{
8155 // Calculate final results for 2D diferential flow.
8156
8157 // to be improved - check pointers used in this method
8158
8159 Int_t t = 0; // RP or POI
8160
8161 if(type == "RP")
8162 {
8163 t = 0;
8164 } else if(type == "POI")
8165 {
8166 t = 1;
8167 }
489d5531 8168
1268c371 8169 // Differential flow:
8170 Double_t v2Prime = 0.; // v'{2}
8171 Double_t v4Prime = 0.; // v'{4}
8172 // Differential cumulants:
8173 Double_t qc2Prime = 0.; // QC{2'}
8174 Double_t qc4Prime = 0.; // QC{4'}
8175 // Looping over all (pt,eta) bins and calculating differential flow:
8176 for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 8177 {
1268c371 8178 for(Int_t e=1;e<=fnBinsEta;e++)
489d5531 8179 {
1268c371 8180 // QC{2'}:
8181 qc2Prime = f2DDiffFlowCumulants[t][0]->GetBinContent(f2DDiffFlowCumulants[t][0]->GetBin(p,e));
8182 if(qc2Prime>=0.)
8183 {
8184 v2Prime = pow(qc2Prime,0.5);
8185 f2DDiffFlow[t][0]->SetBinContent(f2DDiffFlow[t][0]->GetBin(p,e),v2Prime);
8186 }
8187 // QC{4'}:
8188 qc4Prime = f2DDiffFlowCumulants[t][1]->GetBinContent(f2DDiffFlowCumulants[t][1]->GetBin(p,e));
8189 if(qc4Prime<=0.)
8190 {
8191 v4Prime = pow(-1.*qc4Prime,1./4.);
8192 f2DDiffFlow[t][1]->SetBinContent(f2DDiffFlow[t][1]->GetBin(p,e),v4Prime);
8193 }
8194 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
8195 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
8196
8197} // end of void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlow(TString type)
489d5531 8198
489d5531 8199//================================================================================================================================
8200
489d5531 8201void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()
8202{
8203 // a) Store all flags for integrated flow in profile fIntFlowFlags.
8204
8205 if(!fIntFlowFlags)
8206 {
8207 cout<<"WARNING: fIntFlowFlags is NULL in AFAWQC::SFFIF() !!!!"<<endl;
8208 exit(0);
8209 }
8210
8211 // particle weights used or not:
403e3389 8212 fIntFlowFlags->Fill(0.5,(Int_t)fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights);
489d5531 8213 // which event weights were used:
8214 if(strcmp(fMultiplicityWeight->Data(),"combinations"))
8215 {
8216 fIntFlowFlags->Fill(1.5,0); // 0 = "combinations" (default)
8217 } else if(strcmp(fMultiplicityWeight->Data(),"unit"))
8218 {
8219 fIntFlowFlags->Fill(1.5,1); // 1 = "unit"
8220 } else if(strcmp(fMultiplicityWeight->Data(),"multiplicity"))
8221 {
8222 fIntFlowFlags->Fill(1.5,2); // 2 = "multiplicity"
8223 }
489d5531 8224 fIntFlowFlags->Fill(2.5,(Int_t)fApplyCorrectionForNUA);
8225 fIntFlowFlags->Fill(3.5,(Int_t)fPrintFinalResults[0]);
8226 fIntFlowFlags->Fill(4.5,(Int_t)fPrintFinalResults[1]);
8227 fIntFlowFlags->Fill(5.5,(Int_t)fPrintFinalResults[2]);
b3dacf6b 8228 fIntFlowFlags->Fill(6.5,(Int_t)fPrintFinalResults[3]);
8229 fIntFlowFlags->Fill(7.5,(Int_t)fApplyCorrectionForNUAVsM);
b77b6434 8230 fIntFlowFlags->Fill(8.5,(Int_t)fPropagateErrorAlsoFromNIT);
b3dacf6b 8231 fIntFlowFlags->Fill(9.5,(Int_t)fCalculateCumulantsVsM);
0dd3b008 8232 fIntFlowFlags->Fill(10.5,(Int_t)fMinimumBiasReferenceFlow);
8e1cefdd 8233 fIntFlowFlags->Fill(11.5,(Int_t)fForgetAboutCovariances);
e5834fcb 8234 fIntFlowFlags->Fill(12.5,(Int_t)fStorePhiDistributionForOneEvent);
dd442cd2 8235 fIntFlowFlags->Fill(13.5,(Int_t)fFillMultipleControlHistograms);
3435cacb 8236 fIntFlowFlags->Fill(14.5,(Int_t)fCalculateAllCorrelationsVsM);
489d5531 8237} // end of void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()
8238
489d5531 8239//================================================================================================================================
8240
489d5531 8241void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()
8242{
8243 // Store all flags for differential flow in the profile fDiffFlowFlags.
8244
8245 if(!fDiffFlowFlags)
8246 {
1268c371 8247 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::SDFF() !!!!\n\n");
489d5531 8248 exit(0);
8249 }
8250
1268c371 8251 fDiffFlowFlags->Fill(0.5,fCalculateDiffFlow); // calculate differential flow
403e3389 8252 fDiffFlowFlags->Fill(1.5,fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights); // particle weights used or not?
1268c371 8253 //fDiffFlowFlags->Fill(2.5,""); // which event weight was used? ("combinations", "unit" or "multiplicity") to be improved - finalized
8254 fDiffFlowFlags->Fill(3.5,fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not
8255 fDiffFlowFlags->Fill(4.5,fCalculate2DDiffFlow); // calculate also 2D differential flow vs (pt,eta)
62e36168 8256 fDiffFlowFlags->Fill(5.5,fCalculateDiffFlowVsEta); // if you set kFALSE only differential flow vs pt is calculated
1268c371 8257
489d5531 8258} // end of void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()
8259
489d5531 8260//================================================================================================================================
8261
489d5531 8262void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms()
8263{
8264 // Access all pointers to common control and common result histograms and profiles.
8265
1268c371 8266 TString sCommonConstantsName = "fCommonConstants";
8267 sCommonConstantsName += fAnalysisLabel->Data();
8268 fCommonConstants = dynamic_cast<TProfile*>(fHistList->FindObject(sCommonConstantsName.Data()));
8269 if(!fCommonConstants)
8270 {
8271 printf("\n WARNING (QC): fCommonConstants is NULL in AFAWQC::GPFCH() !!!!\n\n");
8272 exit(0);
8273 }
8274
8275 // to be improved - lines bellow can be implemented better.
8276
489d5531 8277 TString commonHistsName = "AliFlowCommonHistQC";
8278 commonHistsName += fAnalysisLabel->Data();
8279 AliFlowCommonHist *commonHist = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHistsName.Data()));
b77b6434 8280 if(commonHist)
8281 {
8282 this->SetCommonHists(commonHist);
8283 if(fCommonHists->GetHarmonic())
8284 {
8285 fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
8286 }
8287 } // end of if(commonHist)
489d5531 8288 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
8289 commonHists2ndOrderName += fAnalysisLabel->Data();
8290 AliFlowCommonHist *commonHist2nd = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists2ndOrderName.Data()));
8291 if(commonHist2nd) this->SetCommonHists2nd(commonHist2nd);
8292 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
8293 commonHists4thOrderName += fAnalysisLabel->Data();
8294 AliFlowCommonHist *commonHist4th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists4thOrderName.Data()));
8295 if(commonHist4th) this->SetCommonHists4th(commonHist4th);
8296 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
8297 commonHists6thOrderName += fAnalysisLabel->Data();
8298 AliFlowCommonHist *commonHist6th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists6thOrderName.Data()));
8299 if(commonHist6th) this->SetCommonHists6th(commonHist6th);
8300 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
8301 commonHists8thOrderName += fAnalysisLabel->Data();
8302 AliFlowCommonHist *commonHist8th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists8thOrderName.Data()));
dd442cd2 8303 if(commonHist8th) this->SetCommonHists8th(commonHist8th);
8304
489d5531 8305 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
8306 commonHistResults2ndOrderName += fAnalysisLabel->Data();
b77b6434 8307 AliFlowCommonHistResults *commonHistRes2nd = dynamic_cast<AliFlowCommonHistResults*>
8308 (fHistList->FindObject(commonHistResults2ndOrderName.Data()));
489d5531 8309 if(commonHistRes2nd) this->SetCommonHistsResults2nd(commonHistRes2nd);
8310 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
8311 commonHistResults4thOrderName += fAnalysisLabel->Data();
8312 AliFlowCommonHistResults *commonHistRes4th = dynamic_cast<AliFlowCommonHistResults*>
8313 (fHistList->FindObject(commonHistResults4thOrderName.Data()));
8314 if(commonHistRes4th) this->SetCommonHistsResults4th(commonHistRes4th);
8315 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
8316 commonHistResults6thOrderName += fAnalysisLabel->Data();
8317 AliFlowCommonHistResults *commonHistRes6th = dynamic_cast<AliFlowCommonHistResults*>
8318 (fHistList->FindObject(commonHistResults6thOrderName.Data()));
8319 if(commonHistRes6th) this->SetCommonHistsResults6th(commonHistRes6th);
8320 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
8321 commonHistResults8thOrderName += fAnalysisLabel->Data();
8322 AliFlowCommonHistResults *commonHistRes8th = dynamic_cast<AliFlowCommonHistResults*>
8323 (fHistList->FindObject(commonHistResults8thOrderName.Data()));
8324 if(commonHistRes8th) this->SetCommonHistsResults8th(commonHistRes8th);
8325
8326} // end of void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms()
8327
489d5531 8328//================================================================================================================================
8329
489d5531 8330void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms()
8331{
8332 // Get pointers for histograms with particle weights.
8333
8334 TList *weightsList = dynamic_cast<TList*>(fHistList->FindObject("Weights"));
ca5f47e7 8335 if(!weightsList){printf("\n WARNING (QC): weightsList is NULL in AFAWQC::GPFPWH() !!!!\n");exit(0);}
8336 this->SetWeightsList(weightsList);
489d5531 8337 TString fUseParticleWeightsName = "fUseParticleWeightsQC"; // to be improved (hirdwired label QC)
8338 fUseParticleWeightsName += fAnalysisLabel->Data();
8339 TProfile *useParticleWeights = dynamic_cast<TProfile*>(weightsList->FindObject(fUseParticleWeightsName.Data()));
8340 if(useParticleWeights)
8341 {
8342 this->SetUseParticleWeights(useParticleWeights);
8343 fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1);
8344 fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2);
8345 fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3);
403e3389 8346 fUseTrackWeights = (Int_t)fUseParticleWeights->GetBinContent(4);
489d5531 8347 }
8348} // end of void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms();
8349
489d5531 8350//================================================================================================================================
8351
489d5531 8352void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms()
8353{
8354 // Get pointers for histograms and profiles relevant for integrated flow:
8355 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults.
8356 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow.
8357 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds.
8358 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds.
8359
8360 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data member?)
8361 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data member?)
b40a910e 8362 TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"}; // to be improved (should I promote this to data member?)
8363 TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"}; // to be improved (should I promote this to data member?)
489d5531 8364
8365 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults:
8366 TList *intFlowList = NULL;
8367 intFlowList = dynamic_cast<TList*>(fHistList->FindObject("Integrated Flow"));
8368 if(!intFlowList)
8369 {
8370 cout<<"WARNING: intFlowList is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8371 exit(0);
8372 }
8373
b92ea2b9 8374 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow:
8375 TString intFlowFlagsName = "fIntFlowFlags";
8376 intFlowFlagsName += fAnalysisLabel->Data();
8377 TProfile *intFlowFlags = dynamic_cast<TProfile*>(intFlowList->FindObject(intFlowFlagsName.Data()));
8378 if(intFlowFlags)
8379 {
8380 this->SetIntFlowFlags(intFlowFlags);
8381 fApplyCorrectionForNUA = (Bool_t)intFlowFlags->GetBinContent(3);
8382 fApplyCorrectionForNUAVsM = (Bool_t)intFlowFlags->GetBinContent(8);
8383 fCalculateCumulantsVsM = (Bool_t)intFlowFlags->GetBinContent(10);
8384 } else
8385 {
8386 cout<<"WARNING: intFlowFlags is NULL in FAWQC::GPFIFH() !!!!"<<endl;
8387 }
489d5531 8388
8389 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds:
8390 TList *intFlowProfiles = NULL;
8391 intFlowProfiles = dynamic_cast<TList*>(intFlowList->FindObject("Profiles"));
8392 if(intFlowProfiles)
8393 {
8394 // average multiplicities:
8395 TString avMultiplicityName = "fAvMultiplicity";
8396 avMultiplicityName += fAnalysisLabel->Data();
8397 TProfile *avMultiplicity = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(avMultiplicityName.Data()));
8398 if(avMultiplicity)
8399 {
8400 this->SetAvMultiplicity(avMultiplicity);
8401 } else
8402 {
8403 cout<<"WARNING: avMultiplicity is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8404 }
8405 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with wrong errors!):
8406 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
8407 intFlowCorrelationsProName += fAnalysisLabel->Data();
8408 TProfile *intFlowCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsProName.Data()));
8409 if(intFlowCorrelationsPro)
8410 {
8411 this->SetIntFlowCorrelationsPro(intFlowCorrelationsPro);
8412 } else
8413 {
8414 cout<<"WARNING: intFlowCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8415 }
b40a910e 8416 // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8^2>>:
8417 TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
8418 intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
8419 TProfile *intFlowSquaredCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowSquaredCorrelationsProName.Data()));
8420 if(intFlowSquaredCorrelationsPro)
8421 {
8422 this->SetIntFlowSquaredCorrelationsPro(intFlowSquaredCorrelationsPro);
8423 } else
8424 {
8425 cout<<"WARNING: intFlowSquaredCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8426 }
b3dacf6b 8427 if(fCalculateCumulantsVsM)
ff70ca91 8428 {
b40a910e 8429 // Average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (error is wrong here):
b3dacf6b 8430 TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
8431 intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
8432 for(Int_t ci=0;ci<4;ci++) // correlation index
ff70ca91 8433 {
b3dacf6b 8434 TProfile *intFlowCorrelationsVsMPro = dynamic_cast<TProfile*>
8435 (intFlowProfiles->FindObject(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data())));
8436 if(intFlowCorrelationsVsMPro)
8437 {
8438 this->SetIntFlowCorrelationsVsMPro(intFlowCorrelationsVsMPro,ci);
8439 } else
8440 {
8441 cout<<"WARNING: "<<Form("intFlowCorrelationsVsMPro[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8442 }
8443 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b40a910e 8444 // Average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
8445 TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
8446 intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
8447 for(Int_t ci=0;ci<4;ci++) // correlation index
8448 {
8449 TProfile *intFlowSquaredCorrelationsVsMPro = dynamic_cast<TProfile*>
8450 (intFlowProfiles->FindObject(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data())));
8451 if(intFlowSquaredCorrelationsVsMPro)
8452 {
8453 this->SetIntFlowSquaredCorrelationsVsMPro(intFlowSquaredCorrelationsVsMPro,ci);
8454 } else
8455 {
8456 cout<<"WARNING: "<<Form("intFlowSquaredCorrelationsVsMPro[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8457 }
8458 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b3dacf6b 8459 } // end of if(fCalculateCumulantsVsM)
489d5531 8460 // average all correlations for integrated flow (with wrong errors!):
8461 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
8462 intFlowCorrelationsAllProName += fAnalysisLabel->Data();
8463 TProfile *intFlowCorrelationsAllPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsAllProName.Data()));
8464 if(intFlowCorrelationsAllPro)
8465 {
8466 this->SetIntFlowCorrelationsAllPro(intFlowCorrelationsAllPro);
8467 } else
8468 {
8469 cout<<"WARNING: intFlowCorrelationsAllPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8470 }
8471 // average extra correlations for integrated flow (which appear only when particle weights are used):
8472 // (to be improved: Weak point in implementation, I am assuming here that method GetPointersForParticleWeightsHistograms() was called)
403e3389 8473 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 8474 {
8475 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
8476 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
8477 TProfile *intFlowExtraCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowExtraCorrelationsProName.Data()));
8478 if(intFlowExtraCorrelationsPro)
8479 {
8480 this->SetIntFlowExtraCorrelationsPro(intFlowExtraCorrelationsPro);
8481 } else
8482 {
8483 cout<<"WARNING: intFlowExtraCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8484 }
403e3389 8485 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 8486 // average products of correlations <2>, <4>, <6> and <8>:
8487 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
8488 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
8489 TProfile *intFlowProductOfCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrelationsProName.Data()));
8490 if(intFlowProductOfCorrelationsPro)
8491 {
8492 this->SetIntFlowProductOfCorrelationsPro(intFlowProductOfCorrelationsPro);
8493 } else
8494 {
8495 cout<<"WARNING: intFlowProductOfCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8496 }
8497 // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
8498 // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 8499 if(fCalculateCumulantsVsM)
8500 {
8501 TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
8502 intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
403e3389 8503 TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
8504 "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
b3dacf6b 8505 for(Int_t pi=0;pi<6;pi++)
8506 {
8507 TProfile *intFlowProductOfCorrelationsVsMPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data())));
8508 if(intFlowProductOfCorrelationsVsMPro)
8509 {
8510 this->SetIntFlowProductOfCorrelationsVsMPro(intFlowProductOfCorrelationsVsMPro,pi);
8511 } else
8512 {
8513 cout<<"WARNING: "<<Form("intFlowProductOfCorrelationsVsMPro[%d]",pi)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8514 }
8515 } // end of for(Int_t pi=0;pi<6;pi++)
8516 } // end of if(fCalculateCumulantsVsM)
489d5531 8517 // average correction terms for non-uniform acceptance (with wrong errors!):
8518 for(Int_t sc=0;sc<2;sc++)
8519 {
8520 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
8521 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
8522 TProfile *intFlowCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAProName.Data(),sinCosFlag[sc].Data()))));
8523 if(intFlowCorrectionTermsForNUAPro)
8524 {
8525 this->SetIntFlowCorrectionTermsForNUAPro(intFlowCorrectionTermsForNUAPro,sc);
8526 } else
8527 {
8528 cout<<"WARNING: intFlowCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8529 cout<<"sc = "<<sc<<endl;
8530 }
2001bc3a 8531 // versus multiplicity:
b3dacf6b 8532 if(fCalculateCumulantsVsM)
2001bc3a 8533 {
b3dacf6b 8534 TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
8535 TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
8536 intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
8537 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2001bc3a 8538 {
b3dacf6b 8539 TProfile *intFlowCorrectionTermsForNUAVsMPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(Form("%s: #LT#LT%s%s#GT#GT",intFlowCorrectionTermsForNUAVsMProName.Data(),sinCosFlag[sc].Data(),correctionTermFlag[ci].Data())));
8540 if(intFlowCorrectionTermsForNUAVsMPro)
8541 {
8542 this->SetIntFlowCorrectionTermsForNUAVsMPro(intFlowCorrectionTermsForNUAVsMPro,sc,ci);
8543 } else
8544 {
8545 cout<<"WARNING: intFlowCorrectionTermsForNUAVsMPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8546 cout<<"sc = "<<sc<<endl;
8547 cout<<"ci = "<<ci<<endl;
8548 }
8549 } // end of for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
8550 } // end of if(fCalculateCumulantsVsM)
489d5531 8551 } // end of for(Int_t sc=0;sc<2;sc++)
0328db2d 8552 // average products of correction terms for NUA:
8553 TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
8554 intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
8555 TProfile *intFlowProductOfCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrectionTermsForNUAProName.Data()));
8556 if(intFlowProductOfCorrectionTermsForNUAPro)
8557 {
8558 this->SetIntFlowProductOfCorrectionTermsForNUAPro(intFlowProductOfCorrectionTermsForNUAPro);
8559 } else
8560 {
8561 cout<<"WARNING: intFlowProductOfCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8562 }
489d5531 8563 } else // to if(intFlowProfiles)
8564 {
8565 cout<<"WARNING: intFlowProfiles is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8566 }
8567
8568 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds.
8569 TList *intFlowResults = NULL;
8570 intFlowResults = dynamic_cast<TList*>(intFlowList->FindObject("Results"));
8571 if(intFlowResults)
8572 {
8573 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!):
8574 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
8575 intFlowCorrelationsHistName += fAnalysisLabel->Data();
8576 TH1D *intFlowCorrelationsHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsHistName.Data()));
8577 if(intFlowCorrelationsHist)
8578 {
8579 this->SetIntFlowCorrelationsHist(intFlowCorrelationsHist);
8580 } else
8581 {
8582 cout<<"WARNING: intFlowCorrelationsHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8583 }
ff70ca91 8584 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!) vs M:
b3dacf6b 8585 if(fCalculateCumulantsVsM)
ff70ca91 8586 {
b3dacf6b 8587 TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
8588 intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
8589 for(Int_t ci=0;ci<4;ci++) // correlation index
ff70ca91 8590 {
b3dacf6b 8591 TH1D *intFlowCorrelationsVsMHist = dynamic_cast<TH1D*>
8592 (intFlowResults->FindObject(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data())));
8593 if(intFlowCorrelationsVsMHist)
8594 {
8595 this->SetIntFlowCorrelationsVsMHist(intFlowCorrelationsVsMHist,ci);
8596 } else
8597 {
8598 cout<<"WARNING: "<<Form("intFlowCorrelationsVsMHist[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8599 }
8600 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
8601 } // end of if(fCalculateCumulantsVsM)
489d5531 8602 // average all correlations for integrated flow (with correct errors!):
8603 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
8604 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
8605 TH1D *intFlowCorrelationsAllHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsAllHistName.Data()));
8606 if(intFlowCorrelationsAllHist)
8607 {
8608 this->SetIntFlowCorrelationsAllHist(intFlowCorrelationsAllHist);
8609 } else
8610 {
8611 cout<<"WARNING: intFlowCorrelationsAllHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8612 }
8613 // average correction terms for non-uniform acceptance (with correct errors!):
8614 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
8615 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
8616 for(Int_t sc=0;sc<2;sc++)
8617 {
8618 TH1D *intFlowCorrectionTermsForNUAHist = dynamic_cast<TH1D*>(intFlowResults->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAHistName.Data(),sinCosFlag[sc].Data()))));
8619 if(intFlowCorrectionTermsForNUAHist)
8620 {
8621 this->SetIntFlowCorrectionTermsForNUAHist(intFlowCorrectionTermsForNUAHist,sc);
8622 } else
8623 {
8624 cout<<"WARNING: intFlowCorrectionTermsForNUAHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8625 cout<<"sc = "<<sc<<endl;
8626 }
8627 } // end of for(Int_t sc=0;sc<2;sc++)
8628 // covariances (multiplied with weight dependent prefactor):
8629 TString intFlowCovariancesName = "fIntFlowCovariances";
8630 intFlowCovariancesName += fAnalysisLabel->Data();
8631 TH1D *intFlowCovariances = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesName.Data()));
8632 if(intFlowCovariances)
8633 {
8634 this->SetIntFlowCovariances(intFlowCovariances);
8635 } else
8636 {
8637 cout<<"WARNING: intFlowCovariances is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8638 }
8639 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
8640 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
8641 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
8642 for(Int_t power=0;power<2;power++)
8643 {
8644 TH1D *intFlowSumOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s",intFlowSumOfEventWeightsName.Data(),powerFlag[power].Data())));
8645 if(intFlowSumOfEventWeights)
8646 {
8647 this->SetIntFlowSumOfEventWeights(intFlowSumOfEventWeights,power);
8648 } else
8649 {
8650 cout<<"WARNING: intFlowSumOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8651 cout<<"power = "<<power<<endl;
8652 }
8653 } // end of for(Int_t power=0;power<2;power++)
8654 // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
8655 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
8656 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
8657 TH1D *intFlowSumOfProductOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsName.Data()));
8658 if(intFlowSumOfProductOfEventWeights)
8659 {
8660 this->SetIntFlowSumOfProductOfEventWeights(intFlowSumOfProductOfEventWeights);
8661 } else
8662 {
8663 cout<<"WARNING: intFlowSumOfProductOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8664 }
ff70ca91 8665 // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
8666 // [0=Cov(2,4),1=Cov(2,6),2=Cov(2,8),3=Cov(4,6),4=Cov(4,8),5=Cov(6,8)]:
b3dacf6b 8667 if(fCalculateCumulantsVsM)
ff70ca91 8668 {
b3dacf6b 8669 TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
8670 intFlowCovariancesVsMName += fAnalysisLabel->Data();
8671 TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
8672 for(Int_t ci=0;ci<6;ci++)
8673 {
8674 TH1D *intFlowCovariancesVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data())));
8675 if(intFlowCovariancesVsM)
ff70ca91 8676 {
b3dacf6b 8677 this->SetIntFlowCovariancesVsM(intFlowCovariancesVsM,ci);
ff70ca91 8678 } else
8679 {
b3dacf6b 8680 cout<<"WARNING: "<<Form("intFlowCovariancesVsM[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8681 }
b3dacf6b 8682 } // end of for(Int_t ci=0;ci<6;ci++)
8683 } // end of if(fCalculateCumulantsVsM)
8684 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
8685 // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
8686 if(fCalculateCumulantsVsM)
8687 {
8688 TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
8689 intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
8690 TString sumFlag[2][4] = {{"#sum_{i=1}^{N} w_{<2>}","#sum_{i=1}^{N} w_{<4>}","#sum_{i=1}^{N} w_{<6>}","#sum_{i=1}^{N} w_{<8>}"},
8691 {"#sum_{i=1}^{N} w_{<2>}^{2}","#sum_{i=1}^{N} w_{<4>}^{2}","#sum_{i=1}^{N} w_{<6>}^{2}","#sum_{i=1}^{N} w_{<8>}^{2}"}};
8692 for(Int_t si=0;si<4;si++)
8693 {
8694 for(Int_t power=0;power<2;power++)
8695 {
8696 TH1D *intFlowSumOfEventWeightsVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data())));
8697 if(intFlowSumOfEventWeightsVsM)
8698 {
8699 this->SetIntFlowSumOfEventWeightsVsM(intFlowSumOfEventWeightsVsM,si,power);
8700 } else
8701 {
8702 cout<<"WARNING: "<<Form("intFlowSumOfEventWeightsVsM[%d][%d]",si,power)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8703 }
8704 } // end of for(Int_t power=0;power<2;power++)
8705 } // end of for(Int_t si=0;si<4;si++)
8706 } // end of if(fCalculateCumulantsVsM)
ff70ca91 8707 // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
8708 // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
8709 // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
b3dacf6b 8710 if(fCalculateCumulantsVsM)
ff70ca91 8711 {
b3dacf6b 8712 TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
8713 intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
8714 TString sopowFlag[6] = {"#sum_{i=1}^{N} w_{<2>} w_{<4>}","#sum_{i=1}^{N} w_{<2>} w_{<6>}","#sum_{i=1}^{N} w_{<2>} w_{<8>}",
8715 "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
8716 for(Int_t pi=0;pi<6;pi++)
ff70ca91 8717 {
b3dacf6b 8718 TH1D *intFlowSumOfProductOfEventWeightsVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data())));
8719 if(intFlowSumOfProductOfEventWeightsVsM)
8720 {
8721 this->SetIntFlowSumOfProductOfEventWeightsVsM(intFlowSumOfProductOfEventWeightsVsM,pi);
8722 } else
8723 {
8724 cout<<"WARNING: "<<Form("intFlowSumOfProductOfEventWeightsVsM[%d]",pi)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8725 }
8726 } // end of for(Int_t pi=0;pi<6;pi++)
8727 } // end of if(fCalculateCumulantsVsM)
0328db2d 8728 // covariances for NUA (multiplied with weight dependent prefactor):
8729 TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
8730 intFlowCovariancesNUAName += fAnalysisLabel->Data();
8731 TH1D *intFlowCovariancesNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesNUAName.Data()));
8732 if(intFlowCovariancesNUA)
8733 {
8734 this->SetIntFlowCovariancesNUA(intFlowCovariancesNUA);
8735 } else
8736 {
8737 cout<<"WARNING: intFlowCovariancesNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8738 }
8739 // sum of linear and quadratic event weights NUA terms:
8740 TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
8741 intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
8742 for(Int_t sc=0;sc<2;sc++)
8743 {
8744 for(Int_t power=0;power<2;power++)
8745 {
8746 TH1D *intFlowSumOfEventWeightsNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s, %s",intFlowSumOfEventWeightsNUAName.Data(),powerFlag[power].Data(),sinCosFlag[sc].Data())));
8747 if(intFlowSumOfEventWeightsNUA)
8748 {
8749 this->SetIntFlowSumOfEventWeightsNUA(intFlowSumOfEventWeightsNUA,sc,power);
8750 } else
8751 {
8752 cout<<"WARNING: intFlowSumOfEventWeightsNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8753 cout<<"sc = "<<sc<<endl;
8754 cout<<"power = "<<power<<endl;
8755 }
8756 } // end of for(Int_t power=0;power<2;power++)
8757 } // end of for(Int_t sc=0;sc<2;sc++)
8758 // sum of products of event weights for NUA terms:
8759 TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
8760 intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
8761 TH1D *intFlowSumOfProductOfEventWeightsNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsNUAName.Data()));
8762 if(intFlowSumOfProductOfEventWeightsNUA)
8763 {
8764 this->SetIntFlowSumOfProductOfEventWeightsNUA(intFlowSumOfProductOfEventWeightsNUA);
8765 } else
8766 {
8767 cout<<"WARNING: intFlowSumOfProductOfEventWeightsNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8768 }
b3dacf6b 8769 // Final results for reference Q-cumulants:
489d5531 8770 TString intFlowQcumulantsName = "fIntFlowQcumulants";
8771 intFlowQcumulantsName += fAnalysisLabel->Data();
8772 TH1D *intFlowQcumulants = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsName.Data()));
8773 if(intFlowQcumulants)
8774 {
8775 this->SetIntFlowQcumulants(intFlowQcumulants);
8776 } else
8777 {
8778 cout<<"WARNING: intFlowQcumulants is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8779 }
b3dacf6b 8780 // Final results for reference Q-cumulants rebinned in M:
8781 if(fCalculateCumulantsVsM)
8782 {
8783 TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
8784 intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
8785 TH1D *intFlowQcumulantsRebinnedInM = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsRebinnedInMName.Data()));
8786 if(intFlowQcumulantsRebinnedInM)
8787 {
8788 this->SetIntFlowQcumulantsRebinnedInM(intFlowQcumulantsRebinnedInM);
8789 } else
8790 {
8791 cout<<"WARNING: intFlowQcumulantsRebinnedInM is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8792 }
8793 } // end of if(fCalculateCumulantsVsM)
b92ea2b9 8794 // Ratio between error squared: with/without non-isotropic terms:
8795 TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
8796 intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
8797 TH1D *intFlowQcumulantsErrorSquaredRatio = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsErrorSquaredRatioName.Data()));
8798 if(intFlowQcumulantsErrorSquaredRatio)
8799 {
8800 this->SetIntFlowQcumulantsErrorSquaredRatio(intFlowQcumulantsErrorSquaredRatio);
8801 } else
8802 {
8803 cout<<" WARNING: intntFlowQcumulantsErrorSquaredRatio is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8804 }
ff70ca91 8805 // final results for integrated Q-cumulants versus multiplicity:
ff70ca91 8806 TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
b3dacf6b 8807 if(fCalculateCumulantsVsM)
ff70ca91 8808 {
b3dacf6b 8809 TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
8810 intFlowQcumulantsVsMName += fAnalysisLabel->Data();
8811 for(Int_t co=0;co<4;co++) // cumulant order
ff70ca91 8812 {
b3dacf6b 8813 TH1D *intFlowQcumulantsVsM = dynamic_cast<TH1D*>
8814 (intFlowResults->FindObject(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data())));
8815 if(intFlowQcumulantsVsM)
8816 {
8817 this->SetIntFlowQcumulantsVsM(intFlowQcumulantsVsM,co);
8818 } else
8819 {
8820 cout<<"WARNING: "<<Form("intFlowQcumulantsVsM[%d]",co)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8821 }
8822 } // end of for(Int_t co=0;co<4;co++) // cumulant order
8823 } // end of if(fCalculateCumulantsVsM)
8824 // Final reference flow estimates from Q-cumulants:
489d5531 8825 TString intFlowName = "fIntFlow";
8826 intFlowName += fAnalysisLabel->Data();
8827 TH1D *intFlow = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowName.Data()));
8828 if(intFlow)
8829 {
8830 this->SetIntFlow(intFlow);
8831 } else
8832 {
8833 cout<<"WARNING: intFlow is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8834 }
b3dacf6b 8835 // Final reference flow estimates from Q-cumulants vs M rebinned in M:
8836 if(fCalculateCumulantsVsM)
ff70ca91 8837 {
b3dacf6b 8838 TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
8839 intFlowRebinnedInMName += fAnalysisLabel->Data();
8840 TH1D *intFlowRebinnedInM = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowRebinnedInMName.Data()));
8841 if(intFlowRebinnedInM)
ff70ca91 8842 {
b3dacf6b 8843 this->SetIntFlowRebinnedInM(intFlowRebinnedInM);
8844 } else
ff70ca91 8845 {
b3dacf6b 8846 cout<<"WARNING: intFlowRebinnedInM is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8847 }
8848 } // end of if(fCalculateCumulantsVsM)
8849 // integrated flow from Q-cumulants versus multiplicity:
8850 if(fCalculateCumulantsVsM)
8851 {
8852 TString intFlowVsMName = "fIntFlowVsM";
8853 intFlowVsMName += fAnalysisLabel->Data();
b77b6434 8854 TString flowFlag[4] = {Form("v_{%d}{2,QC}",fHarmonic),Form("v_{%d}{4,QC}",fHarmonic),Form("v_{%d}{6,QC}",fHarmonic),Form("v_{%d}{8,QC}",fHarmonic)};
b3dacf6b 8855 for(Int_t co=0;co<4;co++) // cumulant order
8856 {
8857 TH1D *intFlowVsM = dynamic_cast<TH1D*>
b77b6434 8858 (intFlowResults->FindObject(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data())));
b3dacf6b 8859 if(intFlowVsM)
8860 {
8861 this->SetIntFlowVsM(intFlowVsM,co);
8862 } else
8863 {
8864 cout<<"WARNING: "<<Form("intFlowVsM[%d]",co)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8865 }
8866 } // end of for(Int_t co=0;co<4;co++) // cumulant order
8867 } // end of if(fCalculateCumulantsVsM)
2001bc3a 8868 // quantifying detector effects effects to correlations:
8869 TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
8870 intFlowDetectorBiasName += fAnalysisLabel->Data();
8871 TH1D *intFlowDetectorBias = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowDetectorBiasName.Data()));
8872 if(intFlowDetectorBias)
8873 {
8874 this->SetIntFlowDetectorBias(intFlowDetectorBias);
8875 } else
8876 {
8877 cout<<"WARNING: intFlowDetectorBias is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8878 }
8879 // quantifying detector effects effects to correlations vs multiplicity:
b77b6434 8880 if(fCalculateCumulantsVsM)
2001bc3a 8881 {
3c5d5752 8882 TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
8883 intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
8884 for(Int_t ci=0;ci<4;ci++) // correlation index
2001bc3a 8885 {
3c5d5752 8886 TH1D *intFlowDetectorBiasVsM = dynamic_cast<TH1D*>
8887 (intFlowResults->FindObject(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data())));
8888 if(intFlowDetectorBiasVsM)
8889 {
8890 this->SetIntFlowDetectorBiasVsM(intFlowDetectorBiasVsM,ci);
8891 } else
8892 {
8893 cout<<"WARNING: "<<Form("intFlowDetectorBiasVsM[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8894 }
8895 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b77b6434 8896 } // end of if(fCalculateCumulantsVsM)
489d5531 8897 } else // to if(intFlowResults)
8898 {
8899 cout<<"WARNING: intFlowResults is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8900 }
ff70ca91 8901
489d5531 8902} // end of void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms()
8903
489d5531 8904//================================================================================================================================
8905
1268c371 8906void AliFlowAnalysisWithQCumulants::GetPointersFor2DDiffFlowHistograms()
8907{
8908 // Get pointers for 2D differential flow histograms.
8909 // a) Check pointers used in this method;
8910 // b) Get pointers to 2D differential flow lists;
8911 // c) Get pointers to 2D differential flow profiles;
8912 // d) Get pointers to 2D differential flow histograms.
8913
8914 // a) Check pointers used in this method:
8915 if(!fDiffFlowList)
8916 {
8917 printf("\n WARNING (QC): fDiffFlowList is NULL in AFAWQC::GPF2DDFH() !!!!\n");
8918 printf(" Call method GetPointersForDiffFlowHistograms() first.\n\n");
8919 exit(0);
8920 }
8921 if(!fDiffFlowFlags)
8922 {
8923 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::GPF2DDFH() !!!!\n\n");
8924 printf(" Call method GetPointersForDiffFlowHistograms() first.\n\n");
8925 exit(0);
8926 }
8927
8928 // b) Get pointers to 2D differential flow lists:
8929 this->SetCalculate2DDiffFlow((Bool_t)fDiffFlowFlags->GetBinContent(5)); // to be improved - hardwired 5
8930 if(!fCalculate2DDiffFlow){return;}
8931 TString typeFlag[2] = {"RP","POI"};
8932 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
8933 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
8934 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
8935 // Base list:
8936 TString diffFlow2DListName = "2D";
8937 diffFlow2DListName += fAnalysisLabel->Data();
8938 fDiffFlow2D = dynamic_cast<TList*>(fDiffFlowList->FindObject(diffFlow2DListName.Data()));
8939 if(!fDiffFlow2D)
8940 {
8941 printf("\n WARNING (QC): fDiffFlow2D is NULL in AFAWQC::GPFDFH() !!!!\n\n");
8942 exit(0);
8943 }
8944 // Lists holding profiles with 2D correlations:
8945 TString s2DDiffFlowCorrelationsProListName = "Profiles with 2D correlations";
8946 s2DDiffFlowCorrelationsProListName += fAnalysisLabel->Data(); // to be improved
8947 for(Int_t t=0;t<2;t++)
8948 {
8949 f2DDiffFlowCorrelationsProList[t] = dynamic_cast<TList*>(fDiffFlow2D->FindObject(Form("Profiles with 2D correlations (%s)",typeFlag[t].Data())));
8950 if(!f2DDiffFlowCorrelationsProList[t])
8951 {
8952 printf("\n WARNING (QC): f2DDiffFlowCorrelationsProList[%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t);
8953 exit(0);
8954 }
8955 } // end of for(Int_t t=0;t<2;t++)
8956
8957 // c) Get pointers to 2D differential flow profiles:
8958 TString s2DDiffFlowCorrelationsProName = "f2DDiffFlowCorrelationsPro";
8959 s2DDiffFlowCorrelationsProName += fAnalysisLabel->Data();
8960 for(Int_t t=0;t<2;t++) // type: RP or POI
8961 {
8962 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
8963 {
8964 f2DDiffFlowCorrelationsPro[t][rci] = dynamic_cast<TProfile2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowCorrelationsProName.Data(),typeFlag[t].Data(),reducedCorrelationIndex[rci].Data())));
8965 if(!f2DDiffFlowCorrelationsPro[t][rci])
8966 {
8967 printf("\n WARNING (QC): f2DDiffFlowCorrelationsPro[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
8968 exit(0);
8969 } else
8970 {
8971 this->Set2DDiffFlowCorrelationsPro(f2DDiffFlowCorrelationsPro[t][rci],t,rci);
8972 }
8973 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
8974 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
8975
8976 // d) Get pointers to 2D differential flow histograms:
8977 TString s2DDiffFlowCumulantsName = "f2DDiffFlowCumulants";
8978 s2DDiffFlowCumulantsName += fAnalysisLabel->Data();
8979 TString s2DDiffFlowName = "f2DDiffFlow";
8980 s2DDiffFlowName += fAnalysisLabel->Data();
8981 for(Int_t t=0;t<2;t++) // type: RP or POI
8982 {
8983 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
8984 {
8985 // 2D differential cumulants:
8986 f2DDiffFlowCumulants[t][rci] = dynamic_cast<TH2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowCumulantsName.Data(),typeFlag[t].Data(),differentialCumulantIndex[rci].Data())));
8987 if(!f2DDiffFlowCumulants[t][rci])
8988 {
8989 printf("\n WARNING (QC): f2DDiffFlowCumulants[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
8990 exit(0);
8991 } else
8992 {
8993 this->Set2DDiffFlowCumulants(f2DDiffFlowCumulants[t][rci],t,rci);
8994 }
8995 // 2D differential flow:
8996 f2DDiffFlow[t][rci] = dynamic_cast<TH2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowName.Data(),typeFlag[t].Data(),differentialFlowIndex[rci].Data())));
8997 if(!f2DDiffFlow[t][rci])
8998 {
8999 printf("\n WARNING (QC): f2DDiffFlow[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
9000 exit(0);
9001 } else
9002 {
9003 this->Set2DDiffFlow(f2DDiffFlow[t][rci],t,rci);
9004 }
9005 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9006 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9007
9008} // end of void AliFlowAnalysisWithQCumulants::GetPointersFor2DDiffFlowHistograms()
9009
9010//================================================================================================================================
9011
64e500e3 9012void AliFlowAnalysisWithQCumulants::GetPointersForOtherDiffCorrelators()
9013{
9014 // Get pointers for other differential correlators.
9015 // a) Get pointer to list with other differential correlators;
9016 // b) Declare local flags;
9017 // c) Get pointers to other differential profiles.
9018
62e36168 9019 if(!fCalculateDiffFlow){return;} // TBI: This must eventually be moved somewhere else
9020
64e500e3 9021 // a) Get pointer to list with other differential correlators:
9022 fOtherDiffCorrelatorsList = dynamic_cast<TList*>(fHistList->FindObject("Other differential correlators"));
9023 if(!fOtherDiffCorrelatorsList)
9024 {
9025 printf("\n WARNING (QC): fOtherDiffCorrelatorsList is NULL in AFAWQC::GPFDFH() !!!!\n\n");
9026 exit(0);
9027 }
9028
9029 // b) Declare local flags: // (to be improved - promoted to data members)
9030 TString typeFlag[2] = {"RP","POI"};
9031 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9032 TString sinCosFlag[2] = {"sin","cos"};
9033
9034 // c) Get pointers to other differential profiles:
9035 TString otherDiffCorrelatorsName = "fOtherDiffCorrelators";
9036 otherDiffCorrelatorsName += fAnalysisLabel->Data();
9037 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9038 {
62e36168 9039 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 9040 {
9041 for(Int_t sc=0;sc<2;sc++) // sin or cos
9042 {
9043 for(Int_t ci=0;ci<1;ci++) // correlator index
9044 {
9045 fOtherDiffCorrelators[t][pe][sc][ci] = dynamic_cast<TProfile*>(fOtherDiffCorrelatorsList->FindObject(Form("%s, %s, %s, %s, ci = %d",otherDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1)));
9046 if(!fOtherDiffCorrelators[t][pe][sc][ci])
9047 {
9048 printf("\n WARNING (QC): fOtherDiffCorrelators[%i][%i][%i][%i] is NULL in AFAWQC::GPFODC() !!!!\n\n",t,pe,sc,ci);
9049 exit(0);
9050 } else
9051 {
9052 this->SetOtherDiffCorrelators(fOtherDiffCorrelators[t][pe][sc][ci],t,pe,sc,ci);
9053 }
9054 } // end of for(Int_t ci=0;ci<1;ci++) // correlator index
9055 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9056 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9057 } // end of for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9058
9059} // end of void AliFlowAnalysisWithQCumulants::GetPointersForOtherDiffCorrelators()
9060
9061//================================================================================================================================
9062
489d5531 9063void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms()
9064{
9065 // Get pointer to all objects relevant for differential flow.
1268c371 9066 // a) Get pointer to base list for differential flow fDiffFlowList;
9067 // b) Get pointer to profile fDiffFlowFlags holding all flags for differential flow. Access and set some flags;
9068 // c) Get pointers to nested lists fDiffFlowListProfiles and fDiffFlowListResults;
9069 // d) Define flags locally (to be improved: should I promote these flags to data members?);
9070 // e) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;
9071 // f) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.
9072
9073 // a) Get pointer to base list for differential flow fDiffFlowList:
9074 fDiffFlowList = dynamic_cast<TList*>(fHistList->FindObject("Differential Flow"));
9075 if(!fDiffFlowList)
489d5531 9076 {
1268c371 9077 printf("\n WARNING (QC): fDiffFlowList is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9078 exit(0);
9079 }
1268c371 9080
9081 // b) Get pointer to profile fDiffFlowFlags holding all flags for differential flow. Access and set some flags:
9082 TString diffFlowFlagsName = "fDiffFlowFlags";
9083 diffFlowFlagsName += fAnalysisLabel->Data();
9084 fDiffFlowFlags = dynamic_cast<TProfile*>(fDiffFlowList->FindObject(diffFlowFlagsName.Data()));
9085 if(fDiffFlowFlags)
9086 {
62d19320 9087 this->SetCalculateDiffFlow((Bool_t)fDiffFlowFlags->GetBinContent(1)); // to be improved - hardwired 1
62e36168 9088 this->SetCalculateDiffFlowVsEta((Bool_t)fDiffFlowFlags->GetBinContent(6)); // to be improved - hardwired 6
1268c371 9089 } else
9090 {
9091 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::GPFDFH() !!!!\n\n");
9092 printf("\n Flags in method Finish() are wrong.\n\n");
9093 exit(0);
9094 }
9095
9096 if(!fCalculateDiffFlow){return;} // IMPORTANT: do not move this anywhere above in this method (to be improved)
9097
9098 // c) Get pointers to nested lists fDiffFlowListProfiles and fDiffFlowListResults:
9099 // List holding nested lists holding profiles:
489d5531 9100 TList *diffFlowListProfiles = NULL;
1268c371 9101 diffFlowListProfiles = dynamic_cast<TList*>(fDiffFlowList->FindObject("Profiles"));
489d5531 9102 if(!diffFlowListProfiles)
9103 {
1268c371 9104 printf("\n WARNING (QC): diffFlowListProfiles is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9105 exit(0);
9106 }
1268c371 9107 // List holding nested lists holding histograms with final results:
489d5531 9108 TList *diffFlowListResults = NULL;
1268c371 9109 diffFlowListResults = dynamic_cast<TList*>(fDiffFlowList->FindObject("Results"));
489d5531 9110 if(!diffFlowListResults)
9111 {
1268c371 9112 printf("\n WARNING (QC): diffFlowListResults is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9113 exit(0);
9114 }
9115
1268c371 9116 // d) Define flags locally (to be improved: should I promote these flags to data members?):
9117 TString typeFlag[2] = {"RP","POI"};
9118 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9119 TString powerFlag[2] = {"linear","quadratic"};
9120 TString sinCosFlag[2] = {"sin","cos"};
9121 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9122 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9123 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
9124 TString reducedSquaredCorrelationIndex[4] = {"<2'>^{2}","<4'>^{2}","<6'>^{2}","<8'>^{2}"};
9125 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};
9126 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"};
489d5531 9127
1268c371 9128 // e) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold:
489d5531 9129 // correlations:
9130 TList *diffFlowCorrelationsProList[2][2] = {{NULL}};
9131 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";
9132 diffFlowCorrelationsProName += fAnalysisLabel->Data();
b40a910e 9133 TProfile *diffFlowCorrelationsPro[2][2][4] = {{{NULL}}};
9134 // squared correlations:
9135 TString diffFlowSquaredCorrelationsProName = "fDiffFlowSquaredCorrelationsPro";
9136 diffFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
9137 TProfile *diffFlowSquaredCorrelationsPro[2][2][4] = {{{NULL}}};
489d5531 9138 // products of correlations:
9139 TList *diffFlowProductOfCorrelationsProList[2][2] = {{NULL}};
9140 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";
9141 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
9142 TProfile *diffFlowProductOfCorrelationsPro[2][2][8][8] = {{{{NULL}}}};
9143 // corrections:
9144 TList *diffFlowCorrectionsProList[2][2] = {{NULL}};
9145 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";
9146 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
9147 TProfile *diffFlowCorrectionTermsForNUAPro[2][2][2][10] = {{{{NULL}}}};
9148 for(Int_t t=0;t<2;t++)
9149 {
62e36168 9150 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++)
489d5531 9151 {
9152 diffFlowCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9153 if(!diffFlowCorrelationsProList[t][pe])
9154 {
9155 cout<<"WARNING: diffFlowCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9156 cout<<"t = "<<t<<endl;
9157 cout<<"pe = "<<pe<<endl;
9158 exit(0);
9159 }
9160 for(Int_t ci=0;ci<4;ci++) // correlation index
9161 {
b40a910e 9162 // reduced correlations:
489d5531 9163 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())));
9164 if(diffFlowCorrelationsPro[t][pe][ci])
9165 {
9166 this->SetDiffFlowCorrelationsPro(diffFlowCorrelationsPro[t][pe][ci],t,pe,ci);
9167 } else
9168 {
9169 cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9170 cout<<"t = "<<t<<endl;
9171 cout<<"pe = "<<pe<<endl;
9172 cout<<"ci = "<<ci<<endl;
9173 }
b40a910e 9174 // reduced squared correlations:
9175 diffFlowSquaredCorrelationsPro[t][pe][ci] = dynamic_cast<TProfile*>(diffFlowCorrelationsProList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowSquaredCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedSquaredCorrelationIndex[ci].Data())));
9176 if(diffFlowSquaredCorrelationsPro[t][pe][ci])
9177 {
9178 this->SetDiffFlowSquaredCorrelationsPro(diffFlowSquaredCorrelationsPro[t][pe][ci],t,pe,ci);
9179 } else
9180 {
9181 cout<<"WARNING: diffFlowSquaredCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9182 cout<<"t = "<<t<<endl;
9183 cout<<"pe = "<<pe<<endl;
9184 cout<<"ci = "<<ci<<endl;
9185 }
489d5531 9186 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9187 // products of correlations:
9188 diffFlowProductOfCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9189 if(!diffFlowProductOfCorrelationsProList[t][pe])
9190 {
9191 cout<<"WARNING: ddiffFlowProductOfCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9192 cout<<"t = "<<t<<endl;
9193 cout<<"pe = "<<pe<<endl;
9194 exit(0);
9195 }
9196 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9197 {
9198 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9199 {
9200 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())));
9201 if(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2])
9202 {
9203 this->SetDiffFlowProductOfCorrelationsPro(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2],t,pe,mci1,mci2);
9204 } else
9205 {
b40a910e 9206 cout<<"WARNING: diffFlowProductOfCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
489d5531 9207 cout<<"t = "<<t<<endl;
9208 cout<<"pe = "<<pe<<endl;
9209 cout<<"mci1 = "<<mci1<<endl;
9210 cout<<"mci2 = "<<mci2<<endl;
9211 }
9212 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9213 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9214 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9215 // corrections:
9216 diffFlowCorrectionsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9217 if(!diffFlowCorrectionsProList[t][pe])
9218 {
9219 cout<<"WARNING: diffFlowCorrectionsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9220 cout<<"t = "<<t<<endl;
9221 cout<<"pe = "<<pe<<endl;
9222 exit(0);
9223 }
9224 // correction terms for NUA:
9225 for(Int_t sc=0;sc<2;sc++) // sin or cos
9226 {
9227 for(Int_t cti=0;cti<9;cti++) // correction term index
9228 {
9229 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)));
9230 if(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti])
9231 {
9232 this->SetDiffFlowCorrectionTermsForNUAPro(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti],t,pe,sc,cti);
9233 } else
9234 {
9235 cout<<"WARNING: diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9236 cout<<"t = "<<t<<endl;
9237 cout<<"pe = "<<pe<<endl;
9238 cout<<"sc = "<<sc<<endl;
9239 cout<<"cti = "<<cti<<endl;
9240 }
9241 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
9242 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9243 // ...
9244 } // end of for(Int_t pe=0;pe<2;pe++)
9245 } // end of for(Int_t t=0;t<2;t++)
9246
1268c371 9247 // f) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold:
489d5531 9248 // reduced correlations:
9249 TList *diffFlowCorrelationsHistList[2][2] = {{NULL}};
9250 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";
9251 diffFlowCorrelationsHistName += fAnalysisLabel->Data();
9252 TH1D *diffFlowCorrelationsHist[2][2][4] = {{{NULL}}};
9253 // corrections for NUA:
9254 TList *diffFlowCorrectionsHistList[2][2] = {{NULL}};
9255 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";
9256 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
9257 TH1D *diffFlowCorrectionTermsForNUAHist[2][2][2][10] = {{{{NULL}}}};
9258 // differential Q-cumulants:
9259 TList *diffFlowCumulantsHistList[2][2] = {{NULL}};
9260 TString diffFlowCumulantsName = "fDiffFlowCumulants";
9261 diffFlowCumulantsName += fAnalysisLabel->Data();
9262 TH1D *diffFlowCumulants[2][2][4] = {{{NULL}}};
1268c371 9263 // detector bias to differential Q-cumulants:
9264 TList *diffFlowDetectorBiasHistList[2][2] = {{NULL}};
9265 TString diffFlowDetectorBiasName = "fDiffFlowDetectorBias";
9266 diffFlowDetectorBiasName += fAnalysisLabel->Data();
9267 TH1D *diffFlowDetectorBias[2][2][4] = {{{NULL}}};
489d5531 9268 // differential flow estimates from Q-cumulants:
9269 TList *diffFlowHistList[2][2] = {{NULL}};
9270 TString diffFlowName = "fDiffFlow";
9271 diffFlowName += fAnalysisLabel->Data();
9272 TH1D *diffFlow[2][2][4] = {{{NULL}}};
9273 // differential covariances:
9274 TList *diffFlowCovariancesHistList[2][2] = {{NULL}};
9275 TString diffFlowCovariancesName = "fDiffFlowCovariances";
9276 diffFlowCovariancesName += fAnalysisLabel->Data();
9277 TH1D *diffFlowCovariances[2][2][5] = {{{NULL}}};
9278 for(Int_t t=0;t<2;t++) // type: RP or POI
9279 {
62e36168 9280 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9281 {
9282 // reduced correlations:
9283 diffFlowCorrelationsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9284 if(!diffFlowCorrelationsHistList[t][pe])
9285 {
9286 cout<<"WARNING: diffFlowCorrelationsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9287 cout<<"t = "<<t<<endl;
9288 cout<<"pe = "<<pe<<endl;
9289 exit(0);
9290 }
9291 for(Int_t index=0;index<4;index++)
9292 {
9293 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())));
9294 if(diffFlowCorrelationsHist[t][pe][index])
9295 {
9296 this->SetDiffFlowCorrelationsHist(diffFlowCorrelationsHist[t][pe][index],t,pe,index);
9297 } else
9298 {
9299 cout<<"WARNING: diffFlowCorrelationsHist[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9300 cout<<"t = "<<t<<endl;
9301 cout<<"pe = "<<pe<<endl;
9302 cout<<"index = "<<index<<endl;
9303 exit(0);
9304 }
9305 } // end of for(Int_t index=0;index<4;index++)
9306 // corrections:
9307 diffFlowCorrectionsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9308 if(!diffFlowCorrectionsHistList[t][pe])
9309 {
9310 cout<<"WARNING: diffFlowCorrectionsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9311 cout<<"t = "<<t<<endl;
9312 cout<<"pe = "<<pe<<endl;
9313 exit(0);
9314 }
9315 // correction terms for NUA:
9316 for(Int_t sc=0;sc<2;sc++) // sin or cos
9317 {
9318 for(Int_t cti=0;cti<9;cti++) // correction term index
9319 {
9320 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)));
9321 if(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti])
9322 {
9323 this->SetDiffFlowCorrectionTermsForNUAHist(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti],t,pe,sc,cti);
9324 } else
9325 {
9326 cout<<"WARNING: diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9327 cout<<"t = "<<t<<endl;
9328 cout<<"pe = "<<pe<<endl;
9329 cout<<"sc = "<<sc<<endl;
9330 cout<<"cti = "<<cti<<endl;
9331 }
9332 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
9333 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9334 // ...
9335 // differential Q-cumulants:
9336 diffFlowCumulantsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9337 if(!diffFlowCumulantsHistList[t][pe])
9338 {
9339 cout<<"WARNING: diffFlowCumulantsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9340 cout<<"t = "<<t<<endl;
9341 cout<<"pe = "<<pe<<endl;
9342 exit(0);
9343 }
9344 for(Int_t index=0;index<4;index++)
9345 {
9346 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())));
9347 if(diffFlowCumulants[t][pe][index])
9348 {
9349 this->SetDiffFlowCumulants(diffFlowCumulants[t][pe][index],t,pe,index);
9350 } else
9351 {
9352 cout<<"WARNING: diffFlowCumulants[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9353 cout<<"t = "<<t<<endl;
9354 cout<<"pe = "<<pe<<endl;
9355 cout<<"index = "<<index<<endl;
9356 exit(0);
9357 }
9358 } // end of for(Int_t index=0;index<4;index++)
1268c371 9359 // Detector bias to differential Q-cumulants:
9360 diffFlowDetectorBiasHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Detector bias (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9361 if(!diffFlowDetectorBiasHistList[t][pe])
9362 {
9363 cout<<"WARNING: diffFlowDetectorBiasHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9364 cout<<"t = "<<t<<endl;
9365 cout<<"pe = "<<pe<<endl;
9366 exit(0);
9367 }
9368 for(Int_t index=0;index<4;index++)
9369 {
9370 diffFlowDetectorBias[t][pe][index] = dynamic_cast<TH1D*>(diffFlowDetectorBiasHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowDetectorBiasName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data())));
9371 if(diffFlowDetectorBias[t][pe][index])
9372 {
9373 this->SetDiffFlowDetectorBias(diffFlowDetectorBias[t][pe][index],t,pe,index);
9374 } else
9375 {
9376 cout<<"WARNING: diffFlowDetectorBias[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9377 cout<<"t = "<<t<<endl;
9378 cout<<"pe = "<<pe<<endl;
9379 cout<<"index = "<<index<<endl;
9380 exit(0);
9381 }
9382 } // end of for(Int_t index=0;index<4;index++)
489d5531 9383 // differential flow estimates from Q-cumulants:
9384 diffFlowHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9385 if(!diffFlowHistList[t][pe])
9386 {
9387 cout<<"WARNING: diffFlowHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9388 cout<<"t = "<<t<<endl;
9389 cout<<"pe = "<<pe<<endl;
9390 exit(0);
9391 }
9392 for(Int_t index=0;index<4;index++)
9393 {
9394 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())));
9395 if(diffFlow[t][pe][index])
9396 {
9397 this->SetDiffFlow(diffFlow[t][pe][index],t,pe,index);
9398 } else
9399 {
9400 cout<<"WARNING: diffFlow[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9401 cout<<"t = "<<t<<endl;
9402 cout<<"pe = "<<pe<<endl;
9403 cout<<"index = "<<index<<endl;
9404 exit(0);
9405 }
9406 } // end of for(Int_t index=0;index<4;index++)
9407 // differential covariances:
9408 diffFlowCovariancesHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9409 if(!diffFlowCovariancesHistList[t][pe])
9410 {
9411 cout<<"WARNING: diffFlowCovariancesHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9412 cout<<"t = "<<t<<endl;
9413 cout<<"pe = "<<pe<<endl;
9414 exit(0);
9415 }
9416 for(Int_t covIndex=0;covIndex<5;covIndex++)
9417 {
9418 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())));
9419 if(diffFlowCovariances[t][pe][covIndex])
9420 {
9421 this->SetDiffFlowCovariances(diffFlowCovariances[t][pe][covIndex],t,pe,covIndex);
9422 } else
9423 {
9424 cout<<"WARNING: diffFlowCovariances[t][pe][covIndex] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9425 cout<<"t = "<<t<<endl;
9426 cout<<"pe = "<<pe<<endl;
9427 cout<<"covIndex = "<<covIndex<<endl;
9428 exit(0);
9429 }
9430 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9431 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9432 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9433 // sum of event weights for reduced correlations:
9434 TList *diffFlowSumOfEventWeightsHistList[2][2][2] = {{{NULL}}};
9435 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";
9436 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();
9437 TH1D *diffFlowSumOfEventWeights[2][2][2][4] = {{{{NULL}}}};
9438 for(Int_t t=0;t<2;t++) // type is RP or POI
9439 {
62e36168 9440 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9441 {
9442 for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2
9443 {
9444 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())));
9445 if(!diffFlowSumOfEventWeightsHistList[t][pe][p])
9446 {
9447 cout<<"WARNING: diffFlowSumOfEventWeightsHistList[t][pe][p] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9448 cout<<"t = "<<t<<endl;
9449 cout<<"pe = "<<pe<<endl;
9450 cout<<"power = "<<p<<endl;
9451 exit(0);
9452 }
9453 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation
9454 {
9455 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())));
9456 if(diffFlowSumOfEventWeights[t][pe][p][ew])
9457 {
9458 this->SetDiffFlowSumOfEventWeights(diffFlowSumOfEventWeights[t][pe][p][ew],t,pe,p,ew);
9459 } else
9460 {
9461 cout<<"WARNING: diffFlowSumOfEventWeights[t][pe][p][ew] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9462 cout<<"t = "<<t<<endl;
9463 cout<<"pe = "<<pe<<endl;
9464 cout<<"power = "<<p<<endl;
9465 cout<<"ew = "<<ew<<endl;
9466 exit(0);
9467 }
9468 }
9469 } // end of for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2
9470 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9471 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI
9472 //
9473 TList *diffFlowSumOfProductOfEventWeightsHistList[2][2] = {{NULL}};
9474 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";
9475 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
9476 TH1D *diffFlowSumOfProductOfEventWeights[2][2][8][8] = {{{{NULL}}}};
9477 for(Int_t t=0;t<2;t++) // type is RP or POI
9478 {
62e36168 9479 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9480 {
9481 diffFlowSumOfProductOfEventWeightsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9482 if(!diffFlowSumOfProductOfEventWeightsHistList[t][pe])
9483 {
9484 cout<<"WARNING: diffFlowSumOfProductOfEventWeightsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9485 cout<<"t = "<<t<<endl;
9486 cout<<"pe = "<<pe<<endl;
9487 exit(0);
9488 }
9489 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9490 {
9491 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9492 {
9493 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())));
9494 if(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2])
9495 {
9496 this->SetDiffFlowSumOfProductOfEventWeights(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2],t,pe,mci1,mci2);
9497 } else
9498 {
9499 cout<<"WARNING: diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9500 cout<<"t = "<<t<<endl;
9501 cout<<"pe = "<<pe<<endl;
9502 cout<<"mci1 = "<<mci1<<endl;
9503 cout<<"mci2 = "<<mci2<<endl;
9504 exit(0);
9505 }
9506 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9507 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9508 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9509 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9510 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI
9511
9512} // end void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms()
9513
489d5531 9514//================================================================================================================================
9515
1268c371 9516void AliFlowAnalysisWithQCumulants::BookEverythingFor2DDifferentialFlow()
9517{
9518 // Book all objects needed for 2D differential flow.
9519 // a) Define flags locally (to be improved: should I promote flags to data members?);
9520 // b) Book e-b-e quantities;
9521 // c) Book 2D profiles;
9522 // d) Book 2D histograms.
9523
9524 if(!fCalculate2DDiffFlow){return;}
9525
9526 // a) Define flags locally (to be improved: should I promote flags to data members?):
9527 TString typeFlag[2] = {"RP","POI"};
9528 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
9529 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9530 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9531
9532 // b) Book e-b-e quantities:
9533 TProfile2D styleRe("typeMultiplePowerRe","typeMultiplePowerRe",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9534 TProfile2D styleIm("typeMultiplePowerIm","typeMultiplePowerIm",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9535 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9536 {
9537 for(Int_t m=0;m<4;m++)
9538 {
9539 for(Int_t k=0;k<9;k++)
9540 {
9541 fReRPQ2dEBE[t][m][k] = (TProfile2D*)styleRe.Clone(Form("typeFlag%dmultiple%dpower%dRe",t,m,k));
9542 fImRPQ2dEBE[t][m][k] = (TProfile2D*)styleIm.Clone(Form("typeFlag%dmultiple%dpower%dIm",t,m,k));
9543 }
9544 }
9545 }
9546 TProfile2D styleS("typePower","typePower",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9547 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9548 {
9549 for(Int_t k=0;k<9;k++)
9550 {
9551 fs2dEBE[t][k] = (TProfile2D*)styleS.Clone(Form("typeFlag%dpower%d",t,k));
9552 }
9553 }
9554
9555 // c) Book 2D profiles:
9556 TString s2DDiffFlowCorrelationsProName = "f2DDiffFlowCorrelationsPro";
9557 s2DDiffFlowCorrelationsProName += fAnalysisLabel->Data();
9558 for(Int_t t=0;t<2;t++) // type: RP or POI
9559 {
9560 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9561 {
9562 f2DDiffFlowCorrelationsPro[t][rci] = new TProfile2D(Form("%s, %s, %s",s2DDiffFlowCorrelationsProName.Data(),typeFlag[t].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s",s2DDiffFlowCorrelationsProName.Data(),typeFlag[t].Data(),reducedCorrelationIndex[rci].Data()),fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax,"");
9563 f2DDiffFlowCorrelationsPro[t][rci]->Sumw2();
9564 f2DDiffFlowCorrelationsPro[t][rci]->SetXTitle("p_{t}");
9565 f2DDiffFlowCorrelationsPro[t][rci]->SetYTitle("#eta");
9566 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlowCorrelationsPro[t][rci]);
9567 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9568 } // end of for(Int_t t=0;t<2;t++) // type: RP or POIs
9569
9570 // d) Book 2D histograms:
9571 TString s2DDiffFlowCumulantsName = "f2DDiffFlowCumulants";
9572 s2DDiffFlowCumulantsName += fAnalysisLabel->Data();
9573 TString s2DDiffFlowName = "f2DDiffFlow";
9574 s2DDiffFlowName += fAnalysisLabel->Data();
9575 for(Int_t t=0;t<2;t++) // type: RP or POI
9576 {
9577 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9578 {
9579 // 2D diferential cumulants:
9580 f2DDiffFlowCumulants[t][rci] = new TH2D(Form("%s, %s, %s",s2DDiffFlowCumulantsName.Data(),typeFlag[t].Data(),differentialCumulantIndex[rci].Data()),Form("%s, %s, %s",s2DDiffFlowCumulantsName.Data(),typeFlag[t].Data(),differentialCumulantIndex[rci].Data()),fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9581 f2DDiffFlowCumulants[t][rci]->SetXTitle("p_{t}");
9582 f2DDiffFlowCumulants[t][rci]->SetYTitle("#eta");
9583 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlowCumulants[t][rci]); // to be improved - moved to another list
9584 // 2D differential flow:
9585 f2DDiffFlow[t][rci] = new TH2D(Form("%s, %s, %s",s2DDiffFlowName.Data(),typeFlag[t].Data(),differentialFlowIndex[rci].Data()),Form("%s, %s, %s",s2DDiffFlowName.Data(),typeFlag[t].Data(),differentialFlowIndex[rci].Data()),fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9586 f2DDiffFlow[t][rci]->SetXTitle("p_{t}");
9587 f2DDiffFlow[t][rci]->SetYTitle("#eta");
9588 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlow[t][rci]); // to be improved - moved to another list
9589 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9590 } // end of for(Int_t t=0;t<2;t++) // type: RP or POIs
9591
9592} // void AliFlowAnalysisWithQCumulants::BookEverythingFor2DDifferentialFlow()
9593
9594//================================================================================================================================
489d5531 9595
9596void AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()
9597{
9598 // Book all histograms and profiles needed for differential flow.
1268c371 9599 // a) Book profile to hold all flags for differential flow;
9600 // b) Define flags locally (to be improved: should I promote flags to data members?);
489d5531 9601 // c) Book e-b-e quantities;
9602 // d) Book profiles;
9603 // e) Book histograms holding final results.
9604
1268c371 9605 // a) Book profile to hold all flags for differential flow:
9606 TString diffFlowFlagsName = "fDiffFlowFlags";
9607 diffFlowFlagsName += fAnalysisLabel->Data();
62e36168 9608 fDiffFlowFlags = new TProfile(diffFlowFlagsName.Data(),"Flags for differential flow",6,0,6);
1268c371 9609 fDiffFlowFlags->SetTickLength(-0.01,"Y");
9610 fDiffFlowFlags->SetMarkerStyle(25);
9611 fDiffFlowFlags->SetLabelSize(0.04,"X");
9612 fDiffFlowFlags->SetLabelOffset(0.02,"Y");
9613 fDiffFlowFlags->GetXaxis()->SetBinLabel(1,"Calculate diff. flow");
9614 fDiffFlowFlags->GetXaxis()->SetBinLabel(2,"Particle weights");
9615 fDiffFlowFlags->GetXaxis()->SetBinLabel(3,"Event weights");
9616 fDiffFlowFlags->GetXaxis()->SetBinLabel(4,"Correct for NUA");
9617 fDiffFlowFlags->GetXaxis()->SetBinLabel(5,"Calculate 2D diff. flow");
62e36168 9618 fDiffFlowFlags->GetXaxis()->SetBinLabel(6,"Calculate diff. flow vs eta");
1268c371 9619 fDiffFlowList->Add(fDiffFlowFlags);
9620
9621 if(!fCalculateDiffFlow){return;}
9622
9623 // b) Define flags locally (to be improved: should I promote flags to data members?):
489d5531 9624 TString typeFlag[2] = {"RP","POI"};
9625 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9626 TString powerFlag[2] = {"linear","quadratic"};
9627 TString sinCosFlag[2] = {"sin","cos"};
9628 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9629 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9630 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
b40a910e 9631 TString reducedSquaredCorrelationIndex[4] = {"<2'>^{2}","<4'>^{2}","<6'>^{2}","<8'>^{2}"};
489d5531 9632 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};
9633 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"};
9634 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
9635 Double_t minPtEta[2] = {fPtMin,fEtaMin};
9636 Double_t maxPtEta[2] = {fPtMax,fEtaMax};
1268c371 9637
489d5531 9638 // c) Book e-b-e quantities:
9639 // Event-by-event r_{m*n,k}(pt,eta), p_{m*n,k}(pt,eta) and q_{m*n,k}(pt,eta)
9640 // Explanantion of notation:
9641 // 1.) n is harmonic, m is multiple of harmonic;
9642 // 2.) k is power of particle weight;
9643 // 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);
9644 // 4.) p_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for POIs in particular (pt,eta) bin
9645 // (if i-th POI is also RP, than it is weighted with w_i^k);
9646 // 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
9647 // (i-th RP&&POI is weighted with w_i^k)
9648
9649 // 1D:
9650 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP && POI )
9651 {
62e36168 9652 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9653 {
9654 for(Int_t m=0;m<4;m++) // multiple of harmonic
9655 {
9656 for(Int_t k=0;k<9;k++) // power of particle weight
9657 {
9658 fReRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),
9659 Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9660 fImRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),
9661 Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9662 }
9663 }
9664 }
9665 }
9666 // to be improved (add explanation of fs1dEBE[t][pe][k]):
9667 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9668 {
62e36168 9669 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9670 {
9671 for(Int_t k=0;k<9;k++) // power of particle weight
9672 {
9673 fs1dEBE[t][pe][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),
9674 Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9675 }
9676 }
9677 }
9678 // correction terms for nua:
9679 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9680 {
62e36168 9681 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9682 {
9683 for(Int_t sc=0;sc<2;sc++) // sin or cos
9684 {
9685 for(Int_t cti=0;cti<9;cti++) // correction term index
9686 {
9687 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = new TH1D(Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),
9688 Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9689 }
9690 }
9691 }
9692 }
489d5531 9693 // reduced correlations e-b-e:
9694 TString diffFlowCorrelationsEBEName = "fDiffFlowCorrelationsEBE";
9695 diffFlowCorrelationsEBEName += fAnalysisLabel->Data();
9696 for(Int_t t=0;t<2;t++) // type: RP or POI
9697 {
62e36168 9698 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9699 {
9700 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9701 {
9702 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]);
9703 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9704 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9705 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9706 // event weights for reduced correlations e-b-e:
9707 TString diffFlowEventWeightsForCorrelationsEBEName = "fDiffFlowEventWeightsForCorrelationsEBE";
9708 diffFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
9709 for(Int_t t=0;t<2;t++) // type: RP or POI
9710 {
62e36168 9711 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9712 {
9713 for(Int_t rci=0;rci<4;rci++) // event weight for reduced correlation index
9714 {
9715 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]);
9716 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9717 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9718 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9719
9720 // d) Book profiles;
9721 // reduced correlations:
9722 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";
9723 diffFlowCorrelationsProName += fAnalysisLabel->Data();
b40a910e 9724 // reduced squared correlations:
9725 TString diffFlowSquaredCorrelationsProName = "fDiffFlowSquaredCorrelationsPro";
9726 diffFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
489d5531 9727 // corrections terms:
9728 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";
9729 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
b40a910e 9730 // reduced correlations:
489d5531 9731 for(Int_t t=0;t<2;t++) // type: RP or POI
9732 {
62e36168 9733 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9734 {
9735 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9736 {
489d5531 9737 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");
b40a910e 9738 fDiffFlowCorrelationsPro[t][pe][rci]->Sumw2();
489d5531 9739 fDiffFlowCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
9740 fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
9741 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9742 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9743 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
b40a910e 9744 // reduced squared correlations:
9745 for(Int_t t=0;t<2;t++) // type: RP or POI
9746 {
62e36168 9747 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
b40a910e 9748 {
9749 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9750 {
9751 fDiffFlowSquaredCorrelationsPro[t][pe][rci] = new TProfile(Form("%s, %s, %s, %s",diffFlowSquaredCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedSquaredCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowSquaredCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedSquaredCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe],"s");
9752 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->Sumw2();
9753 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
9754 fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowSquaredCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
9755 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9756 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9757 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
489d5531 9758 // correction terms for nua:
9759 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9760 {
62e36168 9761 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9762 {
9763 for(Int_t sc=0;sc<2;sc++) // sin or cos
9764 {
9765 for(Int_t cti=0;cti<9;cti++) // correction term index
9766 {
9767 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]);
9768 fDiffFlowCorrectionsProList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]);
9769 }
9770 }
9771 }
9772 }
64e500e3 9773 // Other differential correlators:
9774 TString otherDiffCorrelatorsName = "fOtherDiffCorrelators";
9775 otherDiffCorrelatorsName += fAnalysisLabel->Data();
9776 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9777 {
62e36168 9778 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 9779 {
9780 for(Int_t sc=0;sc<2;sc++) // sin or cos
9781 {
9782 for(Int_t ci=0;ci<1;ci++) // correlator index
9783 {
9784 fOtherDiffCorrelators[t][pe][sc][ci] = new TProfile(Form("%s, %s, %s, %s, ci = %d",otherDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1),Form("%s, %s, %s, %s, ci = %d",otherDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9785 fOtherDiffCorrelators[t][pe][sc][ci]->Sumw2();
9786 fOtherDiffCorrelatorsList->Add(fOtherDiffCorrelators[t][pe][sc][ci]);
9787 }
9788 }
9789 }
9790 }
489d5531 9791 // e) Book histograms holding final results.
9792 // reduced correlations:
9793 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";
9794 diffFlowCorrelationsHistName += fAnalysisLabel->Data();
9795 // corrections terms:
9796 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";
9797 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
9798 // differential covariances:
9799 TString diffFlowCovariancesName = "fDiffFlowCovariances";
9800 diffFlowCovariancesName += fAnalysisLabel->Data();
9801 // differential Q-cumulants:
9802 TString diffFlowCumulantsName = "fDiffFlowCumulants";
9803 diffFlowCumulantsName += fAnalysisLabel->Data();
1268c371 9804 // Detector bias to differential Q-cumulants:
9805 TString diffFlowDetectorBiasName = "fDiffFlowDetectorBias";
9806 diffFlowDetectorBiasName += fAnalysisLabel->Data();
489d5531 9807 // differential flow:
9808 TString diffFlowName = "fDiffFlow";
9809 diffFlowName += fAnalysisLabel->Data();
9810 for(Int_t t=0;t<2;t++) // type: RP or POI
9811 {
62e36168 9812 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9813 {
9814 for(Int_t index=0;index<4;index++)
9815 {
9816 // reduced correlations:
9817 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]);
9818 fDiffFlowCorrelationsHist[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9819 fDiffFlowCorrelationsHistList[t][pe]->Add(fDiffFlowCorrelationsHist[t][pe][index]);
9820 // differential Q-cumulants:
9821 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]);
9822 fDiffFlowCumulants[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9823 fDiffFlowCumulantsHistList[t][pe]->Add(fDiffFlowCumulants[t][pe][index]);
1268c371 9824 // Detector bias to differential Q-cumulants:
9825 fDiffFlowDetectorBias[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowDetectorBiasName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowDetectorBiasName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9826 fDiffFlowDetectorBias[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9827 fDiffFlowDetectorBias[t][pe][index]->SetTitle(Form("#frac{corrected}{measured} %s",differentialCumulantIndex[index].Data()));
9828 fDiffFlowDetectorBiasHistList[t][pe]->Add(fDiffFlowDetectorBias[t][pe][index]);
489d5531 9829 // differential flow estimates from Q-cumulants:
9830 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]);
9831 fDiffFlow[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9832 fDiffFlowHistList[t][pe]->Add(fDiffFlow[t][pe][index]);
9833 } // end of for(Int_t index=0;index<4;index++)
9834 for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9835 {
9836 // differential covariances:
9837 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]);
9838 fDiffFlowCovariances[t][pe][covIndex]->SetXTitle(ptEtaFlag[pe].Data());
9839 fDiffFlowCovariancesHistList[t][pe]->Add(fDiffFlowCovariances[t][pe][covIndex]);
9840 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9841 // products of both types of correlations:
9842 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";
9843 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
9844 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9845 {
9846 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9847 {
9848 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]);
9849 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());
9850 fDiffFlowProductOfCorrelationsProList[t][pe]->Add(fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]);
9851 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9852 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9853 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9854 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9855 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9856 // sums of event weights for reduced correlations:
9857 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";
9858 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();
9859 for(Int_t t=0;t<2;t++) // type is RP or POI
9860 {
62e36168 9861 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9862 {
9863 for(Int_t p=0;p<2;p++) // power of weights is either 1 or 2
9864 {
9865 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation
9866 {
9867 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]);
9868 fDiffFlowSumOfEventWeights[t][pe][p][ew]->SetXTitle(ptEtaFlag[pe].Data());
9869 fDiffFlowSumOfEventWeightsHistList[t][pe][p]->Add(fDiffFlowSumOfEventWeights[t][pe][p][ew]); // to be improved (add dedicated list to hold all this)
9870 }
9871 }
9872 }
9873 }
9874 // sum of products of event weights for both types of correlations:
9875 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";
9876 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
9877 for(Int_t t=0;t<2;t++) // type is RP or POI
9878 {
62e36168 9879 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9880 {
9881 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9882 {
9883 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9884 {
9885 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]);
9886 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());
9887 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->Add(fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]);
9888 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9889 }
9890 }
9891 }
9892 }
9893 // correction terms for nua:
9894 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9895 {
62e36168 9896 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9897 {
9898 for(Int_t sc=0;sc<2;sc++) // sin or cos
9899 {
9900 for(Int_t cti=0;cti<9;cti++) // correction term index
9901 {
9902 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]);
9903 fDiffFlowCorrectionsHistList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]);
9904 }
9905 }
9906 }
9907 }
9908
9909} // end of AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()
9910
489d5531 9911//================================================================================================================================
9912
489d5531 9913void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()
9914{
9915 // Calculate generalized Q-cumulants (cumulants corrected for non-unifom acceptance).
9916
b92ea2b9 9917 // Isotropic cumulants:
2701c4bc 9918 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1);
9919 Double_t qc2Error = fIntFlowQcumulants->GetBinError(1);
9920 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2);
9921 Double_t qc4Error = fIntFlowQcumulants->GetBinError(2);
9922 //Double_t qc6 = fIntFlowQcumulants->GetBinContent(3);
9923 //Double_t qc6Error = fIntFlowQcumulants->GetBinError(3);
9924 //Double_t qc8 = fIntFlowQcumulants->GetBinContent(4);
9925 //Double_t qc8Error = fIntFlowQcumulants->GetBinError(4);
b92ea2b9 9926
9927 // Measured 2-, 4-, 6- and 8-particle correlations:
489d5531 9928 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
b92ea2b9 9929 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <<2>>
489d5531 9930 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
b92ea2b9 9931 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <<4>>
489d5531 9932 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
489d5531 9933 //Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <<6>>
b92ea2b9 9934 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
489d5531 9935 //Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <<8>>
b92ea2b9 9936
9937 // Non-isotropic terms:
9938 Double_t c1 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>
9939 Double_t c1Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(1); // statistical error of <<cos(n*phi1)>>
9940 Double_t c2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>
9941 Double_t c2Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(2); // statistical error of <<cos(n*(phi1+phi2))>>
9942 Double_t c3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>
9943 Double_t c3Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(3); // statistical error of <<cos(n*(phi1-phi2-phi3))>>
9944 Double_t s1 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>
9945 Double_t s1Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(1); // statistical error of <<sin(n*phi1)>>
9946 Double_t s2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>
9947 Double_t s2Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(2); // statistical error of <<sin(n*(phi1+phi2))>>
9948 Double_t s3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>
9949 Double_t s3Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(3); // statistical error of <<sin(n*(phi1-phi2-phi3))>>
9950
9951 // Shortcuts:
9952 Double_t a1 = 2.*pow(c1,2.)+2.*pow(s1,2.)-two;
9953 Double_t a2 = 6.*pow(c1,3.)-2.*c1*c2+c3+6.*c1*pow(s1,2.)-2.*s1*s2-4.*c1*two;
9954 Double_t a3 = 2.*pow(s1,2.)-2.*pow(c1,2.)+c2;
9955 Double_t a4 = 6.*pow(s1,3.)+6.*pow(c1,2.)*s1+2.*c2*s1-2.*c1*s2-s3-4.*s1*two;
9956 Double_t a5 = 4.*c1*s1-s2;
9957
9958 // Covariances (including weight dependent prefactor):
8e1cefdd 9959 Double_t wCov1 = 0.; // w*Cov(<2>,<cos(phi))
9960 Double_t wCov2 = 0.; // w*Cov(<2>,<sin(phi))
9961 Double_t wCov3 = 0.; // w*Cov(<cos(phi),<sin(phi))
9962 Double_t wCov4 = 0.; // w*Cov(<2>,<4>)
9963 Double_t wCov5 = 0.; // w*Cov(<2>,<cos(#phi_{1}+#phi_{2})>)
9964 Double_t wCov6 = 0.; // w*Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9965 Double_t wCov7 = 0.; // w*Cov(<2>,<sin(#phi_{1}+#phi_{2})>)
9966 Double_t wCov8 = 0.; // w*Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9967 Double_t wCov9 = 0.; // w*Cov(<4>,<cos(#phi)>
9968 Double_t wCov10 = 0.; // w*Cov(<4>,<cos(#phi_{1}+#phi_{2})>)
9969 Double_t wCov11 = 0.; // w*Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9970 Double_t wCov12 = 0.; // w*Cov(<4>,<sin(#phi)>
9971 Double_t wCov13 = 0.; // w*Cov(<4>,<sin(#phi_{1}+#phi_{2})>)
9972 Double_t wCov14 = 0.; // w*Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9973 Double_t wCov15 = 0.; // w*Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)
9974 Double_t wCov16 = 0.; // w*Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9975 Double_t wCov17 = 0.; // w*Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)
9976 Double_t wCov18 = 0.; // w*Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9977 Double_t wCov19 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9978 Double_t wCov20 = 0.; // w*Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)
9979 Double_t wCov21 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)
9980 Double_t wCov22 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9981 Double_t wCov23 = 0.; // w*Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9982 Double_t wCov24 = 0.; // w*Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9983 Double_t wCov25 = 0.; // w*Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)
9984 Double_t wCov26 = 0.; // w*Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)
9985 Double_t wCov27 = 0.; // w*Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9986 Double_t wCov28 = 0.; // w*Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9987 if(!fForgetAboutCovariances)
9988 {
9989 wCov1 = fIntFlowCovariancesNUA->GetBinContent(1); // w*Cov(<2>,<cos(phi))
9990 wCov2 = fIntFlowCovariancesNUA->GetBinContent(2); // w*Cov(<2>,<sin(phi))
9991 wCov3 = fIntFlowCovariancesNUA->GetBinContent(3); // w*Cov(<cos(phi),<sin(phi))
9992 wCov4 = fIntFlowCovariances->GetBinContent(1); // w*Cov(<2>,<4>)
9993 wCov5 = fIntFlowCovariancesNUA->GetBinContent(4); // w*Cov(<2>,<cos(#phi_{1}+#phi_{2})>)
9994 wCov6 = fIntFlowCovariancesNUA->GetBinContent(6); // w*Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
9995 wCov7 = fIntFlowCovariancesNUA->GetBinContent(5); // w*Cov(<2>,<sin(#phi_{1}+#phi_{2})>)
9996 wCov8 = fIntFlowCovariancesNUA->GetBinContent(7); // w*Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
9997 wCov9 = fIntFlowCovariancesNUA->GetBinContent(8); // w*Cov(<4>,<cos(#phi)>
9998 wCov10 = fIntFlowCovariancesNUA->GetBinContent(10); // w*Cov(<4>,<cos(#phi_{1}+#phi_{2})>)
9999 wCov11 = fIntFlowCovariancesNUA->GetBinContent(12); // w*Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10000 wCov12 = fIntFlowCovariancesNUA->GetBinContent(9); // w*Cov(<4>,<sin(#phi)>
10001 wCov13 = fIntFlowCovariancesNUA->GetBinContent(11); // w*Cov(<4>,<sin(#phi_{1}+#phi_{2})>)
10002 wCov14 = fIntFlowCovariancesNUA->GetBinContent(13); // w*Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10003 wCov15 = fIntFlowCovariancesNUA->GetBinContent(14); // w*Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10004 wCov16 = fIntFlowCovariancesNUA->GetBinContent(16); // w*Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10005 wCov17 = fIntFlowCovariancesNUA->GetBinContent(15); // w*Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10006 wCov18 = fIntFlowCovariancesNUA->GetBinContent(17); // w*Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10007 wCov19 = fIntFlowCovariancesNUA->GetBinContent(23); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10008 wCov20 = fIntFlowCovariancesNUA->GetBinContent(18); // w*Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10009 wCov21 = fIntFlowCovariancesNUA->GetBinContent(22); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)
10010 wCov22 = fIntFlowCovariancesNUA->GetBinContent(24); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10011 wCov23 = fIntFlowCovariancesNUA->GetBinContent(20); // w*Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10012 wCov24 = fIntFlowCovariancesNUA->GetBinContent(25); // w*Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10013 wCov25 = fIntFlowCovariancesNUA->GetBinContent(27); // w*Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)
10014 wCov26 = fIntFlowCovariancesNUA->GetBinContent(19); // w*Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10015 wCov27 = fIntFlowCovariancesNUA->GetBinContent(21); // w*Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10016 wCov28 = fIntFlowCovariancesNUA->GetBinContent(26); // w*Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10017 } // end of if(!fForgetAboutCovariances)
10018
b92ea2b9 10019 // Calculating generalized QC{2}:
10020 // Generalized QC{2}:
10021 Double_t gQC2 = two - pow(c1,2.) - pow(s1,2.);
10022 if(fApplyCorrectionForNUA){fIntFlowQcumulants->SetBinContent(1,gQC2);}
10023 // Statistical error of generalized QC{2}:
10024 Double_t gQC2ErrorSquared = pow(twoError,2.)+4.*pow(c1,2.)*pow(c1Error,2.)
10025 + 4.*pow(s1,2.)*pow(s1Error,2.)
10026 - 4*c1*wCov1-4*s1*wCov2
10027 + 8.*c1*s1*wCov3;
10028 // Store ratio of error squared - with/without NUA terms:
10029 Double_t ratioErrorSquaredQC2 = 0.;
10030 if(fIntFlowQcumulants->GetBinError(1)>0.)
10031 {
10032 ratioErrorSquaredQC2 = (gQC2ErrorSquared/pow(fIntFlowQcumulants->GetBinError(1),2.));
10033 fIntFlowQcumulantsErrorSquaredRatio->SetBinContent(1,ratioErrorSquaredQC2);
10034 }
10035 // If enabled, store error by including non-isotropic terms:
b77b6434 10036 if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10037 {
10038 if(gQC2ErrorSquared>=0.)
10039 {
10040 fIntFlowQcumulants->SetBinError(1,pow(gQC2ErrorSquared,0.5));
10041 } else
10042 {
10043 fIntFlowQcumulants->SetBinError(1,0.);
10044 cout<<endl;
10045 cout<<" WARNING (QC): Statistical error of generalized QC{2} is imaginary !!!!"<<endl;
10046 cout<<endl;
10047 }
b77b6434 10048 } // end of if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10049 // Quantify detector bias to QC{2}:
2701c4bc 10050 if(TMath::Abs(qc2)>0.)
b92ea2b9 10051 {
2701c4bc 10052 fIntFlowDetectorBias->SetBinContent(1,gQC2/qc2);
10053 if(qc2Error>0.)
b92ea2b9 10054 {
2701c4bc 10055 Double_t errorSquared = gQC2ErrorSquared/pow(qc2,2.)+pow(gQC2,2.)*pow(qc2Error,2.)/pow(qc2,4.);
b92ea2b9 10056 if(errorSquared>0.)
10057 {
10058 fIntFlowDetectorBias->SetBinError(1,pow(errorSquared,0.5));
10059 }
10060 }
2701c4bc 10061 } // end of if(TMath::Abs(qc2)>0.)
b92ea2b9 10062
10063 // Calculating generalized QC{4}:
10064 // Generalized QC{4}:
10065 Double_t gQC4 = four-2.*pow(two,2.)
10066 - 4.*c1*c3+4.*s1*s3-pow(c2,2.)-pow(s2,2.)
10067 + 4.*c2*(pow(c1,2.)-pow(s1,2.))+8.*s2*s1*c1
10068 + 8.*two*(pow(c1,2.)+pow(s1,2.))-6.*pow((pow(c1,2.)+pow(s1,2.)),2.);
10069 if(fApplyCorrectionForNUA){fIntFlowQcumulants->SetBinContent(2,gQC4);}
10070 // Statistical error of generalized QC{4}:
10071 Double_t gQC4ErrorSquared = 16.*pow(a1,2.)*pow(twoError,2.)+pow(fourError,2.)+16.*pow(a2,2.)*pow(c1Error,2.)
10072 + 4.*pow(a3,2.)*pow(c2Error,2.)+16.*pow(c1,2.)*pow(c3Error,2.)
10073 + 16.*pow(a4,2.)*pow(s1Error,2.)+4.*pow(a5,2.)*pow(s2Error,2.)
10074 + 16.*pow(s1,2.)*pow(s3Error,2.)+8.*a1*wCov4-32.*a1*a2*wCov1
10075 - 16.*a3*a1*wCov5-32.*c1*a1*wCov6-32.*a1*a4*wCov2+16.*a5*a1*wCov7
10076 + 32.*s1*a1*wCov8-8.*a2*wCov9-4.*a3*wCov10-8.*c1*wCov11-8.*a4*wCov12
10077 + 4.*a5*wCov13+8.*s1*wCov14+16.*a3*a2*wCov15+32.*c1*a2*wCov16+32.*a2*a4*wCov3
10078 - 16.*a5*a2*wCov17-32.*s1*a2*wCov18+16.*c1*a3*wCov19+16.*a3*a4*wCov20
10079 - 8.*a3*a5*wCov21-16.*s1*a3*wCov22+32.*c1*a4*wCov23-16.*c1*a5*wCov24
10080 - 32.*c1*s1*wCov25-16.*a5*a4*wCov26-32.*s1*a4*wCov27+16.*s1*a5*wCov28;
10081 // Store ratio of error squared - with/without NUA terms:
10082 Double_t ratioErrorSquaredQC4 = 0.;
10083 if(fIntFlowQcumulants->GetBinError(2)>0.)
10084 {
10085 ratioErrorSquaredQC4 = (gQC4ErrorSquared/pow(fIntFlowQcumulants->GetBinError(2),2.));
10086 fIntFlowQcumulantsErrorSquaredRatio->SetBinContent(2,ratioErrorSquaredQC4);
10087 }
b77b6434 10088 if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10089 {
10090 if(gQC4ErrorSquared>=0.)
10091 {
10092 fIntFlowQcumulants->SetBinError(2,pow(gQC4ErrorSquared,0.5));
10093 } else
10094 {
10095 fIntFlowQcumulants->SetBinError(2,0.);
10096 cout<<endl;
10097 cout<<" WARNING (QC): Statistical error of generalized QC{4} is imaginary !!!!"<<endl;
10098 cout<<endl;
10099 }
b77b6434 10100 } // end of if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10101 // Quantify detector bias to QC{4}:
2701c4bc 10102 if(TMath::Abs(qc4)>0.)
b92ea2b9 10103 {
2701c4bc 10104 fIntFlowDetectorBias->SetBinContent(2,gQC4/qc4);
10105 if(qc4Error>0.)
b92ea2b9 10106 {
2701c4bc 10107 Double_t errorSquared = gQC4ErrorSquared/pow(qc4,2.)+pow(gQC4,2.)*pow(qc4Error,2.)/pow(qc4,4.);
b92ea2b9 10108 if(errorSquared>0.)
10109 {
10110 fIntFlowDetectorBias->SetBinError(2,pow(errorSquared,0.5));
10111 }
10112 }
2701c4bc 10113 } // end of if(TMath::Abs(qc4)>0.)
489d5531 10114
b92ea2b9 10115
10116 // .... to be improved (continued for 6th and 8th order) ....
10117
10118
2001bc3a 10119 // versus multiplicity:
b77b6434 10120 if(fCalculateCumulantsVsM) // to be improved - propagate error for nua terms vs M
2001bc3a 10121 {
10122 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
b77b6434 10123 Double_t value[4] = {0.}; // QCs vs M
10124 Double_t error[4] = {0.}; // error of QCs vs M
10125 Double_t dSum1[4] = {0.}; // sum value_i/(error_i)^2
10126 Double_t dSum2[4] = {0.}; // sum 1/(error_i)^2
2001bc3a 10127 for(Int_t b=1;b<=nBins;b++)
10128 {
b92ea2b9 10129 // Measured correlations:
2001bc3a 10130 two = fIntFlowCorrelationsVsMHist[0]->GetBinContent(b); // <<2>> vs M
10131 four = fIntFlowCorrelationsVsMHist[1]->GetBinContent(b); // <<4>> vs M
b92ea2b9 10132 // Isotropic cumulants:
2701c4bc 10133 qc2 = two;
10134 qc4 = four-2.*pow(two,2.);
b92ea2b9 10135 // Non-isotropic terms:
10136 c1 = fIntFlowCorrectionTermsForNUAVsMPro[1][0]->GetBinContent(b); // <<cos(n*phi1)>>
10137 c2 = fIntFlowCorrectionTermsForNUAVsMPro[1][1]->GetBinContent(b); // <<cos(n*(phi1+phi2))>>
10138 c3 = fIntFlowCorrectionTermsForNUAVsMPro[1][2]->GetBinContent(b); // <<cos(n*(phi1-phi2-phi3))>>
10139 s1 = fIntFlowCorrectionTermsForNUAVsMPro[0][0]->GetBinContent(b); // <<sin(n*phi1)>>
10140 s2 = fIntFlowCorrectionTermsForNUAVsMPro[0][1]->GetBinContent(b); // <<sin(n*(phi1+phi2))>>
10141 s3 = fIntFlowCorrectionTermsForNUAVsMPro[0][2]->GetBinContent(b); // <<sin(n*(phi1-phi2-phi3))>>
10142 // Generalized QC{2} vs M:
10143 gQC2 = two - pow(c1,2.) - pow(s1,2.);
b77b6434 10144 if(fApplyCorrectionForNUAVsM){fIntFlowQcumulantsVsM[0]->SetBinContent(b,gQC2);}
b92ea2b9 10145 // Generalized QC{4} vs M:
10146 gQC4 = four-2.*pow(two,2.)
10147 - 4.*c1*c3+4.*s1*s3-pow(c2,2.)-pow(s2,2.)
10148 + 4.*c2*(pow(c1,2.)-pow(s1,2.))+8.*s2*s1*c1
10149 + 8.*two*(pow(c1,2.)+pow(s1,2.))-6.*pow((pow(c1,2.)+pow(s1,2.)),2.);
b77b6434 10150 if(fApplyCorrectionForNUAVsM){fIntFlowQcumulantsVsM[1]->SetBinContent(b,gQC4);}
b92ea2b9 10151 // Detector bias vs M:
2701c4bc 10152 if(TMath::Abs(qc2)>0.)
b92ea2b9 10153 {
2701c4bc 10154 fIntFlowDetectorBiasVsM[0]->SetBinContent(b,gQC2/qc2);
10155 } // end of if(TMath::Abs(qc2)>0.)
10156 if(TMath::Abs(qc4)>0.)
b92ea2b9 10157 {
2701c4bc 10158 fIntFlowDetectorBiasVsM[1]->SetBinContent(b,gQC4/qc4);
10159 } // end of if(TMath::Abs(qc4)>0.)
b77b6434 10160 // Rebin in M:
10161 for(Int_t co=0;co<4;co++)
10162 {
10163 value[co] = fIntFlowQcumulantsVsM[co]->GetBinContent(b);
10164 error[co] = fIntFlowQcumulantsVsM[co]->GetBinError(b);
10165 if(error[co]>0.)
10166 {
10167 dSum1[co]+=value[co]/(error[co]*error[co]);
10168 dSum2[co]+=1./(error[co]*error[co]);
10169 }
10170 } // end of for(Int_t co=0;co<4;co++)
10171 } // end of for(Int_t b=1;b<=nBins;b++)
10172 // Store rebinned Q-cumulants:
10173 if(fApplyCorrectionForNUAVsM)
10174 {
10175 for(Int_t co=0;co<4;co++)
10176 {
10177 if(dSum2[co]>0.)
10178 {
10179 fIntFlowQcumulantsRebinnedInM->SetBinContent(co+1,dSum1[co]/dSum2[co]);
10180 fIntFlowQcumulantsRebinnedInM->SetBinError(co+1,pow(1./dSum2[co],0.5));
10181 }
10182 } // end of for(Int_t co=0;co<4;co++)
10183 } // end of if(fApplyCorrectionForNUAVsM)
10184 } // end of if(fCalculateCumulantsVsM)
2001bc3a 10185
489d5531 10186} // end of void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()
0328db2d 10187
489d5531 10188//================================================================================================================================
10189
489d5531 10190void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()
10191{
0328db2d 10192 // From profile fIntFlowCorrectionTermsForNUAPro[sc] access measured correction terms for NUA
489d5531 10193 // and their spread, correctly calculate the statistical errors and store the final
0328db2d 10194 // results and statistical errors for correction terms for NUA in histogram fIntFlowCorrectionTermsForNUAHist[sc].
489d5531 10195 //
10196 // Remark: Statistical error of correction temrs is calculated as:
10197 //
10198 // statistical error = termA * spread * termB:
10199 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)
10200 // termB = 1/sqrt(1-termA^2)
10201
b92ea2b9 10202 TString sinCosFlag[2] = {"sin","cos"}; // to be improved - promore this to data member?
10203 TString nonisotropicTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
10204
489d5531 10205 for(Int_t sc=0;sc<2;sc++) // sin or cos correction terms
10206 {
b92ea2b9 10207 for(Int_t ci=1;ci<=4;ci++) // correction term index (to be improved - hardwired 4)
489d5531 10208 {
10209 Double_t correction = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci);
0328db2d 10210 Double_t spread = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinError(ci);
10211 Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeightsNUA[sc][0]->GetBinContent(ci);
10212 Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeightsNUA[sc][1]->GetBinContent(ci);
10213 Double_t termA = 0.;
10214 Double_t termB = 0.;
b92ea2b9 10215 if(TMath::Abs(sumOfLinearEventWeights)>1.e-44)
0328db2d 10216 {
10217 termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;
10218 } else
10219 {
b92ea2b9 10220 cout<<" WARNING (QC): sumOfLinearEventWeights == 0 in AFAWQC::FCTFNIF() !!!!"<<endl;
10221 cout<<Form(" (for <<%s[%s]>> non-isotropic term)",sinCosFlag[sc].Data(),nonisotropicTermFlag[ci-1].Data())<<endl;
0328db2d 10222 }
489d5531 10223 if(1.-pow(termA,2.) > 0.)
10224 {
10225 termB = 1./pow(1-pow(termA,2.),0.5);
10226 } else
10227 {
b92ea2b9 10228 cout<<" WARNING (QC): 1.-pow(termA,2.) <= 0 in AFAWQC::FCTFNIF() !!!!"<<endl;
10229 cout<<Form(" (for <<%s[%s]>> non-isotropic term)",sinCosFlag[sc].Data(),nonisotropicTermFlag[ci-1].Data())<<endl;
489d5531 10230 }
10231 Double_t statisticalError = termA * spread * termB;
489d5531 10232 fIntFlowCorrectionTermsForNUAHist[sc]->SetBinContent(ci,correction);
0328db2d 10233 fIntFlowCorrectionTermsForNUAHist[sc]->SetBinError(ci,statisticalError);
b92ea2b9 10234 } // end of for(Int_t ci=1;ci<=4;ci++) // correction term index
489d5531 10235 } // end of for(Int sc=0;sc<2;sc++) // sin or cos correction terms
10236
10237} // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()
10238
489d5531 10239//================================================================================================================================
10240
489d5531 10241void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms()
10242{
10243 // Get pointers to all objects relevant for calculations with nested loops.
10244
10245 TList *nestedLoopsList = dynamic_cast<TList*>(fHistList->FindObject("Nested Loops"));
10246 if(nestedLoopsList)
10247 {
10248 this->SetNestedLoopsList(nestedLoopsList);
10249 } else
10250 {
10251 cout<<"WARNING: nestedLoopsList is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10252 exit(0);
10253 }
10254
10255 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
10256 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)
10257 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)
10258 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)
10259
10260 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";
10261 evaluateNestedLoopsName += fAnalysisLabel->Data();
10262 TProfile *evaluateNestedLoops = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(evaluateNestedLoopsName.Data()));
10263 Bool_t bEvaluateIntFlowNestedLoops = kFALSE;
10264 Bool_t bEvaluateDiffFlowNestedLoops = kFALSE;
10265 if(evaluateNestedLoops)
10266 {
10267 this->SetEvaluateNestedLoops(evaluateNestedLoops);
10268 bEvaluateIntFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(1);
10269 bEvaluateDiffFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(2);
10270 }
10271 // nested loops relevant for integrated flow:
10272 if(bEvaluateIntFlowNestedLoops)
10273 {
10274 // correlations:
10275 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";
10276 intFlowDirectCorrelationsName += fAnalysisLabel->Data();
10277 TProfile *intFlowDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowDirectCorrelationsName.Data()));
10278 if(intFlowDirectCorrelations)
10279 {
10280 this->SetIntFlowDirectCorrelations(intFlowDirectCorrelations);
10281 } else
10282 {
10283 cout<<"WARNING: intFlowDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10284 exit(0);
10285 }
403e3389 10286 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 10287 {
10288 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";
10289 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();
10290 TProfile *intFlowExtraDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowExtraDirectCorrelationsName.Data()));
10291 if(intFlowExtraDirectCorrelations)
10292 {
10293 this->SetIntFlowExtraDirectCorrelations(intFlowExtraDirectCorrelations);
10294 } else
10295 {
10296 cout<<"WARNING: intFlowExtraDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10297 exit(0);
10298 }
403e3389 10299 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 10300 // correction terms for non-uniform acceptance:
10301 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";
10302 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
10303 TProfile *intFlowDirectCorrectionTermsForNUA[2] = {NULL};
10304 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
10305 {
10306 intFlowDirectCorrectionTermsForNUA[sc] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data())));
10307 if(intFlowDirectCorrectionTermsForNUA[sc])
10308 {
10309 this->SetIntFlowDirectCorrectionTermsForNUA(intFlowDirectCorrectionTermsForNUA[sc],sc);
10310 } else
10311 {
10312 cout<<"WARNING: intFlowDirectCorrectionTermsForNUA[sc] is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10313 cout<<"sc = "<<sc<<endl;
10314 exit(0);
10315 }
10316 } // end of for(Int_t sc=0;sc<2;sc++)
10317 } // end of if(bEvaluateIntFlowNestedLoops)
10318
10319 // nested loops relevant for differential flow:
10320 if(bEvaluateDiffFlowNestedLoops)
10321 {
10322 // correlations:
10323 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";
10324 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();
10325 TProfile *diffFlowDirectCorrelations[2][2][4] = {{{NULL}}};
10326 for(Int_t t=0;t<2;t++)
10327 {
10328 for(Int_t pe=0;pe<2;pe++)
10329 {
10330 for(Int_t ci=0;ci<4;ci++) // correlation index
10331 {
10332 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())));
10333 if(diffFlowDirectCorrelations[t][pe][ci])
10334 {
10335 this->SetDiffFlowDirectCorrelations(diffFlowDirectCorrelations[t][pe][ci],t,pe,ci);
10336 } else
10337 {
10338 cout<<"WARNING: diffFlowDirectCorrelations[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10339 cout<<"t = "<<t<<endl;
10340 cout<<"pe = "<<pe<<endl;
10341 cout<<"ci = "<<ci<<endl;
10342 }
10343 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
10344 } // end of for(Int_t pe=0;pe<2;pe++)
10345 } // end of for(Int_t t=0;t<2;t++)
10346 // correction terms for non-uniform acceptance:
10347 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";
10348 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
10349 TProfile *diffFlowDirectCorrectionTermsForNUA[2][2][2][10] = {{{{NULL}}}};
10350 for(Int_t t=0;t<2;t++)
10351 {
10352 for(Int_t pe=0;pe<2;pe++)
10353 {
10354 // correction terms for NUA:
10355 for(Int_t sc=0;sc<2;sc++) // sin or cos
10356 {
10357 for(Int_t cti=0;cti<9;cti++) // correction term index
10358 {
10359 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)));
10360 if(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti])
10361 {
10362 this->SetDiffFlowDirectCorrectionTermsForNUA(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti],t,pe,sc,cti);
10363 } else
10364 {
10365 cout<<"WARNING: diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10366 cout<<"t = "<<t<<endl;
10367 cout<<"pe = "<<pe<<endl;
10368 cout<<"sc = "<<sc<<endl;
10369 cout<<"cti = "<<cti<<endl;
10370 }
10371 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
10372 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
10373 } // end of for(Int_t pe=0;pe<2;pe++)
10374 } // end of for(Int_t t=0;t<2;t++)
64e500e3 10375 // other differential correlators:
10376 TString otherDirectDiffCorrelatorsName = "fOtherDirectDiffCorrelators";
10377 otherDirectDiffCorrelatorsName += fAnalysisLabel->Data();
10378 TProfile *otherDirectDiffCorrelators[2][2][2][1] = {{{{NULL}}}};
10379 for(Int_t t=0;t<2;t++)
10380 {
10381 for(Int_t pe=0;pe<2;pe++)
10382 {
10383 // correction terms for NUA:
10384 for(Int_t sc=0;sc<2;sc++) // sin or cos
10385 {
10386 for(Int_t ci=0;ci<1;ci++) // correlator index
10387 {
10388 otherDirectDiffCorrelators[t][pe][sc][ci] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s, %s, %s, %s, ci = %d",otherDirectDiffCorrelatorsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),ci+1)));
10389 if(otherDirectDiffCorrelators[t][pe][sc][ci])
10390 {
10391 this->SetOtherDirectDiffCorrelators(otherDirectDiffCorrelators[t][pe][sc][ci],t,pe,sc,ci);
10392 } else
10393 {
10394 cout<<"WARNING: otherDirectDiffCorrelators[t][pe][sc][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10395 cout<<"t = "<<t<<endl;
10396 cout<<"pe = "<<pe<<endl;
10397 cout<<"sc = "<<sc<<endl;
10398 cout<<"ci = "<<ci<<endl;
10399 }
10400 } // end of for(Int_t ci=0;ci<9;ci++) // correction term index
10401 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
10402 } // end of for(Int_t pe=0;pe<2;pe++)
10403 } // end of for(Int_t t=0;t<2;t++)
489d5531 10404 // number of RPs and POIs in selected pt and eta bins for cross-checkings:
10405 TString noOfParticlesInBinName = "fNoOfParticlesInBin";
10406 TH1D *noOfParticlesInBin = NULL;
10407 noOfParticlesInBin = dynamic_cast<TH1D*>(nestedLoopsList->FindObject(noOfParticlesInBinName.Data()));
10408 if(noOfParticlesInBin)
10409 {
10410 this->SetNoOfParticlesInBin(noOfParticlesInBin);
10411 } else
10412 {
10413 cout<<endl;
10414 cout<<" WARNING (QC): noOfParticlesInBin is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10415 cout<<endl;
10416 }
10417 } // end of if(bEvaluateDiffFlowNestedLoops)
10418
10419} // end of void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms()
10420
489d5531 10421//================================================================================================================================
10422
489d5531 10423void AliFlowAnalysisWithQCumulants::StoreHarmonic()
10424{
10425 // Store flow harmonic in common control histograms.
10426
10427 (fCommonHists->GetHarmonic())->Fill(0.5,fHarmonic);
dd442cd2 10428 if(fFillMultipleControlHistograms)
10429 {
10430 (fCommonHists2nd->GetHarmonic())->Fill(0.5,fHarmonic);
10431 (fCommonHists4th->GetHarmonic())->Fill(0.5,fHarmonic);
10432 (fCommonHists6th->GetHarmonic())->Fill(0.5,fHarmonic);
10433 (fCommonHists8th->GetHarmonic())->Fill(0.5,fHarmonic);
10434 }
10435
489d5531 10436} // end of void AliFlowAnalysisWithQCumulants::StoreHarmonic()
10437
489d5531 10438//================================================================================================================================
10439
489d5531 10440void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta) // type = RP or POI
10441{
10442 // Calculate all correlations needed for differential flow using particle weights.
10443
2a98ceb8 10444 Int_t t = 0; // type flag
10445 Int_t pe = 0; // ptEta flag
489d5531 10446
10447 if(type == "RP")
10448 {
10449 t = 0;
10450 } else if(type == "POI")
10451 {
10452 t = 1;
10453 }
10454
10455 if(ptOrEta == "Pt")
10456 {
10457 pe = 0;
10458 } else if(ptOrEta == "Eta")
10459 {
10460 pe = 1;
10461 }
10462
10463 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
10464 Double_t minPtEta[2] = {fPtMin,fEtaMin};
10465 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
10466 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
10467
10468 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
10469 Double_t dReQ1n1k = (*fReQ)(0,1);
10470 Double_t dReQ2n2k = (*fReQ)(1,2);
10471 Double_t dReQ1n3k = (*fReQ)(0,3);
10472 //Double_t dReQ4n4k = (*fReQ)(3,4);
10473 Double_t dImQ1n1k = (*fImQ)(0,1);
10474 Double_t dImQ2n2k = (*fImQ)(1,2);
10475 Double_t dImQ1n3k = (*fImQ)(0,3);
10476 //Double_t dImQ4n4k = (*fImQ)(3,4);
10477
1268c371 10478 // S^M_{p,k} (see .h file for the definition of fSpk):
10479 Double_t dSM1p1k = (*fSpk)(0,1);
10480 Double_t dSM1p2k = (*fSpk)(0,2);
10481 Double_t dSM1p3k = (*fSpk)(0,3);
10482 Double_t dSM2p1k = (*fSpk)(1,1);
10483 Double_t dSM3p1k = (*fSpk)(2,1);
489d5531 10484
10485 // looping over all bins and calculating reduced correlations:
10486 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10487 {
10488 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):
10489 Double_t p1n0kRe = 0.;
10490 Double_t p1n0kIm = 0.;
10491
10492 // number of POIs in particular (pt,eta) bin):
10493 Double_t mp = 0.;
10494
10495 // real and imaginary parts of q_{m*n,k}:
10496 // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)
10497 Double_t q1n2kRe = 0.;
10498 Double_t q1n2kIm = 0.;
10499 Double_t q2n1kRe = 0.;
10500 Double_t q2n1kIm = 0.;
10501
10502 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10503 Double_t s1p1k = 0.;
10504 Double_t s1p2k = 0.;
10505 Double_t s1p3k = 0.;
10506
10507 // M0111 from Eq. (118) in QC2c (to be improved (notation))
10508 Double_t dM0111 = 0.;
10509
10510 if(type == "POI")
10511 {
10512 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
10513 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
10514 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
10515 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
10516
10517 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10518
10519 t = 1; // typeFlag = RP or POI
10520
10521 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
10522 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
10523 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
10524 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
10525 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
10526 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
10527 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
10528 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
10529 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
10530
10531 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10532 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
10533 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
10534 s1p3k = pow(fs1dEBE[2][pe][3]->GetBinContent(b)*fs1dEBE[2][pe][3]->GetBinEntries(b),1.);
10535
10536 // M0111 from Eq. (118) in QC2c (to be improved (notation)):
10537 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)
10538 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)
10539 + 2.*(s1p3k-s1p2k*dSM1p1k));
10540 }
10541 else if(type == "RP")
10542 {
10543 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
10544 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
10545 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
10546 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
10547 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
10548 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
10549 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
10550 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
10551 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
10552
10553 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10554 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
10555 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
10556 s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
10557
10558 // to be improved (cross-checked):
10559 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
10560 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
10561 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
10562 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
10563
10564 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10565
10566 t = 0; // typeFlag = RP or POI
10567
10568 // M0111 from Eq. (118) in QC2c (to be improved (notation)):
10569 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)
10570 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)
10571 + 2.*(s1p3k-s1p2k*dSM1p1k));
10572 //...............................................................................................
10573 }
10574
10575 // 2'-particle correlation:
10576 Double_t two1n1nW0W1 = 0.;
10577 if(mp*dSM1p1k-s1p1k)
10578 {
10579 two1n1nW0W1 = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)
10580 / (mp*dSM1p1k-s1p1k);
10581
10582 // fill profile to get <<2'>>
b40a910e 10583 fDiffFlowCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1,mp*dSM1p1k-s1p1k);
10584 // fill profile to get <<2'>^2>
10585 fDiffFlowSquaredCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1*two1n1nW0W1,mp*dSM1p1k-s1p1k);
489d5531 10586 // histogram to store <2'> e-b-e (needed in some other methods):
10587 fDiffFlowCorrelationsEBE[t][pe][0]->SetBinContent(b,two1n1nW0W1);
10588 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->SetBinContent(b,mp*dSM1p1k-s1p1k);
10589 } // end of if(mp*dSM1p1k-s1p1k)
10590
10591 // 4'-particle correlation:
10592 Double_t four1n1n1n1nW0W1W1W1 = 0.;
10593 if(dM0111)
10594 {
10595 four1n1n1n1nW0W1W1W1 = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)
10596 - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))
10597 - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k
10598 - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)
10599 + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)
10600 - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)
10601 - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k
10602 + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k)
10603 + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k)
10604 + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k)
10605 + 2.*s1p1k*dSM1p2k
10606 - 6.*s1p3k)
10607 / dM0111; // to be improved (notation of dM0111)
10608
10609 // fill profile to get <<4'>>
b40a910e 10610 fDiffFlowCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1,dM0111);
10611 // fill profile to get <<4'>^2>
10612 fDiffFlowSquaredCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1*four1n1n1n1nW0W1W1W1,dM0111);
489d5531 10613 // histogram to store <4'> e-b-e (needed in some other methods):
10614 fDiffFlowCorrelationsEBE[t][pe][1]->SetBinContent(b,four1n1n1n1nW0W1W1W1);
10615 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->SetBinContent(b,dM0111);
10616 } // end of if(dM0111)
10617 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10618
10619} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta); // type = RP or POI
10620
489d5531 10621//================================================================================================================================
10622
489d5531 10623void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)
10624{
10625 // Fill common control histograms.
10626
10627 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)
10628 fCommonHists->FillControlHistograms(anEvent);
dd442cd2 10629 if(fFillMultipleControlHistograms)
489d5531 10630 {
dd442cd2 10631 if(nRP>1)
489d5531 10632 {
dd442cd2 10633 fCommonHists2nd->FillControlHistograms(anEvent);
10634 if(nRP>3)
489d5531 10635 {
dd442cd2 10636 fCommonHists4th->FillControlHistograms(anEvent);
10637 if(nRP>5)
489d5531 10638 {
dd442cd2 10639 fCommonHists6th->FillControlHistograms(anEvent);
10640 if(nRP>7)
10641 {
10642 fCommonHists8th->FillControlHistograms(anEvent);
10643 } // end of if(nRP>7)
10644 } // end of if(nRP>5)
10645 } // end of if(nRP>3)
10646 } // end of if(nRP>1)
10647 } // end of if(fFillMultipleControlHistograms)
489d5531 10648
10649} // end of void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)
10650
489d5531 10651//================================================================================================================================
10652
489d5531 10653void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities()
10654{
10655 // Reset all event by event quantities.
10656
1268c371 10657 // Reference flow:
489d5531 10658 fReQ->Zero();
10659 fImQ->Zero();
1268c371 10660 fSpk->Zero();
489d5531 10661 fIntFlowCorrelationsEBE->Reset();
10662 fIntFlowEventWeightsForCorrelationsEBE->Reset();
10663 fIntFlowCorrelationsAllEBE->Reset();
10664
b92ea2b9 10665 for(Int_t sc=0;sc<2;sc++)
489d5531 10666 {
b92ea2b9 10667 fIntFlowCorrectionTermsForNUAEBE[sc]->Reset();
10668 fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc]->Reset();
489d5531 10669 }
10670
1268c371 10671 // Differential flow:
10672 if(fCalculateDiffFlow)
489d5531 10673 {
1268c371 10674 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
489d5531 10675 {
62e36168 10676 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // 1D in pt or eta
489d5531 10677 {
1268c371 10678 for(Int_t m=0;m<4;m++) // multiple of harmonic
489d5531 10679 {
1268c371 10680 for(Int_t k=0;k<9;k++) // power of weight
10681 {
10682 if(fReRPQ1dEBE[t][pe][m][k]) fReRPQ1dEBE[t][pe][m][k]->Reset();
10683 if(fImRPQ1dEBE[t][pe][m][k]) fImRPQ1dEBE[t][pe][m][k]->Reset();
10684 }
10685 }
489d5531 10686 }
1268c371 10687 }
10688 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )
10689 {
62e36168 10690 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // 1D in pt or eta
489d5531 10691 {
1268c371 10692 for(Int_t k=0;k<9;k++)
10693 {
10694 if(fs1dEBE[t][pe][k]) fs1dEBE[t][pe][k]->Reset();
10695 }
489d5531 10696 }
10697 }
1268c371 10698 // e-b-e reduced correlations:
10699 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)
10700 {
62e36168 10701 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 10702 {
1268c371 10703 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
10704 {
10705 if(fDiffFlowCorrelationsEBE[t][pe][rci]) fDiffFlowCorrelationsEBE[t][pe][rci]->Reset();
10706 if(fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]) fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]->Reset();
10707 }
489d5531 10708 }
1268c371 10709 }
10710 // correction terms for NUA:
10711 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)
10712 {
62e36168 10713 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 10714 {
1268c371 10715 for(Int_t sc=0;sc<2;sc++) // sin or cos
489d5531 10716 {
1268c371 10717 for(Int_t cti=0;cti<9;cti++) // correction term index
10718 {
489d5531 10719 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti]->Reset();
1268c371 10720 }
489d5531 10721 }
1268c371 10722 }
10723 }
10724 } // end of if(fCalculateDiffFlow)
10725
489d5531 10726 // 2D (pt,eta)
1268c371 10727 if(fCalculate2DDiffFlow)
489d5531 10728 {
10729 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
10730 {
10731 for(Int_t m=0;m<4;m++) // multiple of harmonic
10732 {
10733 for(Int_t k=0;k<9;k++) // power of weight
10734 {
b77b6434 10735 if(fReRPQ2dEBE[t][m][k]){fReRPQ2dEBE[t][m][k]->Reset();}
10736 if(fImRPQ2dEBE[t][m][k]){fImRPQ2dEBE[t][m][k]->Reset();}
489d5531 10737 }
10738 }
10739 }
10740 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )
10741 {
10742 for(Int_t k=0;k<9;k++)
10743 {
b77b6434 10744 if(fs2dEBE[t][k]){fs2dEBE[t][k]->Reset();}
489d5531 10745 }
10746 }
1268c371 10747 } // end of if(fCalculate2DDiffFlow)
489d5531 10748
10749} // end of void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities();
10750
489d5531 10751//================================================================================================================================
10752
489d5531 10753void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)
10754{
10755 // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).
10756
10757 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:
10758 // 0: <<sin n(psi1)>>
10759 // 1: <<sin n(psi1+phi2)>>
10760 // 2: <<sin n(psi1+phi2-phi3)>>
10761 // 3: <<sin n(psi1-phi2-phi3)>>:
10762 // 4:
10763 // 5:
10764 // 6:
10765
10766 // multiplicity:
1268c371 10767 Double_t dMult = (*fSpk)(0,0);
489d5531 10768
10769 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
10770 Double_t dReQ1n = (*fReQ)(0,0);
10771 Double_t dReQ2n = (*fReQ)(1,0);
10772 //Double_t dReQ3n = (*fReQ)(2,0);
10773 //Double_t dReQ4n = (*fReQ)(3,0);
10774 Double_t dImQ1n = (*fImQ)(0,0);
10775 Double_t dImQ2n = (*fImQ)(1,0);
10776 //Double_t dImQ3n = (*fImQ)(2,0);
10777 //Double_t dImQ4n = (*fImQ)(3,0);
10778
2a98ceb8 10779 Int_t t = 0; // type flag
10780 Int_t pe = 0; // ptEta flag
489d5531 10781
10782 if(type == "RP")
10783 {
10784 t = 0;
10785 } else if(type == "POI")
10786 {
10787 t = 1;
10788 }
10789
10790 if(ptOrEta == "Pt")
10791 {
10792 pe = 0;
10793 } else if(ptOrEta == "Eta")
10794 {
10795 pe = 1;
10796 }
10797
10798 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
10799 Double_t minPtEta[2] = {fPtMin,fEtaMin};
10800 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
10801 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
10802
10803 // looping over all bins and calculating correction terms:
10804 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10805 {
10806 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
10807 Double_t p1n0kRe = 0.;
10808 Double_t p1n0kIm = 0.;
10809
10810 // number of POIs in particular pt or eta bin:
10811 Double_t mp = 0.;
10812
10813 // 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):
10814 Double_t q1n0kRe = 0.;
10815 Double_t q1n0kIm = 0.;
10816 Double_t q2n0kRe = 0.;
10817 Double_t q2n0kIm = 0.;
10818
10819 // number of particles which are both RPs and POIs in particular pt or eta bin:
10820 Double_t mq = 0.;
10821
10822 if(type == "POI")
10823 {
10824 // q_{m*n,0}:
10825 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
10826 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
10827 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
10828 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
10829 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
10830 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
10831 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
10832 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
10833
10834 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10835 }
10836 else if(type == "RP")
10837 {
10838 // q_{m*n,0}:
10839 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
10840 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
10841 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
10842 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
10843 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
10844 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
10845 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
10846 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
10847
10848 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10849 }
10850 if(type == "POI")
10851 {
10852 // p_{m*n,0}:
10853 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
10854 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
10855 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
10856 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
10857
10858 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10859
10860 t = 1; // typeFlag = RP or POI
10861 }
10862 else if(type == "RP")
10863 {
10864 // p_{m*n,0} = q_{m*n,0}:
10865 p1n0kRe = q1n0kRe;
10866 p1n0kIm = q1n0kIm;
10867
10868 mp = mq;
10869
10870 t = 0; // typeFlag = RP or POI
10871 }
10872
10873 // <<sin n(psi1)>>:
10874 Double_t sinP1nPsi = 0.;
10875 if(mp)
10876 {
10877 sinP1nPsi = p1n0kIm/mp;
10878 // fill profile for <<sin n(psi1)>>:
10879 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);
10880 // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):
10881 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);
10882 } // end of if(mp)
10883
10884 // <<sin n(psi1+phi2)>>:
10885 Double_t sinP1nPsiP1nPhi = 0.;
10886 if(mp*dMult-mq)
10887 {
10888 sinP1nPsiP1nPhi = (p1n0kRe*dImQ1n+p1n0kIm*dReQ1n-q2n0kIm)/(mp*dMult-mq);
10889 // fill profile for <<sin n(psi1+phi2)>>:
10890 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhi,mp*dMult-mq);
10891 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
10892 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhi);
10893 } // end of if(mp*dMult-mq)
10894
10895 // <<sin n(psi1+phi2-phi3)>>:
10896 Double_t sinP1nPsi1P1nPhi2MPhi3 = 0.;
10897 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10898 {
10899 sinP1nPsi1P1nPhi2MPhi3 = (p1n0kIm*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)
10900 - 1.*(q2n0kIm*dReQ1n-q2n0kRe*dImQ1n)
10901 - mq*dImQ1n+2.*q1n0kIm)
10902 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10903 // fill profile for <<sin n(psi1+phi2)>>:
10904 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10905 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
10906 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3);
10907 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10908
10909 // <<sin n(psi1-phi2-phi3)>>:
10910 Double_t sinP1nPsi1M1nPhi2MPhi3 = 0.;
10911 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10912 {
10913 sinP1nPsi1M1nPhi2MPhi3 = (p1n0kIm*(pow(dReQ1n,2.)-pow(dImQ1n,2.))-2.*p1n0kRe*dReQ1n*dImQ1n
10914 - 1.*(p1n0kIm*dReQ2n-p1n0kRe*dImQ2n)
10915 + 2.*mq*dImQ1n-2.*q1n0kIm)
10916 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10917 // fill profile for <<sin n(psi1+phi2)>>:
10918 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10919 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
10920 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3);
10921 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10922 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10923
10924} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)
10925
10926
10927//================================================================================================================================
10928
10929
10930void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)
10931{
10932 // Calculate correction terms for non-uniform acceptance for differential flow (cos terms).
10933
10934 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:
10935 // 0: <<cos n(psi)>>
10936 // 1: <<cos n(psi1+phi2)>>
10937 // 2: <<cos n(psi1+phi2-phi3)>>
10938 // 3: <<cos n(psi1-phi2-phi3)>>
10939 // 4:
10940 // 5:
10941 // 6:
10942
10943 // multiplicity:
1268c371 10944 Double_t dMult = (*fSpk)(0,0);
489d5531 10945
10946 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
10947 Double_t dReQ1n = (*fReQ)(0,0);
10948 Double_t dReQ2n = (*fReQ)(1,0);
10949 //Double_t dReQ3n = (*fReQ)(2,0);
10950 //Double_t dReQ4n = (*fReQ)(3,0);
10951 Double_t dImQ1n = (*fImQ)(0,0);
10952 Double_t dImQ2n = (*fImQ)(1,0);
10953 //Double_t dImQ3n = (*fImQ)(2,0);
10954 //Double_t dImQ4n = (*fImQ)(3,0);
10955
2a98ceb8 10956 Int_t t = 0; // type flag
10957 Int_t pe = 0; // ptEta flag
489d5531 10958
10959 if(type == "RP")
10960 {
10961 t = 0;
10962 } else if(type == "POI")
10963 {
10964 t = 1;
10965 }
10966
10967 if(ptOrEta == "Pt")
10968 {
10969 pe = 0;
10970 } else if(ptOrEta == "Eta")
10971 {
10972 pe = 1;
10973 }
10974
10975 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
10976 Double_t minPtEta[2] = {fPtMin,fEtaMin};
10977 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
10978 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
10979
10980 // looping over all bins and calculating correction terms:
10981 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10982 {
10983 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
10984 Double_t p1n0kRe = 0.;
10985 Double_t p1n0kIm = 0.;
10986
10987 // number of POIs in particular pt or eta bin:
10988 Double_t mp = 0.;
10989
10990 // 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):
10991 Double_t q1n0kRe = 0.;
10992 Double_t q1n0kIm = 0.;
10993 Double_t q2n0kRe = 0.;
10994 Double_t q2n0kIm = 0.;
10995
10996 // number of particles which are both RPs and POIs in particular pt or eta bin:
10997 Double_t mq = 0.;
10998
10999 if(type == "POI")
11000 {
11001 // q_{m*n,0}:
11002 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
11003 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
11004 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
11005 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
11006 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
11007 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
11008 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
11009 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
11010
11011 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11012 }
11013 else if(type == "RP")
11014 {
11015 // q_{m*n,0}:
11016 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
11017 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
11018 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
11019 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
11020 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
11021 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
11022 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
11023 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
11024
11025 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11026 }
11027 if(type == "POI")
11028 {
11029 // p_{m*n,0}:
11030 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
11031 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
11032 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
11033 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
11034
11035 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11036
11037 t = 1; // typeFlag = RP or POI
11038 }
11039 else if(type == "RP")
11040 {
11041 // p_{m*n,0} = q_{m*n,0}:
11042 p1n0kRe = q1n0kRe;
11043 p1n0kIm = q1n0kIm;
11044
11045 mp = mq;
11046
11047 t = 0; // typeFlag = RP or POI
11048 }
11049
11050 // <<cos n(psi1)>>:
11051 Double_t cosP1nPsi = 0.;
11052 if(mp)
11053 {
11054 cosP1nPsi = p1n0kRe/mp;
11055
11056 // fill profile for <<cos n(psi1)>>:
11057 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);
11058 // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):
11059 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);
11060 } // end of if(mp)
11061
11062 // <<cos n(psi1+phi2)>>:
11063 Double_t cosP1nPsiP1nPhi = 0.;
11064 if(mp*dMult-mq)
11065 {
11066 cosP1nPsiP1nPhi = (p1n0kRe*dReQ1n-p1n0kIm*dImQ1n-q2n0kRe)/(mp*dMult-mq);
11067 // fill profile for <<sin n(psi1+phi2)>>:
11068 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhi,mp*dMult-mq);
11069 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11070 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhi);
11071 } // end of if(mp*dMult-mq)
11072
11073 // <<cos n(psi1+phi2-phi3)>>:
11074 Double_t cosP1nPsi1P1nPhi2MPhi3 = 0.;
11075 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11076 {
11077 cosP1nPsi1P1nPhi2MPhi3 = (p1n0kRe*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)
11078 - 1.*(q2n0kRe*dReQ1n+q2n0kIm*dImQ1n)
11079 - mq*dReQ1n+2.*q1n0kRe)
11080 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11081 // fill profile for <<sin n(psi1+phi2)>>:
11082 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11083 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11084 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3);
11085 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11086
11087 // <<cos n(psi1-phi2-phi3)>>:
11088 Double_t cosP1nPsi1M1nPhi2MPhi3 = 0.;
11089 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11090 {
11091 cosP1nPsi1M1nPhi2MPhi3 = (p1n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))+2.*p1n0kIm*dReQ1n*dImQ1n
11092 - 1.*(p1n0kRe*dReQ2n+p1n0kIm*dImQ2n)
11093 - 2.*mq*dReQ1n+2.*q1n0kRe)
11094 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11095 // fill profile for <<sin n(psi1+phi2)>>:
11096 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11097 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11098 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3);
11099 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11100 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11101
11102} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)
11103
489d5531 11104//==================================================================================================================================
11105
489d5531 11106void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)
11107{
1268c371 11108 // Transfer profiles into histogams and correctly propagate the error.
489d5531 11109
2a98ceb8 11110 Int_t t = 0; // type flag
11111 Int_t pe = 0; // ptEta flag
489d5531 11112
11113 if(type == "RP")
11114 {
11115 t = 0;
11116 } else if(type == "POI")
11117 {
11118 t = 1;
11119 }
11120
11121 if(ptOrEta == "Pt")
11122 {
11123 pe = 0;
11124 } else if(ptOrEta == "Eta")
11125 {
11126 pe = 1;
11127 }
11128
11129 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
11130 //Double_t minPtEta[2] = {fPtMin,fEtaMin};
11131 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
11132 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
11133
11134 for(Int_t sc=0;sc<2;sc++) // sin or cos
11135 {
11136 for(Int_t cti=0;cti<9;cti++) // correction term index
11137 {
11138 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11139 {
11140 Double_t correctionTerm = fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(b);
11141 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]->SetBinContent(b,correctionTerm);
11142 // to be improved (propagate error correctly)
11143 // ...
11144 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11145 } // correction term index
11146 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
11147
11148}// end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)
11149
489d5531 11150//==================================================================================================================================
11151
489d5531 11152void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
11153{
1268c371 11154 // Calculate generalized differential flow cumulants (corrected for non-uniform acceptance).
11155
11156 // to be improved - propagate error also from non-isotropic terms
489d5531 11157
1268c371 11158 Int_t t = 0; // RP = 0, POI = 1
11159 Int_t pe = 0; // pt = 0, eta = 1
489d5531 11160
11161 if(type == "RP")
11162 {
1268c371 11163 t = 0;
489d5531 11164 } else if(type == "POI")
11165 {
1268c371 11166 t = 1;
489d5531 11167 }
11168
11169 if(ptOrEta == "Pt")
11170 {
1268c371 11171 pe = 0;
489d5531 11172 } else if(ptOrEta == "Eta")
11173 {
1268c371 11174 pe = 1;
489d5531 11175 }
1268c371 11176
11177 // Common:
489d5531 11178 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 11179 // 2-particle correlation:
11180 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
1268c371 11181 // sinus terms coming from reference flow:
489d5531 11182 Double_t sinP1nPhi = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>
11183 Double_t sinP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>
11184 Double_t sinP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>
1268c371 11185 // cosinus terms coming from reference flow:
489d5531 11186 Double_t cosP1nPhi = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>
11187 Double_t cosP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>
11188 Double_t cosP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>
11189
11190 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11191 {
11192 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>
11193 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>
11194 Double_t sinP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][0]->GetBinContent(b); // <<sin n(Psi)>>
11195 Double_t cosP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][0]->GetBinContent(b); // <<cos n(Psi)>>
11196 Double_t sinP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][1]->GetBinContent(b); // <<sin n(psi1+phi2)>>
11197 Double_t cosP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][1]->GetBinContent(b); // <<cos n(psi1+phi2)>>
11198 Double_t sinP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][2]->GetBinContent(b); // <<sin n(psi1+phi2-phi3)>>
11199 Double_t cosP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][2]->GetBinContent(b); // <<cos n(psi1+phi2-phi3)>>
11200 Double_t sinP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][3]->GetBinContent(b); // <<sin n(psi1-phi2-phi3)>>
11201 Double_t cosP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][3]->GetBinContent(b); // <<cos n(psi1-phi2-phi3)>>
1268c371 11202 // Generalized QC{2'}:
489d5531 11203 Double_t qc2Prime = twoPrime - sinP1nPsi*sinP1nPhi - cosP1nPsi*cosP1nPhi;
1268c371 11204 if(fApplyCorrectionForNUA)
11205 {
11206 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);
11207 }
11208 if(TMath::Abs(twoPrime)>0.)
11209 {
11210 fDiffFlowDetectorBias[t][pe][0]->SetBinContent(b,qc2Prime/twoPrime); // detector bias = generalized/isotropic cumulant.
11211 }
11212 // Generalized QC{4'}:
489d5531 11213 Double_t qc4Prime = fourPrime-2.*twoPrime*two
11214 - cosP1nPsi*cosP1nPhi1M1nPhi2M1nPhi3
11215 + sinP1nPsi*sinP1nPhi1M1nPhi2M1nPhi3
11216 - cosP1nPhi*cosP1nPsi1M1nPhi2M1nPhi3
11217 + sinP1nPhi*sinP1nPsi1M1nPhi2M1nPhi3
11218 - 2.*cosP1nPhi*cosP1nPsi1P1nPhi2M1nPhi3
11219 - 2.*sinP1nPhi*sinP1nPsi1P1nPhi2M1nPhi3
11220 - cosP1nPsi1P1nPhi2*cosP1nPhi1P1nPhi2
11221 - sinP1nPsi1P1nPhi2*sinP1nPhi1P1nPhi2
11222 + 2.*cosP1nPhi1P1nPhi2*(cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)
11223 + 2.*sinP1nPhi1P1nPhi2*(cosP1nPsi*sinP1nPhi+sinP1nPsi*cosP1nPhi)
11224 + 4.*two*(cosP1nPsi*cosP1nPhi+sinP1nPsi*sinP1nPhi)
11225 + 2.*cosP1nPsi1P1nPhi2*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))
11226 + 4.*sinP1nPsi1P1nPhi2*cosP1nPhi*sinP1nPhi
11227 + 4.*twoPrime*(pow(cosP1nPhi,2.)+pow(sinP1nPhi,2.))
11228 - 6.*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))
11229 * (cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)
11230 - 12.*cosP1nPhi*sinP1nPhi
11231 * (sinP1nPsi*cosP1nPhi+cosP1nPsi*sinP1nPhi);
1268c371 11232 if(fApplyCorrectionForNUA)
11233 {
11234 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime);
11235 }
11236 if(TMath::Abs(fourPrime-2.*twoPrime*two)>0.)
11237 {
11238 fDiffFlowDetectorBias[t][pe][1]->SetBinContent(b,qc4Prime/(fourPrime-2.*twoPrime*two)); // detector bias = generalized/isotropic cumulant.
11239 }
489d5531 11240 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
11241
11242} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
11243
1268c371 11244//==================================================================================================================================
489d5531 11245
11246void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)
11247{
11248 // Calculate differential flow corrected for non-uniform acceptance.
11249
1268c371 11250 // to be improved: eventually I will have to access here masured correlations and NUA terms
11251 // instead of cumulants in order to propagate statistical error correctly also
11252 // to NUA terms (propagating errors directly from cumulants is WRONG for
11253 // differential flow becuase that doesn't account at all cross-covariance terms)
489d5531 11254
1268c371 11255 // REMARK: When NUA correction is apllied error for differential flow DOES NOT get corrected,
11256 // i.e. only value is being corrected, error is still the one relevant for isotropic
11257 // case. This eventually will be resolved.
11258
11259
11260 Int_t t = 0; // RP or POI
11261 Int_t pe = 0; // pt or eta
489d5531 11262
11263 if(type == "RP")
11264 {
1268c371 11265 t = 0;
489d5531 11266 } else if(type == "POI")
11267 {
1268c371 11268 t = 1;
11269 }
489d5531 11270 if(ptOrEta == "Pt")
11271 {
1268c371 11272 pe = 0;
489d5531 11273 } else if(ptOrEta == "Eta")
11274 {
1268c371 11275 pe = 1;
489d5531 11276 }
11277
1268c371 11278 // Common:
489d5531 11279 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
1268c371 11280 // Reference Q-cumulants
11281 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}
11282 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}
11283 // Loop over pt or eta bins:
489d5531 11284 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11285 {
1268c371 11286 // Differential Q-cumulants:
11287 Double_t qc2Prime = fDiffFlowCumulants[t][pe][0]->GetBinContent(b); // QC{2'}
11288 Double_t qc4Prime = fDiffFlowCumulants[t][pe][1]->GetBinContent(b); // QC{4'}
489d5531 11289 // v'{2}:
1268c371 11290 if(qc2>0.)
489d5531 11291 {
1268c371 11292 Double_t v2Prime = qc2Prime/pow(qc2,0.5);
11293 if(TMath::Abs(v2Prime)>0.){fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime);}
489d5531 11294 }
489d5531 11295 // v'{4}:
1268c371 11296 if(qc4<0.)
489d5531 11297 {
1268c371 11298 Double_t v4Prime = -qc4Prime/pow(-qc4,3./4.);
11299 if(TMath::Abs(v4Prime)>0.){fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);}
489d5531 11300 }
11301 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)
11302
11303} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta);
11304
489d5531 11305//==================================================================================================================================
11306
0328db2d 11307void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple * const anEvent)
489d5531 11308{
11309 // Evaluate with nested loops multiparticle correlations for integrated flow (without using the particle weights).
11310
11311 // Remark: Results are stored in profile fIntFlowDirectCorrelations whose binning is organized as follows:
11312 //
11313 // 1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>
11314 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>
11315 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))>
11316 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>
11317 // 5th bin: ---- EMPTY ----
11318 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>
11319 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>
11320 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>
11321 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>
11322 // 10th bin: ---- EMPTY ----
11323 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>
11324 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>
11325 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>
11326 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))>
11327 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>
11328 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>
11329 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))>
11330 // 18th bin: ---- EMPTY ----
11331 // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>
11332 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>
11333 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>
11334 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>
11335 // 23rd bin: ---- EMPTY ----
11336 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>
11337 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>
11338 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>
11339 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>
11340 // 28th bin: ---- EMPTY ----
11341 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
11342 // 30th bin: ---- EMPTY ----
11343 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
8ed4edc7 11344 // 32nd bin: ---- EMPTY ----
b84464d3 11345 // Extra correlations for 3p TY study:
8ed4edc7 11346 // 33rd bin: <4>_{4n,2n|3n,3n}= four4n2n3n3n = <cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4))>
b84464d3 11347 // 34th bin: <5>_{3n,3n|2n,2n,2n} = five3n3n2n2n2n = <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
11348 // Extra correlations for 6p TY study:
11349 // 35th bin: <2>_{5n|5n} = two5n5n = <cos(5n*(phi1-phi2)> T
11350 // 36th bin: <2>_{6n|6n} = two6n6n = <cos(6n*(phi1-phi2)> T
11351 // 37th bin: <3>_{5n|3n,2n} = three5n3n2n = <cos(n*(5*phi1-3*phi2-2*phi3)>
11352 // 38th bin: <3>_{5n|4n,1n} = three5n4n1n = <cos(n*(5*phi1-4*phi2-1*phi3)>
11353 // 39th bin: <3>_{6n|3n,3n} = three6n3n3n = <cos(n*(6*phi1-3*phi2-3*phi3)> T
11354 // 40th bin: <3>_{6n|4n,2n} = three6n4n2n = <cos(n*(6*phi1-4*phi2-2*phi3)> T
11355 // 41st bin: <3>_{6n|5n,1n} = three6n5n1n = <cos(n*(6*phi1-5*phi2-1*phi3)>
11356 // 42nd bin: <4>_{6n|3n,2n,1n} = four6n3n2n1n = <cos(n*(6*phi1-3*phi2-2*phi3-1*phi4)>
11357 // 43rd bin: <4>_{3n,2n|3n,2n} = four3n2n3n2n = <cos(n*(3*phi1+2*phi2-3*phi3-2*phi4)>
11358 // 44th bin: <4>_{4n,1n|3n,2n} = four4n1n3n2n = <cos(n*(4*phi1+1*phi2-3*phi3-2*phi4)>
11359 // 45th bin: <4>_{3n,3n|3n,3n} = four3n3n3n3n = <cos(3.*n*(phi1+phi2-phi3-phi4))> T
11360 // 46th bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n*(4*phi1+2*phi2-3*phi3-3*phi4)>
11361 // 47th bin: <4>_{5n,1n|3n,3n} = four5n1n3n3n = <cos(n*(5*phi1+1*phi2-3*phi3-3*phi4)>
11362 // 48th bin: <4>_{4n,2n|4n,2n} = four4n2n4n2n = <cos(n*(4*phi1+2*phi2-4*phi3-2*phi4)> T
11363 // 49th bin: <4>_{5n,1n|4n,2n} = four5n1n4n2n = <cos(n*(5*phi1+1*phi2-4*phi3-2*phi4)>
11364 // 50th bin: <4>_{5n|3n,1n,1n} = four5n3n1n1n = <cos(n*(5*phi1-3*phi2-1*phi3-1*phi4)>
11365 // 51st bin: <4>_{5n|2n,2n,1n} = four5n2n2n1n = <cos(n*(5*phi1-2*phi2-2*phi3-1*phi4)>
11366 // 52nd bin: <4>_{5n,1n|5n,1n} = four5n1n5n1n = <cos(n*(5*phi1+1*phi2-5*phi3-1*phi4)>
11367 // 53rd bin: <5>_{3n,3n|3n,2n,1n} = four3n3n3n2n1n = <cos(n*(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
11368 // 54th bin: <5>_{4n,2n|3n,2n,1n} = four4n2n3n2n1n = <cos(n*(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
11369 // 55th bin: <5>_{3n,2n|3n,1n,1n} = four3n2n3n1n1n = <cos(n*(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
11370 // 56th bin: <5>_{3n,2n|2n,2n,1n} = four3n2n2n2n1n = <cos(n*(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
11371 // 57th bin: <5>_{5n,1n|3n,2n,1n} = four5n1n3n2n1n = <cos(n*(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
11372 // 58th bin: <6>_{3n,2n,1n|3n,2n,1n} = six3n2n1n3n2n1n = <cos(n*(3*phi1+2*phi2+1*phi3-3*phi4-2*phi5-1*phi6)>
8ed4edc7 11373
489d5531 11374 Int_t nPrim = anEvent->NumberOfTracks();
11375 AliFlowTrackSimple *aftsTrack = NULL;
11376 Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
11377 Int_t n = fHarmonic;
11378 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 11379 Double_t dMult = (*fSpk)(0,0);
489d5531 11380 cout<<endl;
11381 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
11382 if(dMult<2)
11383 {
11384 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
11385 } else if (dMult>fMaxAllowedMultiplicity)
11386 {
11387 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
11388 } else
11389 {
11390 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;
11391 }
11392
11393 // 2-particle correlations:
11394 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
11395 {
11396 for(Int_t i1=0;i1<nPrim;i1++)
11397 {
11398 aftsTrack=anEvent->GetTrack(i1);
11399 if(!(aftsTrack->InRPSelection())) continue;
11400 phi1=aftsTrack->Phi();
11401 for(Int_t i2=0;i2<nPrim;i2++)
11402 {
11403 if(i2==i1)continue;
11404 aftsTrack=anEvent->GetTrack(i2);
11405 if(!(aftsTrack->InRPSelection())) continue;
11406 phi2=aftsTrack->Phi();
11407 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
11408 // fill the profile with 2-p correlations:
b84464d3 11409 fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),1.); // <cos(n*(phi1-phi2))>
11410 fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),1.); // <cos(2n*(phi1-phi2))>
11411 fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),1.); // <cos(3n*(phi1-phi2))>
11412 fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),1.); // <cos(4n*(phi1-phi2))>
11413 fIntFlowDirectCorrelations->Fill(34.5,cos(5.*n*(phi1-phi2)),1.); // <cos(5n*(phi1-phi2))>
11414 fIntFlowDirectCorrelations->Fill(35.5,cos(6.*n*(phi1-phi2)),1.); // <cos(6n*(phi1-phi2))>
489d5531 11415 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11416 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11417 } // end of if(nPrim>=2)
11418
11419 // 3-particle correlations:
11420 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
11421 {
11422 for(Int_t i1=0;i1<nPrim;i1++)
11423 {
11424 aftsTrack=anEvent->GetTrack(i1);
11425 if(!(aftsTrack->InRPSelection())) continue;
11426 phi1=aftsTrack->Phi();
11427 for(Int_t i2=0;i2<nPrim;i2++)
11428 {
11429 if(i2==i1)continue;
11430 aftsTrack=anEvent->GetTrack(i2);
11431 if(!(aftsTrack->InRPSelection())) continue;
11432 phi2=aftsTrack->Phi();
11433 for(Int_t i3=0;i3<nPrim;i3++)
11434 {
11435 if(i3==i1||i3==i2)continue;
11436 aftsTrack=anEvent->GetTrack(i3);
11437 if(!(aftsTrack->InRPSelection())) continue;
11438 phi3=aftsTrack->Phi();
11439 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
11440 // fill the profile with 3-p correlations:
b84464d3 11441 fIntFlowDirectCorrelations->Fill(5.,cos(2.*n*phi1-n*(phi2+phi3)),1.); //<3>_{2n|nn,n}
11442 fIntFlowDirectCorrelations->Fill(6.,cos(3.*n*phi1-2.*n*phi2-n*phi3),1.); //<3>_{3n|2n,n}
11443 fIntFlowDirectCorrelations->Fill(7.,cos(4.*n*phi1-2.*n*phi2-2.*n*phi3),1.); //<3>_{4n|2n,2n}
11444 fIntFlowDirectCorrelations->Fill(8.,cos(4.*n*phi1-3.*n*phi2-n*phi3),1.); //<3>_{4n|3n,n}
11445 fIntFlowDirectCorrelations->Fill(36.5,cos(5.*n*phi1-3.*n*phi2-2.*n*phi3),1.); //<3>_{5n|3n,2n}
11446 fIntFlowDirectCorrelations->Fill(37.5,cos(5.*n*phi1-4.*n*phi2-1.*n*phi3),1.); //<3>_{5n|4n,1n}
11447 fIntFlowDirectCorrelations->Fill(38.5,cos(6.*n*phi1-3.*n*phi2-3.*n*phi3),1.); //<3>_{6n|3n,3n}
11448 fIntFlowDirectCorrelations->Fill(39.5,cos(6.*n*phi1-4.*n*phi2-2.*n*phi3),1.); //<3>_{6n|4n,2n}
11449 fIntFlowDirectCorrelations->Fill(40.5,cos(6.*n*phi1-5.*n*phi2-1.*n*phi3),1.); //<3>_{6n|5n,1n}
489d5531 11450 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11451 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11452 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11453 } // end of if(nPrim>=3)
11454
11455 // 4-particle correlations:
11456 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
11457 {
11458 for(Int_t i1=0;i1<nPrim;i1++)
11459 {
11460 aftsTrack=anEvent->GetTrack(i1);
11461 if(!(aftsTrack->InRPSelection())) continue;
11462 phi1=aftsTrack->Phi();
11463 for(Int_t i2=0;i2<nPrim;i2++)
11464 {
11465 if(i2==i1)continue;
11466 aftsTrack=anEvent->GetTrack(i2);
11467 if(!(aftsTrack->InRPSelection())) continue;
11468 phi2=aftsTrack->Phi();
11469 for(Int_t i3=0;i3<nPrim;i3++)
11470 {
11471 if(i3==i1||i3==i2)continue;
11472 aftsTrack=anEvent->GetTrack(i3);
11473 if(!(aftsTrack->InRPSelection())) continue;
11474 phi3=aftsTrack->Phi();
11475 for(Int_t i4=0;i4<nPrim;i4++)
11476 {
11477 if(i4==i1||i4==i2||i4==i3)continue;
11478 aftsTrack=anEvent->GetTrack(i4);
11479 if(!(aftsTrack->InRPSelection())) continue;
11480 phi4=aftsTrack->Phi();
11481 if(nPrim==4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush;
11482 // fill the profile with 4-p correlations:
11483 fIntFlowDirectCorrelations->Fill(10.,cos(n*phi1+n*phi2-n*phi3-n*phi4),1.); // <4>_{n,n|n,n}
11484 fIntFlowDirectCorrelations->Fill(11.,cos(2.*n*phi1+n*phi2-2.*n*phi3-n*phi4),1.); // <4>_{2n,n|2n,n}
11485 fIntFlowDirectCorrelations->Fill(12.,cos(2.*n*phi1+2*n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{2n,2n|2n,2n}
11486 fIntFlowDirectCorrelations->Fill(13.,cos(3.*n*phi1-n*phi2-n*phi3-n*phi4),1.); // <4>_{3n|n,n,n}
11487 fIntFlowDirectCorrelations->Fill(14.,cos(3.*n*phi1+n*phi2-3.*n*phi3-n*phi4),1.); // <4>_{3n,n|3n,n}
11488 fIntFlowDirectCorrelations->Fill(15.,cos(3.*n*phi1+n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{3n,n|2n,2n}
11489 fIntFlowDirectCorrelations->Fill(16.,cos(4.*n*phi1-2.*n*phi2-n*phi3-n*phi4),1.); // <4>_{4n|2n,n,n}
b84464d3 11490 fIntFlowDirectCorrelations->Fill(32.,cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{4n,2n|3n,3n}
11491 fIntFlowDirectCorrelations->Fill(41.5,cos(n*(6.*phi1-3.*phi2-2.*phi3-1.*phi4)),1.); // <4>_{6n|3n,2n,1n}
11492 fIntFlowDirectCorrelations->Fill(42.5,cos(n*(3.*phi1+2.*phi2-3.*phi3-2.*phi4)),1.); // <4>_{3n,2n|3n,2n}
11493 fIntFlowDirectCorrelations->Fill(43.5,cos(n*(4.*phi1+1.*phi2-3.*phi3-2.*phi4)),1.); // <4>_{4n,1n|3n,2n}
11494 fIntFlowDirectCorrelations->Fill(44.5,cos(n*(3.*phi1+3.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{3n,3n|3n,3n}
11495 fIntFlowDirectCorrelations->Fill(45.5,cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{4n,2n|3n,3n}
11496 fIntFlowDirectCorrelations->Fill(46.5,cos(n*(5.*phi1+1.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{5n,1n|3n,3n}
11497 fIntFlowDirectCorrelations->Fill(47.5,cos(n*(4.*phi1+2.*phi2-4.*phi3-2.*phi4)),1.); // <4>_{4n,2n|4n,2n}
11498 fIntFlowDirectCorrelations->Fill(48.5,cos(n*(5.*phi1+1.*phi2-4.*phi3-2.*phi4)),1.); // <4>_{5n,1n|4n,2n}
11499 fIntFlowDirectCorrelations->Fill(49.5,cos(n*(5.*phi1-3.*phi2-1.*phi3-1.*phi4)),1.); // <4>_{5n|3n,1n,1n}
11500 fIntFlowDirectCorrelations->Fill(50.5,cos(n*(5.*phi1-2.*phi2-2.*phi3-1.*phi4)),1.); // <4>_{5n|2n,2n,1n}
403e3389 11501 fIntFlowDirectCorrelations->Fill(51.5,cos(n*(5.*phi1+1.*phi2-5.*phi3-1.*phi4)),1.); // <4>_{5n,1n|5n,1n}
11502 fIntFlowDirectCorrelations->Fill(58.5,cos(n*(6.*phi1-4.*phi2-1.*phi3-1.*phi4)),1.); // <4>_{6n|4n,1n,1n}
11503 fIntFlowDirectCorrelations->Fill(59.5,cos(n*(6.*phi1-2.*phi2-2.*phi3-2.*phi4)),1.); // <4>_{6n|2n,2n,2n}
489d5531 11504 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11505 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11506 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11507 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11508 } // end of if(nPrim>=)
11509
11510 // 5-particle correlations:
11511 if(nPrim>=5 && nPrim<=fMaxAllowedMultiplicity)
11512 {
11513 for(Int_t i1=0;i1<nPrim;i1++)
11514 {
11515 aftsTrack=anEvent->GetTrack(i1);
11516 if(!(aftsTrack->InRPSelection())) continue;
11517 phi1=aftsTrack->Phi();
11518 for(Int_t i2=0;i2<nPrim;i2++)
11519 {
11520 if(i2==i1)continue;
11521 aftsTrack=anEvent->GetTrack(i2);
11522 if(!(aftsTrack->InRPSelection())) continue;
11523 phi2=aftsTrack->Phi();
11524 for(Int_t i3=0;i3<nPrim;i3++)
11525 {
11526 if(i3==i1||i3==i2)continue;
11527 aftsTrack=anEvent->GetTrack(i3);
11528 if(!(aftsTrack->InRPSelection())) continue;
11529 phi3=aftsTrack->Phi();
11530 for(Int_t i4=0;i4<nPrim;i4++)
11531 {
11532 if(i4==i1||i4==i2||i4==i3)continue;
11533 aftsTrack=anEvent->GetTrack(i4);
11534 if(!(aftsTrack->InRPSelection())) continue;
11535 phi4=aftsTrack->Phi();
11536 for(Int_t i5=0;i5<nPrim;i5++)
11537 {
11538 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11539 aftsTrack=anEvent->GetTrack(i5);
11540 if(!(aftsTrack->InRPSelection())) continue;
11541 phi5=aftsTrack->Phi();
11542 if(nPrim==5) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<"\r"<<flush;
11543 // fill the profile with 5-p correlations:
b84464d3 11544 fIntFlowDirectCorrelations->Fill(18.,cos(2.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5),1.); // <5>_{2n,n|n,n,n}
11545 fIntFlowDirectCorrelations->Fill(19.,cos(2.*n*phi1+2.*n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); // <5>_{2n,2n|2n,n,n}
11546 fIntFlowDirectCorrelations->Fill(20.,cos(3.*n*phi1+n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); // <5>_{3n,n|2n,n,n}
11547 fIntFlowDirectCorrelations->Fill(21.,cos(4.*n*phi1-n*phi2-n*phi3-n*phi4-n*phi5),1.); // <5>_{4n|n,n,n,n}
11548 fIntFlowDirectCorrelations->Fill(33.,cos(3.*n*phi1+3.*n*phi2-2.*n*phi3-2.*n*phi4-2.*n*phi5),1.); // <5>_{3n,3n|2n,2n,2n}
11549 fIntFlowDirectCorrelations->Fill(52.5,cos(3.*n*phi1+3.*n*phi2-3.*n*phi3-2.*n*phi4-1.*n*phi5),1.); // <5>_{3n,3n|3n,2n,1n}
11550 fIntFlowDirectCorrelations->Fill(53.5,cos(4.*n*phi1+2.*n*phi2-3.*n*phi3-2.*n*phi4-1.*n*phi5),1.); // <5>_{4n,2n|3n,2n,1n}
11551 fIntFlowDirectCorrelations->Fill(54.5,cos(3.*n*phi1+2.*n*phi2-3.*n*phi3-1.*n*phi4-1.*n*phi5),1.); // <5>_{3n,2n|3n,1n,1n}
11552 fIntFlowDirectCorrelations->Fill(55.5,cos(3.*n*phi1+2.*n*phi2-2.*n*phi3-2.*n*phi4-1.*n*phi5),1.); // <5>_{3n,2n|2n,2n,1n}
11553 fIntFlowDirectCorrelations->Fill(56.5,cos(5.*n*phi1+1.*n*phi2-3.*n*phi3-2.*n*phi4-1.*n*phi5),1.); // <5>_{5n,1n|3n,2n,1n}
403e3389 11554 fIntFlowDirectCorrelations->Fill(60.5,cos(6.*n*phi1-2.*n*phi2-2.*n*phi3-1.*n*phi4-1.*n*phi5),1.); // <5>_{6n|2n,2n,1n,1n}
11555 fIntFlowDirectCorrelations->Fill(61.5,cos(4.*n*phi1+1.*n*phi2+1.*n*phi3-3.*n*phi4-3.*n*phi5),1.); // <5>_{4n,1n,1n|3n,3n}
489d5531 11556 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11557 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11558 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11559 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11560 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11561 } // end of if(nPrim>=5)
11562
11563 // 6-particle correlations:
11564 if(nPrim>=6 && nPrim<=fMaxAllowedMultiplicity)
11565 {
11566 for(Int_t i1=0;i1<nPrim;i1++)
11567 {
11568 aftsTrack=anEvent->GetTrack(i1);
11569 if(!(aftsTrack->InRPSelection())) continue;
11570 phi1=aftsTrack->Phi();
11571 for(Int_t i2=0;i2<nPrim;i2++)
11572 {
11573 if(i2==i1)continue;
11574 aftsTrack=anEvent->GetTrack(i2);
11575 if(!(aftsTrack->InRPSelection())) continue;
11576 phi2=aftsTrack->Phi();
11577 for(Int_t i3=0;i3<nPrim;i3++)
11578 {
11579 if(i3==i1||i3==i2)continue;
11580 aftsTrack=anEvent->GetTrack(i3);
11581 if(!(aftsTrack->InRPSelection())) continue;
11582 phi3=aftsTrack->Phi();
11583 for(Int_t i4=0;i4<nPrim;i4++)
11584 {
11585 if(i4==i1||i4==i2||i4==i3)continue;
11586 aftsTrack=anEvent->GetTrack(i4);
11587 if(!(aftsTrack->InRPSelection())) continue;
11588 phi4=aftsTrack->Phi();
11589 for(Int_t i5=0;i5<nPrim;i5++)
11590 {
11591 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11592 aftsTrack=anEvent->GetTrack(i5);
11593 if(!(aftsTrack->InRPSelection())) continue;
11594 phi5=aftsTrack->Phi();
11595 for(Int_t i6=0;i6<nPrim;i6++)
11596 {
11597 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11598 aftsTrack=anEvent->GetTrack(i6);
11599 if(!(aftsTrack->InRPSelection())) continue;
11600 phi6=aftsTrack->Phi();
11601 if(nPrim==6) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<"\r"<<flush;
11602 // fill the profile with 6-p correlations:
403e3389 11603 fIntFlowDirectCorrelations->Fill(23.,cos(n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6),1.); // <6>_{1n,1n,1n|1n,1n,1n}
11604 fIntFlowDirectCorrelations->Fill(24.,cos(2.*n*phi1+n*phi2+n*phi3-2.*n*phi4-n*phi5-n*phi6),1.); // <6>_{2n,1n,1n|2n,1n,1n}
11605 fIntFlowDirectCorrelations->Fill(25.,cos(2.*n*phi1+2.*n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.); // <6>_{2n,2n|1n,1n,1n,1n}
11606 fIntFlowDirectCorrelations->Fill(26.,cos(3.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.); // <6>_{3n,1n|1n,1n,1n,1n}
b84464d3 11607 fIntFlowDirectCorrelations->Fill(57.5,cos(3.*n*phi1+2.*n*phi2+1.*n*phi3-3.*n*phi4-2.*n*phi5-1.*n*phi6),1.); // <6>_{3n,2n,1n|3n,2n,1n}
403e3389 11608 fIntFlowDirectCorrelations->Fill(62.5,cos(3.*n*phi1+3.*n*phi2-2.*n*phi3-2.*n*phi4-1.*n*phi5-1.*n*phi6),1.); // <6>_{3n,3n|2n,2n,1n,1n}
489d5531 11609 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11610 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11611 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11612 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11613 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11614 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11615 } // end of if(nPrim>=6)
11616
11617 // 7-particle correlations:
11618 if(nPrim>=7 && nPrim<=fMaxAllowedMultiplicity)
11619 {
11620 for(Int_t i1=0;i1<nPrim;i1++)
11621 {
11622 aftsTrack=anEvent->GetTrack(i1);
11623 if(!(aftsTrack->InRPSelection())) continue;
11624 phi1=aftsTrack->Phi();
11625 for(Int_t i2=0;i2<nPrim;i2++)
11626 {
11627 if(i2==i1)continue;
11628 aftsTrack=anEvent->GetTrack(i2);
11629 if(!(aftsTrack->InRPSelection())) continue;
11630 phi2=aftsTrack->Phi();
11631 for(Int_t i3=0;i3<nPrim;i3++)
11632 {
11633 if(i3==i1||i3==i2)continue;
11634 aftsTrack=anEvent->GetTrack(i3);
11635 if(!(aftsTrack->InRPSelection())) continue;
11636 phi3=aftsTrack->Phi();
11637 for(Int_t i4=0;i4<nPrim;i4++)
11638 {
11639 if(i4==i1||i4==i2||i4==i3)continue;
11640 aftsTrack=anEvent->GetTrack(i4);
11641 if(!(aftsTrack->InRPSelection())) continue;
11642 phi4=aftsTrack->Phi();
11643 for(Int_t i5=0;i5<nPrim;i5++)
11644 {
11645 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11646 aftsTrack=anEvent->GetTrack(i5);
11647 if(!(aftsTrack->InRPSelection())) continue;
11648 phi5=aftsTrack->Phi();
11649 for(Int_t i6=0;i6<nPrim;i6++)
11650 {
11651 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11652 aftsTrack=anEvent->GetTrack(i6);
11653 if(!(aftsTrack->InRPSelection())) continue;
11654 phi6=aftsTrack->Phi();
11655 for(Int_t i7=0;i7<nPrim;i7++)
11656 {
11657 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;
11658 aftsTrack=anEvent->GetTrack(i7);
11659 if(!(aftsTrack->InRPSelection())) continue;
11660 phi7=aftsTrack->Phi();
11661 if(nPrim==7) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<"\r"<<flush;
11662 // fill the profile with 7-p correlation:
11663 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}
11664 } // end of for(Int_t i7=0;i7<nPrim;i7++)
11665 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11666 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11667 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11668 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11669 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11670 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11671 } // end of if(nPrim>=7)
11672
11673 // 8-particle correlations:
11674 if(nPrim>=8 && nPrim<=fMaxAllowedMultiplicity)
11675 {
11676 for(Int_t i1=0;i1<nPrim;i1++)
11677 {
11678 aftsTrack=anEvent->GetTrack(i1);
11679 if(!(aftsTrack->InRPSelection())) continue;
11680 phi1=aftsTrack->Phi();
11681 for(Int_t i2=0;i2<nPrim;i2++)
11682 {
11683 if(i2==i1)continue;
11684 aftsTrack=anEvent->GetTrack(i2);
11685 if(!(aftsTrack->InRPSelection())) continue;
11686 phi2=aftsTrack->Phi();
11687 for(Int_t i3=0;i3<nPrim;i3++)
11688 {
11689 if(i3==i1||i3==i2)continue;
11690 aftsTrack=anEvent->GetTrack(i3);
11691 if(!(aftsTrack->InRPSelection())) continue;
11692 phi3=aftsTrack->Phi();
11693 for(Int_t i4=0;i4<nPrim;i4++)
11694 {
11695 if(i4==i1||i4==i2||i4==i3)continue;
11696 aftsTrack=anEvent->GetTrack(i4);
11697 if(!(aftsTrack->InRPSelection())) continue;
11698 phi4=aftsTrack->Phi();
11699 for(Int_t i5=0;i5<nPrim;i5++)
11700 {
11701 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11702 aftsTrack=anEvent->GetTrack(i5);
11703 if(!(aftsTrack->InRPSelection())) continue;
11704 phi5=aftsTrack->Phi();
11705 for(Int_t i6=0;i6<nPrim;i6++)
11706 {
11707 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11708 aftsTrack=anEvent->GetTrack(i6);
11709 if(!(aftsTrack->InRPSelection())) continue;
11710 phi6=aftsTrack->Phi();
11711 for(Int_t i7=0;i7<nPrim;i7++)
11712 {
11713 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;
11714 aftsTrack=anEvent->GetTrack(i7);
11715 if(!(aftsTrack->InRPSelection())) continue;
11716 phi7=aftsTrack->Phi();
11717 for(Int_t i8=0;i8<nPrim;i8++)
11718 {
11719 if(i8==i1||i8==i2||i8==i3||i8==i4||i8==i5||i8==i6||i8==i7)continue;
11720 aftsTrack=anEvent->GetTrack(i8);
11721 if(!(aftsTrack->InRPSelection())) continue;
11722 phi8=aftsTrack->Phi();
11723 cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<" "<<i8<<"\r"<<flush;
11724 // fill the profile with 8-p correlation:
11725 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}
11726 } // end of for(Int_t i8=0;i8<nPrim;i8++)
11727 } // end of for(Int_t i7=0;i7<nPrim;i7++)
11728 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11729 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11730 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11731 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11732 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11733 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11734 } // end of if(nPrim>=8)
11735
11736 cout<<endl;
11737
11738} // end of AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)
11739
11740
11741//==================================================================================================================================
11742
11743
11744void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()
11745{
11746 // Cross-check results for multiparticle correlations needed for int. flow: results from Q-vectors vs results from nested loops.
11747
11748 cout<<endl;
11749 cout<<endl;
11750 cout<<" *****************************************"<<endl;
11751 cout<<" **** cross-checking the correlations ****"<<endl;
11752 cout<<" **** for integrated flow ****"<<endl;
403e3389 11753 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 11754 {
11755 cout<<" **** (particle weights not used) ****"<<endl;
11756 } else
11757 {
11758 cout<<" **** (particle weights used) ****"<<endl;
11759 }
11760 cout<<" *****************************************"<<endl;
11761 cout<<endl;
11762 cout<<endl;
11763
403e3389 11764 Int_t ciMax = 64; // to be improved (removed eventually when I calculate 6th and 8th order with particle weights)
489d5531 11765
403e3389 11766 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 11767 {
11768 ciMax = 11;
11769 }
11770
11771 for(Int_t ci=1;ci<=ciMax;ci++)
11772 {
11773 if(strcmp((fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)
11774 cout<<(fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)
11775 cout<<"from Q-vectors = "<<fIntFlowCorrelationsAllPro->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)
11776 cout<<"from nested loops = "<<fIntFlowDirectCorrelations->GetBinContent(ci)<<endl;
11777 cout<<endl;
11778 }
11779
11780} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()
11781
489d5531 11782//================================================================================================================================
11783
489d5531 11784void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()
11785{
11786 // Cross-check results for corrections terms for non-uniform acceptance needed for int. flow: results from Q-vectors vs results from nested loops.
11787
11788 cout<<endl;
11789 cout<<endl;
11790 cout<<" *********************************************"<<endl;
11791 cout<<" **** cross-checking the correction terms ****"<<endl;
11792 cout<<" **** for non-uniform acceptance relevant ****"<<endl;
11793 cout<<" **** for integrated flow ****"<<endl;
403e3389 11794 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 11795 {
11796 cout<<" **** (particle weights not used) ****"<<endl;
11797 } else
11798 {
11799 cout<<" **** (particle weights used) ****"<<endl;
11800 }
11801 cout<<" *********************************************"<<endl;
11802 cout<<endl;
11803 cout<<endl;
11804
b92ea2b9 11805 for(Int_t ci=1;ci<=4;ci++) // correction term index (to be improved - hardwired 4)
489d5531 11806 {
11807 for(Int_t sc=0;sc<2;sc++) // sin or cos term
11808 {
11809 if(strcmp((fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)
11810 cout<<(fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)
11811 cout<<"from Q-vectors = "<<fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)
11812 cout<<"from nested loops = "<<fIntFlowDirectCorrectionTermsForNUA[sc]->GetBinContent(ci)<<endl;
11813 cout<<endl;
11814 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos term
11815 } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index
11816
11817} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()
11818
489d5531 11819//================================================================================================================================
11820
0328db2d 11821void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent)
489d5531 11822{
11823 // Evaluate with nested loops multiparticle correlations for integrated flow (using the particle weights).
11824
11825 // Results are stored in profile fIntFlowDirectCorrelations.
11826 // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrelations is organized as follows:
11827 //
11828 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>
11829 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>
11830 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))>
11831 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>
11832 // 5th bin: ---- EMPTY ----
11833 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
11834 // 7th bin: <3>_{3n|2n,1n} = ...
11835 // 8th bin: <3>_{4n|2n,2n} = ...
11836 // 9th bin: <3>_{4n|3n,1n} = ...
11837 // 10th bin: ---- EMPTY ----
11838 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
11839 // 12th bin: <4>_{2n,1n|2n,1n} = ...
11840 // 13th bin: <4>_{2n,2n|2n,2n} = ...
11841 // 14th bin: <4>_{3n|1n,1n,1n} = ...
11842 // 15th bin: <4>_{3n,1n|3n,1n} = ...
11843 // 16th bin: <4>_{3n,1n|2n,2n} = ...
11844 // 17th bin: <4>_{4n|2n,1n,1n} = ...
11845 // 18th bin: ---- EMPTY ----
11846 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...
11847 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...
11848 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...
11849 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...
11850 // 23rd bin: ---- EMPTY ----
11851 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...
11852 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...
11853 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...
11854 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...
11855 // 28th bin: ---- EMPTY ----
11856 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...
11857 // 30th bin: ---- EMPTY ----
11858 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...
57340a27 11859
489d5531 11860 // Remark 2: When particle weights are used there are some extra correlations. They are stored in
11861 // fIntFlowExtraDirectCorrelations binning of which is organized as follows:
57340a27 11862
489d5531 11863 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>
11864 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>
11865 // ...
57340a27 11866
489d5531 11867 Int_t nPrim = anEvent->NumberOfTracks();
11868 AliFlowTrackSimple *aftsTrack = NULL;
11869 //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
11870 //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
11871 Double_t phi1=0., phi2=0., phi3=0., phi4=0.;
11872 Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1.;
11873 Int_t n = fHarmonic;
11874 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 11875 Double_t dMult = (*fSpk)(0,0);
489d5531 11876 cout<<endl;
11877 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
11878 if(dMult<2)
11879 {
11880 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
11881 } else if (dMult>fMaxAllowedMultiplicity)
11882 {
11883 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
11884 } else
11885 {
11886 cout<<"... evaluating nested loops (using particle weights) ..."<<endl;
11887 }
11888
11889 // 2-particle correlations:
11890 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
11891 {
11892 // 2 nested loops multiparticle correlations using particle weights:
11893 for(Int_t i1=0;i1<nPrim;i1++)
11894 {
11895 aftsTrack=anEvent->GetTrack(i1);
11896 if(!(aftsTrack->InRPSelection())) continue;
11897 phi1=aftsTrack->Phi();
11898 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
11899 for(Int_t i2=0;i2<nPrim;i2++)
11900 {
11901 if(i2==i1)continue;
11902 aftsTrack=anEvent->GetTrack(i2);
11903 if(!(aftsTrack->InRPSelection())) continue;
11904 phi2=aftsTrack->Phi();
11905 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
11906 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
11907 // 2-p correlations using particle weights:
11908 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),wPhi1*wPhi2); // <w1 w2 cos( n*(phi1-phi2))>
11909 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))>
11910 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))>
11911 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))>
11912 // extra correlations:
11913 // 2-p extra correlations (do not appear if particle weights are not used):
11914 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),pow(wPhi1,3)*wPhi2); // <w1^3 w2 cos(n*(phi1-phi2))>
11915 // ...
11916 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11917 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11918 } // end of if(nPrim>=2)
11919
11920 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
57340a27 11921 {
489d5531 11922 // 3 nested loops multiparticle correlations using particle weights:
11923 for(Int_t i1=0;i1<nPrim;i1++)
57340a27 11924 {
489d5531 11925 aftsTrack=anEvent->GetTrack(i1);
11926 if(!(aftsTrack->InRPSelection())) continue;
11927 phi1=aftsTrack->Phi();
11928 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
11929 for(Int_t i2=0;i2<nPrim;i2++)
11930 {
11931 if(i2==i1)continue;
11932 aftsTrack=anEvent->GetTrack(i2);
11933 if(!(aftsTrack->InRPSelection())) continue;
11934 phi2=aftsTrack->Phi();
11935 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
11936 for(Int_t i3=0;i3<nPrim;i3++)
11937 {
11938 if(i3==i1||i3==i2)continue;
11939 aftsTrack=anEvent->GetTrack(i3);
11940 if(!(aftsTrack->InRPSelection())) continue;
11941 phi3=aftsTrack->Phi();
11942 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
11943 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
11944 // 3-p correlations using particle weights:
11945 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))>
11946 // ...
11947 // extra correlations:
11948 // 2-p extra correlations (do not appear if particle weights are not used):
11949 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(1.5,cos(n*(phi1-phi2)),wPhi1*wPhi2*pow(wPhi3,2)); // <w1 w2 w3^2 cos(n*(phi1-phi2))>
11950 // ...
11951 // 3-p extra correlations (do not appear if particle weights are not used):
11952 // ...
11953 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11954 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11955 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11956 } // end of if(nPrim>=3)
57340a27 11957
489d5531 11958 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
11959 {
11960 // 4 nested loops multiparticle correlations using particle weights:
11961 for(Int_t i1=0;i1<nPrim;i1++)
11962 {
11963 aftsTrack=anEvent->GetTrack(i1);
11964 if(!(aftsTrack->InRPSelection())) continue;
11965 phi1=aftsTrack->Phi();
11966 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
11967 for(Int_t i2=0;i2<nPrim;i2++)
11968 {
11969 if(i2==i1)continue;
11970 aftsTrack=anEvent->GetTrack(i2);
11971 if(!(aftsTrack->InRPSelection())) continue;
11972 phi2=aftsTrack->Phi();
11973 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
11974 for(Int_t i3=0;i3<nPrim;i3++)
11975 {
11976 if(i3==i1||i3==i2)continue;
11977 aftsTrack=anEvent->GetTrack(i3);
11978 if(!(aftsTrack->InRPSelection())) continue;
11979 phi3=aftsTrack->Phi();
11980 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
11981 for(Int_t i4=0;i4<nPrim;i4++)
11982 {
11983 if(i4==i1||i4==i2||i4==i3)continue;
11984 aftsTrack=anEvent->GetTrack(i4);
11985 if(!(aftsTrack->InRPSelection())) continue;
11986 phi4=aftsTrack->Phi();
11987 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
11988 if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))
11989 // 4-p correlations using particle weights:
11990 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4);
11991 // extra correlations:
11992 // 2-p extra correlations (do not appear if particle weights are not used):
11993 // ...
11994 // 3-p extra correlations (do not appear if particle weights are not used):
11995 // ...
11996 // 4-p extra correlations (do not appear if particle weights are not used):
11997 // ...
11998 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11999 } // end of for(Int_t i3=0;i3<nPrim;i3++)
12000 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12001 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12002 } // end of if(nPrim>=4)
57340a27 12003
489d5531 12004 cout<<endl;
57340a27 12005
489d5531 12006} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)
57340a27 12007
489d5531 12008//================================================================================================================================
12009
489d5531 12010void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()
57340a27 12011{
489d5531 12012 // Cross-check results for extra multiparticle correlations needed for int. flow
12013 // which appear only when particle weights are used: results from Q-vectors vs results from nested loops.
57340a27 12014
489d5531 12015 cout<<endl;
12016 cout<<endl;
12017 cout<<" ***********************************************"<<endl;
12018 cout<<" **** cross-checking the extra correlations ****"<<endl;
12019 cout<<" **** for integrated flow ****"<<endl;
12020 cout<<" ***********************************************"<<endl;
12021 cout<<endl;
12022 cout<<endl;
12023
12024 for(Int_t eci=1;eci<=2;eci++) // to be improved (increased eciMax eventually when I calculate 6th and 8th)
57340a27 12025 {
489d5531 12026 if(strcmp((fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci), "") == 0) continue;
12027 cout<<(fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci)<<":"<<endl;
12028 cout<<"from Q-vectors = "<<fIntFlowExtraCorrelationsPro->GetBinContent(eci)<<endl;
12029 cout<<"from nested loops = "<<fIntFlowExtraDirectCorrelations->GetBinContent(eci)<<endl;
12030 cout<<endl;
12031 }
57340a27 12032
489d5531 12033} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()
57340a27 12034
489d5531 12035//================================================================================================================================
3b552efe 12036
0328db2d 12037void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoops(AliFlowEventSimple * const anEvent)
489d5531 12038{
12039 // Evaluate with nested loops correction terms for non-uniform acceptance relevant for NONAME integrated flow (to be improved (name)).
12040 //
12041 // Remark: Both sin and cos correction terms are calculated in this method. Sin terms are stored in fIntFlowDirectCorrectionTermsForNUA[0],
12042 // and cos terms in fIntFlowDirectCorrectionTermsForNUA[1]. Binning of fIntFlowDirectCorrectionTermsForNUA[sc] is organized as follows
12043 // (sc stands for either sin or cos):
12044
12045 // 1st bin: <<sc(n*(phi1))>>
12046 // 2nd bin: <<sc(n*(phi1+phi2))>>
12047 // 3rd bin: <<sc(n*(phi1-phi2-phi3))>>
12048 // 4th bin: <<sc(n*(2phi1-phi2))>>
12049
12050 Int_t nPrim = anEvent->NumberOfTracks();
12051 AliFlowTrackSimple *aftsTrack = NULL;
12052 Double_t phi1=0., phi2=0., phi3=0.;
12053 Int_t n = fHarmonic;
12054 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 12055 Double_t dMult = (*fSpk)(0,0);
489d5531 12056 cout<<endl;
12057 cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
12058 if(dMult<1)
3b552efe 12059 {
489d5531 12060 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
12061 } else if (dMult>fMaxAllowedMultiplicity)
3b552efe 12062 {
489d5531 12063 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
12064 } else
12065 {
12066 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;
12067 }
12068
12069 if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
12070 {
12071 // 1-particle correction terms for non-uniform acceptance:
12072 for(Int_t i1=0;i1<nPrim;i1++)
12073 {
12074 aftsTrack=anEvent->GetTrack(i1);
12075 if(!(aftsTrack->InRPSelection())) continue;
12076 phi1=aftsTrack->Phi();
12077 if(nPrim==1) cout<<i1<<"\r"<<flush;
12078 // sin terms:
12079 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),1.); // <sin(n*phi1)>
12080 // cos terms:
12081 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),1.); // <cos(n*phi1)>
12082 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12083 } // end of if(nPrim>=1)
12084
12085 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
12086 {
12087 // 2-particle correction terms for non-uniform acceptance:
12088 for(Int_t i1=0;i1<nPrim;i1++)
12089 {
12090 aftsTrack=anEvent->GetTrack(i1);
12091 if(!(aftsTrack->InRPSelection())) continue;
12092 phi1=aftsTrack->Phi();
12093 for(Int_t i2=0;i2<nPrim;i2++)
3b552efe 12094 {
489d5531 12095 if(i2==i1)continue;
12096 aftsTrack=anEvent->GetTrack(i2);
12097 if(!(aftsTrack->InRPSelection())) continue;
12098 phi2=aftsTrack->Phi();
12099 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
12100 // sin terms:
3b552efe 12101 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),1.); // <<sin(n*(phi1+phi2))>>
489d5531 12102 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(3.5,sin(n*(2*phi1-phi2)),1.); // <<sin(n*(2*phi1-phi2))>>
12103 // cos terms:
3b552efe 12104 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),1.); // <<cos(n*(phi1+phi2))>>
489d5531 12105 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(3.5,cos(n*(2*phi1-phi2)),1.); // <<cos(n*(2*phi1-phi2))>>
12106 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12107 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12108 } // end of if(nPrim>=2)
12109
12110 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
12111 {
12112 // 3-particle correction terms for non-uniform acceptance:
12113 for(Int_t i1=0;i1<nPrim;i1++)
12114 {
12115 aftsTrack=anEvent->GetTrack(i1);
12116 if(!(aftsTrack->InRPSelection())) continue;
12117 phi1=aftsTrack->Phi();
12118 for(Int_t i2=0;i2<nPrim;i2++)
12119 {
12120 if(i2==i1)continue;
12121 aftsTrack=anEvent->GetTrack(i2);
12122 if(!(aftsTrack->InRPSelection())) continue;
12123 phi2=aftsTrack->Phi();
12124 for(Int_t i3=0;i3<nPrim;i3++)
12125 {
12126 if(i3==i1||i3==i2)continue;
12127 aftsTrack=anEvent->GetTrack(i3);
12128 if(!(aftsTrack->InRPSelection())) continue;
12129 phi3=aftsTrack->Phi();
12130 if(nPrim>=3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush; // to be improved (eventually I will change this if statement)
12131 // sin terms:
12132 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),1.); // <<sin(n*(phi1-phi2-phi3))>>
12133 // cos terms:
12134 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),1.); // <<cos(n*(phi1-phi2-phi3))>>
12135 } // end of for(Int_t i3=0;i3<nPrim;i3++)
12136 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12137 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12138 } // end of if(nPrim>=3)
12139
12140 cout<<endl;
12141}
64e500e3 12142
489d5531 12143//================================================================================================================================
64e500e3 12144
0328db2d 12145void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12146{
12147 // Evaluate reduced correlations with nested loops without using the particle weights.
12148
12149 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12150 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:
12151 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>]
12152 // Remark 3: <2'> = <cos(n*(psi1-phi2))>
12153 // <4'> = <cos(n*(psi1+phi2-phi3-phi4))>
12154 // ...
12155
2a98ceb8 12156 Int_t typeFlag = 0;
12157 Int_t ptEtaFlag = 0;
489d5531 12158 if(type == "RP")
12159 {
12160 typeFlag = 0;
12161 } else if(type == "POI")
12162 {
12163 typeFlag = 1;
12164 }
12165 if(ptOrEta == "Pt")
12166 {
12167 ptEtaFlag = 0;
12168 } else if(ptOrEta == "Eta")
12169 {
12170 ptEtaFlag = 1;
12171 }
12172 // shortcuts:
12173 Int_t t = typeFlag;
12174 Int_t pe = ptEtaFlag;
12175
12176 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12177 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12178 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12179
12180 Int_t nPrim = anEvent->NumberOfTracks();
12181 AliFlowTrackSimple *aftsTrack = NULL;
12182
12183 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12184
3b552efe 12185 Int_t n = fHarmonic;
489d5531 12186
12187 // 2'-particle correlations:
12188 for(Int_t i1=0;i1<nPrim;i1++)
12189 {
12190 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12191 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12192 if(typeFlag==1) // this is diff flow of POIs
489d5531 12193 {
12194 if(ptOrEta == "Pt")
12195 {
12196 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12197 } else if (ptOrEta == "Eta")
12198 {
12199 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12200 }
12201 } else // this is diff flow of RPs
12202 {
489d5531 12203 if(ptOrEta == "Pt")
12204 {
12205 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12206 } else if (ptOrEta == "Eta")
12207 {
12208 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12209 }
12210 }
489d5531 12211
12212 psi1=aftsTrack->Phi();
12213 for(Int_t i2=0;i2<nPrim;i2++)
12214 {
12215 if(i2==i1)continue;
12216 aftsTrack=anEvent->GetTrack(i2);
12217 // RP condition (!(first) particle in the correlator must be RP):
12218 if(!(aftsTrack->InRPSelection()))continue;
12219 phi2=aftsTrack->Phi();
12220 // 2'-particle correlations:
12221 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),1.); // <cos(n*(psi1-phi2))
12222 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12223 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12224
12225 /*
12226
12227 // 3'-particle correlations:
12228 for(Int_t i1=0;i1<nPrim;i1++)
12229 {
12230 aftsTrack=anEvent->GetTrack(i1);
12231 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12232 if(ptOrEta == "Pt")
12233 {
12234 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12235 } else if (ptOrEta == "Eta")
12236 {
12237 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12238 }
12239 psi1=aftsTrack->Phi();
12240 for(Int_t i2=0;i2<nPrim;i2++)
12241 {
12242 if(i2==i1)continue;
12243 aftsTrack=anEvent->GetTrack(i2);
12244 // RP condition (!(first) particle in the correlator must be RP):
12245 if(!(aftsTrack->InRPSelection())) continue;
12246 phi2=aftsTrack->Phi();
12247 for(Int_t i3=0;i3<nPrim;i3++)
12248 {
12249 if(i3==i1||i3==i2)continue;
12250 aftsTrack=anEvent->GetTrack(i3);
12251 // RP condition (!(first) particle in the correlator must be RP):
12252 if(!(aftsTrack->InRPSelection())) continue;
12253 phi3=aftsTrack->Phi();
12254 // 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))>
12255 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12256 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12257 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12258
12259 */
12260
12261 // 4'-particle correlations:
12262 for(Int_t i1=0;i1<nPrim;i1++)
12263 {
12264 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12265 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12266 if(typeFlag==1) // this is diff flow of POIs
489d5531 12267 {
12268 if(ptOrEta == "Pt")
12269 {
12270 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12271 } else if (ptOrEta == "Eta")
12272 {
12273 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12274 }
12275 } else // this is diff flow of RPs
12276 {
489d5531 12277 if(ptOrEta == "Pt")
12278 {
12279 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12280 } else if (ptOrEta == "Eta")
12281 {
12282 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12283 }
12284 }
489d5531 12285
12286 psi1=aftsTrack->Phi();
12287 for(Int_t i2=0;i2<nPrim;i2++)
12288 {
12289 if(i2==i1) continue;
12290 aftsTrack=anEvent->GetTrack(i2);
12291 // RP condition (!(first) particle in the correlator must be RP):
12292 if(!(aftsTrack->InRPSelection())) continue;
12293 phi2=aftsTrack->Phi();
12294 for(Int_t i3=0;i3<nPrim;i3++)
12295 {
12296 if(i3==i1||i3==i2) continue;
12297 aftsTrack=anEvent->GetTrack(i3);
12298 // RP condition (!(first) particle in the correlator must be RP):
12299 if(!(aftsTrack->InRPSelection())) continue;
12300 phi3=aftsTrack->Phi();
12301 for(Int_t i4=0;i4<nPrim;i4++)
12302 {
12303 if(i4==i1||i4==i2||i4==i3) continue;
12304 aftsTrack=anEvent->GetTrack(i4);
12305 // RP condition (!(first) particle in the correlator must be RP):
12306 if(!(aftsTrack->InRPSelection())) continue;
12307 phi4=aftsTrack->Phi();
12308 // 4'-particle correlations:
12309 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),1.); // <cos(n(psi1+phi2-phi3-phi4))>
12310 }//end of for(Int_t i4=0;i4<nPrim;i4++)
12311 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12312 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12313 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12314
12315 // count # of RPs and POIs in selected pt and eta bins for cross-checkings:
3b552efe 12316 for(Int_t i=0;i<nPrim;i++)
12317 {
12318 aftsTrack=anEvent->GetTrack(i);
12319 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12320 if(typeFlag==1) // this is diff flow of POIs
489d5531 12321 {
12322 if(ptOrEta == "Pt")
12323 {
12324 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12325 } else if (ptOrEta == "Eta")
12326 {
12327 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12328 }
12329 } else // this is diff flow of RPs
12330 {
489d5531 12331 if(ptOrEta == "Pt")
12332 {
12333 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12334 } else if (ptOrEta == "Eta")
12335 {
12336 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12337 }
12338 }
12339 if(t==1)t++;
12340 fNoOfParticlesInBin->Fill(t+pe+0.5);
489d5531 12341 }
12342
12343} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12344
489d5531 12345//================================================================================================================================
12346
64e500e3 12347void AliFlowAnalysisWithQCumulants::EvaluateOtherDiffCorrelatorsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
12348{
12349 // Evaluate other differential correlators with nested loops without using the particle weights.
12350
12351 // Remark 1: Other differential correlators are evaluated in pt bin number fCrossCheckInPtBinNo
12352 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12353 // Remark 2: Results are stored in 1 bin profiles fOtherDirectDiffCorrelators[t][pe][sc][ci], where indices runs as follows:
12354 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms][ci = correlator index]
12355 // Remark 3: Correlator index 'ci' runs as follows:
12356 // 0: <exp(n*(psi1-3phi2+2phi3))> (Teaney-Yan correlator)
12357
12358 Int_t typeFlag = 0;
12359 Int_t ptEtaFlag = 0;
12360 if(type == "RP")
12361 {
12362 typeFlag = 0;
12363 } else if(type == "POI")
12364 {
12365 typeFlag = 1;
12366 }
12367 if(ptOrEta == "Pt")
12368 {
12369 ptEtaFlag = 0;
12370 } else if(ptOrEta == "Eta")
12371 {
12372 ptEtaFlag = 1;
12373 }
12374 // shortcuts:
12375 Int_t t = typeFlag;
12376 Int_t pe = ptEtaFlag;
12377
12378 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12379 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12380 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12381
12382 Int_t nPrim = anEvent->NumberOfTracks();
12383 AliFlowTrackSimple *aftsTrack = NULL;
12384
12385 Double_t psi1=0., phi2=0., phi3=0.;
12386
12387 Int_t n = fHarmonic;
12388
12389 // 3-p correlators:
12390 for(Int_t i1=0;i1<nPrim;i1++)
12391 {
12392 aftsTrack=anEvent->GetTrack(i1);
12393 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12394 if(typeFlag==1) // this is diff flow of POIs
12395 {
12396 if(ptOrEta == "Pt")
12397 {
12398 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12399 } else if (ptOrEta == "Eta")
12400 {
12401 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12402 }
12403 } else // this is diff flow of RPs
12404 {
12405 if(ptOrEta == "Pt")
12406 {
12407 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12408 } else if (ptOrEta == "Eta")
12409 {
12410 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12411 }
12412 }
12413 psi1=aftsTrack->Phi();
12414 for(Int_t i2=0;i2<nPrim;i2++)
12415 {
12416 if(i2==i1) continue;
12417 aftsTrack=anEvent->GetTrack(i2);
12418 // RP condition (!(first) particle in the correlator must be RP):
12419 if(!(aftsTrack->InRPSelection())) continue;
12420 phi2=aftsTrack->Phi();
12421 for(Int_t i3=0;i3<nPrim;i3++)
12422 {
12423 if(i3==i1||i3==i2) continue;
12424 aftsTrack=anEvent->GetTrack(i3);
12425 // RP condition (!(first) particle in the correlator must be RP):
12426 if(!(aftsTrack->InRPSelection())) continue;
12427 phi3=aftsTrack->Phi();
12428 // Fill 3-p correlators:
12429 fOtherDirectDiffCorrelators[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-3.*phi2+2.*phi3)),1.); // <cos(n(psi1-3.*phi2+2.*phi3))>
12430 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12431 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12432 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12433} // end of void AliFlowAnalysisWithQCumulants::EvaluateOtherDiffCorrelatorsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
12434
12435//================================================================================================================================
489d5531 12436
12437void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)
12438{
12439 // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors
12440
2a98ceb8 12441 Int_t typeFlag = 0;
12442 Int_t ptEtaFlag = 0;
489d5531 12443 if(type == "RP")
12444 {
12445 typeFlag = 0;
12446 } else if(type == "POI")
12447 {
12448 typeFlag = 1;
12449 }
12450 if(ptOrEta == "Pt")
12451 {
12452 ptEtaFlag = 0;
12453 } else if(ptOrEta == "Eta")
12454 {
12455 ptEtaFlag = 1;
12456 }
12457 // shortcuts:
12458 Int_t t = typeFlag;
12459 Int_t pe = ptEtaFlag;
12460
12461 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12462 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12463 TString reducedCorrelations[4] = {"<<cos(n(psi1-phi2))>>","<<cos(n(psi1+phi2-phi3-phi4))>>","",""}; // to be improved (access this from pro or hist)
12464 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12465 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12466
12467 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
12468
12469
12470 cout<<endl;
12471 cout<<" *****************************************"<<endl;
12472 cout<<" **** cross-checking the correlations ****"<<endl;
12473 cout<<" **** for differential flow ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 12474 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 12475 {
12476 cout<<" **** (particle weights not used) ****"<<endl;
12477 } else
12478 {
12479 cout<<" **** (particle weights used) ****"<<endl;
12480 }
12481 cout<<" *****************************************"<<endl;
12482 cout<<endl;
12483 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
12484 cout<<endl;
12485
12486 for(Int_t rci=0;rci<2;rci++) // to be improved (calculate 6th and 8th order)
12487 {
12488 cout<<" "<<reducedCorrelations[rci].Data()<<":"<<endl;
12489 cout<<" from Q-vectors = "<<fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
12490 cout<<" from nested loops = "<<fDiffFlowDirectCorrelations[t][pe][rci]->GetBinContent(1)<<endl;
12491 cout<<endl;
12492 } // end of for(Int_t rci=0;rci<4;rci++)
12493
12494} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)
12495
3b552efe 12496//================================================================================================================================
12497
64e500e3 12498void AliFlowAnalysisWithQCumulants::CrossCheckOtherDiffCorrelators(TString type, TString ptOrEta)
12499{
12500 // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors
12501
12502 Int_t typeFlag = 0;
12503 Int_t ptEtaFlag = 0;
12504 if(type == "RP")
12505 {
12506 typeFlag = 0;
12507 } else if(type == "POI")
12508 {
12509 typeFlag = 1;
12510 }
12511 if(ptOrEta == "Pt")
12512 {
12513 ptEtaFlag = 0;
12514 } else if(ptOrEta == "Eta")
12515 {
12516 ptEtaFlag = 1;
12517 }
12518 // shortcuts:
12519 Int_t t = typeFlag;
12520 Int_t pe = ptEtaFlag;
12521
12522 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12523 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12524 TString otherCorrelators[1] = {"<<cos(n(psi1-3phi2+2phi3))>>"}; // to be improved (access this from pro or hist)
12525 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12526 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12527
12528 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
12529
12530 cout<<endl;
12531 cout<<" *****************************************"<<endl;
12532 cout<<" **** cross-checking the other ****"<<endl;
12533 cout<<" **** diff. correlators ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 12534 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 12535 {
12536 cout<<" **** (particle weights not used) ****"<<endl;
12537 } else
12538 {
12539 cout<<" **** (particle weights used) ****"<<endl;
12540 }
12541 cout<<" *****************************************"<<endl;
12542 cout<<endl;
12543 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
12544 cout<<endl;
12545
12546 for(Int_t ci=0;ci<1;ci++)
12547 {
12548 cout<<" "<<otherCorrelators[ci].Data()<<":"<<endl;
12549 cout<<" from Q-vectors = "<<fOtherDiffCorrelators[t][pe][1][ci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
12550 cout<<" from nested loops = "<<fOtherDirectDiffCorrelators[t][pe][1][ci]->GetBinContent(1)<<endl;
12551 cout<<endl;
12552 } // end of for(Int_t ci=0;ci<1;ci++)
12553
12554} // end of void AliFlowAnalysisWithQCumulants::CrossCheckOtherDiffCorrelators(TString type, TString ptOrEta)
12555
12556//================================================================================================================================
12557
489d5531 12558void AliFlowAnalysisWithQCumulants::PrintNumberOfParticlesInSelectedBin()
3b552efe 12559{
12560 // Print on the screen number of RPs and POIs in selected pt and eta bin for cross checkings.
12561
12562 cout<<endl;
12563 cout<<"Number of RPs in selected pt bin = "<<fNoOfParticlesInBin->GetBinContent(1)<<endl;
12564 cout<<"Number of RPs in selected eta bin = "<<fNoOfParticlesInBin->GetBinContent(2)<<endl;
12565 cout<<"Number of POIs in selected pt bin = "<<fNoOfParticlesInBin->GetBinContent(3)<<endl;
12566 cout<<"Number of POIs in selected eta bin = "<<fNoOfParticlesInBin->GetBinContent(4)<<endl;
12567
489d5531 12568} // end of void AliFlowAnalysisWithQCumulants::PrintNumberOfParticlesInSelectedBin()
12569
3b552efe 12570//================================================================================================================================
12571
0328db2d 12572void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12573{
12574 // Evaluate reduced correlations with nested loops without using the particle weights.
12575
12576 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12577 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:
12578 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>]
12579 // Remark 3: <2'> = <w2 cos(n*(psi1-phi2))>
12580 // <4'> = <w2 w3 w4 cos(n*(psi1+phi2-phi3-phi4))>
12581 // ...
12582
2a98ceb8 12583 Int_t typeFlag = 0;
12584 Int_t ptEtaFlag = 0;
489d5531 12585 if(type == "RP")
12586 {
12587 typeFlag = 0;
12588 } else if(type == "POI")
12589 {
12590 typeFlag = 1;
12591 }
12592 if(ptOrEta == "Pt")
12593 {
12594 ptEtaFlag = 0;
12595 } else if(ptOrEta == "Eta")
12596 {
12597 ptEtaFlag = 1;
12598 }
12599 // shortcuts:
12600 Int_t t = typeFlag;
12601 Int_t pe = ptEtaFlag;
12602
12603 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12604 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12605 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12606
12607 Int_t nPrim = anEvent->NumberOfTracks();
12608 AliFlowTrackSimple *aftsTrack = NULL;
12609
12610 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12611 Double_t wPhi2=1., wPhi3=1., wPhi4=1.;// wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
12612
12613 Int_t n = fHarmonic;
12614
12615 // 2'-particle correlations:
12616 for(Int_t i1=0;i1<nPrim;i1++)
12617 {
12618 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12619 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12620 if(typeFlag==1) // this is diff flow of POIs
489d5531 12621 {
12622 if(ptOrEta == "Pt")
12623 {
12624 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12625 } else if (ptOrEta == "Eta")
12626 {
12627 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12628 }
12629 } else // this is diff flow of RPs
12630 {
489d5531 12631 if(ptOrEta == "Pt")
12632 {
12633 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12634 } else if (ptOrEta == "Eta")
12635 {
12636 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12637 }
489d5531 12638 }
12639 psi1=aftsTrack->Phi();
12640 for(Int_t i2=0;i2<nPrim;i2++)
12641 {
12642 if(i2==i1) continue;
12643 aftsTrack=anEvent->GetTrack(i2);
12644 // RP condition (!(first) particle in the correlator must be RP):
12645 if(!(aftsTrack->InRPSelection())) continue;
12646 phi2=aftsTrack->Phi();
12647 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12648 // 2'-particle correlations:
12649 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),wPhi2); // <w2 cos(n*(psi1-phi2))
12650 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12651 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12652
12653 // 4'-particle correlations:
12654 for(Int_t i1=0;i1<nPrim;i1++)
12655 {
12656 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12657 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12658 if(typeFlag==1) // this is diff flow of POIs
489d5531 12659 {
12660 if(ptOrEta == "Pt")
12661 {
12662 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12663 } else if (ptOrEta == "Eta")
12664 {
12665 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12666 }
12667 } else // this is diff flow of RPs
12668 {
489d5531 12669 if(ptOrEta == "Pt")
12670 {
12671 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12672 } else if (ptOrEta == "Eta")
12673 {
12674 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12675 }
489d5531 12676 }
12677 psi1=aftsTrack->Phi();
12678 for(Int_t i2=0;i2<nPrim;i2++)
12679 {
12680 if(i2==i1) continue;
12681 aftsTrack=anEvent->GetTrack(i2);
12682 // RP condition (!(first) particle in the correlator must be RP):
12683 if(!(aftsTrack->InRPSelection())) continue;
12684 phi2=aftsTrack->Phi();
12685 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12686 for(Int_t i3=0;i3<nPrim;i3++)
12687 {
12688 if(i3==i1||i3==i2) continue;
12689 aftsTrack=anEvent->GetTrack(i3);
12690 // RP condition (!(first) particle in the correlator must be RP):
12691 if(!(aftsTrack->InRPSelection())) continue;
12692 phi3=aftsTrack->Phi();
12693 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
12694 for(Int_t i4=0;i4<nPrim;i4++)
12695 {
12696 if(i4==i1||i4==i2||i4==i3) continue;
12697 aftsTrack=anEvent->GetTrack(i4);
12698 // RP condition (!(first) particle in the correlator must be RP):
12699 if(!(aftsTrack->InRPSelection())) continue;
12700 phi4=aftsTrack->Phi();
12701 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
12702 // 4'-particle correlations <w2 w3 w4 cos(n(psi1+phi2-phi3-phi4))>:
12703 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),wPhi2*wPhi3*wPhi4);
12704 }//end of for(Int_t i4=0;i4<nPrim;i4++)
12705 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12706 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12707 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12708
12709 // count # of RPs and POIs in selected pt and eta bins for cross-checkings: (to be improved - moved to dedicated method)
3b552efe 12710 for(Int_t i=0;i<nPrim;i++)
12711 {
489d5531 12712 aftsTrack=anEvent->GetTrack(i);
12713 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12714 if(typeFlag==1) // this is diff flow of POIs
12715 {
12716 if(ptOrEta == "Pt")
12717 {
12718 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12719 } else if (ptOrEta == "Eta")
12720 {
12721 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12722 }
12723 } else // this is diff flow of RPs
12724 {
12725 if(ptOrEta == "Pt")
12726 {
12727 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12728 } else if (ptOrEta == "Eta")
12729 {
12730 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12731 }
12732 }
12733 if(t==1)t++;
12734 fNoOfParticlesInBin->Fill(t+pe+0.5);
12735 }
12736
12737} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12738
489d5531 12739//================================================================================================================================
12740
0328db2d 12741void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12742{
12743 // Evaluate with nested loops correction terms for non-uniform acceptance (both sin and cos terms) relevant for differential flow.
12744
12745 // Remark 1: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo
12746 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12747 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as:
12748 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows:
12749 // cti:
12750 // 0: <<sc n(psi1)>>
12751 // 1: <<sc n(psi1+phi2)>>
12752 // 2: <<sc n(psi1+phi2-phi3)>>
12753 // 3: <<sc n(psi1-phi2-phi3)>>
12754 // 4:
12755 // 5:
12756 // 6:
12757
2a98ceb8 12758 Int_t typeFlag = 0;
12759 Int_t ptEtaFlag = 0;
489d5531 12760 if(type == "RP")
12761 {
12762 typeFlag = 0;
12763 } else if(type == "POI")
12764 {
12765 typeFlag = 1;
12766 }
12767 if(ptOrEta == "Pt")
12768 {
12769 ptEtaFlag = 0;
12770 } else if(ptOrEta == "Eta")
12771 {
12772 ptEtaFlag = 1;
12773 }
12774 // shortcuts:
12775 Int_t t = typeFlag;
12776 Int_t pe = ptEtaFlag;
12777
12778 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12779 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12780 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12781
12782 Int_t nPrim = anEvent->NumberOfTracks();
12783 AliFlowTrackSimple *aftsTrack = NULL;
12784
12785 Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12786
12787 Int_t n = fHarmonic;
12788
12789 // 1-particle correction terms:
12790 for(Int_t i1=0;i1<nPrim;i1++)
12791 {
12792 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12793 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12794 if(typeFlag==1) // this is diff flow of POIs
489d5531 12795 {
12796 if(ptOrEta == "Pt")
12797 {
12798 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12799 } else if (ptOrEta == "Eta")
12800 {
12801 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12802 }
12803 } else // this is diff flow of RPs
12804 {
489d5531 12805 if(ptOrEta == "Pt")
12806 {
12807 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12808 } else if (ptOrEta == "Eta")
12809 {
12810 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12811 }
12812 }
489d5531 12813 psi1=aftsTrack->Phi();
12814 // sin terms:
12815 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>
12816 // cos terms:
12817 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>
12818 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12819
12820 // 2-particle correction terms:
12821 for(Int_t i1=0;i1<nPrim;i1++)
12822 {
12823 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12824 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12825 if(typeFlag==1) // this is diff flow of POIs
489d5531 12826 {
12827 if(ptOrEta == "Pt")
12828 {
12829 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12830 } else if (ptOrEta == "Eta")
12831 {
12832 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12833 }
12834 } else // this is diff flow of RPs
12835 {
489d5531 12836 if(ptOrEta == "Pt")
12837 {
12838 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12839 } else if (ptOrEta == "Eta")
12840 {
12841 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12842 }
489d5531 12843 }
12844 psi1=aftsTrack->Phi();
12845 for(Int_t i2=0;i2<nPrim;i2++)
12846 {
12847 if(i2==i1) continue;
12848 aftsTrack=anEvent->GetTrack(i2);
12849 // RP condition (!(first) particle in the correlator must be RP):
12850 if(!(aftsTrack->InRPSelection())) continue;
12851 phi2=aftsTrack->Phi();
12852 // sin terms:
12853 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),1.); // <<sin(n*(psi1+phi2))>>
12854 // cos terms:
12855 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),1.); // <<cos(n*(psi1+phi2))>>
12856 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12857 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12858
12859 // 3-particle correction terms:
12860 for(Int_t i1=0;i1<nPrim;i1++)
12861 {
12862 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12863 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12864 if(typeFlag==1) // this is diff flow of POIs
489d5531 12865 {
12866 if(ptOrEta == "Pt")
12867 {
12868 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12869 } else if (ptOrEta == "Eta")
12870 {
12871 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12872 }
12873 } else // this is diff flow of RPs
12874 {
489d5531 12875 if(ptOrEta == "Pt")
12876 {
12877 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12878 } else if (ptOrEta == "Eta")
12879 {
12880 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12881 }
489d5531 12882 }
12883 psi1=aftsTrack->Phi();
12884 for(Int_t i2=0;i2<nPrim;i2++)
12885 {
12886 if(i2==i1) continue;
12887 aftsTrack=anEvent->GetTrack(i2);
12888 // RP condition (!(first) particle in the correlator must be RP):
12889 if(!(aftsTrack->InRPSelection())) continue;
12890 phi2=aftsTrack->Phi();
12891 for(Int_t i3=0;i3<nPrim;i3++)
12892 {
12893 if(i3==i1||i3==i2) continue;
12894 aftsTrack=anEvent->GetTrack(i3);
12895 // RP condition (!(first) particle in the correlator must be RP):
12896 if(!(aftsTrack->InRPSelection())) continue;
12897 phi3=aftsTrack->Phi();
12898 // sin terms:
12899 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),1.); // <<sin(n*(psi1+phi2-phi3))>>
12900 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),1.); // <<sin(n*(psi1-phi2-phi3))>>
12901 // cos terms:
12902 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),1.); // <<cos(n*(psi1+phi2-phi3))>>
12903 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),1.); // <<cos(n*(psi1-phi2-phi3))>>
12904 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12905 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12906 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12907
12908} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12909
12910
12911//================================================================================================================================
12912
12913
12914void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)
12915{
12916 // Compare corrections temrs for non-uniform acceptance needed for diff. flow calculated with nested loops and those calculated from Q-vectors
12917
2a98ceb8 12918 Int_t typeFlag = 0;
12919 Int_t ptEtaFlag = 0;
489d5531 12920 if(type == "RP")
12921 {
12922 typeFlag = 0;
12923 } else if(type == "POI")
12924 {
12925 typeFlag = 1;
12926 }
12927 if(ptOrEta == "Pt")
12928 {
12929 ptEtaFlag = 0;
12930 } else if(ptOrEta == "Eta")
12931 {
12932 ptEtaFlag = 1;
12933 }
12934 // shortcuts:
12935 Int_t t = typeFlag;
12936 Int_t pe = ptEtaFlag;
12937
12938 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12939 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12940 //TString sinCosFlag[2] = {"sin","cos"}; // to be improved (eventually promote to data member)
12941 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)
12942 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)
12943 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12944 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12945
12946 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
12947
12948 cout<<endl;
12949 cout<<" ******************************************"<<endl;
12950 cout<<" **** cross-checking the correction ****"<<endl;
46b94261 12951 cout<<" **** terms for non-uniform acceptance ****"<<endl;
489d5531 12952 cout<<" **** for differential flow ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 12953 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 12954 {
12955 cout<<" **** (particle weights not used) ****"<<endl;
12956 } else
12957 {
12958 cout<<" **** (particle weights used) ****"<<endl;
12959 }
12960 cout<<" ******************************************"<<endl;
12961 cout<<endl;
12962 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
12963 cout<<endl;
12964
12965 for(Int_t cti=0;cti<4;cti++) // correction term index
12966 {
12967 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
12968 {
12969 if(sc==0) // to be improved (this can be implemented better)
12970 {
12971 cout<<" "<<reducedCorrectionSinTerms[cti].Data()<<":"<<endl;
12972 } else
12973 {
12974 cout<<" "<<reducedCorrectionCosTerms[cti].Data()<<":"<<endl;
12975 }
12976 cout<<" from Q-vectors = "<<fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
12977 cout<<" from nested loops = "<<fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]->GetBinContent(1)<<endl;
12978 cout<<endl;
12979 }
12980 } // end of for(Int_t rci=0;rci<4;rci++)
12981
12982} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)
12983
57340a27 12984//================================================================================================================================
12985
489d5531 12986void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()
12987{
12988 // Calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (cos terms).
12989
12990 // **********************************************************************
12991 // **** weighted corrections for non-uniform acceptance (cos terms): ****
12992 // **********************************************************************
57340a27 12993
489d5531 12994 // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
57340a27 12995 //
489d5531 12996 // 1st bin: <<w1 cos(n*(phi1))>> = cosP1nW1
12997 // 2nd bin: <<w1 w2 cos(n*(phi1+phi2))>> = cosP1nP1nW1W1
12998 // 3rd bin: <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1nW1W1W1
12999 // ...
13000
13001 // multiplicity (number of particles used to determine the reaction plane)
1268c371 13002 Double_t dMult = (*fSpk)(0,0);
489d5531 13003
13004 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13005 Double_t dReQ1n1k = (*fReQ)(0,1);
13006 Double_t dReQ2n2k = (*fReQ)(1,2);
13007 //Double_t dReQ3n3k = (*fReQ)(2,3);
13008 //Double_t dReQ4n4k = (*fReQ)(3,4);
13009 Double_t dReQ1n3k = (*fReQ)(0,3);
13010 Double_t dImQ1n1k = (*fImQ)(0,1);
13011 Double_t dImQ2n2k = (*fImQ)(1,2);
13012 //Double_t dImQ3n3k = (*fImQ)(2,3);
13013 //Double_t dImQ4n4k = (*fImQ)(3,4);
13014 //Double_t dImQ1n3k = (*fImQ)(0,3);
13015
13016 // dMs are variables introduced in order to simplify some Eqs. bellow:
13017 //..............................................................................................
1268c371 13018 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
13019 Double_t dM111 = (*fSpk)(2,1)-3.*(*fSpk)(0,2)*(*fSpk)(0,1)
13020 + 2.*(*fSpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k
489d5531 13021 //..............................................................................................
ecac11c2 13022 // 1-particle:
489d5531 13023 Double_t cosP1nW1 = 0.; // <<w1 cos(n*(phi1))>>
13024
1268c371 13025 if(dMult>0 && TMath::Abs((*fSpk)(0,1))>1.e-6)
489d5531 13026 {
1268c371 13027 cosP1nW1 = dReQ1n1k/(*fSpk)(0,1);
489d5531 13028
13029 // average weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
13030 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1nW1);
13031
13032 // final average weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
1268c371 13033 fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1nW1,(*fSpk)(0,1));
489d5531 13034 }
13035
13036 // 2-particle:
13037 Double_t cosP1nP1nW1W1 = 0.; // <<w1 w2 cos(n*(phi1+phi2))>>
13038
1268c371 13039 if(dMult>1 && TMath::Abs(dM11)>1.e-6)
489d5531 13040 {
13041 cosP1nP1nW1W1 = (pow(dReQ1n1k,2)-pow(dImQ1n1k,2)-dReQ2n2k)/dM11;
13042
13043 // average weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
13044 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1nW1W1);
13045
13046 // final average weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
13047 fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1nW1W1,dM11);
13048 }
13049
13050 // 3-particle:
13051 Double_t cosP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>>
13052
1268c371 13053 if(dMult>2 && TMath::Abs(dM111)>1.e-6)
489d5531 13054 {
57340a27 13055 cosP1nM1nM1nW1W1W1 = (dReQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
13056 - dReQ1n1k*dReQ2n2k-dImQ1n1k*dImQ2n2k
1268c371 13057 - 2.*((*fSpk)(0,2))*dReQ1n1k
489d5531 13058 + 2.*dReQ1n3k)
13059 / dM111;
13060
13061 // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
13062 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1nW1W1W1);
13063
13064 // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
13065 fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1nW1W1W1,dM111);
13066 }
13067
13068} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()
13069
13070
13071//================================================================================================================================
13072
13073
13074void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()
13075{
13076 // calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
13077
13078 // **********************************************************************
13079 // **** weighted corrections for non-uniform acceptance (sin terms): ****
13080 // **********************************************************************
13081
13082 // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
57340a27 13083 //
489d5531 13084 // 1st bin: <<w1 sin(n*(phi1))>> = sinP1nW1
13085 // 2nd bin: <<w1 w2 sin(n*(phi1+phi2))>> = sinP1nP1nW1W1
13086 // 3rd bin: <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1nW1W1W1
13087 // ...
13088
13089 // multiplicity (number of particles used to determine the reaction plane)
1268c371 13090 Double_t dMult = (*fSpk)(0,0);
489d5531 13091
13092 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13093 Double_t dReQ1n1k = (*fReQ)(0,1);
13094 Double_t dReQ2n2k = (*fReQ)(1,2);
13095 //Double_t dReQ3n3k = (*fReQ)(2,3);
13096 //Double_t dReQ4n4k = (*fReQ)(3,4);
13097 //Double_t dReQ1n3k = (*fReQ)(0,3);
13098 Double_t dImQ1n1k = (*fImQ)(0,1);
13099 Double_t dImQ2n2k = (*fImQ)(1,2);
13100 //Double_t dImQ3n3k = (*fImQ)(2,3);
13101 //Double_t dImQ4n4k = (*fImQ)(3,4);
13102 Double_t dImQ1n3k = (*fImQ)(0,3);
13103
13104 // dMs are variables introduced in order to simplify some Eqs. bellow:
13105 //..............................................................................................
1268c371 13106 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
13107 Double_t dM111 = (*fSpk)(2,1)-3.*(*fSpk)(0,2)*(*fSpk)(0,1)
13108 + 2.*(*fSpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k
489d5531 13109 //..............................................................................................
13110
13111 // 1-particle:
13112 Double_t sinP1nW1 = 0.; // <<w1 sin(n*(phi1))>>
13113
1268c371 13114 if(dMult>0 && TMath::Abs((*fSpk)(0,1))>1.e-6)
489d5531 13115 {
1268c371 13116 sinP1nW1 = dImQ1n1k/((*fSpk)(0,1));
489d5531 13117
13118 // average weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
13119 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1nW1);
13120
13121 // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1268c371 13122 fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1nW1,(*fSpk)(0,1));
489d5531 13123 }
13124
13125 // 2-particle:
13126 Double_t sinP1nP1nW1W1 = 0.; // <<w1 w2 sin(n*(phi1+phi2))>>
13127
1268c371 13128 if(dMult>1 && TMath::Abs(dM11)>1.e-6)
489d5531 13129 {
13130 sinP1nP1nW1W1 = (2.*dReQ1n1k*dImQ1n1k-dImQ2n2k)/dM11;
13131
13132 // average weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
13133 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1nW1W1);
13134
13135 // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
13136 fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1nW1W1,dM11);
13137 }
13138
13139 // 3-particle:
13140 Double_t sinP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>>
13141
1268c371 13142 if(dMult>2 && TMath::Abs(dM111)>1.e-6)
489d5531 13143 {
57340a27 13144 sinP1nM1nM1nW1W1W1 = (-dImQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
13145 + dReQ1n1k*dImQ2n2k-dImQ1n1k*dReQ2n2k
1268c371 13146 + 2.*((*fSpk)(0,2))*dImQ1n1k
489d5531 13147 - 2.*dImQ1n3k)
13148 / dM111;
13149
13150 // average weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
13151 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1nW1W1W1);
13152
13153 // final average weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
13154 fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1nW1W1W1,dM111);
13155 }
13156
13157} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()
13158
57340a27 13159//================================================================================================================================
489d5531 13160
0328db2d 13161void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent)
489d5531 13162{
13163 // Evaluate with nested loops correction terms for non-uniform acceptance for integrated flow (using the particle weights).
13164
57340a27 13165 // Results are stored in profiles fIntFlowDirectCorrectionTermsForNUA[0] (sin terms) and
13166 // fIntFlowDirectCorrectionTermsForNUA[1] (cos terms).
489d5531 13167
57340a27 13168 // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrectionTermsForNUA[sc] is
489d5531 13169 // organized as follows (sc stands for either sin or cos):
13170 //
13171 // 1st bin: <<w1 sc(n*(phi1))>> = scP1nW1
13172 // 2nd bin: <<w1 w2 sc(n*(phi1+phi2))>> = scP1nP1nW1W1
13173 // 3rd bin: <<w1 w2 w3 sc(n*(phi1-phi2-phi3))>> = scP1nM1nM1nW1W1W1
3b552efe 13174 // ...
489d5531 13175
13176 Int_t nPrim = anEvent->NumberOfTracks();
13177 AliFlowTrackSimple *aftsTrack = NULL;
13178 //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
13179 //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
13180 Double_t phi1=0., phi2=0., phi3=0.;
13181 Double_t wPhi1=1., wPhi2=1., wPhi3=1.;
13182 Int_t n = fHarmonic;
13183 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 13184 Double_t dMult = (*fSpk)(0,0);
489d5531 13185 cout<<endl;
13186 cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
13187 if(dMult<1)
13188 {
13189 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
13190 } else if (dMult>fMaxAllowedMultiplicity)
13191 {
13192 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
13193 } else
13194 {
13195 cout<<"... evaluating nested loops (using particle weights) ..."<<endl;
13196 }
13197
13198 // 1-particle correction terms using particle weights:
13199 if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
13200 {
13201 for(Int_t i1=0;i1<nPrim;i1++)
13202 {
13203 aftsTrack=anEvent->GetTrack(i1);
13204 if(!(aftsTrack->InRPSelection())) continue;
13205 phi1=aftsTrack->Phi();
13206 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
57340a27 13207 // 1-particle correction terms using particle weights:
489d5531 13208 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),wPhi1); // <w1 sin(n*phi1)>
13209 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),wPhi1); // <w1 cos(n*phi1)>
57340a27 13210 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13211 } // end of if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
13212
489d5531 13213 // 2-particle correction terms using particle weights:
13214 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
13215 {
13216 for(Int_t i1=0;i1<nPrim;i1++)
13217 {
13218 aftsTrack=anEvent->GetTrack(i1);
13219 if(!(aftsTrack->InRPSelection())) continue;
13220 phi1=aftsTrack->Phi();
13221 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13222 for(Int_t i2=0;i2<nPrim;i2++)
13223 {
13224 if(i2==i1)continue;
13225 aftsTrack=anEvent->GetTrack(i2);
13226 if(!(aftsTrack->InRPSelection())) continue;
13227 phi2=aftsTrack->Phi();
13228 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13229 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
57340a27 13230 // 2-p correction terms using particle weights:
489d5531 13231 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 sin(n*(phi1+phi2))>
13232 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 cos(n*(phi1+phi2))>
13233 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13234 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13235 } // end of if(nPrim>=2)
13236
13237 // 3-particle correction terms using particle weights:
13238 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
13239 {
13240 for(Int_t i1=0;i1<nPrim;i1++)
13241 {
13242 aftsTrack=anEvent->GetTrack(i1);
13243 if(!(aftsTrack->InRPSelection())) continue;
13244 phi1=aftsTrack->Phi();
13245 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13246 for(Int_t i2=0;i2<nPrim;i2++)
13247 {
13248 if(i2==i1)continue;
13249 aftsTrack=anEvent->GetTrack(i2);
13250 if(!(aftsTrack->InRPSelection())) continue;
13251 phi2=aftsTrack->Phi();
13252 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13253 for(Int_t i3=0;i3<nPrim;i3++)
13254 {
13255 if(i3==i1||i3==i2)continue;
13256 aftsTrack=anEvent->GetTrack(i3);
13257 if(!(aftsTrack->InRPSelection())) continue;
13258 phi3=aftsTrack->Phi();
13259 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13260 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
57340a27 13261 // 3-p correction terms using particle weights:
489d5531 13262 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 sin(n*(phi1-phi2-phi3))>
13263 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 cos(n*(phi1-phi2-phi3))>
13264 } // end of for(Int_t i3=0;i3<nPrim;i3++)
13265 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13266 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13267 } // end of if(nPrim>=3)
13268
57340a27 13269 /*
13270
489d5531 13271 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
13272 {
13273 // 4 nested loops multiparticle correlations using particle weights:
13274 for(Int_t i1=0;i1<nPrim;i1++)
13275 {
13276 aftsTrack=anEvent->GetTrack(i1);
13277 if(!(aftsTrack->InRPSelection())) continue;
13278 phi1=aftsTrack->Phi();
13279 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13280 for(Int_t i2=0;i2<nPrim;i2++)
13281 {
13282 if(i2==i1)continue;
13283 aftsTrack=anEvent->GetTrack(i2);
13284 if(!(aftsTrack->InRPSelection())) continue;
13285 phi2=aftsTrack->Phi();
13286 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13287 for(Int_t i3=0;i3<nPrim;i3++)
13288 {
13289 if(i3==i1||i3==i2)continue;
13290 aftsTrack=anEvent->GetTrack(i3);
13291 if(!(aftsTrack->InRPSelection())) continue;
13292 phi3=aftsTrack->Phi();
13293 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13294 for(Int_t i4=0;i4<nPrim;i4++)
13295 {
13296 if(i4==i1||i4==i2||i4==i3)continue;
13297 aftsTrack=anEvent->GetTrack(i4);
13298 if(!(aftsTrack->InRPSelection())) continue;
13299 phi4=aftsTrack->Phi();
13300 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
13301 if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))
13302 // 4-p correlations using particle weights:
13303 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4);
13304 // extra correlations:
13305 // 2-p extra correlations (do not appear if particle weights are not used):
13306 // ...
13307 // 3-p extra correlations (do not appear if particle weights are not used):
13308 // ...
13309 // 4-p extra correlations (do not appear if particle weights are not used):
13310 // ...
13311 } // end of for(Int_t i4=0;i4<nPrim;i4++)
13312 } // end of for(Int_t i3=0;i3<nPrim;i3++)
13313 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13314 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13315 } // end of if(nPrim>=4)
13316
13317 */
13318
13319 cout<<endl;
13320
13321} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)
13322
57340a27 13323//================================================================================================================================
489d5531 13324
489d5531 13325void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)
13326{
13327 // Calculate correction terms for non-uniform acceptance for differential flow (cos terms) using particle weights.
57340a27 13328
489d5531 13329 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:
57340a27 13330 //
489d5531 13331 // 0: <<cos n(psi)>>
13332 // 1: <<w2 cos n(psi1+phi2)>>
13333 // 2: <<w2 w3 cos n(psi1+phi2-phi3)>>
13334 // 3: <<w2 w3 cos n(psi1-phi2-phi3)>>
13335 // 4:
13336 // 5:
13337 // 6:
13338
13339 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13340 Double_t dReQ1n1k = (*fReQ)(0,1);
13341 Double_t dReQ2n2k = (*fReQ)(1,2);
13342 //Double_t dReQ1n3k = (*fReQ)(0,3);
13343 //Double_t dReQ4n4k = (*fReQ)(3,4);
13344 Double_t dImQ1n1k = (*fImQ)(0,1);
13345 Double_t dImQ2n2k = (*fImQ)(1,2);
13346 //Double_t dImQ1n3k = (*fImQ)(0,3);
13347 //Double_t dImQ4n4k = (*fImQ)(3,4);
13348
1268c371 13349 // S^M_{p,k} (see .h file for the definition of fSpk):
13350 Double_t dSM1p1k = (*fSpk)(0,1);
13351 Double_t dSM1p2k = (*fSpk)(0,2);
13352 Double_t dSM2p1k = (*fSpk)(1,1);
489d5531 13353
2a98ceb8 13354 Int_t t = 0; // type flag
13355 Int_t pe = 0; // ptEta flag
489d5531 13356
13357 if(type == "RP")
13358 {
13359 t = 0;
13360 } else if(type == "POI")
13361 {
13362 t = 1;
13363 }
13364
13365 if(ptOrEta == "Pt")
13366 {
13367 pe = 0;
13368 } else if(ptOrEta == "Eta")
13369 {
13370 pe = 1;
13371 }
13372
13373 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
13374 Double_t minPtEta[2] = {fPtMin,fEtaMin};
13375 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
13376 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13377
13378 // looping over all bins and calculating correction terms:
13379 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13380 {
13381 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
13382 Double_t p1n0kRe = 0.;
13383 Double_t p1n0kIm = 0.;
13384
13385 // number of POIs in particular pt or eta bin:
13386 Double_t mp = 0.;
13387
13388 // real and imaginary parts of q_{m*n,0} (weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):
13389 Double_t q1n2kRe = 0.;
13390 Double_t q1n2kIm = 0.;
13391 Double_t q2n1kRe = 0.;
13392 Double_t q2n1kIm = 0.;
46b94261 13393
489d5531 13394 // s_{1,1}, s_{1,2} // to be improved (add explanation)
13395 Double_t s1p1k = 0.;
13396 Double_t s1p2k = 0.;
46b94261 13397
489d5531 13398 // number of particles which are both RPs and POIs in particular pt or eta bin:
46b94261 13399 Double_t mq = 0.;
489d5531 13400
13401 // M0111 from Eq. (118) in QC2c (to be improved (notation))
13402 Double_t dM01 = 0.;
13403 Double_t dM011 = 0.;
13404
13405 if(type == "POI")
13406 {
13407 // q_{m*n,k}:
13408 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
13409 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
13410 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
13411 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
13412 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
13413 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
13414 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
13415 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
13416 mq = fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
46b94261 13417
489d5531 13418 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
13419 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
13420 }else if(type == "RP")
13421 {
13422 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
13423 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
13424 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
13425 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
13426 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
13427 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
13428 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
13429 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
13430 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
13431 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13432 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
13433 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
3b552efe 13434 //s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
13435
489d5531 13436 mq = fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
13437 }
3b552efe 13438
489d5531 13439 if(type == "POI")
3b552efe 13440 {
13441 // p_{m*n,k}:
489d5531 13442 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
13443 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
13444 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
3b552efe 13445 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
13446 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
489d5531 13447 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13448 dM01 = mp*dSM1p1k-s1p1k;
13449 dM011 = mp*(dSM2p1k-dSM1p2k)
13450 - 2.*(s1p1k*dSM1p1k-s1p2k);
13451
13452 // typeFlag = RP (0) or POI (1):
13453 t = 1;
13454 } else if(type == "RP")
489d5531 13455 {
13456 // to be improved (cross-checked):
13457 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
13458 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
13459 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
13460 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
13461 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
13462 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13463 dM01 = mp*dSM1p1k-s1p1k;
13464 dM011 = mp*(dSM2p1k-dSM1p2k)
13465 - 2.*(s1p1k*dSM1p1k-s1p2k);
489d5531 13466 // typeFlag = RP (0) or POI (1):
3b552efe 13467 t = 0;
13468 }
489d5531 13469
13470 // <<cos n(psi1)>>:
13471 Double_t cosP1nPsi = 0.;
13472 if(mp)
13473 {
13474 cosP1nPsi = p1n0kRe/mp;
13475
13476 // fill profile for <<cos n(psi1)>>:
13477 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);
13478 // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):
13479 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);
46b94261 13480 } // end of if(mp)
57340a27 13481
489d5531 13482 // <<w2 cos n(psi1+phi2)>>:
13483 Double_t cosP1nPsiP1nPhiW2 = 0.;
13484 if(dM01)
13485 {
13486 cosP1nPsiP1nPhiW2 = (p1n0kRe*dReQ1n1k-p1n0kIm*dImQ1n1k-q2n1kRe)/(dM01);
13487 // fill profile for <<w2 cos n(psi1+phi2)>>:
13488 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhiW2,dM01);
13489 // histogram to store <w2 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13490 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhiW2);
13491 } // end of if(dM01)
13492
13493 // <<w2 w3 cos n(psi1+phi2-phi3)>>:
13494 Double_t cosP1nPsi1P1nPhi2MPhi3W2W3 = 0.;
13495 if(dM011)
13496 {
46b94261 13497 cosP1nPsi1P1nPhi2MPhi3W2W3 = (p1n0kRe*(pow(dImQ1n1k,2.)+pow(dReQ1n1k,2.))
13498 - p1n0kRe*dSM1p2k
13499 - q2n1kRe*dReQ1n1k-q2n1kIm*dImQ1n1k
13500 - s1p1k*dReQ1n1k
13501 + 2.*q1n2kRe)
13502 / dM011;
489d5531 13503 // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:
13504 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3W2W3,dM011);
13505 // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13506 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3W2W3);
13507 } // end of if(dM011)
13508
13509 // <<w2 w3 cos n(psi1-phi2-phi3)>>:
13510 Double_t cosP1nPsi1M1nPhi2MPhi3W2W3 = 0.;
13511 if(dM011)
13512 {
13513 cosP1nPsi1M1nPhi2MPhi3W2W3 = (p1n0kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))+2.*p1n0kIm*dReQ1n1k*dImQ1n1k
13514 - 1.*(p1n0kRe*dReQ2n2k+p1n0kIm*dImQ2n2k)
46b94261 13515 - 2.*s1p1k*dReQ1n1k
489d5531 13516 + 2.*q1n2kRe)
13517 / dM011;
13518 // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:
13519 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3W2W3,dM011);
13520 // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13521 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3W2W3);
13522 } // end of if(dM011)
13523
13524 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
46b94261 13525
57340a27 13526} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)
13527
489d5531 13528
13529//================================================================================================================================
13530
13531
13532void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)
13533{
13534 // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).
13535
13536 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:
13537 // 0: <<sin n(psi1)>>
13538 // 1: <<w2 sin n(psi1+phi2)>>
13539 // 2: <<w2 w3 sin n(psi1+phi2-phi3)>>
13540 // 3: <<w2 w3 sin n(psi1-phi2-phi3)>>:
13541 // 4:
13542 // 5:
13543 // 6:
13544
13545 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13546 Double_t dReQ1n1k = (*fReQ)(0,1);
13547 Double_t dReQ2n2k = (*fReQ)(1,2);
13548 //Double_t dReQ1n3k = (*fReQ)(0,3);
13549 //Double_t dReQ4n4k = (*fReQ)(3,4);
13550 Double_t dImQ1n1k = (*fImQ)(0,1);
13551 Double_t dImQ2n2k = (*fImQ)(1,2);
13552 //Double_t dImQ1n3k = (*fImQ)(0,3);
13553 //Double_t dImQ4n4k = (*fImQ)(3,4);
13554
1268c371 13555 // S^M_{p,k} (see .h file for the definition of fSpk):
13556 Double_t dSM1p1k = (*fSpk)(0,1);
13557 Double_t dSM1p2k = (*fSpk)(0,2);
13558 Double_t dSM2p1k = (*fSpk)(1,1);
489d5531 13559
2a98ceb8 13560 Int_t t = 0; // type flag
13561 Int_t pe = 0; // ptEta flag
489d5531 13562
13563 if(type == "RP")
13564 {
13565 t = 0;
13566 } else if(type == "POI")
13567 {
13568 t = 1;
13569 }
13570
13571 if(ptOrEta == "Pt")
13572 {
13573 pe = 0;
13574 } else if(ptOrEta == "Eta")
13575 {
13576 pe = 1;
13577 }
13578
13579 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
13580 Double_t minPtEta[2] = {fPtMin,fEtaMin};
13581 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
13582 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13583
13584 // looping over all bins and calculating correction terms:
13585 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13586 {
13587 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
13588 Double_t p1n0kRe = 0.;
13589 Double_t p1n0kIm = 0.;
13590
13591 // number of POIs in particular pt or eta bin:
13592 Double_t mp = 0.;
13593
13594 // real and imaginary parts of q_{m*n,0} (weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):
13595 Double_t q1n2kRe = 0.;
13596 Double_t q1n2kIm = 0.;
13597 Double_t q2n1kRe = 0.;
13598 Double_t q2n1kIm = 0.;
46b94261 13599
489d5531 13600 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13601 Double_t s1p1k = 0.;
13602 Double_t s1p2k = 0.;
46b94261 13603
489d5531 13604 // number of particles which are both RPs and POIs in particular pt or eta bin:
46b94261 13605 Double_t mq = 0.;
489d5531 13606
13607 // M0111 from Eq. (118) in QC2c (to be improved (notation))
13608 Double_t dM01 = 0.;
13609 Double_t dM011 = 0.;
13610
13611 if(type == "POI")
13612 {
13613 // q_{m*n,k}:
13614 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
13615 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
13616 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
13617 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
13618 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
13619 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
13620 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
13621 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
13622 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
46b94261 13623
489d5531 13624 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
13625 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
13626 }else if(type == "RP")
13627 {
13628 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
13629 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
13630 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
13631 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
13632 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
13633 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
13634 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
13635 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
13636 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
13637 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13638 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
13639 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
13640 //s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
3b552efe 13641 }
13642
13643 if(type == "POI")
13644 {
13645 // p_{m*n,k}:
489d5531 13646 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
13647 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
13648 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
3b552efe 13649 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
13650 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
489d5531 13651 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13652 dM01 = mp*dSM1p1k-s1p1k;
13653 dM011 = mp*(dSM2p1k-dSM1p2k)
13654 - 2.*(s1p1k*dSM1p1k-s1p2k);
13655 // typeFlag = RP (0) or POI (1):
13656 t = 1;
489d5531 13657 } else if(type == "RP")
3b552efe 13658 {
489d5531 13659 // to be improved (cross-checked):
13660 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
13661 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
13662 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
13663 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
13664 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
13665 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13666 dM01 = mp*dSM1p1k-s1p1k;
13667 dM011 = mp*(dSM2p1k-dSM1p2k)
489d5531 13668 - 2.*(s1p1k*dSM1p1k-s1p2k);
13669 // typeFlag = RP (0) or POI (1):
3b552efe 13670 t = 0;
13671 }
13672
489d5531 13673 // <<sin n(psi1)>>:
13674 Double_t sinP1nPsi = 0.;
13675 if(mp)
13676 {
13677 sinP1nPsi = p1n0kIm/mp;
13678
13679 // fill profile for <<sin n(psi1)>>:
13680 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);
13681 // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):
13682 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);
46b94261 13683 } // end of if(mp)
13684
489d5531 13685 // <<w2 sin n(psi1+phi2)>>:
13686 Double_t sinP1nPsiP1nPhiW2 = 0.;
13687 if(dM01)
13688 {
13689 sinP1nPsiP1nPhiW2 = (p1n0kRe*dImQ1n1k+p1n0kIm*dReQ1n1k-q2n1kIm)/(dM01);
13690 // fill profile for <<w2 sin n(psi1+phi2)>>:
13691 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhiW2,dM01);
13692 // histogram to store <w2 sin n(psi1+phi2)> e-b-e (needed in some other methods):
13693 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhiW2);
13694 } // end of if(mp*dMult-mq)
13695
13696 // <<w2 w3 sin n(psi1+phi2-phi3)>>:
13697 Double_t sinP1nPsi1P1nPhi2MPhi3W2W3 = 0.;
13698 if(dM011)
13699 {
46b94261 13700 sinP1nPsi1P1nPhi2MPhi3W2W3 = (p1n0kIm*(pow(dImQ1n1k,2.)+pow(dReQ1n1k,2.))
13701 - p1n0kIm*dSM1p2k
13702 + q2n1kRe*dImQ1n1k-q2n1kIm*dReQ1n1k
13703 - s1p1k*dImQ1n1k
13704 + 2.*q1n2kIm)
13705 / dM011;
489d5531 13706 // fill profile for <<w2 w3 sin n(psi1+phi2-phi3)>>:
13707 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3W2W3,dM011);
13708 // histogram to store <w2 w3 sin n(psi1+phi2-phi3)> e-b-e (needed in some other methods):
13709 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3W2W3);
13710 } // end of if(dM011)
13711
13712 // <<w2 w3 sin n(psi1-phi2-phi3)>>:
13713 Double_t sinP1nPsi1M1nPhi2MPhi3W2W3 = 0.;
13714 if(dM011)
13715 {
13716 sinP1nPsi1M1nPhi2MPhi3W2W3 = (p1n0kIm*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))-2.*p1n0kRe*dReQ1n1k*dImQ1n1k
13717 + 1.*(p1n0kRe*dImQ2n2k-p1n0kIm*dReQ2n2k)
46b94261 13718 + 2.*s1p1k*dImQ1n1k
489d5531 13719 - 2.*q1n2kIm)
13720 / dM011;
13721 // fill profile for <<w2 w3 sin n(psi1-phi2-phi3)>>:
13722 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3W2W3,dM011);
13723 // histogram to store <w2 w3 sin n(psi1-phi2-phi3)> e-b-e (needed in some other methods):
13724 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3W2W3);
13725 } // end of if(dM011)
13726
13727 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13728
13729} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)
13730
489d5531 13731//================================================================================================================================
489d5531 13732
0328db2d 13733void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 13734{
57340a27 13735 // Evaluate with nested loops correction terms for non-uniform acceptance
489d5531 13736 // with using particle weights (both sin and cos terms) relevant for differential flow.
13737
57340a27 13738 // Remark 1: "w1" in expressions bellow is a particle weight used only for particles which were
13739 // flagged both as POI and RP.
489d5531 13740 // Remark 2: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo
13741 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
13742 // Remark 3: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as:
13743 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows:
13744 // cti:
13745 // 0: <<sc n(psi1)>>
13746 // 1: <<w2 sc n(psi1+phi2)>>
13747 // 2: <<w2 w3 sc n(psi1+phi2-phi3)>>
13748 // 3: <<w2 w3 sc n(psi1-phi2-phi3)>>
13749 // 4:
13750 // 5:
13751 // 6:
46b94261 13752
2a98ceb8 13753 Int_t typeFlag = 0;
13754 Int_t ptEtaFlag = 0;
489d5531 13755 if(type == "RP")
13756 {
13757 typeFlag = 0;
13758 } else if(type == "POI")
13759 {
13760 typeFlag = 1;
13761 }
13762 if(ptOrEta == "Pt")
13763 {
13764 ptEtaFlag = 0;
13765 } else if(ptOrEta == "Eta")
13766 {
13767 ptEtaFlag = 1;
13768 }
13769 // shortcuts:
13770 Int_t t = typeFlag;
13771 Int_t pe = ptEtaFlag;
13772
13773 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
13774 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
13775 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13776
13777 Int_t nPrim = anEvent->NumberOfTracks();
13778 AliFlowTrackSimple *aftsTrack = NULL;
13779
13780 Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
13781 Double_t wPhi2=1., wPhi3=1.;
13782
13783 Int_t n = fHarmonic;
13784
13785 // 1'-particle correction terms:
13786 for(Int_t i1=0;i1<nPrim;i1++)
13787 {
13788 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13789 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13790 if(typeFlag==1) // this is diff flow of POIs
489d5531 13791 {
13792 if(ptOrEta == "Pt")
13793 {
13794 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13795 } else if (ptOrEta == "Eta")
13796 {
13797 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13798 }
13799 } else // this is diff flow of RPs
13800 {
489d5531 13801 if(ptOrEta == "Pt")
13802 {
13803 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13804 } else if (ptOrEta == "Eta")
13805 {
13806 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13807 }
489d5531 13808 }
13809 psi1=aftsTrack->Phi();
13810 // sin terms:
13811 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>
13812 // cos terms:
13813 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>
13814 }//end of for(Int_t i1=0;i1<nPrim;i1++)
13815
13816 // 2'-particle correction terms:
13817 for(Int_t i1=0;i1<nPrim;i1++)
13818 {
13819 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13820 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13821 if(typeFlag==1) // this is diff flow of POIs
489d5531 13822 {
13823 if(ptOrEta == "Pt")
13824 {
13825 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13826 } else if (ptOrEta == "Eta")
13827 {
13828 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13829 }
13830 } else // this is diff flow of RPs
13831 {
489d5531 13832 if(ptOrEta == "Pt")
13833 {
13834 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13835 } else if (ptOrEta == "Eta")
13836 {
13837 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13838 }
489d5531 13839 }
13840 psi1=aftsTrack->Phi();
13841 for(Int_t i2=0;i2<nPrim;i2++)
13842 {
13843 if(i2==i1) continue;
13844 aftsTrack=anEvent->GetTrack(i2);
13845 // RP condition (!(first) particle in the correlator must be RP):
13846 if(!(aftsTrack->InRPSelection())) continue;
46b94261 13847 phi2=aftsTrack->Phi();
489d5531 13848 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13849 // sin terms:
13850 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),wPhi2); // <<w2 sin(n*(psi1+phi2))>>
13851 // cos terms:
13852 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),wPhi2); // <<w2 cos(n*(psi1+phi2))>>
13853 }//end of for(Int_t i2=0;i2<nPrim;i2++)
13854 }//end of for(Int_t i1=0;i1<nPrim;i1++)
13855
13856 // 3'-particle correction terms:
13857 for(Int_t i1=0;i1<nPrim;i1++)
13858 {
13859 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13860 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13861 if(typeFlag==1) // this is diff flow of POIs
489d5531 13862 {
13863 if(ptOrEta == "Pt")
13864 {
13865 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13866 } else if (ptOrEta == "Eta")
13867 {
13868 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13869 }
13870 } else // this is diff flow of RPs
13871 {
489d5531 13872 if(ptOrEta == "Pt")
13873 {
13874 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13875 } else if (ptOrEta == "Eta")
13876 {
13877 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13878 }
489d5531 13879 }
13880 psi1=aftsTrack->Phi();
13881 for(Int_t i2=0;i2<nPrim;i2++)
13882 {
13883 if(i2==i1) continue;
13884 aftsTrack=anEvent->GetTrack(i2);
13885 // RP condition (!(first) particle in the correlator must be RP):
13886 if(!(aftsTrack->InRPSelection())) continue;
13887 phi2=aftsTrack->Phi();
13888 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13889 for(Int_t i3=0;i3<nPrim;i3++)
13890 {
13891 if(i3==i1||i3==i2) continue;
13892 aftsTrack=anEvent->GetTrack(i3);
13893 // RP condition (!(first) particle in the correlator must be RP):
13894 if(!(aftsTrack->InRPSelection())) continue;
13895 phi3=aftsTrack->Phi();
13896 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13897 // sin terms:
13898 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),wPhi2*wPhi3); // <<wPhi2*wPhi3 sin(n*(psi1+phi2-phi3))>>
13899 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),wPhi2*wPhi3); // <<wPhi2*wPhi3 sin(n*(psi1-phi2-phi3))>>
13900 // cos terms:
13901 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),wPhi2*wPhi3); // <<wPhi2*wPhi3 cos(n*(psi1+phi2-phi3))>>
13902 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),wPhi2*wPhi3); // <<wPhi2*wPhi3 cos(n*(psi1-phi2-phi3))>>
13903 }//end of for(Int_t i3=0;i3<nPrim;i3++)
13904 }//end of for(Int_t i2=0;i2<nPrim;i2++)
46b94261 13905 }//end of for(Int_t i1=0;i1<nPrim;i1++)
489d5531 13906
13907} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
13908
2001bc3a 13909//================================================================================================================================
13910
b3dacf6b 13911void AliFlowAnalysisWithQCumulants::CheckPointersUsedInFinish()
13912{
13913 // Check all pointers used in method Finish().
13914
b77b6434 13915 if(!fAvMultiplicity)
13916 {
13917 cout<<endl;
13918 cout<<" WARNING (QC): fAvMultiplicity is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13919 cout<<endl;
13920 exit(0);
13921 }
b3dacf6b 13922 if(!fIntFlowCorrelationsPro)
13923 {
13924 cout<<endl;
13925 cout<<" WARNING (QC): fIntFlowCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13926 cout<<endl;
13927 exit(0);
13928 }
b40a910e 13929 if(!fIntFlowSquaredCorrelationsPro)
13930 {
13931 cout<<endl;
13932 cout<<" WARNING (QC): fIntFlowSquaredCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13933 cout<<endl;
13934 exit(0);
13935 }
b3dacf6b 13936 if(!fIntFlowCorrelationsHist)
13937 {
13938 cout<<endl;
13939 cout<<" WARNING (QC): fIntFlowCorrelationsHist is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13940 cout<<endl;
13941 exit(0);
13942 }
403e3389 13943 if((fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights) && !fIntFlowExtraCorrelationsPro)
b77b6434 13944 {
13945 cout<<endl;
13946 cout<<" WARNING (QC): fIntFlowExtraCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13947 cout<<endl;
13948 exit(0);
13949 }
b3dacf6b 13950 for(Int_t power=0;power<2;power++)
13951 {
13952 if(!fIntFlowSumOfEventWeights[power])
13953 {
13954 cout<<endl;
13955 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeights[%d] is NULL in CheckPointersUsedInFinish() !!!!",power)<<endl;
13956 cout<<endl;
13957 exit(0);
13958 }
13959 } // end of for(Int_t power=0;power<2;power++)
13960 if(!fIntFlowProductOfCorrelationsPro)
13961 {
13962 cout<<endl;
13963 cout<<" WARNING (QC): fIntFlowProductOfCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13964 cout<<endl;
13965 exit(0);
13966 }
13967 if(!fIntFlowSumOfProductOfEventWeights)
13968 {
13969 cout<<endl;
13970 cout<<" WARNING (QC): fIntFlowSumOfProductOfEventWeights is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13971 cout<<endl;
13972 exit(0);
13973 }
13974 if(!fIntFlowCovariances)
13975 {
13976 cout<<endl;
13977 cout<<" WARNING (QC): fIntFlowCovariances is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13978 cout<<endl;
13979 exit(0);
13980 }
13981 if(!fIntFlowQcumulants)
13982 {
13983 cout<<endl;
13984 cout<<" WARNING (QC): fIntFlowQcumulants is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13985 cout<<endl;
13986 exit(0);
13987 }
0dd3b008 13988 if(!fIntFlow)
13989 {
13990 cout<<endl;
13991 cout<<" WARNING (QC): fIntFlow is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13992 cout<<endl;
13993 exit(0);
13994 }
13995 if(!fCommonHists)
13996 {
13997 cout<<endl;
13998 cout<<" WARNING (QC): fCommonHists is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
13999 cout<<endl;
14000 exit(0);
14001 }
14002 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))
14003 {
14004 cout<<endl;
14005 cout<<" WARNING (QC): fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th"<<endl;
14006 cout<<" && fCommonHistsResults8th is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14007 cout<<endl;
14008 exit(0);
14009 }
b3dacf6b 14010
b92ea2b9 14011 // NUA stuff:
14012 for(Int_t sc=0;sc<2;sc++) // sin/cos
14013 {
14014 if(!fIntFlowCorrectionTermsForNUAPro[sc])
14015 {
14016 cout<<endl;
14017 cout<<Form(" WARNING (QC): fIntFlowCorrectionTermsForNUAPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",sc)<<endl;
14018 cout<<endl;
14019 exit(0);
14020 }
14021 if(!fIntFlowCorrectionTermsForNUAHist[sc])
14022 {
14023 cout<<endl;
14024 cout<<Form(" WARNING (QC): fIntFlowCorrectionTermsForNUAHist[%d] is NULL in CheckPointersUsedInFinish() !!!!",sc)<<endl;
14025 cout<<endl;
14026 exit(0);
14027 }
14028 for(Int_t lq=0;lq<2;lq++) // linear/quadratic
14029 {
14030 if(!fIntFlowSumOfEventWeightsNUA[sc][lq])
14031 {
14032 cout<<endl;
14033 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeightsNUA[%d][%d] is NULL in CheckPointersUsedInFinish() !!!!",sc,lq)<<endl;
14034 cout<<endl;
14035 exit(0);
14036 }
14037 } // end of for(Int_t lq=0;lq<2;lq++) // linear/quadratic
14038 } // end of for(Int_t power=0;power<2;power++)
14039 if(!fIntFlowProductOfCorrectionTermsForNUAPro)
14040 {
14041 cout<<endl;
14042 cout<<" WARNING (QC): fIntFlowProductOfCorrectionTermsForNUAPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14043 cout<<endl;
14044 exit(0);
14045 }
14046 if(!fIntFlowSumOfProductOfEventWeightsNUA)
14047 {
14048 cout<<endl;
14049 cout<<" WARNING (QC): fIntFlowSumOfProductOfEventWeightsNUA is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14050 cout<<endl;
14051 exit(0);
14052 }
14053 if(!fIntFlowCovariancesNUA)
14054 {
14055 cout<<endl;
14056 cout<<" WARNING (QC): fIntFlowCovariancesNUA is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14057 cout<<endl;
14058 exit(0);
14059 }
14060 if(!fIntFlowQcumulantsErrorSquaredRatio)
14061 {
14062 cout<<endl;
14063 cout<<" WARNING (QC): fIntFlowQcumulantsErrorSquaredRatio is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14064 cout<<endl;
14065 exit(0);
14066 }
14067 if(!fIntFlowDetectorBias)
14068 {
14069 cout<<endl;
14070 cout<<" WARNING (QC): fIntFlowDetectorBias is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14071 cout<<endl;
14072 exit(0);
14073 }
14074
b3dacf6b 14075 // Versus multiplicity:
14076 if(!fCalculateCumulantsVsM){return;}
b77b6434 14077 for(Int_t co=0;co<=3;co++) // cumulant order
b3dacf6b 14078 {
b77b6434 14079 if(!fIntFlowQcumulantsVsM[co])
b3dacf6b 14080 {
14081 cout<<endl;
b77b6434 14082 cout<<Form(" WARNING (QC): fIntFlowQcumulantsVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
b3dacf6b 14083 cout<<endl;
14084 exit(0);
14085 }
b77b6434 14086 if(!fIntFlowVsM[co])
b3dacf6b 14087 {
14088 cout<<endl;
b77b6434 14089 cout<<Form(" WARNING (QC): fIntFlowVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
14090 cout<<endl;
14091 exit(0);
14092 }
14093 if(!fIntFlowDetectorBiasVsM[co])
14094 {
14095 cout<<endl;
14096 cout<<Form(" WARNING (QC): fIntFlowDetectorBiasVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
14097 cout<<endl;
14098 exit(0);
14099 }
14100 } // end of for(Int_t c0=0;c0<=3;c0++) // cumulant order
14101 for(Int_t ci=0;ci<=3;ci++) // correlation index
14102 {
14103 if(!fIntFlowCorrelationsVsMPro[ci])
14104 {
14105 cout<<endl;
14106 cout<<Form(" WARNING (QC): fIntFlowCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
b3dacf6b 14107 cout<<endl;
14108 exit(0);
14109 }
b40a910e 14110 if(!fIntFlowSquaredCorrelationsVsMPro[ci])
14111 {
14112 cout<<endl;
14113 cout<<Form(" WARNING (QC): fIntFlowSquaredCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
14114 cout<<endl;
14115 exit(0);
14116 }
b77b6434 14117 if(!fIntFlowCorrelationsVsMHist[ci])
b92ea2b9 14118 {
14119 cout<<endl;
b77b6434 14120 cout<<Form(" WARNING (QC): fIntFlowCorrelationsVsMHist[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
b92ea2b9 14121 cout<<endl;
14122 exit(0);
14123 }
b3dacf6b 14124 for(Int_t power=0;power<2;power++)
14125 {
14126 if(!fIntFlowSumOfEventWeightsVsM[ci][power])
14127 {
14128 cout<<endl;
14129 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeightsVsM[%d][%d] is NULL in CheckPointersUsedInFinish() !!!!",ci,power)<<endl;
14130 cout<<endl;
14131 exit(0);
14132 }
14133 } // end of for(Int_t power=0;power<2;power++)
14134 } // end of for(Int_t ci=0;ci<=3;ci++) // correlation index
14135 for(Int_t i=0;i<6;i++)
14136 {
14137 if(!fIntFlowProductOfCorrelationsVsMPro[i])
14138 {
14139 cout<<endl;
14140 cout<<Form(" WARNING (QC): fIntFlowProductOfCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14141 cout<<endl;
14142 exit(0);
14143 }
14144 if(!fIntFlowSumOfProductOfEventWeightsVsM[i])
14145 {
14146 cout<<endl;
14147 cout<<Form(" WARNING (QC): fIntFlowSumOfProductOfEventWeightsVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14148 cout<<endl;
14149 exit(0);
14150 }
14151 if(!fIntFlowCovariancesVsM[i])
14152 {
14153 cout<<endl;
14154 cout<<Form(" WARNING (QC): fIntFlowCovariancesVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14155 cout<<endl;
14156 exit(0);
14157 }
14158 } // end of for(Int_t i=0;i<6;i++)
14159 if(!fIntFlowRebinnedInM)
14160 {
14161 cout<<endl;
14162 cout<<" WARNING (QC): fIntFlowRebinnedInM is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14163 cout<<endl;
14164 exit(0);
14165 }
14166 if(!fIntFlowQcumulantsRebinnedInM)
14167 {
14168 cout<<endl;
14169 cout<<" WARNING (QC): fIntFlowQcumulantsRebinnedInM is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14170 cout<<endl;
14171 exit(0);
14172 }
14173
14174} // end of void AliFlowAnalysisWithQCumulants::CheckPointersUsedInFinish()
14175
14176//================================================================================================================================
14177
14178void AliFlowAnalysisWithQCumulants::CheckPointersUsedInMake()
14179{
1268c371 14180 // Check all pointers used in method Make(). // to be improved - check other pointers as well
b3dacf6b 14181
b77b6434 14182 if(!fAvMultiplicity)
14183 {
1268c371 14184 printf("\n WARNING (QC): fAvMultiplicity is NULL in CheckPointersUsedInMake() !!!!\n\n");
b77b6434 14185 exit(0);
14186 }
403e3389 14187 if((fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights) && !fIntFlowExtraCorrelationsPro)
b77b6434 14188 {
1268c371 14189 printf("\n WARNING (QC): fIntFlowExtraCorrelationsPro is NULL in CheckPointersUsedInMake() !!!!\n\n");
b77b6434 14190 exit(0);
14191 }
1268c371 14192 // 2D:
14193 if(fCalculate2DDiffFlow)
14194 {
14195 for(Int_t t=0;t<2;t++) // type = RP or POI
14196 {
14197 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
14198 {
14199 if(!f2DDiffFlowCorrelationsPro[t][rci])
14200 {
14201 printf("\n WARNING (QC): f2DDiffFlowCorrelationsPro[%i][%i] is NULL in CheckPointersUsedInMake() !!!!\n\n",t,rci);
14202 exit(0);
14203 } // end of if(!f2DDiffFlowCorrelationsPro[t][rci])
14204 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
14205 } // end of for(Int_t t=0;t<2;t++)
14206 } // end of if(fCalculate2DDiffFlow)
b3dacf6b 14207
14208} // end of void AliFlowAnalysisWithQCumulants::CheckPointersUsedInMake()
14209
57340a27 14210