]> 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
removed some compiler warnings
[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
3a7af7bd 67using std::endl;
68using std::cout;
69using std::flush;
489d5531 70ClassImp(AliFlowAnalysisWithQCumulants)
71
72AliFlowAnalysisWithQCumulants::AliFlowAnalysisWithQCumulants():
73 // 0.) base:
74 fHistList(NULL),
75 // 1.) common:
53884472 76 fBookOnlyBasicCCH(kTRUE),
489d5531 77 fCommonHists(NULL),
78 fCommonHists2nd(NULL),
79 fCommonHists4th(NULL),
80 fCommonHists6th(NULL),
81 fCommonHists8th(NULL),
82 fCommonHistsResults2nd(NULL),
83 fCommonHistsResults4th(NULL),
84 fCommonHistsResults6th(NULL),
85 fCommonHistsResults8th(NULL),
86 fnBinsPhi(0),
87 fPhiMin(0),
88 fPhiMax(0),
89 fPhiBinWidth(0),
90 fnBinsPt(0),
91 fPtMin(0),
92 fPtMax(0),
93 fPtBinWidth(0),
94 fnBinsEta(0),
95 fEtaMin(0),
96 fEtaMax(0),
97 fEtaBinWidth(0),
1268c371 98 fCommonConstants(NULL),
dd442cd2 99 fFillMultipleControlHistograms(kFALSE),
489d5531 100 fHarmonic(2),
101 fAnalysisLabel(NULL),
102 // 2a.) particle weights:
103 fWeightsList(NULL),
104 fUsePhiWeights(kFALSE),
105 fUsePtWeights(kFALSE),
106 fUseEtaWeights(kFALSE),
403e3389 107 fUseTrackWeights(kFALSE),
489d5531 108 fUseParticleWeights(NULL),
109 fPhiWeights(NULL),
110 fPtWeights(NULL),
111 fEtaWeights(NULL),
112 // 2b.) event weights:
113 fMultiplicityWeight(NULL),
114 // 3.) integrated flow:
115 fIntFlowList(NULL),
116 fIntFlowProfiles(NULL),
117 fIntFlowResults(NULL),
3435cacb 118 fIntFlowAllCorrelationsVsM(NULL),
489d5531 119 fIntFlowFlags(NULL),
b92ea2b9 120 fApplyCorrectionForNUA(kFALSE),
2001bc3a 121 fApplyCorrectionForNUAVsM(kFALSE),
9da1a4f3 122 fnBinsMult(10000),
067e9bc8 123 fMinMult(0.),
124 fMaxMult(10000.),
b77b6434 125 fPropagateErrorAlsoFromNIT(kFALSE),
8ed4edc7 126 fCalculateCumulantsVsM(kFALSE),
3435cacb 127 fCalculateAllCorrelationsVsM(kFALSE),
0dd3b008 128 fMinimumBiasReferenceFlow(kTRUE),
e5834fcb 129 fForgetAboutCovariances(kFALSE),
130 fStorePhiDistributionForOneEvent(kFALSE),
489d5531 131 fReQ(NULL),
132 fImQ(NULL),
1268c371 133 fSpk(NULL),
489d5531 134 fIntFlowCorrelationsEBE(NULL),
135 fIntFlowEventWeightsForCorrelationsEBE(NULL),
136 fIntFlowCorrelationsAllEBE(NULL),
e5834fcb 137 fReferenceMultiplicityEBE(0.),
489d5531 138 fAvMultiplicity(NULL),
139 fIntFlowCorrelationsPro(NULL),
b40a910e 140 fIntFlowSquaredCorrelationsPro(NULL),
489d5531 141 fIntFlowCorrelationsAllPro(NULL),
142 fIntFlowExtraCorrelationsPro(NULL),
143 fIntFlowProductOfCorrelationsPro(NULL),
0328db2d 144 fIntFlowProductOfCorrectionTermsForNUAPro(NULL),
489d5531 145 fIntFlowCorrelationsHist(NULL),
146 fIntFlowCorrelationsAllHist(NULL),
147 fIntFlowCovariances(NULL),
148 fIntFlowSumOfProductOfEventWeights(NULL),
0328db2d 149 fIntFlowCovariancesNUA(NULL),
150 fIntFlowSumOfProductOfEventWeightsNUA(NULL),
489d5531 151 fIntFlowQcumulants(NULL),
b92ea2b9 152 fIntFlowQcumulantsRebinnedInM(NULL),
153 fIntFlowQcumulantsErrorSquaredRatio(NULL),
489d5531 154 fIntFlow(NULL),
b3dacf6b 155 fIntFlowRebinnedInM(NULL),
2001bc3a 156 fIntFlowDetectorBias(NULL),
489d5531 157 // 4.) differential flow:
158 fDiffFlowList(NULL),
159 fDiffFlowProfiles(NULL),
160 fDiffFlowResults(NULL),
1268c371 161 fDiffFlow2D(NULL),
489d5531 162 fDiffFlowFlags(NULL),
1268c371 163 fCalculateDiffFlow(kTRUE),
164 fCalculate2DDiffFlow(kFALSE),
62e36168 165 fCalculateDiffFlowVsEta(kTRUE),
64e500e3 166 // 5.) other differential correlators:
167 fOtherDiffCorrelatorsList(NULL),
168 // 6.) distributions:
57340a27 169 fDistributionsList(NULL),
170 fDistributionsFlags(NULL),
489d5531 171 fStoreDistributions(kFALSE),
64e500e3 172 // 7.) various:
e5834fcb 173 fVariousList(NULL),
174 fPhiDistributionForOneEvent(NULL),
489d5531 175 // x.) debugging and cross-checking:
176 fNestedLoopsList(NULL),
177 fEvaluateIntFlowNestedLoops(kFALSE),
178 fEvaluateDiffFlowNestedLoops(kFALSE),
179 fMaxAllowedMultiplicity(10),
180 fEvaluateNestedLoops(NULL),
181 fIntFlowDirectCorrelations(NULL),
182 fIntFlowExtraDirectCorrelations(NULL),
183 fCrossCheckInPtBinNo(10),
3b552efe 184 fCrossCheckInEtaBinNo(20),
489d5531 185 fNoOfParticlesInBin(NULL)
186 {
187 // constructor
188
189 // base list to hold all output objects:
190 fHistList = new TList();
191 fHistList->SetName("cobjQC");
192 fHistList->SetOwner(kTRUE);
193
194 // list to hold histograms with phi, pt and eta weights:
195 fWeightsList = new TList();
196
197 // multiplicity weight:
198 fMultiplicityWeight = new TString("combinations");
199
200 // analysis label;
201 fAnalysisLabel = new TString();
202
203 // initialize all arrays:
204 this->InitializeArraysForIntFlow();
205 this->InitializeArraysForDiffFlow();
206 this->InitializeArraysForDistributions();
e5834fcb 207 this->InitializeArraysForVarious();
489d5531 208 this->InitializeArraysForNestedLoops();
209
210 } // end of constructor
211
489d5531 212//================================================================================================================
213
489d5531 214AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()
215{
216 // destructor
217
218 delete fHistList;
219
220} // end of AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()
221
489d5531 222//================================================================================================================
223
489d5531 224void AliFlowAnalysisWithQCumulants::Init()
225{
3b552efe 226 // a) Cross check if the settings make sense before starting the QC adventure;
489d5531 227 // b) Access all common constants;
228 // c) Book all objects;
3b552efe 229 // d) Store flags for integrated and differential flow;
489d5531 230 // e) Store flags for distributions of corelations;
231 // f) Store harmonic which will be estimated.
3b552efe 232
489d5531 233 //save old value and prevent histograms from being added to directory
234 //to avoid name clashes in case multiple analaysis objects are used
235 //in an analysis
236 Bool_t oldHistAddStatus = TH1::AddDirectoryStatus();
237 TH1::AddDirectory(kFALSE);
238
3b552efe 239 // a) Cross check if the settings make sense before starting the QC adventure;
489d5531 240 this->CrossCheckSettings();
1268c371 241 // b) Access all common constants and book a profile to hold them:
242 this->CommonConstants("Init");
489d5531 243 // c) Book all objects:
1268c371 244 this->BookAndFillWeightsHistograms();
489d5531 245 this->BookAndNestAllLists();
246 this->BookCommonHistograms();
247 this->BookEverythingForIntegratedFlow();
248 this->BookEverythingForDifferentialFlow();
1268c371 249 this->BookEverythingFor2DDifferentialFlow();
489d5531 250 this->BookEverythingForDistributions();
e5834fcb 251 this->BookEverythingForVarious();
489d5531 252 this->BookEverythingForNestedLoops();
253 // d) Store flags for integrated and differential flow:
254 this->StoreIntFlowFlags();
3b552efe 255 this->StoreDiffFlowFlags();
489d5531 256 // e) Store flags for distributions of corelations:
257 this->StoreFlagsForDistributions();
258 // f) Store harmonic which will be estimated:
259 this->StoreHarmonic();
260
261 TH1::AddDirectory(oldHistAddStatus);
262} // end of void AliFlowAnalysisWithQCumulants::Init()
263
489d5531 264//================================================================================================================
265
489d5531 266void AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)
267{
268 // Running over data only in this method.
269
b3dacf6b 270 // a) Check all pointers used in this method;
271 // b) Define local variables;
272 // c) Fill the common control histograms and call the method to fill fAvMultiplicity;
1268c371 273 // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k};
274 // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!);
275 // f) Call the methods which calculate correlations for reference flow;
276 // g) Call the methods which calculate correlations for differential flow;
277 // h) Call the methods which calculate correlations for 2D differential flow;
64e500e3 278 // i) Call the methods which calculate other differential correlators;
279 // j) Distributions of correlations;
280 // k) Store phi distribution for one event to illustrate flow;
281 // l) Cross-check with nested loops correlators for reference flow;
282 // m) Cross-check with nested loops correlators for differential flow;
283 // n) Reset all event-by-event quantities (very important !!!!).
489d5531 284
b3dacf6b 285 // a) Check all pointers used in this method:
286 this->CheckPointersUsedInMake();
287
288 // b) Define local variables:
489d5531 289 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
290 Double_t dPt = 0.; // transverse momentum
291 Double_t dEta = 0.; // pseudorapidity
489d5531 292 Double_t wPhi = 1.; // phi weight
293 Double_t wPt = 1.; // pt weight
294 Double_t wEta = 1.; // eta weight
38a1e8b3 295 Double_t wTrack = 1.; // track weight
1268c371 296 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of reference particles)
e5834fcb 297 fReferenceMultiplicityEBE = anEvent->GetReferenceMultiplicity(); // reference multiplicity for current event
1268c371 298 Double_t ptEta[2] = {0.,0.}; // 0 = dPt, 1 = dEta
9f33751d 299
b3dacf6b 300 // c) Fill the common control histograms and call the method to fill fAvMultiplicity:
489d5531 301 this->FillCommonControlHistograms(anEvent);
302 this->FillAverageMultiplicities(nRP);
303
1268c371 304 // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k}:
9f33751d 305 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI where:
1268c371 306 // nRP = # of reference particles;
307 // nPOI = # of particles of interest.
489d5531 308 AliFlowTrackSimple *aftsTrack = NULL;
1268c371 309 Int_t n = fHarmonic; // shortcut for the harmonic
489d5531 310 for(Int_t i=0;i<nPrim;i++)
311 {
312 aftsTrack=anEvent->GetTrack(i);
313 if(aftsTrack)
314 {
1268c371 315 if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())){continue;} // safety measure: consider only tracks which are RPs or POIs
489d5531 316 if(aftsTrack->InRPSelection()) // RP condition:
317 {
318 dPhi = aftsTrack->Phi();
319 dPt = aftsTrack->Pt();
320 dEta = aftsTrack->Eta();
321 if(fUsePhiWeights && fPhiWeights && fnBinsPhi) // determine phi weight for this particle:
322 {
323 wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
324 }
325 if(fUsePtWeights && fPtWeights && fnBinsPt) // determine pt weight for this particle:
326 {
327 wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth)));
328 }
329 if(fUseEtaWeights && fEtaWeights && fEtaBinWidth) // determine eta weight for this particle:
330 {
331 wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
38a1e8b3 332 }
333 // Access track weight:
403e3389 334 if(fUseTrackWeights)
335 {
336 wTrack = aftsTrack->Weight();
337 }
1268c371 338 // Calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}] for this event (m = 1,2,...,6, k = 0,1,...,8):
339 for(Int_t m=0;m<6;m++) // to be improved - hardwired 6
489d5531 340 {
1268c371 341 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 342 {
38a1e8b3 343 (*fReQ)(m,k)+=pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1)*n*dPhi);
344 (*fImQ)(m,k)+=pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1)*n*dPhi);
489d5531 345 }
346 }
1268c371 347 // Calculate S_{p,k} for this event (Remark: final calculation of S_{p,k} follows after the loop over data bellow):
489d5531 348 for(Int_t p=0;p<8;p++)
349 {
350 for(Int_t k=0;k<9;k++)
351 {
38a1e8b3 352 (*fSpk)(p,k)+=pow(wPhi*wPt*wEta*wTrack,k);
489d5531 353 }
354 }
1268c371 355 // Differential flow:
356 if(fCalculateDiffFlow || fCalculate2DDiffFlow)
489d5531 357 {
1268c371 358 ptEta[0] = dPt;
359 ptEta[1] = dEta;
360 // Calculate r_{m*n,k} and s_{p,k} (r_{m,k} is 'p-vector' for RPs):
361 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 362 {
1268c371 363 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 364 {
1268c371 365 if(fCalculateDiffFlow)
366 {
62e36168 367 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 368 {
38a1e8b3 369 fReRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
370 fImRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 371 if(m==0) // s_{p,k} does not depend on index m
372 {
38a1e8b3 373 fs1dEBE[0][pe][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 374 } // end of if(m==0) // s_{p,k} does not depend on index m
375 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
376 } // end of if(fCalculateDiffFlow)
377 if(fCalculate2DDiffFlow)
378 {
38a1e8b3 379 fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
380 fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 381 if(m==0) // s_{p,k} does not depend on index m
382 {
38a1e8b3 383 fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 384 } // end of if(m==0) // s_{p,k} does not depend on index m
385 } // end of if(fCalculate2DDiffFlow)
386 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
387 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
388 // Checking if RP particle is also POI particle:
389 if(aftsTrack->InPOISelection())
489d5531 390 {
1268c371 391 // Calculate q_{m*n,k} and s_{p,k} ('q-vector' and 's' for RPs && POIs):
392 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 393 {
1268c371 394 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 395 {
1268c371 396 if(fCalculateDiffFlow)
397 {
62e36168 398 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 399 {
38a1e8b3 400 fReRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
401 fImRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 402 if(m==0) // s_{p,k} does not depend on index m
403 {
38a1e8b3 404 fs1dEBE[2][pe][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 405 } // end of if(m==0) // s_{p,k} does not depend on index m
406 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
407 } // end of if(fCalculateDiffFlow)
408 if(fCalculate2DDiffFlow)
409 {
38a1e8b3 410 fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
411 fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 412 if(m==0) // s_{p,k} does not depend on index m
413 {
38a1e8b3 414 fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k),1.);
1268c371 415 } // end of if(m==0) // s_{p,k} does not depend on index m
416 } // end of if(fCalculate2DDiffFlow)
417 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
418 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
419 } // end of if(aftsTrack->InPOISelection())
420 } // end of if(fCalculateDiffFlow || fCalculate2DDiffFlow)
489d5531 421 } // end of if(pTrack->InRPSelection())
489d5531 422 if(aftsTrack->InPOISelection())
423 {
424 dPhi = aftsTrack->Phi();
425 dPt = aftsTrack->Pt();
426 dEta = aftsTrack->Eta();
38a1e8b3 427 wPhi = 1.;
428 wPt = 1.;
429 wEta = 1.;
430 wTrack = 1.;
431 if(fUsePhiWeights && fPhiWeights && fnBinsPhi && aftsTrack->InRPSelection()) // determine phi weight for POI && RP particle:
432 {
433 wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
434 }
435 if(fUsePtWeights && fPtWeights && fnBinsPt && aftsTrack->InRPSelection()) // determine pt weight for POI && RP particle:
436 {
437 wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth)));
438 }
439 if(fUseEtaWeights && fEtaWeights && fEtaBinWidth && aftsTrack->InRPSelection()) // determine eta weight for POI && RP particle:
440 {
441 wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
442 }
443 // Access track weight for POI && RP particle:
403e3389 444 if(aftsTrack->InRPSelection() && fUseTrackWeights)
38a1e8b3 445 {
446 wTrack = aftsTrack->Weight();
447 }
1268c371 448 ptEta[0] = dPt;
449 ptEta[1] = dEta;
450 // Calculate p_{m*n,k} ('p-vector' for POIs):
451 for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
489d5531 452 {
1268c371 453 for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
489d5531 454 {
1268c371 455 if(fCalculateDiffFlow)
456 {
62e36168 457 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
1268c371 458 {
38a1e8b3 459 fReRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
460 fImRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 461 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
462 } // end of if(fCalculateDiffFlow)
463 if(fCalculate2DDiffFlow)
464 {
38a1e8b3 465 fReRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
466 fImRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
1268c371 467 } // end of if(fCalculate2DDiffFlow)
468 } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
469 } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
b77b6434 470 } // end of if(pTrack->InPOISelection())
489d5531 471 } else // to if(aftsTrack)
472 {
38a1e8b3 473 printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
489d5531 474 }
475 } // end of for(Int_t i=0;i<nPrim;i++)
476
1268c371 477 // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
489d5531 478 for(Int_t p=0;p<8;p++)
479 {
480 for(Int_t k=0;k<9;k++)
481 {
1268c371 482 (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
483 // ... for the time being s_{p,k} dosn't need higher powers, so no need to finalize it here ...
484 } // end of for(Int_t k=0;k<9;k++)
485 } // end of for(Int_t p=0;p<8;p++)
489d5531 486
1268c371 487 // f) Call the methods which calculate correlations for reference flow:
489d5531 488 if(!fEvaluateIntFlowNestedLoops)
489 {
403e3389 490 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 491 {
1268c371 492 if(nRP>1){this->CalculateIntFlowCorrelations();} // without using particle weights
403e3389 493 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 494 {
1268c371 495 if(nRP>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
496 }
497 // Whether or not using particle weights the following is calculated in the same way:
498 if(nRP>3){this->CalculateIntFlowProductOfCorrelations();}
499 if(nRP>1){this->CalculateIntFlowSumOfEventWeights();}
500 if(nRP>1){this->CalculateIntFlowSumOfProductOfEventWeights();}
501 // Non-isotropic terms:
403e3389 502 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 503 {
1268c371 504 if(nRP>0){this->CalculateIntFlowCorrectionsForNUASinTerms();}
505 if(nRP>0){this->CalculateIntFlowCorrectionsForNUACosTerms();}
403e3389 506 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b92ea2b9 507 {
1268c371 508 if(nRP>0){this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights();}
509 if(nRP>0){this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights();}
510 }
511 // Whether or not using particle weights the following is calculated in the same way:
512 if(nRP>0){this->CalculateIntFlowProductOfCorrectionTermsForNUA();}
513 if(nRP>0){this->CalculateIntFlowSumOfEventWeightsNUA();}
514 if(nRP>0){this->CalculateIntFlowSumOfProductOfEventWeightsNUA();}
489d5531 515 } // end of if(!fEvaluateIntFlowNestedLoops)
516
1268c371 517 // g) Call the methods which calculate correlations for differential flow:
518 if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 519 {
403e3389 520 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 521 {
1268c371 522 // Without using particle weights:
489d5531 523 this->CalculateDiffFlowCorrelations("RP","Pt");
62e36168 524 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelations("RP","Eta");}
489d5531 525 this->CalculateDiffFlowCorrelations("POI","Pt");
62e36168 526 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelations("POI","Eta");}
1268c371 527 // Non-isotropic terms:
b92ea2b9 528 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");
62e36168 529 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");}
b92ea2b9 530 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");
62e36168 531 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");}
b92ea2b9 532 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");
62e36168 533 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");}
b92ea2b9 534 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");
62e36168 535 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");}
403e3389 536 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 537 {
1268c371 538 // With using particle weights:
489d5531 539 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt");
62e36168 540 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta");}
489d5531 541 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt");
62e36168 542 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta");}
1268c371 543 // Non-isotropic terms:
b92ea2b9 544 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");
62e36168 545 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");}
b92ea2b9 546 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");
62e36168 547 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");}
b92ea2b9 548 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");
62e36168 549 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");}
b92ea2b9 550 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");
62e36168 551 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");}
1268c371 552 }
553 // Whether or not using particle weights the following is calculated in the same way:
489d5531 554 this->CalculateDiffFlowProductOfCorrelations("RP","Pt");
62e36168 555 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowProductOfCorrelations("RP","Eta");}
489d5531 556 this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
62e36168 557 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowProductOfCorrelations("POI","Eta");}
489d5531 558 this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
62e36168 559 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfEventWeights("RP","Eta");}
489d5531 560 this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
62e36168 561 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfEventWeights("POI","Eta");}
489d5531 562 this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Pt");
62e36168 563 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Eta");}
489d5531 564 this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Pt");
62e36168 565 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Eta");}
1268c371 566 } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 567
1268c371 568 // h) Call the methods which calculate correlations for 2D differential flow:
569 if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
570 {
403e3389 571 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 572 {
1268c371 573 // Without using particle weights:
574 this->Calculate2DDiffFlowCorrelations("RP");
575 this->Calculate2DDiffFlowCorrelations("POI");
576 // Non-isotropic terms:
577 // ... to be ctd ...
403e3389 578 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 579 {
580 // With using particle weights:
581 // ... to be ctd ...
582 // Non-isotropic terms:
583 // ... to be ctd ...
584 }
585 // Whether or not using particle weights the following is calculated in the same way:
586 // ... to be ctd ...
587 } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
64e500e3 588
589 // i) Call the methods which calculate other differential correlators:
b84464d3 590 if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
64e500e3 591 {
403e3389 592 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 593 {
594 // Without using particle weights:
595 this->CalculateOtherDiffCorrelators("RP","Pt");
62e36168 596 if(fCalculateDiffFlowVsEta){this->CalculateOtherDiffCorrelators("RP","Eta");}
64e500e3 597 this->CalculateOtherDiffCorrelators("POI","Pt");
62e36168 598 if(fCalculateDiffFlowVsEta){this->CalculateOtherDiffCorrelators("POI","Eta");}
403e3389 599 } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 600 {
601 // With using particle weights:
602 // ... to be ctd ...
603 }
604 // Whether or not using particle weights the following is calculated in the same way:
605 // ... to be ctd ...
606 } // end of if(!fEvaluateDiffFlowNestedLoops)
607
608 // j) Distributions of correlations:
e5834fcb 609 if(fStoreDistributions){this->StoreDistributionsOfCorrelations();}
610
64e500e3 611 // k) Store phi distribution for one event to illustrate flow:
e5834fcb 612 if(fStorePhiDistributionForOneEvent){this->StorePhiDistributionForOneEvent(anEvent);}
1268c371 613
64e500e3 614 // l) Cross-check with nested loops correlators for reference flow:
1268c371 615 if(fEvaluateIntFlowNestedLoops){this->EvaluateIntFlowNestedLoops(anEvent);}
616
64e500e3 617 // m) Cross-check with nested loops correlators for differential flow:
1268c371 618 if(fEvaluateDiffFlowNestedLoops){this->EvaluateDiffFlowNestedLoops(anEvent);}
489d5531 619
64e500e3 620 // n) Reset all event-by-event quantities (very important !!!!):
489d5531 621 this->ResetEventByEventQuantities();
622
623} // end of AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)
624
489d5531 625//================================================================================================================================
626
489d5531 627void AliFlowAnalysisWithQCumulants::Finish()
628{
629 // Calculate the final results.
489d5531 630
b3dacf6b 631 // a) Check all pointers used in this method;
632 // b) Acces the constants;
633 // c) Access the flags;
b92ea2b9 634 // d) Calculate reference cumulants (not corrected for detector effects);
635 // e) Correct reference cumulants for detector effects;
636 // f) Calculate reference flow;
b77b6434 637 // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen;
b92ea2b9 638 // h) Calculate the final results for differential flow (without/with weights);
639 // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA);
640 // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults;
641 // k) Store results for differential flow in AliFlowCommonHistResults;
642 // l) Print the final results for integrated flow (RP/POI) on the screen;
643 // m) Cross-checking: Results from Q-vectors vs results from nested loops.
b3dacf6b 644
645 // a) Check all pointers used in this method:
646 this->CheckPointersUsedInFinish();
647
648 // b) Acces the constants:
1268c371 649 this->CommonConstants("Finish");
489d5531 650
b3dacf6b 651 if(fCommonHists && fCommonHists->GetHarmonic()) // to be improved (moved somewhere else)
489d5531 652 {
b3dacf6b 653 fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
489d5531 654 }
b3dacf6b 655
1268c371 656 // 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 657 fUsePhiWeights = (Bool_t)fUseParticleWeights->GetBinContent(1);
658 fUsePtWeights = (Bool_t)fUseParticleWeights->GetBinContent(2);
659 fUseEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(3);
403e3389 660 fUseTrackWeights = (Bool_t)fUseParticleWeights->GetBinContent(4);
b3dacf6b 661 fApplyCorrectionForNUA = (Bool_t)fIntFlowFlags->GetBinContent(3);
662 fPrintFinalResults[0] = (Bool_t)fIntFlowFlags->GetBinContent(4);
663 fPrintFinalResults[1] = (Bool_t)fIntFlowFlags->GetBinContent(5);
664 fPrintFinalResults[2] = (Bool_t)fIntFlowFlags->GetBinContent(6);
665 fPrintFinalResults[3] = (Bool_t)fIntFlowFlags->GetBinContent(7);
666 fApplyCorrectionForNUAVsM = (Bool_t)fIntFlowFlags->GetBinContent(8);
b77b6434 667 fPropagateErrorAlsoFromNIT = (Bool_t)fIntFlowFlags->GetBinContent(9);
0dd3b008 668 fCalculateCumulantsVsM = (Bool_t)fIntFlowFlags->GetBinContent(10);
669 fMinimumBiasReferenceFlow = (Bool_t)fIntFlowFlags->GetBinContent(11);
e5834fcb 670 fForgetAboutCovariances = (Bool_t)fIntFlowFlags->GetBinContent(12);
671 fStorePhiDistributionForOneEvent = (Bool_t)fIntFlowFlags->GetBinContent(13);
3435cacb 672 fFillMultipleControlHistograms = (Bool_t)fIntFlowFlags->GetBinContent(14);
673 fCalculateAllCorrelationsVsM = (Bool_t)fIntFlowFlags->GetBinContent(15);
b3dacf6b 674 fEvaluateIntFlowNestedLoops = (Bool_t)fEvaluateNestedLoops->GetBinContent(1);
675 fEvaluateDiffFlowNestedLoops = (Bool_t)fEvaluateNestedLoops->GetBinContent(2);
489d5531 676 fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);
677 fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4);
1268c371 678
b92ea2b9 679 // d) Calculate reference cumulants (not corrected for detector effects):
489d5531 680 this->FinalizeCorrelationsIntFlow();
681 this->CalculateCovariancesIntFlow();
682 this->CalculateCumulantsIntFlow();
489d5531 683
b92ea2b9 684 // e) Correct reference cumulants for detector effects:
685 this->FinalizeCorrectionTermsForNUAIntFlow();
686 this->CalculateCovariancesNUAIntFlow();
687 this->CalculateQcumulantsCorrectedForNUAIntFlow();
688
689 // f) Calculate reference flow:
690 this->CalculateReferenceFlow();
489d5531 691
b77b6434 692 // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen:
489d5531 693 this->FillCommonHistResultsIntFlow();
b3dacf6b 694 if(fPrintFinalResults[0]){this->PrintFinalResultsForIntegratedFlow("RF");}
695 if(fPrintFinalResults[3] && fCalculateCumulantsVsM){this->PrintFinalResultsForIntegratedFlow("RF, rebinned in M");}
489d5531 696
1268c371 697 // h) Calculate the final results for differential flow (without/with weights):
698 if(fCalculateDiffFlow)
699 {
700 this->FinalizeReducedCorrelations("RP","Pt");
62e36168 701 if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("RP","Eta");}
1268c371 702 this->FinalizeReducedCorrelations("POI","Pt");
62e36168 703 if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("POI","Eta");}
1268c371 704 this->CalculateDiffFlowCovariances("RP","Pt");
62e36168 705 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("RP","Eta");}
1268c371 706 this->CalculateDiffFlowCovariances("POI","Pt");
62e36168 707 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("POI","Eta");}
1268c371 708 this->CalculateDiffFlowCumulants("RP","Pt");
62e36168 709 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("RP","Eta");}
1268c371 710 this->CalculateDiffFlowCumulants("POI","Pt");
62e36168 711 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("POI","Eta");}
1268c371 712 this->CalculateDiffFlow("RP","Pt");
62e36168 713 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("RP","Eta");}
1268c371 714 this->CalculateDiffFlow("POI","Pt");
62e36168 715 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("POI","Eta");}
1268c371 716 } // if(fCalculateDiffFlow)
717
718 // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA):
719 if(fCalculateDiffFlow)
489d5531 720 {
721 this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");
62e36168 722 if(fCalculateDiffFlowVsEta){this->FinalizeCorrectionTermsForNUADiffFlow("RP","Eta");}
489d5531 723 this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");
62e36168 724 if(fCalculateDiffFlowVsEta){this->FinalizeCorrectionTermsForNUADiffFlow("POI","Eta");}
489d5531 725 this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Pt");
62e36168 726 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Eta");}
489d5531 727 this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Pt");
62e36168 728 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Eta");}
1268c371 729 if(fApplyCorrectionForNUA)
730 {
731 this->CalculateDiffFlowCorrectedForNUA("RP","Pt");
62e36168 732 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectedForNUA("RP","Eta");}
1268c371 733 this->CalculateDiffFlowCorrectedForNUA("POI","Pt");
62e36168 734 if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCorrectedForNUA("POI","Eta");}
1268c371 735 }
736 } // end of if(fCalculateDiffFlow && fApplyCorrectionForNUA)
737
738 // i) Calcualate final results for 2D differential flow:
739 if(fCalculate2DDiffFlow)
740 {
741 this->Calculate2DDiffFlowCumulants("RP");
742 this->Calculate2DDiffFlowCumulants("POI");
743 this->Calculate2DDiffFlow("RP");
744 this->Calculate2DDiffFlow("POI");
745 } // end of if(fCalculate2DDiffFlow)
746
747 // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults:
748 if(fCalculateDiffFlow)
749 {
750 this->CalculateFinalResultsForRPandPOIIntegratedFlow("RP");
751 this->CalculateFinalResultsForRPandPOIIntegratedFlow("POI");
3b552efe 752 }
489d5531 753
1268c371 754 // k) Store results for differential flow in AliFlowCommonHistResults:
755 if(fCalculateDiffFlow)
756 {
757 this->FillCommonHistResultsDiffFlow("RP");
758 this->FillCommonHistResultsDiffFlow("POI");
759 }
760
761 // l) Print the final results for integrated flow (RP/POI) on the screen:
762 if(fPrintFinalResults[1] && fCalculateDiffFlow){this->PrintFinalResultsForIntegratedFlow("RP");}
763 if(fPrintFinalResults[2] && fCalculateDiffFlow){this->PrintFinalResultsForIntegratedFlow("POI");}
764
765 // m) Cross-checking: Results from Q-vectors vs results from nested loops:
766 // m1) Reference flow:
489d5531 767 if(fEvaluateIntFlowNestedLoops)
768 {
769 this->CrossCheckIntFlowCorrelations();
770 this->CrossCheckIntFlowCorrectionTermsForNUA();
403e3389 771 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights){this->CrossCheckIntFlowExtraCorrelations();}
489d5531 772 } // end of if(fEvaluateIntFlowNestedLoops)
1268c371 773 // m2) Differential flow:
774 if(fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
489d5531 775 {
b3dacf6b 776 // Correlations:
489d5531 777 this->PrintNumberOfParticlesInSelectedBin();
778 this->CrossCheckDiffFlowCorrelations("RP","Pt");
62e36168 779 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrelations("RP","Eta");}
489d5531 780 this->CrossCheckDiffFlowCorrelations("POI","Pt");
62e36168 781 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrelations("POI","Eta");}
b3dacf6b 782 // Correction terms for non-uniform acceptance:
489d5531 783 this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt");
62e36168 784 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Eta");}
489d5531 785 this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");
62e36168 786 if(fCalculateDiffFlowVsEta){this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Eta");}
64e500e3 787 // Other differential correlators:
788 this->CrossCheckOtherDiffCorrelators("RP","Pt");
62e36168 789 if(fCalculateDiffFlowVsEta){this->CrossCheckOtherDiffCorrelators("RP","Eta");}
64e500e3 790 this->CrossCheckOtherDiffCorrelators("POI","Pt");
62e36168 791 if(fCalculateDiffFlowVsEta){this->CrossCheckOtherDiffCorrelators("POI","Eta");}
489d5531 792 } // end of if(fEvaluateDiffFlowNestedLoops)
793
794} // end of AliFlowAnalysisWithQCumulants::Finish()
795
489d5531 796//================================================================================================================================
797
1268c371 798void AliFlowAnalysisWithQCumulants::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
799{
800 // Evalauted all correlators for reference flow with nested loops.
801
802 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = nRP + nPOI
803 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
804 {
805 // Without using particle weights:
403e3389 806 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 807 {
808 // Correlations:
809 this->CalculateIntFlowCorrelations(); // from Q-vectors
810 this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
811 // Correction for non-uniform acceptance:
812 this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)
813 this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)
814 this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)
815 }
816 // Using particle weights:
403e3389 817 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 818 {
819 // Correlations
820 this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors
821 this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
822 // Correction for non-uniform acceptance:
823 this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)
824 this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)
825 this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
826 }
827 } else if(nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)
828 {
829 cout<<endl;
830 cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;
831 } else
832 {
833 cout<<endl;
834 cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;
835 }
836
837} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
838
839//================================================================================================================================
840
841void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
842{
843 // Evalauted all correlators for differential flow with nested loops.
844
845 if(!fCalculateDiffFlow){return;}
846
847 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = nRP + nPOI
848 if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
849 {
850 // Without using particle weights:
403e3389 851 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 852 {
64e500e3 853 // 1.) Reduced correlations:
1268c371 854 // Q-vectors:
855 this->CalculateDiffFlowCorrelations("RP","Pt");
856 this->CalculateDiffFlowCorrelations("RP","Eta");
857 this->CalculateDiffFlowCorrelations("POI","Pt");
858 this->CalculateDiffFlowCorrelations("POI","Eta");
859 // Nested loops:
860 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt");
861 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta");
862 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt");
863 this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta");
64e500e3 864 // 2.) Reduced corrections for non-uniform acceptance:
1268c371 865 // Q-vectors:
866 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");
867 this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");
868 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");
869 this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");
870 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");
871 this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");
872 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");
873 this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
874 // Nested loops:
875 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Pt");
876 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta");
877 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt");
878 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta");
64e500e3 879 // 3.) Other differential correlators:
880 // Q-vectors:
881 this->CalculateOtherDiffCorrelators("RP","Pt");
882 this->CalculateOtherDiffCorrelators("RP","Eta");
883 this->CalculateOtherDiffCorrelators("POI","Pt");
884 this->CalculateOtherDiffCorrelators("POI","Eta");
885 // Nested loops:
886 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Pt");
887 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Eta");
888 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Pt");
889 this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Eta");
403e3389 890 } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1268c371 891 // Using particle weights:
403e3389 892 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 893 {
894 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt");
895 this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta");
896 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt");
897 this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta");
898 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");
899 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");
900 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");
901 this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");
902 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");
903 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");
904 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");
905 this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");
906 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt");
907 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta");
908 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt");
909 this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta");
910 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt");
911 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta");
912 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt");
913 this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta");
403e3389 914 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1268c371 915 } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
916
917} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
918
919//================================================================================================================================
920
489d5531 921void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()
922{
b92ea2b9 923 // Calculate correction terms for non-uniform acceptance of the detector for reference flow (cos terms).
489d5531 924
925 // multiplicity:
1268c371 926 Double_t dMult = (*fSpk)(0,0);
489d5531 927
928 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
929 Double_t dReQ1n = (*fReQ)(0,0);
930 Double_t dReQ2n = (*fReQ)(1,0);
931 //Double_t dReQ3n = (*fReQ)(2,0);
932 //Double_t dReQ4n = (*fReQ)(3,0);
933 Double_t dImQ1n = (*fImQ)(0,0);
934 Double_t dImQ2n = (*fImQ)(1,0);
935 //Double_t dImQ3n = (*fImQ)(2,0);
936 //Double_t dImQ4n = (*fImQ)(3,0);
937
938 // *************************************************************
939 // **** corrections for non-uniform acceptance (cos terms): ****
940 // *************************************************************
941 //
942 // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors
943 // are stored in 1D profile fQCorrectionsCos.
944 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
945 // --------------------------------------------------------------------------------------------------------------------
946 // 1st bin: <<cos(n*(phi1))>> = cosP1n
947 // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n
948 // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n
949 // 4th bin: <<cos(n*(2phi1-phi2))>> = cosP2nM1n
950 // --------------------------------------------------------------------------------------------------------------------
951
952 // 1-particle:
953 Double_t cosP1n = 0.; // <<cos(n*(phi1))>>
954
955 if(dMult>0)
956 {
957 cosP1n = dReQ1n/dMult;
958
959 // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
960 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);
0328db2d 961 // event weights for NUA terms:
962 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(1,dMult);
489d5531 963
964 // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
965 fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);
b3dacf6b 966 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][0]->Fill(dMult+0.5,cosP1n,dMult);}
489d5531 967 }
968
969 // 2-particle:
3b552efe 970 Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>
489d5531 971 Double_t cosP2nM1n = 0.; // <<cos(n*(2phi1-phi2))>>
972
973 if(dMult>1)
974 {
975 cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1));
976 cosP2nM1n = (dReQ2n*dReQ1n+dImQ2n*dImQ1n-dReQ1n)/(dMult*(dMult-1));
977
978 // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
3b552efe 979 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);
489d5531 980 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(4,cosP2nM1n);
0328db2d 981 // event weights for NUA terms:
982 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(2,dMult*(dMult-1));
983 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(4,dMult*(dMult-1));
984
489d5531 985 // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
3b552efe 986 fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));
489d5531 987 fIntFlowCorrectionTermsForNUAPro[1]->Fill(3.5,cosP2nM1n,dMult*(dMult-1));
b3dacf6b 988 if(fCalculateCumulantsVsM)
989 {
990 fIntFlowCorrectionTermsForNUAVsMPro[1][1]->Fill(dMult+0.5,cosP1nP1n,dMult*(dMult-1));
991 fIntFlowCorrectionTermsForNUAVsMPro[1][3]->Fill(dMult+0.5,cosP2nM1n,dMult*(dMult-1));
992 }
489d5531 993 }
994
995 // 3-particle:
996 Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>
997
998 if(dMult>2)
999 {
1000 cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)
1001 / (dMult*(dMult-1)*(dMult-2));
1002
1003 // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
1004 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);
0328db2d 1005 // event weights for NUA terms:
1006 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
489d5531 1007
1008 // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
2001bc3a 1009 fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
b3dacf6b 1010 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][2]->Fill(dMult+0.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
489d5531 1011 }
1012
1013} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()
1014
1015
1016//================================================================================================================================
1017
1018
1019void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()
1020{
1021 // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
1022
1023 // multiplicity:
1268c371 1024 Double_t dMult = (*fSpk)(0,0);
489d5531 1025
1026 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1027 Double_t dReQ1n = (*fReQ)(0,0);
1028 Double_t dReQ2n = (*fReQ)(1,0);
1029 //Double_t dReQ3n = (*fReQ)(2,0);
1030 //Double_t dReQ4n = (*fReQ)(3,0);
1031 Double_t dImQ1n = (*fImQ)(0,0);
1032 Double_t dImQ2n = (*fImQ)(1,0);
1033 //Double_t dImQ3n = (*fImQ)(2,0);
1034 //Double_t dImQ4n = (*fImQ)(3,0);
1035
1036 // *************************************************************
1037 // **** corrections for non-uniform acceptance (sin terms): ****
1038 // *************************************************************
1039 //
1040 // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors
1041 // are stored in 1D profile fQCorrectionsSin.
1042 // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
1043 // --------------------------------------------------------------------------------------------------------------------
1044 // 1st bin: <<sin(n*(phi1))>> = sinP1n
1045 // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n
1046 // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n
1047 // 4th bin: <<sin(n*(2phi1-phi2))>> = sinP2nM1n
1048 // --------------------------------------------------------------------------------------------------------------------
1049
1050 // 1-particle:
1051 Double_t sinP1n = 0.; // <sin(n*(phi1))>
1052
1053 if(dMult>0)
1054 {
1055 sinP1n = dImQ1n/dMult;
1056
1057 // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
0328db2d 1058 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);
1059 // event weights for NUA terms:
1060 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(1,dMult);
489d5531 1061
1062 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1063 fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);
b3dacf6b 1064 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][0]->Fill(dMult+0.5,sinP1n,dMult);}
489d5531 1065 }
1066
1067 // 2-particle:
1068 Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>
1069 Double_t sinP2nM1n = 0.; // <<sin(n*(2phi1-phi2))>>
1070 if(dMult>1)
1071 {
3b552efe 1072 sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1));
489d5531 1073 sinP2nM1n = (dImQ2n*dReQ1n-dReQ2n*dImQ1n-dImQ1n)/(dMult*(dMult-1));
1074
1075 // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
1076 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);
3b552efe 1077 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(4,sinP2nM1n);
0328db2d 1078 // event weights for NUA terms:
1079 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(2,dMult*(dMult-1));
1080 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(4,dMult*(dMult-1));
489d5531 1081
1082 // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1083 fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));
1084 fIntFlowCorrectionTermsForNUAPro[0]->Fill(3.5,sinP2nM1n,dMult*(dMult-1));
b3dacf6b 1085 if(fCalculateCumulantsVsM)
1086 {
1087 fIntFlowCorrectionTermsForNUAVsMPro[0][1]->Fill(dMult+0.5,sinP1nP1n,dMult*(dMult-1));
1088 fIntFlowCorrectionTermsForNUAVsMPro[0][3]->Fill(dMult+0.5,sinP2nM1n,dMult*(dMult-1));
1089 }
489d5531 1090 }
1091
1092 // 3-particle:
1093 Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>
1094
1095 if(dMult>2)
1096 {
1097 sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)
1098 / (dMult*(dMult-1)*(dMult-2));
1099
1100 // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
1101 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);
0328db2d 1102 // event weights for NUA terms:
1103 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
489d5531 1104
1105 // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
2001bc3a 1106 fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
b3dacf6b 1107 if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][2]->Fill(dMult+0.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
489d5531 1108 }
1109
1110} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()
1111
489d5531 1112//================================================================================================================================
1113
489d5531 1114void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)
1115{
1268c371 1116 // a) Get pointers for common control and common result histograms;
1117 // b) Get pointers for histograms holding particle weights;
1118 // c) Get pointers for reference flow histograms;
1119 // d) Get pointers for differential flow histograms;
1120 // e) Get pointers for 2D differential flow histograms;
64e500e3 1121 // f) Get pointers for other differential correlators;
1122 // g) Get pointers for nested loops' histograms.
489d5531 1123
1124 if(outputListHistos)
3b552efe 1125 {
1126 this->SetHistList(outputListHistos);
1127 if(!fHistList)
1128 {
1268c371 1129 printf("\n WARNING (QC): fHistList is NULL in AFAWQC::GOH() !!!!\n\n");
3b552efe 1130 exit(0);
489d5531 1131 }
1132 this->GetPointersForCommonHistograms();
1133 this->GetPointersForParticleWeightsHistograms();
1134 this->GetPointersForIntFlowHistograms();
1135 this->GetPointersForDiffFlowHistograms();
1268c371 1136 this->GetPointersFor2DDiffFlowHistograms();
64e500e3 1137 this->GetPointersForOtherDiffCorrelators();
489d5531 1138 this->GetPointersForNestedLoopsHistograms();
3b552efe 1139 } else
1140 {
1268c371 1141 printf("\n WARNING (QC): outputListHistos is NULL in AFAWQC::GOH() !!!!\n\n");
3b552efe 1142 exit(0);
489d5531 1143 }
1144
1145} // end of void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)
ad87ae62 1146
489d5531 1147//================================================================================================================================
1148
489d5531 1149TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta) const
ad87ae62 1150{
489d5531 1151 // project 2D profile onto pt axis to get 1D profile
1152
1153 Int_t nBinsPt = profilePtEta->GetNbinsX();
1154 Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();
1155 Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();
1156
1157 Int_t nBinsEta = profilePtEta->GetNbinsY();
1158
1159 TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax);
1160
1161 for(Int_t p=1;p<=nBinsPt;p++)
1162 {
1163 Double_t contentPt = 0.;
1164 Double_t entryPt = 0.;
1165 Double_t spreadPt = 0.;
1166 Double_t sum1 = 0.;
1167 Double_t sum2 = 0.;
1168 Double_t sum3 = 0.;
1169 for(Int_t e=1;e<=nBinsEta;e++)
1170 {
1171 contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1172 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1173 entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1174
1175 sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1176 * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)
1177 + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.));
1178 sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1179 sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1180 * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));
1181 }
1182 if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)
1183 {
1184 spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);
1185 }
1186 profilePt->SetBinContent(p,contentPt);
1187 profilePt->SetBinEntries(p,entryPt);
1188 {
1189 profilePt->SetBinError(p,spreadPt);
1190 }
1191
1192 }
1193
1194 return profilePt;
1195
1196} // end of TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta)
1197
1198
1199//================================================================================================================================
1200
1201
1202TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta) const
1203{
1204 // project 2D profile onto eta axis to get 1D profile
1205
1206 Int_t nBinsEta = profilePtEta->GetNbinsY();
1207 Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();
1208 Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();
1209
1210 Int_t nBinsPt = profilePtEta->GetNbinsX();
1211
1212 TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax);
1213
1214 for(Int_t e=1;e<=nBinsEta;e++)
1215 {
1216 Double_t contentEta = 0.;
1217 Double_t entryEta = 0.;
1218 for(Int_t p=1;p<=nBinsPt;p++)
1219 {
1220 contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1221 * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1222 entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1223 }
1224 profileEta->SetBinContent(e,contentEta);
1225 profileEta->SetBinEntries(e,entryEta);
1226 }
1227
1228 return profileEta;
1229
1230} // end of TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta)
1231
489d5531 1232//================================================================================================================================
1233
489d5531 1234void AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type)
1235{
2001bc3a 1236 // Printing on the screen the final results for integrated flow (RF, POI and RP).
489d5531 1237
1238 Int_t n = fHarmonic;
1239
489d5531 1240 Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}
1241 Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}
1242
2001bc3a 1243 if(type == "RF")
489d5531 1244 {
0dd3b008 1245 for(Int_t b=0;b<4;b++)
1246 {
b77b6434 1247 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1);
1248 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1);
1249 dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1);
1250 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1);
1251 dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1);
1252 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1);
1253 dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1);
1254 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1);
0dd3b008 1255 }
489d5531 1256 } else if(type == "RP")
1257 {
1258 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1);
1259 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1);
1260 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1);
1261 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1);
1262 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1);
1263 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1);
1264 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1);
1265 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1);
1266 } else if(type == "POI")
1267 {
1268 dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1);
1269 dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1);
1270 dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1);
1271 dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1);
1272 dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1);
1273 dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1);
1274 dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1);
1275 dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1);
b77b6434 1276 } else if(type == "RF, rebinned in M" && fCalculateCumulantsVsM)
b3dacf6b 1277 {
0dd3b008 1278 for(Int_t b=0;b<4;b++)
1279 {
1280 dVn[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
1281 dVnErr[b] = fIntFlowRebinnedInM->GetBinError(b+1);
1282 }
b3dacf6b 1283 }
489d5531 1284
1285 TString title = " flow estimates from Q-cumulants";
1286 TString subtitle = " (";
b3dacf6b 1287 TString subtitle2 = " (rebinned in M)";
489d5531 1288
b3dacf6b 1289 if(type != "RF, rebinned in M")
489d5531 1290 {
403e3389 1291 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b3dacf6b 1292 {
1293 subtitle.Append(type);
1294 subtitle.Append(", without weights)");
1295 } else
1296 {
1297 subtitle.Append(type);
1298 subtitle.Append(", with weights)");
1299 }
1300 } else
489d5531 1301 {
403e3389 1302 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
b3dacf6b 1303 {
1304 subtitle.Append("RF");
1305 subtitle.Append(", without weights)");
1306 } else
1307 {
1308 subtitle.Append("RF");
1309 subtitle.Append(", with weights)");
1310 }
1311 }
1312
489d5531 1313 cout<<endl;
1314 cout<<"*************************************"<<endl;
1315 cout<<"*************************************"<<endl;
1316 cout<<title.Data()<<endl;
1317 cout<<subtitle.Data()<<endl;
b3dacf6b 1318 if(type == "RF, rebinned in M"){cout<<subtitle2.Data()<<endl;}
489d5531 1319 cout<<endl;
1320
1321 for(Int_t i=0;i<4;i++)
1322 {
2001bc3a 1323 cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
489d5531 1324 }
2001bc3a 1325
489d5531 1326 cout<<endl;
b92ea2b9 1327 if(type == "RF")
1328 {
b77b6434 1329 if(fApplyCorrectionForNUA)
1330 {
1331 cout<<" detector bias (corrected for): "<<endl;
1332 } else
1333 {
1334 cout<<" detector bias (not corrected for):"<<endl;
1335 }
b92ea2b9 1336 cout<<" to QC{2}: "<<fIntFlowDetectorBias->GetBinContent(1)<<" +/- "<<fIntFlowDetectorBias->GetBinError(1)<<endl;
1337 cout<<" to QC{4}: "<<fIntFlowDetectorBias->GetBinContent(2)<<" +/- "<<fIntFlowDetectorBias->GetBinError(2)<<endl;
1338 cout<<endl;
1339 }
b3dacf6b 1340 if(type == "RF" || type == "RF, rebinned in M")
489d5531 1341 {
2001bc3a 1342 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
489d5531 1343 }
1344 else if (type == "RP")
1345 {
2001bc3a 1346 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
489d5531 1347 }
1348 else if (type == "POI")
1349 {
2001bc3a 1350 cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
1351 }
1352
489d5531 1353 cout<<"*************************************"<<endl;
1354 cout<<"*************************************"<<endl;
1355 cout<<endl;
1356
2001bc3a 1357}// end of AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type="RF");
489d5531 1358
1359//================================================================================================================================
1360
489d5531 1361void AliFlowAnalysisWithQCumulants::WriteHistograms(TString outputFileName)
1362{
1363 //store the final results in output .root file
1364 TFile *output = new TFile(outputFileName.Data(),"RECREATE");
1365 //output->WriteObject(fHistList, "cobjQC","SingleKey");
1366 fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
1367 delete output;
1368}
1369
1370
1371//================================================================================================================================
1372
1373
1374void AliFlowAnalysisWithQCumulants::WriteHistograms(TDirectoryFile *outputFileName)
1375{
1376 //store the final results in output .root file
1377 fHistList->SetName("cobjQC");
1378 fHistList->SetOwner(kTRUE);
1379 outputFileName->Add(fHistList);
1380 outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
1381}
1382
489d5531 1383//================================================================================================================================
1384
489d5531 1385void AliFlowAnalysisWithQCumulants::BookCommonHistograms()
1386{
1387 // Book common control histograms and common histograms for final results.
1268c371 1388 // a) Book common control histograms;
1389 // b) Book common result histograms.
1390
1391 // a) Book common control histograms:
1392 // Common control histograms (all events):
489d5531 1393 TString commonHistsName = "AliFlowCommonHistQC";
1394 commonHistsName += fAnalysisLabel->Data();
62d19320 1395 fCommonHists = new AliFlowCommonHist(commonHistsName.Data(),commonHistsName.Data(),fBookOnlyBasicCCH);
489d5531 1396 fHistList->Add(fCommonHists);
1268c371 1397 // Common control histograms (selected events):
dd442cd2 1398 if(fFillMultipleControlHistograms)
1399 {
1268c371 1400 // Common control histogram filled for events with 2 and more reference particles:
dd442cd2 1401 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
1402 commonHists2ndOrderName += fAnalysisLabel->Data();
62d19320 1403 fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data(),commonHists2ndOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1404 fHistList->Add(fCommonHists2nd);
1268c371 1405 // Common control histogram filled for events with 2 and more reference particles:
dd442cd2 1406 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
1407 commonHists4thOrderName += fAnalysisLabel->Data();
62d19320 1408 fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data(),commonHists4thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1409 fHistList->Add(fCommonHists4th);
1268c371 1410 // Common control histogram filled for events with 6 and more reference particles:
dd442cd2 1411 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
1412 commonHists6thOrderName += fAnalysisLabel->Data();
62d19320 1413 fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data(),commonHists6thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1414 fHistList->Add(fCommonHists6th);
1268c371 1415 // Common control histogram filled for events with 8 and more reference particles:
dd442cd2 1416 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
1417 commonHists8thOrderName += fAnalysisLabel->Data();
62d19320 1418 fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data(),commonHists8thOrderName.Data(),fBookOnlyBasicCCH);
dd442cd2 1419 fHistList->Add(fCommonHists8th);
1420 } // end of if(fFillMultipleControlHistograms)
1421
1268c371 1422 // b) Book common result histograms:
1423 // Common result histograms for QC{2}:
489d5531 1424 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
1425 commonHistResults2ndOrderName += fAnalysisLabel->Data();
62e36168 1426 fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
489d5531 1427 fHistList->Add(fCommonHistsResults2nd);
1268c371 1428 // Common result histograms for QC{4}:
489d5531 1429 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
1430 commonHistResults4thOrderName += fAnalysisLabel->Data();
62e36168 1431 fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
489d5531 1432 fHistList->Add(fCommonHistsResults4th);
1268c371 1433 // Common result histograms for QC{6}:
489d5531 1434 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
1435 commonHistResults6thOrderName += fAnalysisLabel->Data();
62e36168 1436 fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
489d5531 1437 fHistList->Add(fCommonHistsResults6th);
1268c371 1438 // Common result histograms for QC{8}:
489d5531 1439 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
1440 commonHistResults8thOrderName += fAnalysisLabel->Data();
62e36168 1441 fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
489d5531 1442 fHistList->Add(fCommonHistsResults8th);
1443
1444} // end of void AliFlowAnalysisWithQCumulants::BookCommonHistograms()
1445
489d5531 1446//================================================================================================================================
1447
489d5531 1448void AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()
1449{
1268c371 1450 // Book and fill histograms which hold phi, pt and eta weights.
489d5531 1451
1452 if(!fWeightsList)
1453 {
1268c371 1454 printf("\n WARNING (QC): fWeightsList is NULL in AFAWQC::BAFWH() !!!! \n\n");
489d5531 1455 exit(0);
1456 }
1457
1458 TString fUseParticleWeightsName = "fUseParticleWeightsQC";
1459 fUseParticleWeightsName += fAnalysisLabel->Data();
403e3389 1460 fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",4,0,4);
489d5531 1461 fUseParticleWeights->SetLabelSize(0.06);
1462 (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");
1463 (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");
1464 (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");
403e3389 1465 (fUseParticleWeights->GetXaxis())->SetBinLabel(4,"w_{track}");
489d5531 1466 fUseParticleWeights->Fill(0.5,(Int_t)fUsePhiWeights);
1467 fUseParticleWeights->Fill(1.5,(Int_t)fUsePtWeights);
1468 fUseParticleWeights->Fill(2.5,(Int_t)fUseEtaWeights);
403e3389 1469 fUseParticleWeights->Fill(3.5,(Int_t)fUseTrackWeights);
489d5531 1470 fWeightsList->Add(fUseParticleWeights);
1471
1472 if(fUsePhiWeights)
1473 {
1474 if(fWeightsList->FindObject("phi_weights"))
1475 {
1476 fPhiWeights = dynamic_cast<TH1F*>(fWeightsList->FindObject("phi_weights"));
1268c371 1477 if(!fPhiWeights)
1478 {
1479 printf("\n WARNING (QC): fPhiWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1480 exit(0);
1481 }
489d5531 1482 if(TMath::Abs(fPhiWeights->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
1483 {
1484 cout<<endl;
1485 cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
1486 cout<<endl;
6fbbbbf1 1487 //exit(0);
489d5531 1488 }
1489 } else
1490 {
1491 cout<<"WARNING: fWeightsList->FindObject(\"phi_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1492 exit(0);
1493 }
1494 } // end of if(fUsePhiWeights)
1495
1496 if(fUsePtWeights)
1497 {
1498 if(fWeightsList->FindObject("pt_weights"))
1499 {
1500 fPtWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("pt_weights"));
1268c371 1501 if(!fPtWeights)
1502 {
1503 printf("\n WARNING (QC): fPtWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1504 exit(0);
1505 }
489d5531 1506 if(TMath::Abs(fPtWeights->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
1507 {
1508 cout<<endl;
1509 cout<<"WARNING (QC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
1510 cout<<endl;
6fbbbbf1 1511 //exit(0);
489d5531 1512 }
1513 } else
1514 {
1515 cout<<"WARNING: fWeightsList->FindObject(\"pt_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1516 exit(0);
1517 }
1518 } // end of if(fUsePtWeights)
1519
1520 if(fUseEtaWeights)
1521 {
1522 if(fWeightsList->FindObject("eta_weights"))
1523 {
1524 fEtaWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("eta_weights"));
1268c371 1525 if(!fEtaWeights)
1526 {
1527 printf("\n WARNING (QC): fEtaWeights is NULL in AFAWQC::BAFWH() !!!!\n\n");
1528 exit(0);
1529 }
489d5531 1530 if(TMath::Abs(fEtaWeights->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
1531 {
1532 cout<<endl;
1533 cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
1534 cout<<endl;
6fbbbbf1 1535 //exit(0);
489d5531 1536 }
1537 } else
1538 {
1539 cout<<"WARNING: fUseEtaWeights && fWeightsList->FindObject(\"eta_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
1540 exit(0);
1541 }
1542 } // end of if(fUseEtaWeights)
1543
1544} // end of AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()
1545
489d5531 1546//================================================================================================================================
1547
489d5531 1548void AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()
1549{
1550 // Book all objects for integrated flow:
e5834fcb 1551 // a) Book profile to hold all flags for integrated flow;
1552 // b) Book event-by-event quantities;
1553 // c) Book profiles; // to be improved (comment)
489d5531 1554 // d) Book histograms holding the final results.
1555
1556 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
1557 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)
1558
1559 // a) Book profile to hold all flags for integrated flow:
1560 TString intFlowFlagsName = "fIntFlowFlags";
1561 intFlowFlagsName += fAnalysisLabel->Data();
3435cacb 1562 fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",15,0,15);
489d5531 1563 fIntFlowFlags->SetTickLength(-0.01,"Y");
1564 fIntFlowFlags->SetMarkerStyle(25);
403e3389 1565 fIntFlowFlags->SetLabelSize(0.04);
489d5531 1566 fIntFlowFlags->SetLabelOffset(0.02,"Y");
1567 fIntFlowFlags->GetXaxis()->SetBinLabel(1,"Particle Weights");
1568 fIntFlowFlags->GetXaxis()->SetBinLabel(2,"Event Weights");
1569 fIntFlowFlags->GetXaxis()->SetBinLabel(3,"Corrected for NUA?");
b3dacf6b 1570 fIntFlowFlags->GetXaxis()->SetBinLabel(4,"Print RF results");
489d5531 1571 fIntFlowFlags->GetXaxis()->SetBinLabel(5,"Print RP results");
3b552efe 1572 fIntFlowFlags->GetXaxis()->SetBinLabel(6,"Print POI results");
b3dacf6b 1573 fIntFlowFlags->GetXaxis()->SetBinLabel(7,"Print RF (rebinned in M) results");
1574 fIntFlowFlags->GetXaxis()->SetBinLabel(8,"Corrected for NUA vs M?");
1575 fIntFlowFlags->GetXaxis()->SetBinLabel(9,"Propagate errors to v_{n} from correlations?");
1576 fIntFlowFlags->GetXaxis()->SetBinLabel(10,"Calculate cumulants vs M");
0dd3b008 1577 fIntFlowFlags->GetXaxis()->SetBinLabel(11,"fMinimumBiasReferenceFlow");
8e1cefdd 1578 fIntFlowFlags->GetXaxis()->SetBinLabel(12,"fForgetAboutCovariances");
e5834fcb 1579 fIntFlowFlags->GetXaxis()->SetBinLabel(13,"fStorePhiDistributionForOneEvent");
dd442cd2 1580 fIntFlowFlags->GetXaxis()->SetBinLabel(14,"fFillMultipleControlHistograms");
3435cacb 1581 fIntFlowFlags->GetXaxis()->SetBinLabel(15,"Calculate all correlations vs M");
489d5531 1582 fIntFlowList->Add(fIntFlowFlags);
1583
1584 // b) Book event-by-event quantities:
1585 // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M:
8ed4edc7 1586 fReQ = new TMatrixD(6,9);
1587 fImQ = new TMatrixD(6,9);
1268c371 1588 fSpk = new TMatrixD(8,9);
489d5531 1589 // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):
1590 TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";
1591 intFlowCorrelationsEBEName += fAnalysisLabel->Data();
1592 fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);
1593 // weights for average correlations <2>, <4>, <6> and <8> for single event:
1594 TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";
1595 intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
1596 fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);
1597 // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):
1598 TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";
1599 intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();
403e3389 1600 fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),64,0,64);
489d5531 1601 // average correction terms for non-uniform acceptance for single event
1602 // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):
1603 TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";
1604 fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
1605 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
1606 {
b92ea2b9 1607 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 1608 }
0328db2d 1609 // event weights for terms for non-uniform acceptance:
1610 TString fIntFlowEventWeightForCorrectionTermsForNUAEBEName = "fIntFlowEventWeightForCorrectionTermsForNUAEBE";
1611 fIntFlowEventWeightForCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
1612 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
1613 {
b92ea2b9 1614 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 1615 }
489d5531 1616 // c) Book profiles: // to be improved (comment)
1617 // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:
1618 TString avMultiplicityName = "fAvMultiplicity";
1619 avMultiplicityName += fAnalysisLabel->Data();
403e3389 1620 fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average multiplicities of reference particles (RPs)",9,0,9);
489d5531 1621 fAvMultiplicity->SetTickLength(-0.01,"Y");
1622 fAvMultiplicity->SetMarkerStyle(25);
1623 fAvMultiplicity->SetLabelSize(0.05);
1624 fAvMultiplicity->SetLabelOffset(0.02,"Y");
403e3389 1625 fAvMultiplicity->SetYTitle("Average multiplicity");
489d5531 1626 (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");
1627 (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");
1628 (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");
1629 (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");
1630 (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");
1631 (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");
1632 (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");
1633 (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");
1634 (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");
1635 fIntFlowProfiles->Add(fAvMultiplicity);
b40a910e 1636 // Average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):
1637 TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
489d5531 1638 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
1639 intFlowCorrelationsProName += fAnalysisLabel->Data();
1640 fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");
b40a910e 1641 fIntFlowCorrelationsPro->Sumw2();
489d5531 1642 fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");
1643 fIntFlowCorrelationsPro->SetMarkerStyle(25);
1644 fIntFlowCorrelationsPro->SetLabelSize(0.06);
1645 fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");
68a3b4b1 1646 for(Int_t b=0;b<4;b++)
b3dacf6b 1647 {
68a3b4b1 1648 (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(b+1,correlationFlag[b].Data());
b3dacf6b 1649 }
489d5531 1650 fIntFlowProfiles->Add(fIntFlowCorrelationsPro);
b40a910e 1651 // Average correlations squared <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> for all events:
1652 TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"};
1653 TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
1654 intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
1655 fIntFlowSquaredCorrelationsPro = new TProfile(intFlowSquaredCorrelationsProName.Data(),"Average squared correlations for all events",4,0,4,"s");
1656 fIntFlowSquaredCorrelationsPro->Sumw2();
1657 fIntFlowSquaredCorrelationsPro->SetTickLength(-0.01,"Y");
1658 fIntFlowSquaredCorrelationsPro->SetMarkerStyle(25);
1659 fIntFlowSquaredCorrelationsPro->SetLabelSize(0.06);
1660 fIntFlowSquaredCorrelationsPro->SetLabelOffset(0.01,"Y");
1661 for(Int_t b=0;b<4;b++)
1662 {
1663 (fIntFlowSquaredCorrelationsPro->GetXaxis())->SetBinLabel(b+1,squaredCorrelationFlag[b].Data());
1664 }
1665 fIntFlowProfiles->Add(fIntFlowSquaredCorrelationsPro);
b3dacf6b 1666 if(fCalculateCumulantsVsM)
1667 {
1668 for(Int_t ci=0;ci<4;ci++) // correlation index
1669 {
b40a910e 1670 // average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (with wrong errors):
b3dacf6b 1671 TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
1672 intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
1673 fIntFlowCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data()),
1674 Form("%s vs multiplicity",correlationFlag[ci].Data()),
b40a910e 1675 fnBinsMult,fMinMult,fMaxMult,"s");
1676 fIntFlowCorrelationsVsMPro[ci]->Sumw2();
b3dacf6b 1677 fIntFlowCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
1678 fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("M");
1679 fIntFlowProfiles->Add(fIntFlowCorrelationsVsMPro[ci]);
b40a910e 1680 // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
1681 TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
1682 intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
1683 fIntFlowSquaredCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data()),
1684 Form("%s vs multiplicity",squaredCorrelationFlag[ci].Data()),
1685 fnBinsMult,fMinMult,fMaxMult,"s");
1686 fIntFlowSquaredCorrelationsVsMPro[ci]->Sumw2();
1687 fIntFlowSquaredCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(squaredCorrelationFlag[ci].Data());
1688 fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("M");
1689 fIntFlowProfiles->Add(fIntFlowSquaredCorrelationsVsMPro[ci]);
b3dacf6b 1690 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
1691 } // end of if(fCalculateCumulantsVsM)
489d5531 1692 // averaged all correlations for all events (with wrong errors!):
1693 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
1694 intFlowCorrelationsAllProName += fAnalysisLabel->Data();
403e3389 1695 fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average all correlations for all events",64,0,64);
b84464d3 1696 fIntFlowCorrelationsAllPro->Sumw2();
489d5531 1697 fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");
1698 fIntFlowCorrelationsAllPro->SetMarkerStyle(25);
1699 fIntFlowCorrelationsAllPro->SetLabelSize(0.03);
1700 fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");
1701 // 2-p correlations:
403e3389 1702 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT_{n|n}");
1703 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"#LT#LT2#GT#GT_{2n|2n}");
1704 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"#LT#LT2#GT#GT_{3n|3n}");
1705 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"#LT#LT2#GT#GT_{4n|4n}");
489d5531 1706 // 3-p correlations:
403e3389 1707 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"#LT#LT3#GT#GT_{2n|n,n}");
1708 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"#LT#LT3#GT#GT_{3n|2n,n}");
1709 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"#LT#LT3#GT#GT_{4n|2n,2n}");
1710 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"#LT#LT3#GT#GT_{4n|3n,n}");
489d5531 1711 // 4-p correlations:
403e3389 1712 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"#LT#LT4#GT#GT_{n,n|n,n}");
1713 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"#LT#LT4#GT#GT_{2n,n|2n,n}");
1714 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"#LT#LT4#GT#GT_{2n,2n|2n,2n}");
1715 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"#LT#LT4#GT#GT_{3n|n,n,n}");
1716 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"#LT#LT4#GT#GT_{3n,n|3n,n}");
1717 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"#LT#LT4#GT#GT_{3n,n|2n,2n}");
1718 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"#LT#LT4#GT#GT_{4n|2n,n,n}");
489d5531 1719 // 5-p correlations:
403e3389 1720 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"#LT#LT5#GT#GT_{2n,n|n,n,n}");
1721 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"#LT#LT5#GT#GT_{2n,2n|2n,n,n}");
1722 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"#LT#LT5#GT#GT_{3n,n|2n,n,n}");
1723 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"#LT#LT5#GT#GT_{4n|n,n,n,n}");
489d5531 1724 // 6-p correlations:
403e3389 1725 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"#LT#LT6#GT#GT_{n,n,n|n,n,n}");
1726 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"#LT#LT6#GT#GT_{2n,n,n|2n,n,n}");
1727 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"#LT#LT6#GT#GT_{2n,2n|n,n,n,n}");
1728 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"#LT#LT6#GT#GT_{3n,n|n,n,n,n}");
489d5531 1729 // 7-p correlations:
403e3389 1730 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}");
489d5531 1731 // 8-p correlations:
403e3389 1732 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}");
b84464d3 1733 // EXTRA correlations for v3{5} study:
403e3389 1734 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(33,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
1735 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(34,"#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}");
b84464d3 1736 // EXTRA correlations for Teaney-Yan study:
403e3389 1737 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(35,"#LT#LT2#GT#GT_{5n|5n}");
1738 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(36,"#LT#LT2#GT#GT_{6n|6n}");
1739 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(37,"#LT#LT3#GT#GT_{5n|3n,2n}");
1740 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(38,"#LT#LT3#GT#GT_{5n|4n,1n}");
1741 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(39,"#LT#LT3#GT#GT_{6n|3n,3n}");
1742 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(40,"#LT#LT3#GT#GT_{6n|4n,2n}");
1743 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(41,"#LT#LT3#GT#GT_{6n|5n,1n}");
1744 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(42,"#LT#LT4#GT#GT_{6n|3n,2n,1n}");
1745 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(43,"#LT#LT4#GT#GT_{3n,2n|3n,2n}");
1746 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(44,"#LT#LT4#GT#GT_{4n,1n|3n,2n}");
1747 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(45,"#LT#LT4#GT#GT_{3n,3n|3n,3n}");
1748 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(46,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
1749 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(47,"#LT#LT4#GT#GT_{5n,1n|3n,3n}");
1750 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(48,"#LT#LT4#GT#GT_{4n,2n|4n,2n}");
1751 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(49,"#LT#LT4#GT#GT_{5n,1n|4n,2n}");
1752 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(50,"#LT#LT4#GT#GT_{5n|3n,1n,1n}");
1753 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(51,"#LT#LT4#GT#GT_{5n|2n,2n,1n}");
1754 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(52,"#LT#LT4#GT#GT_{5n,1n|5n,1n}");
1755 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(53,"#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}");
1756 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(54,"#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}");
1757 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(55,"#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}");
1758 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(56,"#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}");
1759 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(57,"#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}");
1760 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(58,"#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}");
1761 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(59,"#LT#LT4#GT#GT_{6n|4n,1n,1n}");
1762 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(60,"#LT#LT4#GT#GT_{6n|2n,2n,2n}");
1763 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(61,"#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}");
1764 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(62,"#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}");
1765 (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(63,"#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}");
489d5531 1766 fIntFlowProfiles->Add(fIntFlowCorrelationsAllPro);
3435cacb 1767 // average all correlations versus multiplicity (errors via Sumw2 - to be improved):
1768 if(fCalculateAllCorrelationsVsM)
1769 {
1770 // 2-p correlations vs M:
1771 fIntFlowCorrelationsAllVsMPro[0] = new TProfile("two1n1n","#LT#LT2#GT#GT_{n|n}",fnBinsMult,fMinMult,fMaxMult);
1772 fIntFlowCorrelationsAllVsMPro[0]->Sumw2();
1773 fIntFlowCorrelationsAllVsMPro[0]->GetXaxis()->SetTitle("M");
1774 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[0]);
1775 fIntFlowCorrelationsAllVsMPro[1] = new TProfile("two2n2n","#LT#LT2#GT#GT_{2n|2n}",fnBinsMult,fMinMult,fMaxMult);
1776 fIntFlowCorrelationsAllVsMPro[1]->Sumw2();
1777 fIntFlowCorrelationsAllVsMPro[1]->GetXaxis()->SetTitle("M");
1778 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[1]);
1779 fIntFlowCorrelationsAllVsMPro[2] = new TProfile("two3n3n","#LT#LT2#GT#GT_{3n|3n}",fnBinsMult,fMinMult,fMaxMult);
1780 fIntFlowCorrelationsAllVsMPro[2]->Sumw2();
1781 fIntFlowCorrelationsAllVsMPro[2]->GetXaxis()->SetTitle("M");
1782 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[2]);
1783 fIntFlowCorrelationsAllVsMPro[3] = new TProfile("two4n4n","#LT#LT2#GT#GT_{4n|4n}",fnBinsMult,fMinMult,fMaxMult);
1784 fIntFlowCorrelationsAllVsMPro[3]->Sumw2();
1785 fIntFlowCorrelationsAllVsMPro[3]->GetXaxis()->SetTitle("M");
1786 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[3]);
1787 // 3-p correlations vs M:
1788 fIntFlowCorrelationsAllVsMPro[5] = new TProfile("three2n1n1n","#LT#LT3#GT#GT_{2n|n,n}",fnBinsMult,fMinMult,fMaxMult);
1789 fIntFlowCorrelationsAllVsMPro[5]->Sumw2();
1790 fIntFlowCorrelationsAllVsMPro[5]->GetXaxis()->SetTitle("M");
1791 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[5]);
1792 fIntFlowCorrelationsAllVsMPro[6] = new TProfile("three3n2n1n","#LT#LT3#GT#GT_{3n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
1793 fIntFlowCorrelationsAllVsMPro[6]->Sumw2();
1794 fIntFlowCorrelationsAllVsMPro[6]->GetXaxis()->SetTitle("M");
1795 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[6]);
1796 fIntFlowCorrelationsAllVsMPro[7] = new TProfile("three4n2n2n","#LT#LT3#GT#GT_{4n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1797 fIntFlowCorrelationsAllVsMPro[7]->Sumw2();
1798 fIntFlowCorrelationsAllVsMPro[7]->GetXaxis()->SetTitle("M");
1799 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[7]);
1800 fIntFlowCorrelationsAllVsMPro[8] = new TProfile("three4n3n1n","#LT#LT3#GT#GT_{4n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
1801 fIntFlowCorrelationsAllVsMPro[8]->Sumw2();
1802 fIntFlowCorrelationsAllVsMPro[8]->GetXaxis()->SetTitle("M");
1803 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[8]);
1804 // 4-p correlations vs M:
1805 fIntFlowCorrelationsAllVsMPro[10] = new TProfile("four1n1n1n1n","#LT#LT4#GT#GT_{n,n|n,n}",fnBinsMult,fMinMult,fMaxMult);
1806 fIntFlowCorrelationsAllVsMPro[10]->Sumw2();
1807 fIntFlowCorrelationsAllVsMPro[10]->GetXaxis()->SetTitle("M");
1808 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[10]);
1809 fIntFlowCorrelationsAllVsMPro[11] = new TProfile("four2n1n2n1n","#LT#LT4#GT#GT_{2n,n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
1810 fIntFlowCorrelationsAllVsMPro[11]->Sumw2();
1811 fIntFlowCorrelationsAllVsMPro[11]->GetXaxis()->SetTitle("M");
1812 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[11]);
1813 fIntFlowCorrelationsAllVsMPro[12] = new TProfile("four2n2n2n2n","#LT#LT4#GT#GT_{2n,2n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1814 fIntFlowCorrelationsAllVsMPro[12]->Sumw2();
1815 fIntFlowCorrelationsAllVsMPro[12]->GetXaxis()->SetTitle("M");
1816 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[12]);
1817 fIntFlowCorrelationsAllVsMPro[13] = new TProfile("four3n1n1n1n","#LT#LT4#GT#GT_{3n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1818 fIntFlowCorrelationsAllVsMPro[13]->Sumw2();
1819 fIntFlowCorrelationsAllVsMPro[13]->GetXaxis()->SetTitle("M");
1820 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[13]);
1821 fIntFlowCorrelationsAllVsMPro[14] = new TProfile("four3n1n3n1n","#LT#LT4#GT#GT_{3n,n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
1822 fIntFlowCorrelationsAllVsMPro[14]->Sumw2();
1823 fIntFlowCorrelationsAllVsMPro[14]->GetXaxis()->SetTitle("M");
1824 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[14]);
1825 fIntFlowCorrelationsAllVsMPro[15] = new TProfile("four3n1n2n2n","#LT#LT4#GT#GT_{3n,n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1826 fIntFlowCorrelationsAllVsMPro[15]->Sumw2();
1827 fIntFlowCorrelationsAllVsMPro[15]->GetXaxis()->SetTitle("M");
1828 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[15]);
1829 fIntFlowCorrelationsAllVsMPro[16] = new TProfile("four4n2n1n1n","#LT#LT4#GT#GT_{4n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1830 fIntFlowCorrelationsAllVsMPro[16]->Sumw2();
1831 fIntFlowCorrelationsAllVsMPro[16]->GetXaxis()->SetTitle("M");
1832 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[16]);
1833 // 5-p correlations vs M:
403e3389 1834 fIntFlowCorrelationsAllVsMPro[18] = new TProfile("five2n1n1n1n1n","#LT#LT5#GT#GT_{2n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
3435cacb 1835 fIntFlowCorrelationsAllVsMPro[18]->Sumw2();
1836 fIntFlowCorrelationsAllVsMPro[18]->GetXaxis()->SetTitle("M");
1837 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[18]);
1838 fIntFlowCorrelationsAllVsMPro[19] = new TProfile("five2n2n2n1n1n","#LT#LT5#GT#GT_{2n,2n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1839 fIntFlowCorrelationsAllVsMPro[19]->Sumw2();
1840 fIntFlowCorrelationsAllVsMPro[19]->GetXaxis()->SetTitle("M");
1841 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[19]);
1842 fIntFlowCorrelationsAllVsMPro[20] = new TProfile("five3n1n2n1n1n","#LT#LT5#GT#GT_{3n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1843 fIntFlowCorrelationsAllVsMPro[20]->Sumw2();
1844 fIntFlowCorrelationsAllVsMPro[20]->GetXaxis()->SetTitle("M");
1845 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[20]);
1846 fIntFlowCorrelationsAllVsMPro[21] = new TProfile("five4n1n1n1n1n","#LT#LT5#GT#GT_{4n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1847 fIntFlowCorrelationsAllVsMPro[21]->Sumw2();
1848 fIntFlowCorrelationsAllVsMPro[21]->GetXaxis()->SetTitle("M");
1849 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[21]);
1850 // 6-p correlations vs M:
1851 fIntFlowCorrelationsAllVsMPro[23] = new TProfile("six1n1n1n1n1n1n","#LT#LT6#GT#GT_{n,n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1852 fIntFlowCorrelationsAllVsMPro[23]->Sumw2();
1853 fIntFlowCorrelationsAllVsMPro[23]->GetXaxis()->SetTitle("M");
1854 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[23]);
1855 fIntFlowCorrelationsAllVsMPro[24] = new TProfile("six2n1n1n2n1n1n","#LT#LT6#GT#GT_{2n,n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1856 fIntFlowCorrelationsAllVsMPro[24]->Sumw2();
1857 fIntFlowCorrelationsAllVsMPro[24]->GetXaxis()->SetTitle("M");
1858 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[24]);
1859 fIntFlowCorrelationsAllVsMPro[25] = new TProfile("six2n2n1n1n1n1n","#LT#LT6#GT#GT_{2n,2n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1860 fIntFlowCorrelationsAllVsMPro[25]->Sumw2();
1861 fIntFlowCorrelationsAllVsMPro[25]->GetXaxis()->SetTitle("M");
1862 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[25]);
1863 fIntFlowCorrelationsAllVsMPro[26] = new TProfile("six3n1n1n1n1n1n","#LT#LT6#GT#GT_{3n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1864 fIntFlowCorrelationsAllVsMPro[26]->Sumw2();
1865 fIntFlowCorrelationsAllVsMPro[26]->GetXaxis()->SetTitle("M");
1866 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[26]);
1867 // 7-p correlations vs M:
1868 fIntFlowCorrelationsAllVsMPro[28] = new TProfile("seven2n1n1n1n1n1n1n","#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1869 fIntFlowCorrelationsAllVsMPro[28]->Sumw2();
1870 fIntFlowCorrelationsAllVsMPro[28]->GetXaxis()->SetTitle("M");
1871 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[28]);
1872 // 8-p correlations vs M:
1873 fIntFlowCorrelationsAllVsMPro[30] = new TProfile("eight1n1n1n1n1n1n1n1n","#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
1874 fIntFlowCorrelationsAllVsMPro[30]->Sumw2();
1875 fIntFlowCorrelationsAllVsMPro[30]->GetXaxis()->SetTitle("M");
1876 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[30]);
b84464d3 1877 // EXTRA correlations vs M for v3{5} study (to be improved - put them in a right order somewhere):
3435cacb 1878 fIntFlowCorrelationsAllVsMPro[32] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1879 fIntFlowCorrelationsAllVsMPro[32]->Sumw2();
1880 fIntFlowCorrelationsAllVsMPro[32]->GetXaxis()->SetTitle("M");
1881 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[32]);
b84464d3 1882 fIntFlowCorrelationsAllVsMPro[33] = new TProfile("five3n3n2n2n2n","#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
3435cacb 1883 fIntFlowCorrelationsAllVsMPro[33]->Sumw2();
1884 fIntFlowCorrelationsAllVsMPro[33]->GetXaxis()->SetTitle("M");
1885 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[33]);
b84464d3 1886 // EXTRA correlations vs M for Teaney-Yan study (to be improved - put them in a right order somewhere):
1887 fIntFlowCorrelationsAllVsMPro[34] = new TProfile("two5n5n","#LT#LT2#GT#GT_{5n|5n}",fnBinsMult,fMinMult,fMaxMult);
1888 fIntFlowCorrelationsAllVsMPro[34]->Sumw2();
1889 fIntFlowCorrelationsAllVsMPro[34]->GetXaxis()->SetTitle("M");
1890 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[34]);
1891 fIntFlowCorrelationsAllVsMPro[35] = new TProfile("two6n6n","#LT#LT2#GT#GT_{6n|6n}",fnBinsMult,fMinMult,fMaxMult);
1892 fIntFlowCorrelationsAllVsMPro[35]->Sumw2();
1893 fIntFlowCorrelationsAllVsMPro[35]->GetXaxis()->SetTitle("M");
1894 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[35]);
1895 fIntFlowCorrelationsAllVsMPro[36] = new TProfile("three5n3n2n","#LT#LT3#GT#GT_{5n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1896 fIntFlowCorrelationsAllVsMPro[36]->Sumw2();
1897 fIntFlowCorrelationsAllVsMPro[36]->GetXaxis()->SetTitle("M");
1898 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[36]);
1899 fIntFlowCorrelationsAllVsMPro[37] = new TProfile("three5n4n1n","#LT#LT3#GT#GT_{5n|4n,1n}",fnBinsMult,fMinMult,fMaxMult);
1900 fIntFlowCorrelationsAllVsMPro[37]->Sumw2();
1901 fIntFlowCorrelationsAllVsMPro[37]->GetXaxis()->SetTitle("M");
1902 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[37]);
1903 fIntFlowCorrelationsAllVsMPro[38] = new TProfile("three6n3n3n","#LT#LT3#GT#GT_{6n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1904 fIntFlowCorrelationsAllVsMPro[38]->Sumw2();
1905 fIntFlowCorrelationsAllVsMPro[38]->GetXaxis()->SetTitle("M");
1906 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[38]);
1907 fIntFlowCorrelationsAllVsMPro[39] = new TProfile("three6n4n2n","#LT#LT3#GT#GT_{6n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1908 fIntFlowCorrelationsAllVsMPro[39]->Sumw2();
1909 fIntFlowCorrelationsAllVsMPro[39]->GetXaxis()->SetTitle("M");
1910 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[39]);
1911 fIntFlowCorrelationsAllVsMPro[40] = new TProfile("three6n5n1n","#LT#LT3#GT#GT_{6n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
1912 fIntFlowCorrelationsAllVsMPro[40]->Sumw2();
1913 fIntFlowCorrelationsAllVsMPro[40]->GetXaxis()->SetTitle("M");
1914 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[40]);
1915 fIntFlowCorrelationsAllVsMPro[41] = new TProfile("four6n3n2n1n","#LT#LT4#GT#GT_{6n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1916 fIntFlowCorrelationsAllVsMPro[41]->Sumw2();
1917 fIntFlowCorrelationsAllVsMPro[41]->GetXaxis()->SetTitle("M");
1918 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[41]);
1919 fIntFlowCorrelationsAllVsMPro[42] = new TProfile("four3n2n3n2n","#LT#LT4#GT#GT_{3n,2n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1920 fIntFlowCorrelationsAllVsMPro[42]->Sumw2();
1921 fIntFlowCorrelationsAllVsMPro[42]->GetXaxis()->SetTitle("M");
1922 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[42]);
1923 fIntFlowCorrelationsAllVsMPro[43] = new TProfile("four4n1n3n2n","#LT#LT4#GT#GT_{4n,1n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
1924 fIntFlowCorrelationsAllVsMPro[43]->Sumw2();
1925 fIntFlowCorrelationsAllVsMPro[43]->GetXaxis()->SetTitle("M");
1926 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[43]);
1927 fIntFlowCorrelationsAllVsMPro[44] = new TProfile("four3n3n3n3n","#LT#LT4#GT#GT_{3n,3n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1928 fIntFlowCorrelationsAllVsMPro[44]->Sumw2();
1929 fIntFlowCorrelationsAllVsMPro[44]->GetXaxis()->SetTitle("M");
1930 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[44]);
1931 fIntFlowCorrelationsAllVsMPro[45] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1932 fIntFlowCorrelationsAllVsMPro[45]->Sumw2();
1933 fIntFlowCorrelationsAllVsMPro[45]->GetXaxis()->SetTitle("M");
1934 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[45]);
1935 fIntFlowCorrelationsAllVsMPro[46] = new TProfile("four5n1n3n3n","#LT#LT4#GT#GT_{5n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1936 fIntFlowCorrelationsAllVsMPro[46]->Sumw2();
1937 fIntFlowCorrelationsAllVsMPro[46]->GetXaxis()->SetTitle("M");
1938 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[46]);
1939 fIntFlowCorrelationsAllVsMPro[47] = new TProfile("four4n2n4n2n","#LT#LT4#GT#GT_{4n,2n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1940 fIntFlowCorrelationsAllVsMPro[47]->Sumw2();
1941 fIntFlowCorrelationsAllVsMPro[47]->GetXaxis()->SetTitle("M");
1942 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[47]);
1943 fIntFlowCorrelationsAllVsMPro[48] = new TProfile("four5n1n4n2n","#LT#LT4#GT#GT_{5n,1n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
1944 fIntFlowCorrelationsAllVsMPro[48]->Sumw2();
1945 fIntFlowCorrelationsAllVsMPro[48]->GetXaxis()->SetTitle("M");
1946 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[48]);
1947 fIntFlowCorrelationsAllVsMPro[49] = new TProfile("four5n3n1n1n","#LT#LT4#GT#GT_{5n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1948 fIntFlowCorrelationsAllVsMPro[49]->Sumw2();
1949 fIntFlowCorrelationsAllVsMPro[49]->GetXaxis()->SetTitle("M");
1950 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[49]);
1951 fIntFlowCorrelationsAllVsMPro[50] = new TProfile("four5n2n2n1n","#LT#LT4#GT#GT_{5n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1952 fIntFlowCorrelationsAllVsMPro[50]->Sumw2();
1953 fIntFlowCorrelationsAllVsMPro[50]->GetXaxis()->SetTitle("M");
1954 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[50]);
1955 fIntFlowCorrelationsAllVsMPro[51] = new TProfile("four5n1n5n1n","#LT#LT4#GT#GT_{5n,1n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
1956 fIntFlowCorrelationsAllVsMPro[51]->Sumw2();
1957 fIntFlowCorrelationsAllVsMPro[51]->GetXaxis()->SetTitle("M");
1958 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[51]);
1959 fIntFlowCorrelationsAllVsMPro[52] = new TProfile("five3n3n3n2n1n","#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1960 fIntFlowCorrelationsAllVsMPro[52]->Sumw2();
1961 fIntFlowCorrelationsAllVsMPro[52]->GetXaxis()->SetTitle("M");
1962 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[52]);
1963 fIntFlowCorrelationsAllVsMPro[53] = new TProfile("five4n2n3n2n1n","#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1964 fIntFlowCorrelationsAllVsMPro[53]->Sumw2();
1965 fIntFlowCorrelationsAllVsMPro[53]->GetXaxis()->SetTitle("M");
1966 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[53]);
1967 fIntFlowCorrelationsAllVsMPro[54] = new TProfile("five3n2n3n1n1n","#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1968 fIntFlowCorrelationsAllVsMPro[54]->Sumw2();
1969 fIntFlowCorrelationsAllVsMPro[54]->GetXaxis()->SetTitle("M");
1970 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[54]);
1971 fIntFlowCorrelationsAllVsMPro[55] = new TProfile("five3n2n2n2n1n","#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1972 fIntFlowCorrelationsAllVsMPro[55]->Sumw2();
1973 fIntFlowCorrelationsAllVsMPro[55]->GetXaxis()->SetTitle("M");
1974 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[55]);
1975 fIntFlowCorrelationsAllVsMPro[56] = new TProfile("five5n1n3n2n1n","#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1976 fIntFlowCorrelationsAllVsMPro[56]->Sumw2();
1977 fIntFlowCorrelationsAllVsMPro[56]->GetXaxis()->SetTitle("M");
1978 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[56]);
1979 fIntFlowCorrelationsAllVsMPro[57] = new TProfile("six3n2n1n3n2n1n","#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
1980 fIntFlowCorrelationsAllVsMPro[57]->Sumw2();
1981 fIntFlowCorrelationsAllVsMPro[57]->GetXaxis()->SetTitle("M");
403e3389 1982 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[57]);
1983 fIntFlowCorrelationsAllVsMPro[58] = new TProfile("four6n4n1n1n","#LT#LT4#GT#GT_{6n|4n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1984 fIntFlowCorrelationsAllVsMPro[58]->Sumw2();
1985 fIntFlowCorrelationsAllVsMPro[58]->GetXaxis()->SetTitle("M");
1986 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[58]);
1987 fIntFlowCorrelationsAllVsMPro[59] = new TProfile("four6n2n2n2n","#LT#LT4#GT#GT_{6n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
1988 fIntFlowCorrelationsAllVsMPro[59]->Sumw2();
1989 fIntFlowCorrelationsAllVsMPro[59]->GetXaxis()->SetTitle("M");
1990 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[59]);
1991 fIntFlowCorrelationsAllVsMPro[60] = new TProfile("five6n2n2n1n1n","#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
1992 fIntFlowCorrelationsAllVsMPro[60]->Sumw2();
1993 fIntFlowCorrelationsAllVsMPro[60]->GetXaxis()->SetTitle("M");
1994 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[60]);
1995 fIntFlowCorrelationsAllVsMPro[61] = new TProfile("five4n1n1n3n3n","#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
1996 fIntFlowCorrelationsAllVsMPro[61]->Sumw2();
1997 fIntFlowCorrelationsAllVsMPro[61]->GetXaxis()->SetTitle("M");
1998 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[61]);
1999 fIntFlowCorrelationsAllVsMPro[62] = new TProfile("six3n3n2n2n1n1n","#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2000 fIntFlowCorrelationsAllVsMPro[62]->Sumw2();
2001 fIntFlowCorrelationsAllVsMPro[62]->GetXaxis()->SetTitle("M");
2002 fIntFlowAllCorrelationsVsM->Add(fIntFlowCorrelationsAllVsMPro[62]);
3435cacb 2003 } // end of if(fCalculateAllCorrelationsVsM)
489d5531 2004 // when particle weights are used some extra correlations appear:
403e3389 2005 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2006 {
2007 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
2008 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
2009 fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");
2010 fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");
2011 fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);
2012 fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);
2013 fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");
2014 // extra 2-p correlations:
2015 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");
2016 (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");
2017 fIntFlowProfiles->Add(fIntFlowExtraCorrelationsPro);
403e3389 2018 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2019 // average product of correlations <2>, <4>, <6> and <8>:
403e3389 2020 TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
2021 "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
489d5531 2022 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
2023 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
2024 fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);
2025 fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");
2026 fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25);
2027 fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);
2028 fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");
68a3b4b1 2029 for(Int_t b=0;b<6;b++)
b3dacf6b 2030 {
68a3b4b1 2031 (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(b+1,productFlag[b].Data());
b3dacf6b 2032 }
2033 fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsPro);
ff70ca91 2034 // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
2035 // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 2036 if(fCalculateCumulantsVsM)
2037 {
2038 TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
2039 intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
2040 for(Int_t pi=0;pi<6;pi++)
2041 {
2042 fIntFlowProductOfCorrelationsVsMPro[pi] = new TProfile(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data()),
2043 Form("%s versus multiplicity",productFlag[pi].Data()),
2044 fnBinsMult,fMinMult,fMaxMult);
2045 fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("M");
2046 fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsVsMPro[pi]);
2047 } // end of for(Int_t pi=0;pi<6;pi++)
2048 } // end of if(fCalculateCumulantsVsM)
0328db2d 2049 // average product of correction terms for NUA:
2050 TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
2051 intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2052 fIntFlowProductOfCorrectionTermsForNUAPro = new TProfile(intFlowProductOfCorrectionTermsForNUAProName.Data(),"Average products of correction terms for NUA",27,0,27);
2053 fIntFlowProductOfCorrectionTermsForNUAPro->SetTickLength(-0.01,"Y");
2054 fIntFlowProductOfCorrectionTermsForNUAPro->SetMarkerStyle(25);
403e3389 2055 fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelSize(0.03);
0328db2d 2056 fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelOffset(0.01,"Y");
2057 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(1,"<<2><cos(#phi)>>");
2058 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(2,"<<2><sin(#phi)>>");
2059 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(3,"<<cos(#phi)><sin(#phi)>>");
2060 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2061 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2062 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2063 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2064 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2065 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2066 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2067 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2068 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2069 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2070 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2071 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2072 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2073 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2074 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2075 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2076 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2077 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2078 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2079 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2080 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2081 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2082 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2083 (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2084 fIntFlowProfiles->Add(fIntFlowProductOfCorrectionTermsForNUAPro);
489d5531 2085 // average correction terms for non-uniform acceptance (with wrong errors!):
2086 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2087 {
2088 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
2089 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
b92ea2b9 2090 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 2091 fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");
2092 fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);
403e3389 2093 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.05);
489d5531 2094 fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");
403e3389 2095 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2096 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2097 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2098 (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
489d5531 2099 fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAPro[sc]);
2001bc3a 2100 // versus multiplicity:
b3dacf6b 2101 if(fCalculateCumulantsVsM)
2102 {
2103 TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
2104 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2105 {
2106 TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
2107 intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
2108 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");
2109 fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAVsMPro[sc][ci]);
2110 }
2111 } // end of if(fCalculateCumulantsVsM)
489d5531 2112 } // end of for(Int_t sc=0;sc<2;sc++)
2113
2114 // d) Book histograms holding the final results:
2115 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):
2116 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
2117 intFlowCorrelationsHistName += fAnalysisLabel->Data();
2118 fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);
2119 fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");
2120 fIntFlowCorrelationsHist->SetMarkerStyle(25);
2121 fIntFlowCorrelationsHist->SetLabelSize(0.06);
2122 fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");
403e3389 2123 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT");
2124 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"#LT#LT4#GT#GT");
2125 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"#LT#LT6#GT#GT");
2126 (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"#LT#LT8#GT#GT");
489d5531 2127 fIntFlowResults->Add(fIntFlowCorrelationsHist);
ff70ca91 2128 // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!) vs M:
b3dacf6b 2129 if(fCalculateCumulantsVsM)
2130 {
2131 for(Int_t ci=0;ci<4;ci++) // correlation index
2132 {
2133 TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
2134 intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
2135 fIntFlowCorrelationsVsMHist[ci] = new TH1D(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data()),
2136 Form("%s vs multiplicity",correlationFlag[ci].Data()),
2137 fnBinsMult,fMinMult,fMaxMult);
2138 fIntFlowCorrelationsVsMHist[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2139 fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("M");
2140 fIntFlowResults->Add(fIntFlowCorrelationsVsMHist[ci]);
2141 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2142 } // end of if(fCalculateCumulantsVsM)
489d5531 2143 // average all correlations for all events (with correct errors!):
2144 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
2145 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
8ed4edc7 2146 fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",34,0,34);
489d5531 2147 fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");
2148 fIntFlowCorrelationsAllHist->SetMarkerStyle(25);
2149 fIntFlowCorrelationsAllHist->SetLabelSize(0.03);
2150 fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");
2151 // 2-p correlations:
2152 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");
2153 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");
2154 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");
2155 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");
2156 // 3-p correlations:
2157 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");
2158 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");
2159 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");
2160 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");
2161 // 4-p correlations:
2162 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}");
2163 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");
2164 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");
2165 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");
2166 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");
2167 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}");
2168 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");
2169 // 5-p correlations:
2170 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}");
2171 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");
2172 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");
2173 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");
2174 // 6-p correlations:
2175 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");
2176 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");
2177 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");
2178 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");
2179 // 7-p correlations:
2180 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");
2181 // 8-p correlations:
2182 (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");
2183 fIntFlowResults->Add(fIntFlowCorrelationsAllHist);
2184 // average correction terms for non-uniform acceptance (with correct errors!):
2185 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2186 {
2187 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
2188 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
b92ea2b9 2189 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 2190 fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");
2191 fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);
403e3389 2192 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.05);
489d5531 2193 fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");
b92ea2b9 2194 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
403e3389 2195 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2196 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2197 (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
489d5531 2198 fIntFlowResults->Add(fIntFlowCorrectionTermsForNUAHist[sc]);
2199 } // end of for(Int_t sc=0;sc<2;sc++)
2200 // covariances (multiplied with weight dependent prefactor):
2201 TString intFlowCovariancesName = "fIntFlowCovariances";
2202 intFlowCovariancesName += fAnalysisLabel->Data();
2203 fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);
2204 fIntFlowCovariances->SetLabelSize(0.04);
2205 fIntFlowCovariances->SetMarkerStyle(25);
403e3389 2206 (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(#LT2#GT,#LT4#GT)");
2207 (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(#LT2#GT,#LT6#GT)");
2208 (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(#LT2#GT,#LT8#GT)");
2209 (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(#LT4#GT,#LT6#GT)");
2210 (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(#LT4#GT,#LT8#GT)");
2211 (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(#LT6#GT,#LT8#GT)");
489d5531 2212 fIntFlowResults->Add(fIntFlowCovariances);
2213 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
2214 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
2215 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
2216 for(Int_t power=0;power<2;power++)
2217 {
2218 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 2219 fIntFlowSumOfEventWeights[power]->SetLabelSize(0.04);
489d5531 2220 fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);
2221 if(power == 0)
2222 {
403e3389 2223 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}");
2224 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}");
2225 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}");
2226 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}");
489d5531 2227 } else if (power == 1)
2228 {
403e3389 2229 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}^{2}");
2230 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}^{2}");
2231 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}^{2}");
2232 (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}^{2}");
489d5531 2233 }
2234 fIntFlowResults->Add(fIntFlowSumOfEventWeights[power]);
2235 }
2236 // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
2237 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
2238 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
2239 fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);
403e3389 2240 fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.04);
489d5531 2241 fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);
403e3389 2242 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT4#GT}");
2243 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT6#GT}");
2244 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT8#GT}");
2245 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT6#GT}");
2246 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT8#GT}");
2247 (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT6#GT} w_{#LT8#GT}");
489d5531 2248 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeights);
ff70ca91 2249 // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
2250 // [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 2251 if(fCalculateCumulantsVsM)
ff70ca91 2252 {
b3dacf6b 2253 TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
2254 intFlowCovariancesVsMName += fAnalysisLabel->Data();
2255 TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
2256 for(Int_t ci=0;ci<6;ci++)
2257 {
2258 fIntFlowCovariancesVsM[ci] = new TH1D(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data()),
2259 Form("%s vs multiplicity",covarianceFlag[ci].Data()),
2260 fnBinsMult,fMinMult,fMaxMult);
2261 fIntFlowCovariancesVsM[ci]->GetYaxis()->SetTitle(covarianceFlag[ci].Data());
2262 fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("M");
2263 fIntFlowResults->Add(fIntFlowCovariancesVsM[ci]);
2264 }
2265 } // end of if(fCalculateCumulantsVsM)
ff70ca91 2266 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
2267 // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
b3dacf6b 2268 if(fCalculateCumulantsVsM)
ff70ca91 2269 {
b3dacf6b 2270 TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
2271 intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
2272 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>}"},
2273 {"#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}"}};
2274 for(Int_t si=0;si<4;si++)
ff70ca91 2275 {
b3dacf6b 2276 for(Int_t power=0;power<2;power++)
2277 {
2278 fIntFlowSumOfEventWeightsVsM[si][power] = new TH1D(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data()),
2279 Form("%s vs multiplicity",sumFlag[power][si].Data()),
2280 fnBinsMult,fMinMult,fMaxMult);
2281 fIntFlowSumOfEventWeightsVsM[si][power]->GetYaxis()->SetTitle(sumFlag[power][si].Data());
2282 fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("M");
2283 fIntFlowResults->Add(fIntFlowSumOfEventWeightsVsM[si][power]);
2284 } // end of for(Int_t power=0;power<2;power++)
2285 } // end of for(Int_t si=0;si<4;si++)
2286 } // end of if(fCalculateCumulantsVsM)
ff70ca91 2287 // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
2288 // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
2289 // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
b3dacf6b 2290 if(fCalculateCumulantsVsM)
2291 {
2292 TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
2293 intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
2294 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>}",
2295 "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
2296 for(Int_t pi=0;pi<6;pi++)
2297 {
2298 fIntFlowSumOfProductOfEventWeightsVsM[pi] = new TH1D(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data()),
2299 Form("%s versus multiplicity",sopowFlag[pi].Data()),
2300 fnBinsMult,fMinMult,fMaxMult);
2301 fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("M");
2302 fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetYaxis()->SetTitle(sopowFlag[pi].Data());
2303 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeightsVsM[pi]);
2304 } // end of for(Int_t pi=0;pi<6;pi++)
2305 } // end of if(fCalculateCumulantsVsM)
0328db2d 2306 // covariances of NUA terms (multiplied with weight dependent prefactor):
2307 TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
2308 intFlowCovariancesNUAName += fAnalysisLabel->Data();
2309 fIntFlowCovariancesNUA = new TH1D(intFlowCovariancesNUAName.Data(),"Covariances for NUA (multiplied with weight dependent prefactor)",27,0,27);
2310 fIntFlowCovariancesNUA->SetLabelSize(0.04);
2311 fIntFlowCovariancesNUA->SetMarkerStyle(25);
2312 fIntFlowCovariancesNUA->GetXaxis()->SetLabelSize(0.02);
2313 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(1,"Cov(<2>,<cos(#phi)>");
2314 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(2,"Cov(<2>,<sin(#phi)>)");
2315 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(3,"Cov(<cos(#phi)>,<sin(#phi)>)");
2316 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2317 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2318 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2319 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2320 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2321 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2322 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2323 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2324 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2325 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2326 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2327 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2328 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2329 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2330 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2331 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2332 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2333 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2334 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2335 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2336 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2337 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2338 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2339 (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2340 fIntFlowResults->Add(fIntFlowCovariancesNUA);
2341 // sum of linear and quadratic event weights for NUA terms:
2342 TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
2343 intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
2344 for(Int_t sc=0;sc<2;sc++)
2345 {
2346 for(Int_t power=0;power<2;power++)
2347 {
b92ea2b9 2348 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 2349 fIntFlowSumOfEventWeightsNUA[sc][power]->SetLabelSize(0.05);
2350 fIntFlowSumOfEventWeightsNUA[sc][power]->SetMarkerStyle(25);
2351 if(power == 0)
2352 {
2353 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}",sinCosFlag[sc].Data()));
2354 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}",sinCosFlag[sc].Data()));
b92ea2b9 2355 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}",sinCosFlag[sc].Data()));
2356 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}",sinCosFlag[sc].Data()));
0328db2d 2357 } else if(power == 1)
2358 {
2359 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}^{2}",sinCosFlag[sc].Data()));
2360 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
2361 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}^{2}",sinCosFlag[sc].Data()));
b92ea2b9 2362 (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
0328db2d 2363 }
2364 fIntFlowResults->Add(fIntFlowSumOfEventWeightsNUA[sc][power]);
2365 }
2366 }
2367 // sum of products of event weights for NUA terms:
2368 TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
2369 intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
2370 fIntFlowSumOfProductOfEventWeightsNUA = new TH1D(intFlowSumOfProductOfEventWeightsNUAName.Data(),"Sum of product of event weights for NUA terms",27,0,27);
403e3389 2371 fIntFlowSumOfProductOfEventWeightsNUA->SetLabelSize(0.02);
0328db2d 2372 fIntFlowSumOfProductOfEventWeightsNUA->SetMarkerStyle(25);
62e36168 2373 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi)#GT}");
2374 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi)#GT}");
2375 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi)#GT}");
2376 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2377 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2378 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2379 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(7,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2380 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(8,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi)#GT}");
2381 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(9,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi)#GT}");
2382 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(10,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2383 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(11,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2384 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(12,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2385 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(13,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2386 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(14,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2387 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(15,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2388 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(16,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2389 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(17,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2390 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(18,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2391 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(19,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2392 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(20,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2393 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(21,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2394 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(22,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2395 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(23,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2396 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(24,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2397 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(25,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2398 (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(26,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2399 (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 2400 fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeightsNUA);
b3dacf6b 2401 // Final results for reference Q-cumulants:
2402 TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
489d5531 2403 TString intFlowQcumulantsName = "fIntFlowQcumulants";
2404 intFlowQcumulantsName += fAnalysisLabel->Data();
b92ea2b9 2405 fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Reference Q-cumulants",4,0,4);
b77b6434 2406 if(fPropagateErrorAlsoFromNIT)
b92ea2b9 2407 {
b77b6434 2408 fIntFlowQcumulants->SetTitle("Reference Q-cumulants (error from non-isotropic terms also propagated)");
b92ea2b9 2409 }
489d5531 2410 fIntFlowQcumulants->SetLabelSize(0.05);
2411 fIntFlowQcumulants->SetMarkerStyle(25);
68a3b4b1 2412 for(Int_t b=0;b<4;b++)
b3dacf6b 2413 {
68a3b4b1 2414 (fIntFlowQcumulants->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
b3dacf6b 2415 }
489d5531 2416 fIntFlowResults->Add(fIntFlowQcumulants);
b3dacf6b 2417 // Final results for reference Q-cumulants rebinned in M:
2418 if(fCalculateCumulantsVsM)
2419 {
2420 TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
2421 intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
2422 fIntFlowQcumulantsRebinnedInM = new TH1D(intFlowQcumulantsRebinnedInMName.Data(),"Reference Q-cumulants rebinned in M",4,0,4);
2423 fIntFlowQcumulantsRebinnedInM->SetLabelSize(0.05);
2424 fIntFlowQcumulantsRebinnedInM->SetMarkerStyle(25);
68a3b4b1 2425 for(Int_t b=0;b<4;b++)
b3dacf6b 2426 {
68a3b4b1 2427 (fIntFlowQcumulantsRebinnedInM->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
b3dacf6b 2428 }
2429 fIntFlowResults->Add(fIntFlowQcumulantsRebinnedInM);
2430 } // end of if(fCalculateCumulantsVsM)
b92ea2b9 2431 // Ratio between error squared: with/without non-isotropic terms:
2432 TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
2433 intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
2434 fIntFlowQcumulantsErrorSquaredRatio = new TH1D(intFlowQcumulantsErrorSquaredRatioName.Data(),"Error squared of reference Q-cumulants: #frac{with NUA terms}{without NUA terms}",4,0,4);
2435 fIntFlowQcumulantsErrorSquaredRatio->SetLabelSize(0.05);
2436 fIntFlowQcumulantsErrorSquaredRatio->SetMarkerStyle(25);
2437 for(Int_t b=0;b<4;b++)
2438 {
2439 (fIntFlowQcumulantsErrorSquaredRatio->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
2440 }
2441 fIntFlowResults->Add(fIntFlowQcumulantsErrorSquaredRatio);
ff70ca91 2442 // final results for integrated Q-cumulants versus multiplicity:
b3dacf6b 2443 if(fCalculateCumulantsVsM)
2444 {
2445 TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
2446 intFlowQcumulantsVsMName += fAnalysisLabel->Data();
2447 for(Int_t co=0;co<4;co++) // cumulant order
2448 {
2449 fIntFlowQcumulantsVsM[co] = new TH1D(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data()),
2450 Form("%s vs multipicity",cumulantFlag[co].Data()),
2451 fnBinsMult,fMinMult,fMaxMult);
2452 fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("M");
2453 fIntFlowQcumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());
2454 fIntFlowResults->Add(fIntFlowQcumulantsVsM[co]);
2455 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2456 } // end of if(fCalculateCumulantsVsM)
489d5531 2457 // final integrated flow estimates from Q-cumulants:
b3dacf6b 2458 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 2459 TString intFlowName = "fIntFlow";
2460 intFlowName += fAnalysisLabel->Data();
2461 // integrated flow from Q-cumulants:
b3dacf6b 2462 fIntFlow = new TH1D(intFlowName.Data(),"Reference flow estimates from Q-cumulants",4,0,4);
489d5531 2463 fIntFlow->SetLabelSize(0.05);
2464 fIntFlow->SetMarkerStyle(25);
68a3b4b1 2465 for(Int_t b=0;b<4;b++)
b3dacf6b 2466 {
68a3b4b1 2467 (fIntFlow->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
b3dacf6b 2468 }
ff70ca91 2469 fIntFlowResults->Add(fIntFlow);
b3dacf6b 2470 // Reference flow vs M rebinned in one huge bin:
2471 if(fCalculateCumulantsVsM)
2472 {
2473 TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
2474 intFlowRebinnedInMName += fAnalysisLabel->Data();
2475 fIntFlowRebinnedInM = new TH1D(intFlowRebinnedInMName.Data(),"Reference flow estimates from Q-cumulants (rebinned in M)",4,0,4);
2476 fIntFlowRebinnedInM->SetLabelSize(0.05);
2477 fIntFlowRebinnedInM->SetMarkerStyle(25);
68a3b4b1 2478 for(Int_t b=0;b<4;b++)
b3dacf6b 2479 {
68a3b4b1 2480 (fIntFlowRebinnedInM->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
b3dacf6b 2481 }
2482 fIntFlowResults->Add(fIntFlowRebinnedInM);
2483 }
ff70ca91 2484 // integrated flow from Q-cumulants: versus multiplicity:
b3dacf6b 2485 if(fCalculateCumulantsVsM)
2486 {
2487 TString intFlowVsMName = "fIntFlowVsM";
2488 intFlowVsMName += fAnalysisLabel->Data();
2489 for(Int_t co=0;co<4;co++) // cumulant order
2490 {
2491 fIntFlowVsM[co] = new TH1D(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data()),
2492 Form("%s vs multipicity",flowFlag[co].Data()),
2493 fnBinsMult,fMinMult,fMaxMult);
2494 fIntFlowVsM[co]->GetXaxis()->SetTitle("M");
2495 fIntFlowVsM[co]->GetYaxis()->SetTitle(flowFlag[co].Data());
2496 fIntFlowResults->Add(fIntFlowVsM[co]);
2497 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2498 } // end of if(fCalculateCumulantsVsM)
2001bc3a 2499 // quantifying detector effects effects to correlations:
2500 TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
2501 intFlowDetectorBiasName += fAnalysisLabel->Data();
2502 fIntFlowDetectorBias = new TH1D(intFlowDetectorBiasName.Data(),"Quantifying detector bias",4,0,4);
2503 fIntFlowDetectorBias->SetLabelSize(0.05);
2504 fIntFlowDetectorBias->SetMarkerStyle(25);
2505 for(Int_t ci=0;ci<4;ci++)
2506 {
2507 (fIntFlowDetectorBias->GetXaxis())->SetBinLabel(ci+1,Form("#frac{corrected}{measured} %s",cumulantFlag[ci].Data()));
2508 }
2509 fIntFlowResults->Add(fIntFlowDetectorBias);
2510 // quantifying detector effects to correlations versus multiplicity:
b3dacf6b 2511 if(fCalculateCumulantsVsM)
2001bc3a 2512 {
b3dacf6b 2513 TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
2514 intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
2515 for(Int_t ci=0;ci<4;ci++) // correlation index
2516 {
2517 fIntFlowDetectorBiasVsM[ci] = new TH1D(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data()),
2518 Form("Quantifying detector bias for %s vs multipicity",cumulantFlag[ci].Data()),
2519 fnBinsMult,fMinMult,fMaxMult);
2520 fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("M");
2521 fIntFlowDetectorBiasVsM[ci]->GetYaxis()->SetTitle("#frac{corrected}{measured}");
b77b6434 2522 fIntFlowResults->Add(fIntFlowDetectorBiasVsM[ci]);
b3dacf6b 2523 } // end of for(Int_t co=0;co<4;co++) // cumulant order
2524 } // end of if(fCalculateCumulantsVsM)
1268c371 2525
489d5531 2526} // end of AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()
2527
489d5531 2528//================================================================================================================================
2529
489d5531 2530void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()
2531{
2532 // Initialize arrays of all objects relevant for calculations with nested loops.
2533
2534 // integrated flow:
2535 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2536 {
2537 fIntFlowDirectCorrectionTermsForNUA[sc] = NULL;
2538 }
2539
2540 // differential flow:
2541 // correlations:
2542 for(Int_t t=0;t<2;t++) // type: RP or POI
2543 {
2544 for(Int_t pe=0;pe<2;pe++) // pt or eta
2545 {
2546 for(Int_t ci=0;ci<4;ci++) // correlation index
2547 {
2548 fDiffFlowDirectCorrelations[t][pe][ci] = NULL;
2549 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2550 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2551 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
2552 // correction terms for non-uniform acceptance:
2553 for(Int_t t=0;t<2;t++) // type: RP or POI
2554 {
2555 for(Int_t pe=0;pe<2;pe++) // pt or eta
2556 {
2557 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2558 {
2559 for(Int_t cti=0;cti<9;cti++) // correction term index
2560 {
2561 fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = NULL;
2562 }
2563 }
2564 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2565 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
2566
64e500e3 2567 // other differential correlators:
2568 for(Int_t t=0;t<2;t++) // type: RP or POI
2569 {
2570 for(Int_t pe=0;pe<2;pe++) // pt or eta
2571 {
2572 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2573 {
2574 for(Int_t ci=0;ci<1;ci++) // correlator index
2575 {
2576 fOtherDirectDiffCorrelators[t][pe][sc][ci] = NULL;
2577 }
2578 }
2579 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2580 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
489d5531 2581
2582} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()
2583
489d5531 2584//================================================================================================================================
2585
489d5531 2586void AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()
2587{
2588 // Book all objects relevant for calculations with nested loops.
2589
2590 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
2591 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)
2592 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)
2593 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)
2594 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
2595 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
2596
2597 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";
2598 evaluateNestedLoopsName += fAnalysisLabel->Data();
2599 fEvaluateNestedLoops = new TProfile(evaluateNestedLoopsName.Data(),"Flags for nested loops",4,0,4);
2600 fEvaluateNestedLoops->SetLabelSize(0.03);
2601 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(1,"fEvaluateIntFlowNestedLoops");
2602 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(2,"fEvaluateDiffFlowNestedLoops");
2603 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(3,"fCrossCheckInPtBinNo");
2604 (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(4,"fCrossCheckInEtaBinNo");
2605 fEvaluateNestedLoops->Fill(0.5,(Int_t)fEvaluateIntFlowNestedLoops);
2606 fEvaluateNestedLoops->Fill(1.5,(Int_t)fEvaluateDiffFlowNestedLoops);
2607 fEvaluateNestedLoops->Fill(2.5,fCrossCheckInPtBinNo);
2608 fEvaluateNestedLoops->Fill(3.5,fCrossCheckInEtaBinNo);
2609 fNestedLoopsList->Add(fEvaluateNestedLoops);
2610 // nested loops for integrated flow:
2611 if(fEvaluateIntFlowNestedLoops)
2612 {
2613 // correlations:
2614 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";
2615 intFlowDirectCorrelationsName += fAnalysisLabel->Data();
403e3389 2616 fIntFlowDirectCorrelations = new TProfile(intFlowDirectCorrelationsName.Data(),"Multiparticle correlations calculated with nested loops (for int. flow)",64,0,64,"s");
489d5531 2617 fNestedLoopsList->Add(fIntFlowDirectCorrelations);
403e3389 2618 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2619 {
2620 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";
2621 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();
2622 fIntFlowExtraDirectCorrelations = new TProfile(intFlowExtraDirectCorrelationsName.Data(),"Extra multiparticle correlations calculated with nested loops (for int. flow)",100,0,100,"s");
2623 fNestedLoopsList->Add(fIntFlowExtraDirectCorrelations);
403e3389 2624 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 2625 // correction terms for non-uniform acceptance:
2626 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2627 {
2628 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";
2629 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
2630 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");
2631 fNestedLoopsList->Add(fIntFlowDirectCorrectionTermsForNUA[sc]);
2632 } // end of for(Int_t sc=0;sc<2;sc++)
2633 } // end of if(fEvaluateIntFlowNestedLoops)
2634
2635 // nested loops for differential flow:
2636 if(fEvaluateDiffFlowNestedLoops)
2637 {
2638 // reduced correlations:
2639 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";
2640 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();
2641 for(Int_t t=0;t<2;t++) // type: RP or POI
2642 {
62e36168 2643 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 2644 {
2645 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
2646 {
2647 // reduced correlations:
2648 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");
2649 fDiffFlowDirectCorrelations[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
2650 fNestedLoopsList->Add(fDiffFlowDirectCorrelations[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
2651 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
2652 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
2653 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
64e500e3 2654
2655
489d5531 2656 // correction terms for non-uniform acceptance:
2657 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";
2658 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
2659 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
2660 {
62e36168 2661 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 2662 {
2663 for(Int_t sc=0;sc<2;sc++) // sin or cos
2664 {
2665 for(Int_t cti=0;cti<9;cti++) // correction term index
2666 {
2667 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");
2668 fNestedLoopsList->Add(fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]);
2669 }
2670 }
2671 }
64e500e3 2672 }
2673 // other differential correlators:
2674 TString otherDirectDiffCorrelatorsName = "fOtherDirectDiffCorrelators";
2675 otherDirectDiffCorrelatorsName += fAnalysisLabel->Data();
2676 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
2677 {
62e36168 2678 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 2679 {
2680 for(Int_t sc=0;sc<2;sc++) // sin or cos
2681 {
2682 for(Int_t ci=0;ci<1;ci++) // correlator index
2683 {
2684 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]);
2685 fNestedLoopsList->Add(fOtherDirectDiffCorrelators[t][pe][sc][ci]);
2686 }
2687 }
2688 }
2689 }
3b552efe 2690 // number of RPs and POIs in selected pt and eta bins for cross-checkings:
2691 TString noOfParticlesInBinName = "fNoOfParticlesInBin";
2692 fNoOfParticlesInBin = new TH1D(noOfParticlesInBinName.Data(),"Number of RPs and POIs in selected p_{T} and #eta bin",4,0,4);
489d5531 2693 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(1,"# of RPs in p_{T} bin");
2694 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(2,"# of RPs in #eta bin");
2695 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(3,"# of POIs in p_{T} bin");
3b552efe 2696 fNoOfParticlesInBin->GetXaxis()->SetBinLabel(4,"# of POIs in #eta bin");
489d5531 2697 fNestedLoopsList->Add(fNoOfParticlesInBin);
2698 } // end of if(fEvaluateDiffFlowNestedLoops)
2699
2700} // end of AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()
2701
489d5531 2702//================================================================================================================================
2703
489d5531 2704void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()
2705{
b84464d3 2706 // Calculate in this method all multiparticle azimuthal correlations.
2707 //
2708 // Remark 1: All multiparticle correlations are stored in TProfile fIntFlowCorrelationsAllPro;
2709 // Remark 2: There is a special TProfile fIntFlowCorrelationsPro holding results
2710 // only for same harmonic's correlations <<2>>, <<4>>, <<6>> and <<8>>;
2711 // Remark 3: Binning of fIntFlowCorrelationsAllPro is organized as follows:
2712 // --------------------------------------------------------------------------------------------------------------------
2713 // 1st bin: <2>_{1n|1n} = two1n1n = cos(1n(phi1-phi2))>
2714 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n(phi1-phi2))>
2715 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n(phi1-phi2))>
2716 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n(phi1-phi2))>
2717 // 5th bin: ---- EMPTY ----
2718 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n(2*phi1-phi2-phi3))>
2719 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n(3*phi1-2*phi2-phi3))>
2720 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n(4*phi1-2*phi2-2*phi3))>
2721 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n(4*phi1-3*phi2-phi3))>
2722 // 10th bin: ---- EMPTY ----
2723 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n(phi1+phi2-phi3-phi4))>
2724 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(n(2*phi1+phi2-2*phi3-phi4))>
2725 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(2n(phi1+phi2-phi3-phi4))>
2726 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n(3*phi1-phi2-phi3-phi4))>
2727 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n(3*phi1+phi2-3*phi3-phi4))>
2728 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n(3*phi1+phi2-2*phi3-2*phi4))>
2729 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n(4*phi1-2*phi2-phi3-phi4))>
2730 // 18th bin: ---- EMPTY ----
2731 // 19th bin: <5>_{2n,1n|1n,1n,1n} = five2n1n1n1n1n = <cos(n(2*phi1+phi2-phi3-phi4-phi5))>
2732 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n(2*phi1+2*phi2-2*phi3-phi4-phi5))>
2733 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n(3*phi1+phi2-2*phi3-phi4-phi5))>
2734 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n(4*phi1-phi2-phi3-phi4-phi5))>
2735 // 23rd bin: ---- EMPTY ----
2736 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n(phi1+phi2+phi3-phi4-phi5-phi6))>
2737 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n(2*phi1+phi2+phi3-2*phi4-phi5-phi6))>
2738 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n(2*phi1+2*phi2-phi3-phi4-phi5-phi6))>
2739 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n(3*phi1+phi2-phi3-phi4-phi5-phi6))>
2740 // 28th bin: ---- EMPTY ----
2741 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n(2*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
2742 // 30th bin: ---- EMPTY ----
2743 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
2744 // 32nd bin: ---- EMPTY ----
2745 // Extra correlations for v3{5} study:
2746 // 33rd bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n(4*phi1+2*phi2-3*phi3-3*phi4))>
2747 // 34th bin: <5>_{3n,3n|2n,2n,2n} = five3n3n2n2n2n = <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
2748 // Extra correlations for Teaney-Yan study:
2749 // 35th bin: <2>_{5n|5n} = two5n5n = <cos(5n(phi1-phi2)>
2750 // 36th bin: <2>_{6n|6n} = two6n6n = <cos(6n(phi1-phi2)>
2751 // 37th bin: <3>_{5n|3n,2n} = three5n3n2n = <cos(n(5*phi1-3*phi2-2*phi3)>
2752 // 38th bin: <3>_{5n|4n,1n} = three5n4n1n = <cos(n(5*phi1-4*phi2-1*phi3)>
2753 // 39th bin: <3>_{6n|3n,3n} = three6n3n3n = <cos(n(6*phi1-3*phi2-3*phi3)>
2754 // 40th bin: <3>_{6n|4n,2n} = three6n4n2n = <cos(n(6*phi1-4*phi2-2*phi3)>
2755 // 41st bin: <3>_{6n|5n,1n} = three6n5n1n = <cos(n(6*phi1-5*phi2-1*phi3)>
2756 // 42nd bin: <4>_{6n|3n,2n,1n} = four6n3n2n1n = <cos(n(6*phi1-3*phi2-2*phi3-1*phi4)>
2757 // 43rd bin: <4>_{3n,2n|3n,2n} = four3n2n3n2n = <cos(n(3*phi1+2*phi2-3*phi3-2*phi4)>
2758 // 44th bin: <4>_{4n,1n|3n,2n} = four4n1n3n2n = <cos(n(4*phi1+1*phi2-3*phi3-2*phi4)>
2759 // 45th bin: <4>_{3n,3n|3n,3n} = four3n3n3n3n = <cos(3n*(phi1+phi2-phi3-phi4))>
2760 // 46th bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n(4*phi1+2*phi2-3*phi3-3*phi4)>
2761 // 47th bin: <4>_{5n,1n|3n,3n} = four5n1n3n3n = <cos(n(5*phi1+1*phi2-3*phi3-3*phi4)>
2762 // 48th bin: <4>_{4n,2n|4n,2n} = four4n2n4n2n = <cos(n(4*phi1+2*phi2-4*phi3-2*phi4)>
2763 // 49th bin: <4>_{5n,1n|4n,2n} = four5n1n4n2n = <cos(n(5*phi1+1*phi2-4*phi3-2*phi4)>
2764 // 50th bin: <4>_{5n|3n,1n,1n} = four5n3n1n1n = <cos(n(5*phi1-3*phi2-1*phi3-1*phi4)>
2765 // 51st bin: <4>_{5n|2n,2n,1n} = four5n2n2n1n = <cos(n(5*phi1-2*phi2-2*phi3-1*phi4)>
2766 // 52nd bin: <4>_{5n,1n|5n,1n} = four5n1n5n1n = <cos(n(5*phi1+1*phi2-5*phi3-1*phi4)>
2767 // 53rd bin: <5>_{3n,3n|3n,2n,1n} = five3n3n3n2n1n = <cos(n(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
2768 // 54th bin: <5>_{4n,2n|3n,2n,1n} = five4n2n3n2n1n = <cos(n(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
2769 // 55th bin: <5>_{3n,2n|3n,1n,1n} = five3n2n3n1n1n = <cos(n(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
2770 // 56th bin: <5>_{3n,2n|2n,2n,1n} = five3n2n2n2n1n = <cos(n(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
2771 // 57th bin: <5>_{5n,1n|3n,2n,1n} = five5n1n3n2n1n = <cos(n(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
2772 // 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 2773 // Extra correlations for Teaney-Yan study (B):
2774 // 59th bin: <4>_{6n|4n,1n,1n} = four6n4n1n1n = <cos(n(6*phi1-4*phi2-1*phi3-1*phi4)>
2775 // 60th bin: <4>_{6n|2n,2n,2n} = four6n2n2n2n = <cos(n(6*phi1-2*phi2-2*phi3-2*phi4)>
2776 // 61st bin: <5>_{6n|2n,2n,1n,1n} = five6n2n2n1n1n = <cos(n(6*phi1-2*phi2-2*phi3-1*phi4-1*phi5)>
2777 // 62nd bin: <5>_{4n,1n,1n|3n,3n} = five4n1n1n3n3n = <cos(n(4*phi1+1*phi2+1*phi3-3*phi4-3*phi5)>
2778 // 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 2779 // --------------------------------------------------------------------------------------------------------------------
403e3389 2780
2781 // Multiplicity of an event:
1268c371 2782 Double_t dMult = (*fSpk)(0,0);
b84464d3 2783 // Real parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n, 4n, 5n and 6n:
489d5531 2784 Double_t dReQ1n = (*fReQ)(0,0);
2785 Double_t dReQ2n = (*fReQ)(1,0);
2786 Double_t dReQ3n = (*fReQ)(2,0);
2787 Double_t dReQ4n = (*fReQ)(3,0);
b84464d3 2788 Double_t dReQ5n = (*fReQ)(4,0);
8ed4edc7 2789 Double_t dReQ6n = (*fReQ)(5,0);
b84464d3 2790 // Imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n, 4n, 5n and 6n:
489d5531 2791 Double_t dImQ1n = (*fImQ)(0,0);
2792 Double_t dImQ2n = (*fImQ)(1,0);
2793 Double_t dImQ3n = (*fImQ)(2,0);
2794 Double_t dImQ4n = (*fImQ)(3,0);
b84464d3 2795 Double_t dImQ5n = (*fImQ)(4,0);
8ed4edc7 2796 Double_t dImQ6n = (*fImQ)(5,0);
489d5531 2797
b84464d3 2798 // Real parts of expressions involving various combinations of Q-vectors which appears
2799 // simultaneously in several equations for multiparticle correlations bellow:
2800 // Re[Q_{2n}Q_{n}^*Q_{n}^*]
2801 Double_t reQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dReQ2n;
2802 // Re[Q_{6n}Q_{3n}^*Q_{3n}^*]
2803 Double_t reQ6nQ3nstarQ3nstar = pow(dReQ3n,2.)*dReQ6n+2.*dReQ3n*dImQ3n*dImQ6n-pow(dImQ3n,2.)*dReQ6n;
2804 // Re[Q_{4n}Q_{2n}^*Q_{2n}^*]
489d5531 2805 Double_t reQ4nQ2nstarQ2nstar = pow(dReQ2n,2.)*dReQ4n+2.*dReQ2n*dImQ2n*dImQ4n-pow(dImQ2n,2.)*dReQ4n;
b84464d3 2806 // Re[Q_{4n}Q_{3n}^*Q_{n}^*]
489d5531 2807 Double_t reQ4nQ3nstarQ1nstar = dReQ4n*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)+dImQ4n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);
b84464d3 2808 // Re[Q_{3n}Q_{2n}^*Q_{n}^*]
489d5531 2809 Double_t reQ3nQ2nstarQ1nstar = dReQ3n*dReQ2n*dReQ1n-dReQ3n*dImQ2n*dImQ1n+dImQ3n*dReQ2n*dImQ1n
b84464d3 2810 + dImQ3n*dImQ2n*dReQ1n;
2811 // Re[Q_{5n}Q_{3n}^*Q_{2n}^*]
2812 Double_t reQ5nQ3nstarQ2nstar = dReQ5n*dReQ2n*dReQ3n-dReQ5n*dImQ2n*dImQ3n+dImQ5n*dReQ2n*dImQ3n
2813 + dImQ5n*dImQ2n*dReQ3n;
2814 // Re[Q_{5n}Q_{4n}^*Q_{1n}^*]
2815 Double_t reQ5nQ4nstarQ1nstar = dReQ5n*dReQ4n*dReQ1n-dReQ5n*dImQ4n*dImQ1n+dImQ5n*dReQ4n*dImQ1n
2816 + dImQ5n*dImQ4n*dReQ1n;
2817 // Re[Q_{6n}Q_{5n}^*Q_{1n}^*]
2818 Double_t reQ6nQ5nstarQ1nstar = dReQ6n*dReQ5n*dReQ1n-dReQ6n*dImQ5n*dImQ1n+dImQ6n*dReQ5n*dImQ1n
2819 + dImQ6n*dImQ5n*dReQ1n;
2820 // Re[Q_{6n}Q_{4n}^*Q_{2n}^*]
2821 Double_t reQ6nQ4nstarQ2nstar = dReQ6n*dReQ4n*dReQ2n-dReQ6n*dImQ4n*dImQ2n+dImQ6n*dReQ4n*dImQ2n
2822 + dImQ6n*dImQ4n*dReQ2n;
2823 // Re[Q_{3n}Q_{n}Q_{2n}^*Q_{2n}^*]
2824 Double_t reQ3nQ1nQ2nstarQ2nstar = (pow(dReQ2n,2.)-pow(dImQ2n,2.))*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)
2825 + 2.*dReQ2n*dImQ2n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);
2826 // Re[Q_{3n}Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2827 Double_t reQ3nQ1nstarQ1nstarQ1nstar = dReQ3n*pow(dReQ1n,3)-3.*dReQ1n*dReQ3n*pow(dImQ1n,2)
2828 + 3.*dImQ1n*dImQ3n*pow(dReQ1n,2)-dImQ3n*pow(dImQ1n,3);
403e3389 2829 // Re[Q_{6n}Q_{2n}^*Q_{2n}^*Q_{2n}^*]
2830 Double_t reQ6nQ2nstarQ2nstarQ2nstar = dReQ6n*pow(dReQ2n,3)-3.*dReQ2n*dReQ6n*pow(dImQ2n,2)
2831 + 3.*dImQ2n*dImQ6n*pow(dReQ2n,2)-dImQ6n*pow(dImQ2n,3);
b84464d3 2832 // Re[Q_{4n}Q_{2n}^*Q_{n}^*Q_{n}^*]
2833 Double_t reQ4nQ2nstarQ1nstarQ1nstar = (dReQ4n*dReQ2n+dImQ4n*dImQ2n)*(pow(dReQ1n,2)-pow(dImQ1n,2))
2834 + 2.*dReQ1n*dImQ1n*(dImQ4n*dReQ2n-dReQ4n*dImQ2n);
2835 // Re[Q_{4n}Q_{2n}^*Q_{3n}^*Q_{3n}^*]
2836 Double_t reQ4nQ2nQ3nstarQ3nstar = (dReQ4n*dReQ2n-dImQ4n*dImQ2n)*(dReQ3n*dReQ3n-dImQ3n*dImQ3n)
2837 + 2.*(dReQ4n*dImQ2n+dImQ4n*dReQ2n)*dReQ3n*dImQ3n;
2838 // Re[Q_{4n}Q_{n}Q_{3n}^*Q_{2n}^*]
2839 Double_t reQ4nQ1nQ3nstarQ2nstar = dImQ1n*dImQ2n*dImQ3n*dImQ4n+dImQ3n*dImQ4n*dReQ1n*dReQ2n
2840 + dImQ2n*dImQ4n*dReQ1n*dReQ3n-dImQ1n*dImQ4n*dReQ2n*dReQ3n
2841 - dImQ2n*dImQ3n*dReQ1n*dReQ4n+dImQ1n*dImQ3n*dReQ2n*dReQ4n
2842 + dImQ1n*dImQ2n*dReQ3n*dReQ4n+dReQ1n*dReQ2n*dReQ3n*dReQ4n;
2843 // Re[Q_{5n}Q_{n}Q_{4n}^*Q_{2n}^*]
2844 Double_t reQ5nQ1nQ4nstarQ2nstar = dImQ1n*dImQ2n*dImQ4n*dImQ5n+dImQ4n*dImQ5n*dReQ1n*dReQ2n
2845 + dImQ2n*dImQ5n*dReQ1n*dReQ4n-dImQ1n*dImQ5n*dReQ2n*dReQ4n
2846 - dImQ2n*dImQ4n*dReQ1n*dReQ5n+dImQ1n*dImQ4n*dReQ2n*dReQ5n
2847 + dImQ1n*dImQ2n*dReQ4n*dReQ5n+dReQ1n*dReQ2n*dReQ4n*dReQ5n;
2848 // Re[Q_{5n}Q_{n}Q_{3n}^*Q_{3n}^*]
2849 Double_t reQ5nQ1nQ3nstarQ3nstar = dImQ1n*pow(dImQ3n,2.)*dImQ5n+2.*dImQ3n*dImQ5n*dReQ1n*dReQ3n
2850 - dImQ1n*dImQ5n*pow(dReQ3n,2.)-pow(dImQ3n,2.)*dReQ1n*dReQ5n
2851 + 2.*dImQ1n*dImQ3n*dReQ3n*dReQ5n+dReQ1n*pow(dReQ3n,2.)*dReQ5n;
2852 // Re[Q_{5n}Q_{3n}^*Q_{n}^*Q_{n}^*]
2853 Double_t reQ5nQ3nstarQ1nstarQ1nstar = -pow(dImQ1n,2.)*dImQ3n*dImQ5n+dImQ3n*dImQ5n*pow(dReQ1n,2.)
2854 + 2.*dImQ1n*dImQ5n*dReQ1n*dReQ3n-2.*dImQ1n*dImQ3n*dReQ1n*dReQ5n
2855 - pow(dImQ1n,2.)*dReQ3n*dReQ5n+pow(dReQ1n,2.)*dReQ3n*dReQ5n;
2856 // Re[Q_{5n}Q_{2n}^*Q_{2n}^*Q_{n}^*]
2857 Double_t reQ5nQ2nstarQ2nstarQ1nstar = -pow(dImQ2n,2.)*dImQ1n*dImQ5n+dImQ1n*dImQ5n*pow(dReQ2n,2.)
2858 + 2.*dImQ2n*dImQ5n*dReQ2n*dReQ1n-2.*dImQ2n*dImQ1n*dReQ2n*dReQ5n
403e3389 2859 - pow(dImQ2n,2.)*dReQ1n*dReQ5n+pow(dReQ2n,2.)*dReQ1n*dReQ5n;
2860 // Re[Q_{6n}Q_{4n}^*Q_{n}^*Q_{n}^*]
2861 Double_t reQ6nQ4nstarQ1nstarQ1nstar = -pow(dImQ1n,2.)*dImQ4n*dImQ6n+dImQ4n*dImQ6n*pow(dReQ1n,2.)
2862 + 2.*dImQ1n*dImQ6n*dReQ1n*dReQ4n-2.*dImQ1n*dImQ4n*dReQ1n*dReQ6n
2863 - pow(dImQ1n,2.)*dReQ4n*dReQ6n+pow(dReQ1n,2.)*dReQ4n*dReQ6n;
489d5531 2864 // |Q_{2n}|^2 |Q_{n}|^2
2865 Double_t dQ2nQ1nQ2nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));
b84464d3 2866 // |Q_{4n}|^2 |Q_{2n}|^2
2867 Double_t dQ4nQ2nQ4nstarQ2nstar = (pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.));
2868 // |Q_{3n}|^2 |Q_{2n}|^2
2869 Double_t dQ3nQ2nQ3nstarQ2nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.));
2870 // |Q_{5n}|^2 |Q_{n}|^2
2871 Double_t dQ5nQ1nQ5nstarQ1nstar = (pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));
53884472 2872 // |Q_{3n}|^2 |Q_{n}|^2
2873 Double_t dQ3nQ1nQ3nstarQ1nstar = (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));
b84464d3 2874 // Re[Q_{2n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2875 Double_t reQ2nQ1nQ1nstarQ1nstarQ1nstar = (dReQ2n*dReQ1n-dImQ2n*dImQ1n)*(pow(dReQ1n,3)-3.*dReQ1n*pow(dImQ1n,2))
b84464d3 2876 + (dReQ2n*dImQ1n+dReQ1n*dImQ2n)*(3.*dImQ1n*pow(dReQ1n,2)-pow(dImQ1n,3));
2877 // Re[Q_{2n}Q_{2n}Q_{2n}^*Q_{n}^*Q_{n}^*]
489d5531 2878 Double_t reQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))
2879 * (dReQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) + 2.*dImQ2n*dReQ1n*dImQ1n);
b84464d3 2880 // Re[Q_{4n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2881 Double_t reQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dReQ4n-6.*pow(dReQ1n,2.)*dReQ4n*pow(dImQ1n,2.)
2882 + pow(dImQ1n,4.)*dReQ4n+4.*pow(dReQ1n,3.)*dImQ1n*dImQ4n
2883 - 4.*pow(dImQ1n,3.)*dReQ1n*dImQ4n;
b84464d3 2884 // Re[Q_{3n}Q_{n}Q_{2n}^*Q_{n}^*Q_{n}^*]
489d5531 2885 Double_t reQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))
b84464d3 2886 * (dReQ1n*dReQ2n*dReQ3n-dReQ3n*dImQ1n*dImQ2n
2887 + dReQ2n*dImQ1n*dImQ3n+dReQ1n*dImQ2n*dImQ3n);
2888 // Re[Q_{6n}Q_{n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2889 Double_t reQ6nQ3nstarQ2nstarQ1nstar = dReQ1n*dReQ2n*dReQ3n*dReQ6n-dReQ3n*dReQ6n*dImQ1n*dImQ2n
2890 - dReQ2n*dReQ6n*dImQ1n*dImQ3n-dReQ1n*dReQ6n*dImQ2n*dImQ3n
2891 + dReQ2n*dReQ3n*dImQ1n*dImQ6n+dReQ1n*dReQ3n*dImQ2n*dImQ6n
2892 + dReQ1n*dReQ2n*dImQ3n*dImQ6n-dImQ1n*dImQ2n*dImQ3n*dImQ6n;
2893 // Re[Q_{3n}Q_{3n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2894 Double_t reQ3nQ3nQ3nstarQ2nstarQ1nstar = (pow(dImQ3n,2.)+pow(dReQ3n,2.))
2895 * (dImQ2n*dImQ3n*dReQ1n+dImQ1n*dImQ3n*dReQ2n
2896 - dImQ1n*dImQ2n*dReQ3n+dReQ1n*dReQ2n*dReQ3n);
2897 // Re[Q_{3n}Q_{3n}Q_{2n}^*Q_{2n}^*Q_{2n}^*]
2898 Double_t reQ3nQ3nQ2nstarQ2nstarQ2nstar = pow(dReQ2n,3.)*pow(dReQ3n,2.)
2899 - 3.*dReQ2n*pow(dReQ3n,2.)*pow(dImQ2n,2.)
2900 + 6.*pow(dReQ2n,2.)*dReQ3n*dImQ2n*dImQ3n
2901 - 2.*dReQ3n*pow(dImQ2n,3.)*dImQ3n-pow(dReQ2n,3.)*pow(dImQ3n,2.)
2902 + 3.*dReQ2n*pow(dImQ2n,2.)*pow(dImQ3n,2.);
2903 // Re[Q_{4n}Q_{2n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2904 Double_t reQ4nQ2nQ3nstarQ2nstarQ1nstar = (pow(dImQ2n,2.)+pow(dReQ2n,2.))
2905 * (dImQ3n*dImQ4n*dReQ1n+dImQ1n*dImQ4n*dReQ3n
2906 - dImQ1n*dImQ3n*dReQ4n+dReQ1n*dReQ3n*dReQ4n);
2907 // Re[Q_{3n}Q_{2n}Q_{3n}^*Q_{n}^*Q_{n}^*]
2908 Double_t reQ3nQ2nQ3nstarQ1nstarQ1nstar = -(pow(dImQ3n,2.)+pow(dReQ3n,2.))
2909 * (-2.*dImQ1n*dImQ2n*dReQ1n+pow(dImQ1n,2.)*dReQ2n-pow(dReQ1n,2.)*dReQ2n);
2910 // Re[Q_{3n}Q_{2n}Q_{2n}^*Q_{2n}^*Q_{n}^*]
2911 Double_t reQ3nQ2nQ2nstarQ2nstarQ1nstar = (pow(dImQ2n,2.)+pow(dReQ2n,2.))
2912 * (dImQ2n*dImQ3n*dReQ1n+dImQ1n*dImQ3n*dReQ2n
2913 - dImQ1n*dImQ2n*dReQ3n+dReQ1n*dReQ2n*dReQ3n);
2914 // Re[Q_{5n}Q_{n}Q_{3n}^*Q_{2n}^*Q_{n}^*]
2915 Double_t reQ5nQ1nQ3nstarQ2nstarQ1nstar = (pow(dImQ1n,2.)+pow(dReQ1n,2.))
2916 * (dImQ3n*dImQ5n*dReQ2n+dImQ2n*dImQ5n*dReQ3n
2917 - dImQ2n*dImQ3n*dReQ5n+dReQ2n*dReQ3n*dReQ5n);
2918 // Re[Q_{2n}Q_{2n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2919 Double_t reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)*dReQ2n-2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)
2920 + dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dImQ2n)
2921 * (pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)
b84464d3 2922 - dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n+pow(dImQ1n,2.)*dImQ2n);
2923 // Re[Q_{3n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2924 Double_t reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))
2925 * (pow(dReQ1n,3.)*dReQ3n-3.*dReQ1n*dReQ3n*pow(dImQ1n,2.)
2926 + 3.*pow(dReQ1n,2.)*dImQ1n*dImQ3n-pow(dImQ1n,3.)*dImQ3n);
489d5531 2927 // |Q_{2n}|^2 |Q_{n}|^4
b84464d3 2928 Double_t dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.);
2929 // |Q_{3n}|^2 |Q_{2n}|^2 |Q_{n}|^2
2930 Double_t dQ3nQ2nQ1nQ3nstarQ2nstarQ1nstar = (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
2931 * (pow(dReQ1n,2.)+pow(dImQ1n,2.));
2932 // Re[Q_{2n}Q_{n}Q_{n}Q_{n}^*Q_{n}^*Q_{n}^*Q_{n}^*]
489d5531 2933 Double_t reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
2934 * (pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)
53884472 2935 + 2.*dReQ1n*dImQ1n*dImQ2n);
2936 // Re[Q_{6n}Q_{2n}^*Q_{2n}^*Q_{n}^*Q_{n}^*]
2937 Double_t reQ6nQ2nstarQ2nstarQ1nstarQ1nstar = pow(dReQ1n*dReQ2n,2.)*dReQ6n-pow(dReQ2n*dImQ1n,2.)*dReQ6n
2938 - 4.*dReQ1n*dReQ2n*dReQ6n*dImQ1n*dImQ2n
2939 - pow(dReQ1n*dImQ2n,2.)*dReQ6n+pow(dImQ1n*dImQ2n,2.)*dReQ6n
2940 + 2.*dReQ1n*pow(dReQ2n,2.)*dImQ1n*dImQ6n
2941 + 2.*pow(dReQ1n,2.)*dReQ2n*dImQ2n*dImQ6n
2942 - 2.*dReQ2n*pow(dImQ1n,2.)*dImQ2n*dImQ6n
2943 - 2.*dReQ1n*dImQ1n*pow(dImQ2n,2.)*dImQ6n;
2944 // Re[Q_{4n}Q_{1n}Q_{1n}Q_{3n}^*Q_{3n}^*]
2945 Double_t reQ4nQ1nQ1nQ3nstarQ3nstar = pow(dReQ1n*dReQ3n,2.)*dReQ4n-pow(dReQ3n*dImQ1n,2.)*dReQ4n
2946 + 4.*dReQ1n*dReQ3n*dReQ4n*dImQ1n*dImQ3n
2947 - pow(dReQ1n*dImQ3n,2.)*dReQ4n+pow(dImQ1n*dImQ3n,2.)*dReQ4n
2948 - 2.*dReQ1n*pow(dReQ3n,2.)*dImQ1n*dImQ4n
2949 + 2.*pow(dReQ1n,2.)*dReQ3n*dImQ3n*dImQ4n
2950 - 2.*dReQ3n*pow(dImQ1n,2.)*dImQ3n*dImQ4n
2951 + 2.*dReQ1n*dImQ1n*pow(dImQ3n,2.)*dImQ4n;
2952 // Re[Q_{3n}Q_{3n}Q_{2n}^*Q_{2n}^*Q_{1n}^*Q_{1n}^*]
2953 Double_t reQ3nQ3nQ2nstarQ2nstarQ1nstarQ1nstar = (dReQ1n*dReQ2n*dReQ3n-dReQ2n*dReQ3n*dImQ1n-dReQ1n*dReQ3n*dImQ2n
2954 - dReQ3n*dImQ1n*dImQ2n+dReQ1n*dReQ2n*dImQ3n+dReQ2n*dImQ1n*dImQ3n
2955 + dReQ1n*dImQ2n*dImQ3n-dImQ1n*dImQ2n*dImQ3n)*(dReQ1n*dReQ2n*dReQ3n
2956 + dReQ2n*dReQ3n*dImQ1n+dReQ1n*dReQ3n*dImQ2n-dReQ3n*dImQ1n*dImQ2n
2957 - dReQ1n*dReQ2n*dImQ3n+dReQ2n*dImQ1n*dImQ3n+dReQ1n*dImQ2n*dImQ3n
2958 + dImQ1n*dImQ2n*dImQ3n);
489d5531 2959
b84464d3 2960 // Results for multiparticle azimuthal correlations:
489d5531 2961 // 2-particle:
b84464d3 2962 Double_t two1n1n = 0.; // <cos(n(phi1-phi2))>
2963 Double_t two2n2n = 0.; // <cos(2n(phi1-phi2))>
2964 Double_t two3n3n = 0.; // <cos(3n(phi1-phi2))>
2965 Double_t two4n4n = 0.; // <cos(4n(phi1-phi2))>
489d5531 2966 if(dMult>1)
2967 {
2968 two1n1n = (pow(dReQ1n,2.)+pow(dImQ1n,2.)-dMult)/(dMult*(dMult-1.));
2969 two2n2n = (pow(dReQ2n,2.)+pow(dImQ2n,2.)-dMult)/(dMult*(dMult-1.));
2970 two3n3n = (pow(dReQ3n,2.)+pow(dImQ3n,2.)-dMult)/(dMult*(dMult-1.));
2971 two4n4n = (pow(dReQ4n,2.)+pow(dImQ4n,2.)-dMult)/(dMult*(dMult-1.));
b84464d3 2972 // Average 2-particle correlations for single event:
489d5531 2973 fIntFlowCorrelationsAllEBE->SetBinContent(1,two1n1n);
2974 fIntFlowCorrelationsAllEBE->SetBinContent(2,two2n2n);
2975 fIntFlowCorrelationsAllEBE->SetBinContent(3,two3n3n);
b84464d3 2976 fIntFlowCorrelationsAllEBE->SetBinContent(4,two4n4n);
2977 // Average 2-particle correlations for all events:
2978 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1n,dMult*(dMult-1.));
2979 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2n,dMult*(dMult-1.));
2980 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3n,dMult*(dMult-1.));
2981 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4n,dMult*(dMult-1.));
2982 // Store separetately <2>:
2983 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1n); // <2>
2984 // Testing other multiplicity weights:
489d5531 2985 Double_t mWeight2p = 0.;
2986 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
2987 {
2988 mWeight2p = dMult*(dMult-1.);
2989 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
2990 {
2991 mWeight2p = 1.;
2992 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
2993 {
2994 mWeight2p = dMult;
b84464d3 2995 }
489d5531 2996 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,mWeight2p); // eW_<2>
2997 fIntFlowCorrelationsPro->Fill(0.5,two1n1n,mWeight2p);
b40a910e 2998 fIntFlowSquaredCorrelationsPro->Fill(0.5,two1n1n*two1n1n,mWeight2p);
2999 if(fCalculateCumulantsVsM)
3000 {
3001 fIntFlowCorrelationsVsMPro[0]->Fill(dMult+0.5,two1n1n,mWeight2p);
3002 fIntFlowSquaredCorrelationsVsMPro[0]->Fill(dMult+0.5,two1n1n*two1n1n,mWeight2p);
3003 }
3435cacb 3004 if(fCalculateAllCorrelationsVsM)
3005 {
3006 fIntFlowCorrelationsAllVsMPro[0]->Fill(dMult+0.5,two1n1n,mWeight2p);
3007 fIntFlowCorrelationsAllVsMPro[1]->Fill(dMult+0.5,two2n2n,mWeight2p);
3008 fIntFlowCorrelationsAllVsMPro[2]->Fill(dMult+0.5,two3n3n,mWeight2p);
3009 fIntFlowCorrelationsAllVsMPro[3]->Fill(dMult+0.5,two4n4n,mWeight2p);
3010 }
489d5531 3011 } // end of if(dMult>1)
3012
3013 // 3-particle:
b84464d3 3014 Double_t three2n1n1n = 0.; // <cos(n(2*phi1-phi2-phi3))>
3015 Double_t three3n2n1n = 0.; // <cos(n(3*phi1-2*phi2-phi3))>
3016 Double_t three4n2n2n = 0.; // <cos(n(4*phi1-2*phi2-2*phi3))>
3017 Double_t three4n3n1n = 0.; // <cos(n(4*phi1-3*phi2-phi3))>
489d5531 3018 if(dMult>2)
3019 {
3020 three2n1n1n = (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3021 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
3022 / (dMult*(dMult-1.)*(dMult-2.));
3023 three3n2n1n = (reQ3nQ2nstarQ1nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3024 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))
3025 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
3026 / (dMult*(dMult-1.)*(dMult-2.));
3027 three4n2n2n = (reQ4nQ2nstarQ2nstar-2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3028 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*dMult)
3029 / (dMult*(dMult-1.)*(dMult-2.));
3030 three4n3n1n = (reQ4nQ3nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3031 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))
3032 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
b84464d3 3033 / (dMult*(dMult-1.)*(dMult-2.));
3034 // Average 3-particle correlations for single event:
489d5531 3035 fIntFlowCorrelationsAllEBE->SetBinContent(6,three2n1n1n);
3036 fIntFlowCorrelationsAllEBE->SetBinContent(7,three3n2n1n);
3037 fIntFlowCorrelationsAllEBE->SetBinContent(8,three4n2n2n);
3038 fIntFlowCorrelationsAllEBE->SetBinContent(9,three4n3n1n);
b84464d3 3039 // Average 3-particle correlations for all events:
489d5531 3040 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.));
3041 fIntFlowCorrelationsAllPro->Fill(6.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));
3042 fIntFlowCorrelationsAllPro->Fill(7.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.));
3435cacb 3043 fIntFlowCorrelationsAllPro->Fill(8.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.));
b84464d3 3044 // Average 3-particle correlations vs M for all events:
3435cacb 3045 if(fCalculateAllCorrelationsVsM)
3046 {
3047 fIntFlowCorrelationsAllVsMPro[5]->Fill(dMult+0.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.));
3048 fIntFlowCorrelationsAllVsMPro[6]->Fill(dMult+0.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));
3049 fIntFlowCorrelationsAllVsMPro[7]->Fill(dMult+0.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.));
3050 fIntFlowCorrelationsAllVsMPro[8]->Fill(dMult+0.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.));
3051 }
489d5531 3052 } // end of if(dMult>2)
3053
3054 // 4-particle:
b84464d3 3055 Double_t four1n1n1n1n = 0.; // <cos(n(phi1+phi2-phi3-phi4))>
3056 Double_t four2n2n2n2n = 0.; // <cos(2n(phi1+phi2-phi3-phi4))>
3057 Double_t four2n1n2n1n = 0.; // <cos(n(2*phi1+phi2-2*phi3-phi4))>
3058 Double_t four3n1n1n1n = 0.; // <cos(n(3*phi1-phi2-phi3-phi4))>
3059 Double_t four4n2n1n1n = 0.; // <cos(n(4*phi1-2*phi2-phi3-phi4))>
3060 Double_t four3n1n2n2n = 0.; // <cos(n(3*phi1+phi2-2*phi3-2*phi4))>
3061 Double_t four3n1n3n1n = 0.; // <cos(n(3*phi1+phi2-3*phi3-phi4))>
489d5531 3062 if(dMult>3)
3063 {
3064 four1n1n1n1n = (2.*dMult*(dMult-3.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ1n,2.)
3065 + pow(dImQ1n,2.))-2.*reQ2nQ1nstarQ1nstar+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))
3066 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3067 four2n2n2n2n = (2.*dMult*(dMult-3.)+pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ2n,2.)
3068 + pow(dImQ2n,2.))-2.*reQ4nQ2nstarQ2nstar+(pow(dReQ4n,2.)+pow(dImQ4n,2.)))
3069 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3070 four2n1n2n1n = (dQ2nQ1nQ2nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar-2.*reQ2nQ1nstarQ1nstar)
3071 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3072 - ((dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3073 + (dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-(pow(dReQ3n,2.)+pow(dImQ3n,2.)))
3074 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3075 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3076 four3n1n1n1n = (reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar-3.*reQ2nQ1nstarQ1nstar
3077 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
489d5531 3078 + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3079 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3080 four4n2n1n1n = (reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar)
3081 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3082 - (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3083 - 3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))
3084 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3085 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3086 four3n1n2n2n = (reQ3nQ1nQ2nstarQ2nstar-reQ4nQ2nstarQ2nstar-reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar)
489d5531 3087 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
b84464d3 3088 - (2.*reQ2nQ1nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
489d5531 3089 - 4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))
3090 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3091 - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));
3092 four3n1n3n1n = ((pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
b84464d3 3093 - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar
3094 + pow(dReQ4n,2.)+pow(dImQ4n,2.)-(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3095 + pow(dReQ2n,2.)+pow(dImQ2n,2.)-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3096 + dMult*(dMult-6.))
3097 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3098 // Average 4-particle correlations for single event:
489d5531 3099 fIntFlowCorrelationsAllEBE->SetBinContent(11,four1n1n1n1n);
3100 fIntFlowCorrelationsAllEBE->SetBinContent(12,four2n1n2n1n);
3101 fIntFlowCorrelationsAllEBE->SetBinContent(13,four2n2n2n2n);
3102 fIntFlowCorrelationsAllEBE->SetBinContent(14,four3n1n1n1n);
3103 fIntFlowCorrelationsAllEBE->SetBinContent(15,four3n1n3n1n);
3104 fIntFlowCorrelationsAllEBE->SetBinContent(16,four3n1n2n2n);
b84464d3 3105 fIntFlowCorrelationsAllEBE->SetBinContent(17,four4n2n1n1n);
3106 // Average 4-particle correlations for all events:
489d5531 3107 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3108 fIntFlowCorrelationsAllPro->Fill(11.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3109 fIntFlowCorrelationsAllPro->Fill(12.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3110 fIntFlowCorrelationsAllPro->Fill(13.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3111 fIntFlowCorrelationsAllPro->Fill(14.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3112 fIntFlowCorrelationsAllPro->Fill(15.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3113 fIntFlowCorrelationsAllPro->Fill(16.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3114 // Average 4-particle correlations vs M for all events:
3435cacb 3115 if(fCalculateAllCorrelationsVsM)
3116 {
3117 fIntFlowCorrelationsAllVsMPro[10]->Fill(dMult+0.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3118 fIntFlowCorrelationsAllVsMPro[11]->Fill(dMult+0.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3119 fIntFlowCorrelationsAllVsMPro[12]->Fill(dMult+0.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3120 fIntFlowCorrelationsAllVsMPro[13]->Fill(dMult+0.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3121 fIntFlowCorrelationsAllVsMPro[14]->Fill(dMult+0.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3122 fIntFlowCorrelationsAllVsMPro[15]->Fill(dMult+0.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3123 fIntFlowCorrelationsAllVsMPro[16]->Fill(dMult+0.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3124 }
3125 // Store separetately <4>:
489d5531 3126 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1n); // <4>
b84464d3 3127 // Testing other multiplicity weights:
489d5531 3128 Double_t mWeight4p = 0.;
3129 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3130 {
3131 mWeight4p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.);
3132 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3133 {
3134 mWeight4p = 1.;
3135 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3136 {
3137 mWeight4p = dMult;
b84464d3 3138 }
489d5531 3139 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,mWeight4p); // eW_<4>
3140 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1n,mWeight4p);
b40a910e 3141 fIntFlowSquaredCorrelationsPro->Fill(1.5,four1n1n1n1n*four1n1n1n1n,mWeight4p);
3142 if(fCalculateCumulantsVsM)
3143 {
3144 fIntFlowCorrelationsVsMPro[1]->Fill(dMult+0.5,four1n1n1n1n,mWeight4p);
3145 fIntFlowSquaredCorrelationsVsMPro[1]->Fill(dMult+0.5,four1n1n1n1n*four1n1n1n1n,mWeight4p);
3146 }
489d5531 3147 } // end of if(dMult>3)
3148
3149 // 5-particle:
b84464d3 3150 Double_t five2n1n1n1n1n = 0.; // <cos(n(2*phi1+phi2-phi3-phi4-phi5))>
3151 Double_t five2n2n2n1n1n = 0.; // <cos(n(2*phi1+2*phi2-2*phi3-phi4-phi5))>
3152 Double_t five3n1n2n1n1n = 0.; // <cos(n(3*phi1+phi2-2*phi3-phi4-phi5))>
3153 Double_t five4n1n1n1n1n = 0.; // <cos(n(4*phi1-phi2-phi3-phi4-phi5))>
489d5531 3154 if(dMult>4)
b84464d3 3155 {
3156 five2n1n1n1n1n = (reQ2nQ1nQ1nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar+5.*reQ3nQ2nstarQ1nstar
3157 - 3.*(dMult-5.)*reQ2nQ1nstarQ1nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3158 - 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3159 + 3.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3160 - 3.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3161 + 6.*(2.*dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult*(dMult-4.))
489d5531 3162 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3163 five2n2n2n1n1n = (reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ3nQ1nQ2nstarQ2nstar
3164 + 3.*reQ4nQ2nstarQ2nstar+8.*reQ3nQ2nstarQ1nstar+2.*reQ4nQ3nstarQ1nstar
3165 - 2.*(dMult-6.)*reQ2nQ1nstarQ1nstar
3166 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3167 - pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)
3168 + 2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3169 - 4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3170 + 4.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
489d5531 3171 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3172 five4n1n1n1n1n = (reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ4nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nstarQ1nstarQ1nstar
3173 + 8.*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+12.*reQ3nQ2nstarQ1nstar+12.*reQ2nQ1nstarQ1nstar
3174 - 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-8.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3175 - 12.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+24.*dMult)
3176 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3177 five3n1n2n1n1n = (reQ3nQ1nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar
3178 - reQ3nQ1nQ2nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar+reQ4nQ2nstarQ2nstar
3179 - (2.*dMult-13.)*reQ3nQ2nstarQ1nstar+7.*reQ2nQ1nstarQ1nstar
3180 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3181 + 2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3182 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3183 + 2.*(dMult-6.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
489d5531 3184 - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3185 - pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
b84464d3 3186 + 2.*(3.*dMult-11.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3187 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3188 // Average 5-particle correlations for single event:
489d5531 3189 fIntFlowCorrelationsAllEBE->SetBinContent(19,five2n1n1n1n1n);
3190 fIntFlowCorrelationsAllEBE->SetBinContent(20,five2n2n2n1n1n);
3191 fIntFlowCorrelationsAllEBE->SetBinContent(21,five3n1n2n1n1n);
b84464d3 3192 fIntFlowCorrelationsAllEBE->SetBinContent(22,five4n1n1n1n1n);
3193 // Average 5-particle correlations for all events:
489d5531 3194 fIntFlowCorrelationsAllPro->Fill(18.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3195 fIntFlowCorrelationsAllPro->Fill(19.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3196 fIntFlowCorrelationsAllPro->Fill(20.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3197 fIntFlowCorrelationsAllPro->Fill(21.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3198 // Average 5-particle correlations vs M for all events:
3435cacb 3199 if(fCalculateAllCorrelationsVsM)
3200 {
3201 fIntFlowCorrelationsAllVsMPro[18]->Fill(dMult+0.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3202 fIntFlowCorrelationsAllVsMPro[19]->Fill(dMult+0.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3203 fIntFlowCorrelationsAllVsMPro[20]->Fill(dMult+0.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3204 fIntFlowCorrelationsAllVsMPro[21]->Fill(dMult+0.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3205 }
489d5531 3206 } // end of if(dMult>4)
3207
3208 // 6-particle:
b84464d3 3209 Double_t six1n1n1n1n1n1n = 0.; // <cos(n(phi1+phi2+phi3-phi4-phi5-phi6))>
3210 Double_t six2n2n1n1n1n1n = 0.; // <cos(n(2*phi1+2*phi2-phi3-phi4-phi5-phi6))>
3211 Double_t six3n1n1n1n1n1n = 0.; // <cos(n(3*phi1+phi2-phi3-phi4-phi5-phi6))>
3212 Double_t six2n1n1n2n1n1n = 0.; // <cos(n(2*phi1+phi2+phi3-2*phi4-phi5-phi6))>
489d5531 3213 if(dMult>5)
3214 {
b84464d3 3215 six1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)-6.*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3216 + 4.*reQ3nQ1nstarQ1nstarQ1nstar-12.*reQ3nQ2nstarQ1nstar+18.*(dMult-4.)*reQ2nQ1nstarQ1nstar
3217 + 9.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3218 + 4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))-9.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3219 - 9.*(dMult-4.)*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3220 + 18.*(dMult*dMult-7.*dMult+10.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3221 - 6.*dMult*(dMult*dMult-9.*dMult+20.))
3222 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3223 six2n1n1n2n1n1n = (dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3224 - 4.*reQ2nQ1nQ1nstarQ1nstarQ1nstar-2.*reQ2nQ2nQ2nstarQ1nstarQ1nstar
3225 + 4.*reQ4nQ2nstarQ1nstarQ1nstar+4.*reQ3nQ1nQ2nstarQ2nstar+4.*reQ3nQ1nstarQ1nstarQ1nstar
3226 - 8.*reQ4nQ3nstarQ1nstar-4.*reQ4nQ2nstarQ2nstar+4.*(2.*dMult-13.)*reQ3nQ2nstarQ1nstar
3227 + 2.*(7.*dMult-34.)*reQ2nQ1nstarQ1nstar+4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3228 - 4.*(dMult-7.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3229 + 4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-4.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3230 + pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+(2.*dMult*dMult-27.*dMult+76.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3231 - (dMult-12.)*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3232 + 4.*(dMult*dMult-15.*dMult+34.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3233 - 2.*dMult*(dMult*dMult-17.*dMult+60.))
3234 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3235 six2n2n1n1n1n1n = (reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ1nstarQ1nstarQ1nstarQ1nstar
3236 - 8.*reQ2nQ1nQ1nstarQ1nstarQ1nstar+8.*reQ3nQ1nstarQ1nstarQ1nstar+6.*reQ4nQ2nstarQ1nstarQ1nstar
3237 + 8.*reQ3nQ1nQ2nstarQ2nstar-40.*reQ3nQ2nstarQ1nstar-8.*reQ4nQ3nstarQ1nstar-9.*reQ4nQ2nstarQ2nstar
3238 + 24.*(dMult-4.)*reQ2nQ1nstarQ1nstar+24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3239 + 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+16.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3240 + 3.*pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-12.*(2.*dMult-7.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3241 + 12.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-48.*(dMult-3.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3242 + 24.*dMult*(dMult-5.))
3243 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3244 six3n1n1n1n1n1n = (reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ3nQ1nQ2nstarQ1nstarQ1nstar+6.*reQ4nQ2nstarQ1nstarQ1nstar
3245 - reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-4.*reQ2nQ1nQ1nstarQ1nstarQ1nstar+3.*reQ3nQ1nQ2nstarQ2nstar
3246 - 4.*(dMult-5.)*reQ3nQ1nstarQ1nstarQ1nstar-14.*reQ4nQ3nstarQ1nstar
3247 - 3.*reQ4nQ2nstarQ2nstar+4.*(3.*dMult-17.)*reQ3nQ2nstarQ1nstar+12.*(dMult-6.)*reQ2nQ1nstarQ1nstar
3248 + 12.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3249 + 8.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3250 + 6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-8.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3251 - 12.*(dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-48.*(dMult-3.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3252 + 12.*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)+24.*dMult*(dMult-5.))
3253 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3254 // Average 6-particle correlations for single event:
489d5531 3255 fIntFlowCorrelationsAllEBE->SetBinContent(24,six1n1n1n1n1n1n);
3256 fIntFlowCorrelationsAllEBE->SetBinContent(25,six2n1n1n2n1n1n);
3257 fIntFlowCorrelationsAllEBE->SetBinContent(26,six2n2n1n1n1n1n);
3258 fIntFlowCorrelationsAllEBE->SetBinContent(27,six3n1n1n1n1n1n);
b84464d3 3259 // Average 6-particle correlations for all events:
489d5531 3260 fIntFlowCorrelationsAllPro->Fill(23.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3261 fIntFlowCorrelationsAllPro->Fill(24.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3262 fIntFlowCorrelationsAllPro->Fill(25.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3263 fIntFlowCorrelationsAllPro->Fill(26.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3264 // Average 6-particle correlations vs M for all events:
3435cacb 3265 if(fCalculateAllCorrelationsVsM)
3266 {
3267 fIntFlowCorrelationsAllVsMPro[23]->Fill(dMult+0.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3268 fIntFlowCorrelationsAllVsMPro[24]->Fill(dMult+0.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3269 fIntFlowCorrelationsAllVsMPro[25]->Fill(dMult+0.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3270 fIntFlowCorrelationsAllVsMPro[26]->Fill(dMult+0.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
3271 }
b84464d3 3272 // Store separetately <6>:
489d5531 3273 fIntFlowCorrelationsEBE->SetBinContent(3,six1n1n1n1n1n1n); // <6>
b84464d3 3274 // Testing other multiplicity weights:
489d5531 3275 Double_t mWeight6p = 0.;
3276 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3277 {
3278 mWeight6p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.);
3279 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3280 {
3281 mWeight6p = 1.;
3282 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3283 {
3284 mWeight6p = dMult;
3285 }
489d5531 3286 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(3,mWeight6p); // eW_<6>
3287 fIntFlowCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n,mWeight6p);
b40a910e 3288 fIntFlowSquaredCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n*six1n1n1n1n1n1n,mWeight6p);
3289 if(fCalculateCumulantsVsM)
3290 {
3291 fIntFlowCorrelationsVsMPro[2]->Fill(dMult+0.5,six1n1n1n1n1n1n,mWeight6p);
3292 fIntFlowSquaredCorrelationsVsMPro[2]->Fill(dMult+0.5,six1n1n1n1n1n1n*six1n1n1n1n1n1n,mWeight6p);
3293 }
489d5531 3294 } // end of if(dMult>5)
3295
3296 // 7-particle:
b84464d3 3297 Double_t seven2n1n1n1n1n1n1n = 0.; // <cos(n(2*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
489d5531 3298 if(dMult>6)
3299 {
b84464d3 3300 seven2n1n1n1n1n1n1n = (reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-4.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)
3301 - reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-2.*reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar
3302 + 9.*reQ2nQ2nQ2nstarQ1nstarQ1nstar+20.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3303 + 2.*reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-8.*(dMult-8.)*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3304 - 18.*reQ4nQ2nstarQ1nstarQ1nstar-14.*reQ3nQ1nQ2nstarQ2nstar
3305 + 8.*(dMult-7.)*reQ3nQ1nstarQ1nstarQ1nstar+28.*reQ4nQ3nstarQ1nstar
3306 + 12.*reQ4nQ2nstarQ2nstar-8.*(5.*dMult-31.)*reQ3nQ2nstarQ1nstar
3307 + 12.*(dMult*dMult-15.*dMult+46.)*reQ2nQ1nstarQ1nstar
3308 - 16.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3309 - 6.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3310 - 3.*pow(pow(dReQ2n,2.)+pow(dImQ2n,2.),2.)
3311 + 12.*(2.*dMult-13.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3312 - 12.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+16.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3313 - 12.*(dMult-8.)*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3314 + 12.*(3.*dMult-14.)*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)
3315 - 24.*(3.*dMult-7.)*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3316 + 24.*dMult*(dMult-5.)*(dMult-6.))
3317 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.));
3318 // Average 7-particle correlations for single event:
3319 fIntFlowCorrelationsAllEBE->SetBinContent(29,seven2n1n1n1n1n1n1n);
3320 // Average 7-particle correlations for all events:
3321 fIntFlowCorrelationsAllPro->Fill(28.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3322 *(dMult-4.)*(dMult-5.)*(dMult-6.));
3323 // Average 7-particle correlations vs M for all events:
3435cacb 3324 if(fCalculateAllCorrelationsVsM)
3325 {
b84464d3 3326 fIntFlowCorrelationsAllVsMPro[28]->Fill(dMult+0.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3327 *(dMult-4.)*(dMult-5.)*(dMult-6.));
3435cacb 3328 }
489d5531 3329 } // end of if(dMult>6)
3330
3331 // 8-particle:
b84464d3 3332 Double_t eight1n1n1n1n1n1n1n1n = 0.; // <cos(n(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
489d5531 3333 if(dMult>7)
b84464d3 3334 {
3335 eight1n1n1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),4.)-12.*reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar
3336 + 16.*reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar+6.*reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar
3337 - 12.*reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-36.*reQ2nQ2nQ2nstarQ1nstarQ1nstar
3338 - 96.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3339 + 72.*reQ4nQ2nstarQ1nstarQ1nstar+48.*reQ3nQ1nQ2nstarQ2nstar
3340 - 64.*(dMult-6.)*reQ3nQ1nstarQ1nstarQ1nstar
3341 + 96.*(dMult-6.)*reQ2nQ1nQ1nstarQ1nstarQ1nstar
3342 - 96.*reQ4nQ3nstarQ1nstar-36.*reQ4nQ2nstarQ2nstar
3343 + 192.*(dMult-6.)*reQ3nQ2nstarQ1nstar
3344 - 144.*(dMult-7.)*(dMult-4.)*reQ2nQ1nstarQ1nstar
3345 + 64.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3346 - 144.*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3347 + 72.*(dMult-7.)*(dMult-4.)*(pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)+pow(dReQ2n,2.)+pow(dImQ2n,2.))
3348 - 96.*(dMult-7.)*(dMult-6.)*(dMult-2.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3349 + 36.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3350 + 9.*pow(pow(dReQ2n,2.)+pow(dImQ2n,2.),2.)
3351 - 64.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3352 + 36.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3353 - 16.*(dMult-6.)*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)
3354 + 24.*dMult*(dMult-7.)*(dMult-6.)*(dMult-5.))
3355 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3356 // Average 8-particle correlations for single event:
3357 fIntFlowCorrelationsAllEBE->SetBinContent(31,eight1n1n1n1n1n1n1n1n);
3358 // Average 8-particle correlations for all events:
3359 fIntFlowCorrelationsAllPro->Fill(30.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3360 *(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3361 // Average 8-particle correlations vs M for all events:
3435cacb 3362 if(fCalculateAllCorrelationsVsM)
3363 {
b84464d3 3364 fIntFlowCorrelationsAllVsMPro[30]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)
3365 *(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));
3366 }
3367 // Store separetately <8>:
489d5531 3368 fIntFlowCorrelationsEBE->SetBinContent(4,eight1n1n1n1n1n1n1n1n); // <8>
b84464d3 3369 // Testing other multiplicity weights:
489d5531 3370 Double_t mWeight8p = 0.;
3371 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
3372 {
3373 mWeight8p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.);
3374 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
3375 {
3376 mWeight8p = 1.;
3377 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
3378 {
3379 mWeight8p = dMult;
b84464d3 3380 }
489d5531 3381 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(4,mWeight8p); // eW_<8>
b40a910e 3382 fIntFlowCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n,mWeight8p);
3383 fIntFlowSquaredCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n*eight1n1n1n1n1n1n1n1n,mWeight8p);
3384 if(fCalculateCumulantsVsM)
3385 {
3386 fIntFlowCorrelationsVsMPro[3]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n,mWeight8p);
3387 fIntFlowSquaredCorrelationsVsMPro[3]->Fill(dMult+0.5,eight1n1n1n1n1n1n1n1n*eight1n1n1n1n1n1n1n1n,mWeight8p);
3388 }
489d5531 3389 } // end of if(dMult>7)
3390
b84464d3 3391 // EXTRA correlations for v3{5} study:
8ed4edc7 3392 // 4-particle:
b84464d3 3393 Double_t four4n2n3n3n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-3*phi4))>
8ed4edc7 3394 if(dMult>3.)
3395 {
11d3e40e 3396 four4n2n3n3n = (reQ4nQ2nQ3nstarQ3nstar-reQ6nQ4nstarQ2nstar-reQ6nQ3nstarQ3nstar
3397 - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar
3398 + (pow(dReQ6n,2.)+pow(dImQ6n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3399 + 2.*(2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3400 + (pow(dReQ1n,2.)+pow(dImQ1n,2.))-3.*dMult))
b84464d3 3401 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
8ed4edc7 3402 fIntFlowCorrelationsAllPro->Fill(32.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3403 // Average 4-particle correlations vs M for all events:
3435cacb 3404 if(fCalculateAllCorrelationsVsM)
3405 {
3406 fIntFlowCorrelationsAllVsMPro[32]->Fill(dMult+0.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3407 }
11d3e40e 3408 } // end of if(dMult>3.)
8ed4edc7 3409
3410 // 5-particle:
b84464d3 3411 Double_t five3n3n2n2n2n = 0.; // <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
8ed4edc7 3412 if(dMult>4.)
3413 {
b84464d3 3414 five3n3n2n2n2n = (reQ3nQ3nQ2nstarQ2nstarQ2nstar-reQ6nQ2nstarQ2nstarQ2nstar-3.*reQ4nQ2nQ3nstarQ3nstar
3415 - 6.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ6nQ3nstarQ3nstar+3.*reQ6nQ4nstarQ2nstar
3416 + 6.*reQ4nQ3nstarQ1nstar+6.*reQ4nQ2nstarQ2nstar
3417 + 12.*reQ3nQ2nstarQ1nstar+6.*reQ2nQ1nstarQ1nstar
11d3e40e 3418 - 2.*((pow(dReQ6n,2.)+pow(dImQ6n,2.))
3419 + 3.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3420 + 6.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3421 + 9.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3422 + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-12.*dMult))
b84464d3 3423 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3424 fIntFlowCorrelationsAllPro->Fill(33.5,five3n3n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3435cacb 3425 if(fCalculateAllCorrelationsVsM)
3426 {
b84464d3 3427 fIntFlowCorrelationsAllVsMPro[33]->Fill(dMult+0.5,five3n3n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3435cacb 3428 }
11d3e40e 3429 } // end of if(dMult>4.)
8ed4edc7 3430
b84464d3 3431 // EXTRA correlations for Teaney-Yan study:
3432 // 2-particle:
3433 Double_t two5n5n = 0.; // <cos(5n(phi1-phi2))>
3434 Double_t two6n6n = 0.; // <cos(6n(phi1-phi2))>
3435 if(dMult>1)
3436 {
3437 two5n5n = (pow(dReQ5n,2.)+pow(dImQ5n,2.)-dMult)/(dMult*(dMult-1.));
3438 two6n6n = (pow(dReQ6n,2.)+pow(dImQ6n,2.)-dMult)/(dMult*(dMult-1.));
3439 // Average 2-particle correlations for all events:
3440 fIntFlowCorrelationsAllPro->Fill(34.5,two5n5n,dMult*(dMult-1.));
3441 fIntFlowCorrelationsAllPro->Fill(35.5,two6n6n,dMult*(dMult-1.));
3442 if(fCalculateAllCorrelationsVsM)
3443 {
3444 fIntFlowCorrelationsAllVsMPro[34]->Fill(dMult+0.5,two5n5n,dMult*(dMult-1.));
3445 fIntFlowCorrelationsAllVsMPro[35]->Fill(dMult+0.5,two6n6n,dMult*(dMult-1.));
3446 }
3447 } // end of if(dMult>1)
3448
3449 // 3-particle:
3450 Double_t three5n3n2n = 0.; // <cos(n(5*phi1-3*phi2-2*phi3)>
3451 Double_t three5n4n1n = 0.; // <cos(n(5*phi1-4*phi2-1*phi3)>
3452 Double_t three6n3n3n = 0.; // <cos(n(6*phi1-3*phi2-3*phi3)>
3453 Double_t three6n4n2n = 0.; // <cos(n(6*phi1-4*phi2-2*phi3)>
3454 Double_t three6n5n1n = 0.; // <cos(n(6*phi1-5*phi2-1*phi3)>
3455 if(dMult>2)
3456 {
3457 three5n3n2n = (reQ5nQ3nstarQ2nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3458 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))
3459 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
3460 / (dMult*(dMult-1.)*(dMult-2.));
3461 three5n4n1n = (reQ5nQ4nstarQ1nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3462 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))
3463 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
3464 / (dMult*(dMult-1.)*(dMult-2.));
3465 three6n3n3n = (reQ6nQ3nstarQ3nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3466 - (pow(dReQ6n,2.)+pow(dImQ6n,2.))+2.*dMult)
3467 / (dMult*(dMult-1.)*(dMult-2.));
3468 three6n4n2n = (reQ6nQ4nstarQ2nstar-(pow(dReQ6n,2.)+pow(dImQ6n,2.))
3469 - (pow(dReQ4n,2.)+pow(dImQ4n,2.))
3470 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)
3471 / (dMult*(dMult-1.)*(dMult-2.));
3472 three6n5n1n = (reQ6nQ5nstarQ1nstar-(pow(dReQ6n,2.)+pow(dImQ6n,2.))
3473 - (pow(dReQ5n,2.)+pow(dImQ5n,2.))
3474 - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)
3475 / (dMult*(dMult-1.)*(dMult-2.));
3476 // Average 3-particle correlations for all events:
3477 fIntFlowCorrelationsAllPro->Fill(36.5,three5n3n2n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(5*phi1-3*phi2-2*phi3)>>
3478 fIntFlowCorrelationsAllPro->Fill(37.5,three5n4n1n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(5*phi1-4*phi2-1*phi3)>>
3479 fIntFlowCorrelationsAllPro->Fill(38.5,three6n3n3n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-3*phi2-3*phi3)>>
3480 fIntFlowCorrelationsAllPro->Fill(39.5,three6n4n2n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-4*phi2-2*phi3)>>
3481 fIntFlowCorrelationsAllPro->Fill(40.5,three6n5n1n,dMult*(dMult-1.)*(dMult-2.)); // <<cos(n(6*phi1-5*phi2-1*phi3)>>
3482 if(fCalculateAllCorrelationsVsM)
3483 {
3484 fIntFlowCorrelationsAllVsMPro[36]->Fill(dMult+0.5,three5n3n2n,dMult*(dMult-1.)*(dMult-2.));
3485 fIntFlowCorrelationsAllVsMPro[37]->Fill(dMult+0.5,three5n4n1n,dMult*(dMult-1.)*(dMult-2.));
3486 fIntFlowCorrelationsAllVsMPro[38]->Fill(dMult+0.5,three6n3n3n,dMult*(dMult-1.)*(dMult-2.));
3487 fIntFlowCorrelationsAllVsMPro[39]->Fill(dMult+0.5,three6n4n2n,dMult*(dMult-1.)*(dMult-2.));
3488 fIntFlowCorrelationsAllVsMPro[40]->Fill(dMult+0.5,three6n5n1n,dMult*(dMult-1.)*(dMult-2.));
3489 }
3490 } // end of if(dMult>2)
3491
3492 // 4-particle:
3493 Double_t four6n3n2n1n = 0.; // <cos(n(6*phi1-3*phi2-2*phi3-1*phi4)>
3494 Double_t four3n2n3n2n = 0.; // <cos(n(3*phi1+2*phi2-3*phi3-2*phi4)>
3495 Double_t four4n1n3n2n = 0.; // <cos(n(4*phi1+1*phi2-3*phi3-2*phi4)>
3496 Double_t four3n3n3n3n = 0.; // <cos(3n(phi1+phi2-phi3-phi4))>
3497 //Double_t four4n2n3n3n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-3*phi4)> // I already have this one above
3498 Double_t four5n1n3n3n = 0.; // <cos(n(5*phi1+1*phi2-3*phi3-3*phi4)>
3499 Double_t four4n2n4n2n = 0.; // <cos(n(4*phi1+2*phi2-4*phi3-2*phi4)>
3500 Double_t four5n1n4n2n = 0.; // <cos(n(5*phi1+1*phi2-4*phi3-2*phi4)>
3501 Double_t four5n3n1n1n = 0.; // <cos(n(5*phi1-3*phi2-1*phi3-1*phi4)>
3502 Double_t four5n2n2n1n = 0.; // <cos(n(5*phi1-2*phi2-2*phi3-1*phi4)>
403e3389 3503 Double_t four5n1n5n1n = 0.; // <cos(n(5*phi1+1*phi2-5*phi3-1*phi4)>
3504 Double_t four6n4n1n1n = 0.; // <cos(n(6*phi1-4*phi2-1*phi3-1*phi4)>
3505 Double_t four6n2n2n2n = 0.; // <cos(n(6*phi1-2*phi2-2*phi3-2*phi4)>
b84464d3 3506 if(dMult>3)
3507 {
3508 four6n3n2n1n = (reQ6nQ3nstarQ2nstarQ1nstar-reQ6nQ4nstarQ2nstar-reQ6nQ3nstarQ3nstar-reQ6nQ5nstarQ1nstar
3509 - reQ5nQ3nstarQ2nstar-reQ4nQ3nstarQ1nstar-reQ3nQ2nstarQ1nstar
3510 + 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+pow(dReQ5n,2.)+pow(dImQ5n,2.)
3511 + pow(dReQ4n,2.)+pow(dImQ4n,2.)+3.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3512 + 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3513 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3514 four3n2n3n2n = (dQ3nQ2nQ3nstarQ2nstar-2.*reQ5nQ3nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar
3515 + pow(dReQ5n,2.)+pow(dImQ5n,2.)+pow(dReQ1n,2.)+pow(dImQ1n,2.)
3516 -(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.)+pow(dReQ2n,2.)+pow(dImQ2n,2.))
3517 + dMult*(dMult-6.))
3518 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3519 four4n1n3n2n = (reQ4nQ1nQ3nstarQ2nstar-reQ5nQ3nstarQ2nstar-reQ5nQ4nstarQ1nstar-reQ4nQ3nstarQ1nstar
3520 - reQ4nQ2nstarQ2nstar-reQ3nQ2nstarQ1nstar-reQ2nQ1nstarQ1nstar
3521 + pow(dReQ5n,2.)+pow(dImQ5n,2.)+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3522 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3523 + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3524 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3525 four3n3n3n3n = (2.*dMult*(dMult-3.)+pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ3n,2.)
3526 + pow(dImQ3n,2.))-2.*reQ6nQ3nstarQ3nstar+(pow(dReQ6n,2.)+pow(dImQ6n,2.)))
3527 / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));
3528 //four4n2n3n3n = ; // I already have this one above
3529 four5n1n3n3n = (reQ5nQ1nQ3nstarQ3nstar-reQ6nQ5nstarQ1nstar-reQ6nQ3nstarQ3nstar-2.*reQ5nQ3nstarQ2nstar
3530 - 2.*reQ3nQ2nstarQ1nstar+pow(dReQ6n,2.)+pow(dImQ6n,2.)+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3531 + 4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3532 + 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3533 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3534 four4n2n4n2n = (dQ4nQ2nQ4nstarQ2nstar-2.*reQ6nQ4nstarQ2nstar-2.*reQ4nQ2nstarQ2nstar)
3535 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3536 - ((dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3537 + (dMult-4.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-(pow(dReQ6n,2.)+pow(dImQ6n,2.)))
3538 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))
3539 + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));
3540 four5n1n4n2n = (reQ5nQ1nQ4nstarQ2nstar-reQ6nQ5nstarQ1nstar-reQ6nQ4nstarQ2nstar-reQ5nQ4nstarQ1nstar
3541 - reQ5nQ3nstarQ2nstar-reQ4nQ3nstarQ1nstar-reQ2nQ1nstarQ1nstar+pow(dReQ6n,2.)+pow(dImQ6n,2.)
3542 + 2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3543 + pow(dReQ3n,2.)+pow(dImQ3n,2.)+2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3544 + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3545 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3546 four5n3n1n1n = (reQ5nQ3nstarQ1nstarQ1nstar-2.*reQ5nQ4nstarQ1nstar-reQ5nQ3nstarQ2nstar-2.*reQ4nQ3nstarQ1nstar
3547 - reQ2nQ1nstarQ1nstar+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3548 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+pow(dReQ2n,2.)+pow(dImQ2n,2.)
3549 + 4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3550 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3551 four5n2n2n1n = (reQ5nQ2nstarQ2nstarQ1nstar-reQ5nQ4nstarQ1nstar-2.*reQ5nQ3nstarQ2nstar-reQ4nQ2nstarQ2nstar
3552 - 2.*reQ3nQ2nstarQ1nstar+2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))+pow(dReQ4n,2.)+pow(dImQ4n,2.)
3553 + 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3554 + 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)
3555 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3556 four5n1n5n1n = (dQ5nQ1nQ5nstarQ1nstar-2.*reQ6nQ5nstarQ1nstar-2.*reQ5nQ4nstarQ1nstar
3557 + pow(dReQ6n,2.)+pow(dImQ6n,2.)-(dMult-4.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3558 + pow(dReQ4n,2.)+pow(dImQ4n,2.)-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+dMult*(dMult-6.))
53884472 3559 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3560
3561 // TBI: Recursive formula needed:
403e3389 3562 four6n4n1n1n = (reQ6nQ4nstarQ1nstarQ1nstar
3563 - dMult*(dMult-1.)*(dMult-2.)*(three2n1n1n+2.*three5n4n1n+2.*three6n5n1n+three6n4n2n)
3564 - dMult*(dMult-1.)*(2.*two1n1n+1.*two4n4n+1.*two6n6n+1.*two2n2n+2.*two5n5n)
3565 - 1.*dMult)
3566 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
53884472 3567
403e3389 3568 four6n2n2n2n = (reQ6nQ2nstarQ2nstarQ2nstar-3.*reQ6nQ4nstarQ2nstar-3.*reQ4nQ2nstarQ2nstar
3569 + 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+3.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3570 + 6.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-6.*dMult)
3571 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3572 // Average 4-particle correlations for all events:
3573 fIntFlowCorrelationsAllPro->Fill(41.5,four6n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3574 fIntFlowCorrelationsAllPro->Fill(42.5,four3n2n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3575 fIntFlowCorrelationsAllPro->Fill(43.5,four4n1n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3576 fIntFlowCorrelationsAllPro->Fill(44.5,four3n3n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3577 //fIntFlowCorrelationsAllPro->Fill(45.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)); // I already have this one above
3578 fIntFlowCorrelationsAllPro->Fill(46.5,four5n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3579 fIntFlowCorrelationsAllPro->Fill(47.5,four4n2n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3580 fIntFlowCorrelationsAllPro->Fill(48.5,four5n1n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3581 fIntFlowCorrelationsAllPro->Fill(49.5,four5n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3582 fIntFlowCorrelationsAllPro->Fill(50.5,four5n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3583 fIntFlowCorrelationsAllPro->Fill(51.5,four5n1n5n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
403e3389 3584 fIntFlowCorrelationsAllPro->Fill(58.5,four6n4n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3585 fIntFlowCorrelationsAllPro->Fill(59.5,four6n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3586 if(fCalculateAllCorrelationsVsM)
3587 {
3588 fIntFlowCorrelationsAllVsMPro[41]->Fill(dMult+0.5,four6n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3589 fIntFlowCorrelationsAllVsMPro[42]->Fill(dMult+0.5,four3n2n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3590 fIntFlowCorrelationsAllVsMPro[43]->Fill(dMult+0.5,four4n1n3n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3591 fIntFlowCorrelationsAllVsMPro[44]->Fill(dMult+0.5,four3n3n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3592 //fIntFlowCorrelationsAllVsMPro[45]->Fill(dMult+0.5,four4n2n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3593 fIntFlowCorrelationsAllVsMPro[46]->Fill(dMult+0.5,four5n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3594 fIntFlowCorrelationsAllVsMPro[47]->Fill(dMult+0.5,four4n2n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3595 fIntFlowCorrelationsAllVsMPro[48]->Fill(dMult+0.5,four5n1n4n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3596 fIntFlowCorrelationsAllVsMPro[49]->Fill(dMult+0.5,four5n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3597 fIntFlowCorrelationsAllVsMPro[50]->Fill(dMult+0.5,four5n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3598 fIntFlowCorrelationsAllVsMPro[51]->Fill(dMult+0.5,four5n1n5n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
403e3389 3599 fIntFlowCorrelationsAllVsMPro[58]->Fill(dMult+0.5,four6n4n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
3600 fIntFlowCorrelationsAllVsMPro[59]->Fill(dMult+0.5,four6n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));
b84464d3 3601 }
3602 } // end of if(dMult>3)
3603
3604 // 5-particle:
3605 Double_t five3n3n3n2n1n = 0.; // <cos(n(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
3606 Double_t five4n2n3n2n1n = 0.; // <cos(n(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
3607 Double_t five3n2n3n1n1n = 0.; // <cos(n(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
3608 Double_t five3n2n2n2n1n = 0.; // <cos(n(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
3609 Double_t five5n1n3n2n1n = 0.; // <cos(n(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
403e3389 3610 Double_t five6n2n2n1n1n = 0.; // <cos(n(6*phi1-2*phi2-2*phi3-1*phi4-1*phi5)>
3611 Double_t five4n1n1n3n3n = 0.; // <cos(n(4*phi1+1*phi2+1*phi3-3*phi4-3*phi5)>
b84464d3 3612 if(dMult>4)
3613 {
3614 five3n3n3n2n1n = (reQ3nQ3nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ3nstarQ3nstar-reQ4nQ2nQ3nstarQ3nstar
3615 + reQ6nQ5nstarQ1nstar+reQ6nQ4nstarQ2nstar+3.*reQ6nQ3nstarQ3nstar+4.*reQ5nQ3nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar
3616 - 2.*(dMult-6.)*reQ3nQ2nstarQ1nstar-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3617 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3618 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3619 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*(3.*dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3620 - pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)+2.*(dMult-5.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3621 + 2.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3622 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3623 five4n2n3n2n1n = (reQ4nQ2nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ4nstarQ2nstar
3624 - reQ4nQ2nQ3nstarQ3nstar-reQ4nQ1nQ3nstarQ2nstar-reQ4nQ2nstarQ1nstarQ1nstar
3625 - reQ3nQ1nQ2nstarQ2nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3626 + 3.*reQ6nQ4nstarQ2nstar+reQ6nQ5nstarQ1nstar+reQ6nQ3nstarQ3nstar+reQ5nQ4nstarQ1nstar
3627 + 3.*reQ5nQ3nstarQ2nstar-(dMult-7.)*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+7.*reQ3nQ2nstarQ1nstar
3628 + 4.*reQ2nQ1nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3629 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3630 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3631 + (dMult-8.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+(dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3632 + 2.*(dMult-7.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+(dMult-12.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3633 - 2.*dMult*(dMult-12.))
3634 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3635 five3n2n3n1n1n = (reQ3nQ2nQ3nstarQ1nstarQ1nstar-reQ5nQ3nstarQ1nstarQ1nstar-2.*reQ4nQ1nQ3nstarQ2nstar-reQ3nQ1nstarQ1nstarQ1nstar
3636 - 2.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ5nQ4nstarQ1nstar+3.*reQ5nQ3nstarQ2nstar+6.*reQ4nQ3nstarQ1nstar
3637 + 2.*reQ4nQ2nstarQ2nstar+9.*reQ3nQ2nstarQ1nstar-(dMult-8.)*reQ2nQ1nstarQ1nstar
3638 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3639 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3640 - 2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))-4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))
3641 + 2.*(dMult-6.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+(dMult-12.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3642 + 2.*(dMult-9.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-2.*dMult*(dMult-12.))
3643 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3644 five3n2n2n2n1n = (reQ3nQ2nQ2nstarQ2nstarQ1nstar-reQ5nQ2nstarQ2nstarQ1nstar-reQ4nQ1nQ3nstarQ2nstar-reQ3nQ1nQ2nstarQ2nstar
3645 - 2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+reQ5nQ4nstarQ1nstar
3646 + 4.*reQ5nQ3nstarQ2nstar+reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar-2.*(dMult-6.)*reQ3nQ2nstarQ1nstar
3647 + 4.*reQ2nQ1nstarQ1nstar-2.*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3648 - 2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3649 - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3650 - pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3651 + 2.*(dMult-6.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-4.*dMult*(dMult-6.))
3652 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3653 five5n1n3n2n1n = (reQ5nQ1nQ3nstarQ2nstarQ1nstar-reQ6nQ3nstarQ2nstarQ1nstar-reQ5nQ1nQ4nstarQ2nstar-reQ5nQ1nQ3nstarQ3nstar
3654 - reQ4nQ1nQ3nstarQ2nstar-reQ5nQ3nstarQ1nstarQ1nstar-reQ5nQ2nstarQ2nstarQ1nstar
3655 + 3.*reQ6nQ5nstarQ1nstar+reQ6nQ4nstarQ2nstar+reQ6nQ3nstarQ3nstar+4.*reQ5nQ4nstarQ1nstar
3656 - (dMult-7.)*reQ5nQ3nstarQ2nstar+4.*reQ4nQ3nstarQ1nstar+reQ4nQ2nstarQ2nstar+6.*reQ3nQ2nstarQ1nstar
3657 + 3.*reQ2nQ1nstarQ1nstar-(pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3658 - (pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3659 - (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3660 - 2.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))+(dMult-8.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3661 - 4.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+(dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3662 + (dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*(dMult-7.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3663 - 2.*dMult*(dMult-12.))
3664 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
53884472 3665
3666 // Peter Jochumzsen:
3667 five6n2n2n1n1n = (reQ6nQ2nstarQ2nstarQ1nstarQ1nstar
3668 - 12.*pow(dReQ1n,2.)-12.*pow(dImQ1n,2.)
3669 - 14.*pow(dReQ2n,2.)-14.*pow(dImQ2n,2.)
3670 - 8.*pow(dReQ3n,2.)-8.*pow(dImQ3n,2.)
3671 - 6.*pow(dReQ4n,2.)-6.*pow(dImQ4n,2.)
3672 - 4.*pow(dReQ5n,2.)-4.*pow(dImQ5n,2.)
3673 - 6.*pow(dReQ6n,2.)-6.*pow(dImQ6n,2.)
3674 + 2.*reQ2nQ1nstarQ1nstar + 8.*reQ3nQ2nstarQ1nstar
3675 + 5.*reQ6nQ4nstarQ2nstar - reQ6nQ4nstarQ1nstarQ1nstar
3676 + 2.*reQ6nQ3nstarQ3nstar - reQ6nQ2nstarQ2nstarQ2nstar
3677 + 4.*reQ4nQ2nstarQ2nstar - 2.*reQ4nQ2nstarQ1nstarQ1nstar
3678 + 2.*reQ5nQ4nstarQ1nstar - 2.*reQ5nQ2nstarQ2nstarQ1nstar
3679 + 4.*reQ4nQ3nstarQ1nstar + 4.*reQ5nQ3nstarQ2nstar
3680 + 4.*reQ6nQ5nstarQ1nstar - 4.*reQ6nQ3nstarQ2nstarQ1nstar + 24.*dMult)
3681 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3682
53884472 3683 // Peter Jochumzsen:
3684 /*
3685 five4n1n1n3n3n = (reQ6nQ2nstarQ2nstarQ1nstarQ1nstar
3686 - 12.*pow(dReQ1n,2.)-12.*pow(dImQ1n,2.)
3687 - 14.*pow(dReQ2n,2.)-14.*pow(dImQ2n,2.)
3688 - 8.*pow(dReQ3n,2.)-8.*pow(dImQ3n,2.)
3689 - 6.*pow(dReQ4n,2.)-6.*pow(dImQ4n,2.)
3690 - 4.*pow(dReQ5n,2.)-4.*pow(dImQ5n,2.)
3691 - 6.*pow(dReQ6n,2.)-6.*pow(dImQ6n,2.)
3692 + 2.*reQ2nQ1nstarQ1nstar + 8.*reQ3nQ2nstarQ1nstar
3693 + 5.*reQ6nQ4nstarQ2nstar - reQ6nQ4nstarQ1nstarQ1nstar
3694 + 2.*reQ6nQ3nstarQ3nstar - reQ6nQ2nstarQ2nstarQ2nstar
3695 + 4.*reQ4nQ2nstarQ2nstar - 2.*reQ4nQ2nstarQ1nstarQ1nstar
3696 + 2.*reQ5nQ4nstarQ1nstar - 2.*reQ5nQ2nstarQ2nstarQ1nstar
3697 + 4.*reQ4nQ3nstarQ1nstar + 4.*reQ5nQ3nstarQ2nstar
3698 + 4.*reQ6nQ5nstarQ1nstar - 4.*reQ6nQ3nstarQ2nstarQ1nstar + 24.*dMult)
3699 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3700 */
403e3389 3701
b84464d3 3702 // Average 5-particle correlations for all events:
3703 fIntFlowCorrelationsAllPro->Fill(52.5,five3n3n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3704 fIntFlowCorrelationsAllPro->Fill(53.5,five4n2n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3705 fIntFlowCorrelationsAllPro->Fill(54.5,five3n2n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3706 fIntFlowCorrelationsAllPro->Fill(55.5,five3n2n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3707 fIntFlowCorrelationsAllPro->Fill(56.5,five5n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3708 fIntFlowCorrelationsAllPro->Fill(60.5,five6n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3709 fIntFlowCorrelationsAllPro->Fill(61.5,five4n1n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3710 if(fCalculateAllCorrelationsVsM)
3711 {
3712 fIntFlowCorrelationsAllVsMPro[52]->Fill(dMult+0.5,five3n3n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3713 fIntFlowCorrelationsAllVsMPro[53]->Fill(dMult+0.5,five4n2n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3714 fIntFlowCorrelationsAllVsMPro[54]->Fill(dMult+0.5,five3n2n3n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3715 fIntFlowCorrelationsAllVsMPro[55]->Fill(dMult+0.5,five3n2n2n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3716 fIntFlowCorrelationsAllVsMPro[56]->Fill(dMult+0.5,five5n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
403e3389 3717 fIntFlowCorrelationsAllVsMPro[60]->Fill(dMult+0.5,five6n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
3718 fIntFlowCorrelationsAllVsMPro[61]->Fill(dMult+0.5,five4n1n1n3n3n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));
b84464d3 3719 }
3720 } // end of if(dMult>4)
3721
3722 // 6-particle:
3723 Double_t six3n2n1n3n2n1n = 0.; // <cos(n(3*phi1+2*phi2+1*phi3-3*phi4-2*phi5-1*phi6)>
403e3389 3724 Double_t six3n3n2n2n1n1n = 0.; // <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-1*phi5-1*phi6)>
b84464d3 3725 if(dMult>5.)
3726 {
3727 six3n2n1n3n2n1n = (dQ3nQ2nQ1nQ3nstarQ2nstarQ1nstar-2.*reQ3nQ3nQ3nstarQ2nstarQ1nstar
3728 - 2.*reQ3nQ2nQ2nstarQ2nstarQ1nstar-2.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3729 - 2.*reQ3nQ2nQ3nstarQ1nstarQ1nstar-2.*reQ4nQ2nQ3nstarQ2nstarQ1nstar
3730 - 2.*reQ5nQ1nQ3nstarQ2nstarQ1nstar+4.*reQ6nQ3nstarQ2nstarQ1nstar
3731 + 2.*reQ5nQ1nQ4nstarQ2nstar+2.*reQ5nQ1nQ3nstarQ3nstar
3732 + 2.*reQ4nQ2nQ3nstarQ3nstar+6.*reQ4nQ1nQ3nstarQ2nstar
3733 + 2.*reQ5nQ3nstarQ1nstarQ1nstar+2.*reQ5nQ2nstarQ2nstarQ1nstar
3734 + 6.*reQ3nQ1nQ2nstarQ2nstar+2.*reQ4nQ2nstarQ1nstarQ1nstar
3735 - 4.*reQ6nQ5nstarQ1nstar-4.*reQ6nQ4nstarQ2nstar-6.*reQ5nQ4nstarQ1nstar
3736 - 4.*reQ6nQ3nstarQ3nstar+2.*(dMult-11.)*reQ5nQ3nstarQ2nstar
3737 + 2.*(dMult-13.)*reQ4nQ3nstarQ1nstar-8.*reQ4nQ2nstarQ2nstar
3738 + 2.*(5.*dMult-32.)*reQ3nQ2nstarQ1nstar+2.*reQ3nQ1nstarQ1nstarQ1nstar
3739 + 2.*(dMult-13.)*reQ2nQ1nstarQ1nstar
3740 - (dMult-10.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3741 + (pow(dReQ5n,2.)+pow(dImQ5n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3742 + (pow(dReQ4n,2.)+pow(dImQ4n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3743 - (dMult-11.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3744 - (dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3745 + 4.*(pow(dReQ6n,2.)+pow(dImQ6n,2.))-(dMult-12.)*(pow(dReQ5n,2.)+pow(dImQ5n,2.))
3746 - (dMult-16.)*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+pow((pow(dReQ3n,2.)+pow(dImQ3n,2.)),2.)
3747 + (dMult*dMult-19.*dMult+68.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))
3748 + (dMult*dMult-19.*dMult+72.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))
3749 + pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)
3750 + (dMult*dMult-20.*dMult+80.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))
3751 - dMult*(dMult-12.)*(dMult-10.))
3752 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
53884472 3753
3754 // Peter Jochumzsen:
3755 six3n3n2n2n1n1n = (reQ3nQ3nQ2nstarQ2nstarQ1nstarQ1nstar
3756 + (80.-16.*dMult)*pow(dReQ1n,2.)+(80.-16.*dMult)*pow(dImQ1n,2.)
3757 + (78.-16.*dMult)*pow(dReQ2n,2.)+(78.-16.*dMult)*pow(dImQ2n,2.)
3758 + (72.-16.*dMult)*pow(dReQ3n,2.)+(72.-16.*dMult)*pow(dImQ3n,2.)
3759 + 14.*pow(dReQ4n,2.)+14.*pow(dImQ4n,2.)
3760 + 8.*pow(dReQ5n,2.)+8.*pow(dImQ5n,2.)
3761 + 6.*pow(dReQ6n,2.)+6.*pow(dImQ6n,2.)
3762 + 1.*reQ6nQ2nstarQ2nstarQ2nstar - 1.*reQ6nQ2nstarQ2nstarQ1nstarQ1nstar
3763 - 76.*reQ3nQ2nstarQ1nstar + 4.*reQ3nQ1nstarQ1nstarQ1nstar
3764 - 8.*reQ3nQ2nstarQ1nstar + 8.*dQ2nQ1nQ2nstarQ1nstar
3765 + 4.*reQ5nQ2nstarQ2nstarQ1nstar - 2.*reQ6nQ3nstarQ3nstar
3766 + 4.*reQ6nQ3nstarQ2nstarQ1nstar - 4.*reQ5nQ4nstarQ1nstar
3767 + 16.*dMult*reQ3nQ2nstarQ1nstar - 2.*reQ4nQ2nstarQ2nstar
3768 - 4.*reQ3nQ3nQ3nstarQ2nstarQ1nstar -8.*reQ4nQ3nstarQ1nstar
3769 - 10.*reQ4nQ2nstarQ2nstar + 4.*reQ4nQ2nstarQ1nstarQ1nstar
3770 - 12.*reQ4nQ3nstarQ1nstar + 8.*dQ3nQ1nQ3nstarQ1nstar
3771 + 8.*reQ3nQ1nQ2nstarQ2nstar - 4.*reQ3nQ1nQ2nstarQ1nstarQ1nstar
3772 + 5.*reQ4nQ2nQ3nstarQ3nstar+2.*pow(pow(dReQ2n,2.)+pow(dImQ2n,2.),2.)
3773 + 4.*reQ5nQ1nQ3nstarQ3nstar+2.*pow(pow(dReQ3n,2.)+pow(dImQ3n,2.),2.)
3774 - 6.*reQ6nQ3nstarQ3nstar - 14.*reQ2nQ1nstarQ1nstar
3775 - 1.*reQ3nQ3nQ2nstarQ2nstarQ2nstar-4.*reQ3nQ2nQ2nstarQ2nstarQ1nstar
3776 - 1.*reQ4nQ1nQ1nQ3nstarQ3nstar-8.*reQ5nQ3nstarQ2nstar
3777 + 2.*pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),2.) - 10.*reQ2nQ1nstarQ1nstar
3778 - 4.*reQ6nQ5nstarQ1nstar-5.*reQ6nQ4nstarQ2nstar
3779 + 1.*reQ6nQ4nstarQ1nstarQ1nstar-8.*reQ5nQ3nstarQ2nstar
3780 + 4.*reQ4nQ1nQ3nstarQ2nstar+8.*dQ3nQ2nQ3nstarQ2nstar
3781 - 120.*dMult + 16.*dMult*dMult)
3782 / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3783
b84464d3 3784 // Average 6-particle correlations for all events:
3785 fIntFlowCorrelationsAllPro->Fill(57.5,six3n2n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3786 fIntFlowCorrelationsAllPro->Fill(62.5,six3n3n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3787 if(fCalculateAllCorrelationsVsM)
3788 {
3789 fIntFlowCorrelationsAllVsMPro[57]->Fill(dMult+0.5,six3n2n1n3n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
403e3389 3790 fIntFlowCorrelationsAllVsMPro[62]->Fill(dMult+0.5,six3n3n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));
b84464d3 3791 }
3792 } // end of if(dMult>5.)
3793
489d5531 3794} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()
3795
489d5531 3796//================================================================================================================================
3797
e5834fcb 3798void AliFlowAnalysisWithQCumulants::StorePhiDistributionForOneEvent(AliFlowEventSimple *anEvent)
3799{
3800 // Store phi distribution for one event to illustrate flow.
3801
3802 if(fPhiDistributionForOneEvent->GetEntries()>0){return;} // store only phi distribution for one event
3803
3804 Double_t vMin = fPhiDistributionForOneEventSettings[0];
3805 Double_t vMax = fPhiDistributionForOneEventSettings[1];
3806 Double_t refMultMin = fPhiDistributionForOneEventSettings[2];
3807 Double_t refMultMax = fPhiDistributionForOneEventSettings[3];
3808
3809 Double_t vEBE = 0.;
3810 Double_t cumulant4thEBE = fIntFlowCorrelationsEBE->GetBinContent(2)-2.*pow(fIntFlowCorrelationsEBE->GetBinContent(1),2.);
3811 if(cumulant4thEBE<0.)
3812 {
3813 vEBE = pow(-1.*cumulant4thEBE,0.25);
3814 if((vEBE>vMin && vEBE<vMax) && (fReferenceMultiplicityEBE>refMultMin && fReferenceMultiplicityEBE<refMultMax))
3815 {
3958eee6 3816 fPhiDistributionForOneEvent->SetTitle(Form("v_{%i} = %f",fHarmonic,vEBE));
e5834fcb 3817 for(Int_t p=0;p<anEvent->NumberOfTracks();p++)
3818 {
3819 if(anEvent->GetTrack(p)->InRPSelection())
3820 {
3821 fPhiDistributionForOneEvent->Fill(anEvent->GetTrack(p)->Phi());
3822 }
3823 } // end of for(Int_t p=0;p<anEvent->NumberOfTracks();p++)
3958eee6 3824 } else
3825 {
3826 fPhiDistributionForOneEvent->SetTitle(Form("v_{%i} = %f, out of specified boundaries",fHarmonic,vEBE));
3827 }
3828
e5834fcb 3829 } // end of if(cumulant4thEBE<0.)
3830
3831} // end of void AliFlowAnalysisWithQCumulants::StorePhiDistributionForOneEvent(AliFlowEventSimple *anEvent)
3832
3833//================================================================================================================================
489d5531 3834
3835void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()
3836{
0328db2d 3837 // Calculate averages of products of correlations for integrated flow.
489d5531 3838
2001bc3a 3839 // multiplicity:
1268c371 3840 Double_t dMult = (*fSpk)(0,0);
2001bc3a 3841
489d5531 3842 Int_t counter = 0;
3843
3844 for(Int_t ci1=1;ci1<4;ci1++)
3845 {
3846 for(Int_t ci2=ci1+1;ci2<=4;ci2++)
3847 {
ff70ca91 3848 fIntFlowProductOfCorrelationsPro->Fill(0.5+counter,
3849 fIntFlowCorrelationsEBE->GetBinContent(ci1)*
3850 fIntFlowCorrelationsEBE->GetBinContent(ci2),
3851 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
3852 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
3853 // products versus multiplicity: // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 3854 if(fCalculateCumulantsVsM)
3855 {
3856 fIntFlowProductOfCorrelationsVsMPro[counter]->Fill(dMult+0.5, // to be improved: dMult => sum of weights ?
3857 fIntFlowCorrelationsEBE->GetBinContent(ci1)*
3858 fIntFlowCorrelationsEBE->GetBinContent(ci2),
3859 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
3860 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
3861 } // end of if(fCalculateCumulantsVsM)
ff70ca91 3862 counter++;
489d5531 3863 }
3864 }
3865
3866} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()
3867
3868
3869//================================================================================================================================
3870
3871
0328db2d 3872void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrectionTermsForNUA()
3873{
3874 // Calculate averages of products of correction terms for NUA.
3875
3876 // a) Binning of fIntFlowProductOfCorrectionTermsForNUAPro is organized as follows:
3877 // 1st bin: <<2><cos(phi)>>
3878 // 2nd bin: <<2><sin(phi)>>
3879 // 3rd bin: <<cos(phi)><sin(phi)>>
3880 // 4th bin: <<2><cos(phi1+phi2)>>
3881 // 5th bin: <<2><sin(phi1+phi2)>>
3882 // 6th bin: <<2><cos(phi1-phi2-phi3)>>
3883 // 7th bin: <<2><sin(phi1-phi2-phi3)>>
3884 // 8th bin: <<4><cos(phi1)>>
3885 // 9th bin: <<4><sin(phi1)>>
3886 // 10th bin: <<4><cos(phi1+phi2)>>
3887 // 11th bin: <<4><sin(phi1+phi2)>>
3888 // 12th bin: <<4><cos(phi1-phi2-phi3)>>
3889 // 13th bin: <<4><sin(phi1-phi2-phi3)>>
3890 // 14th bin: <<cos(phi1)><cos(phi1+phi2)>>
3891 // 15th bin: <<cos(phi1)><sin(phi1+phi2)>>
3892 // 16th bin: <<cos(phi1)><cos(phi1-phi2-phi3)>>
3893 // 17th bin: <<cos(phi1)><sin(phi1-phi2-phi3)>>
3894 // 18th bin: <<sin(phi1)><cos(phi1+phi2)>>
3895 // 19th bin: <<sin(phi1)><sin(phi1+phi2)>>
3896 // 20th bin: <<sin(phi1)><cos(phi1-phi2-phi3)>>
3897 // 21st bin: <<sin(phi1)><sin(phi1-phi2-phi3)>>
3898 // 22nd bin: <<cos(phi1+phi2)><sin(phi1+phi2)>>
3899 // 23rd bin: <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>
3900 // 24th bin: <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>
3901 // 25th bin: <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>
3902 // 26th bin: <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>
3903 // 27th bin: <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>
3904
3905 // <<2><cos(phi)>>:
3906 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(0.5,
3907 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1),
3908 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3909 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
3910 // <<2><sin(phi)>>:
3911 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(1.5,
3912 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3913 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3914 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3915 // <<cos(phi)><sin(phi)>>:
3916 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(2.5,
3917 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3918 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3919 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3920 // <<2><cos(phi1+phi2)>>:
3921 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(3.5,
3922 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3923 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3924 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3925 // <<2><sin(phi1+phi2)>>:
3926 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(4.5,
3927 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3928 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3929 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3930 // <<2><cos(phi1-phi2-phi3)>>:
3931 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(5.5,
3932 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3933 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3934 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3935 // <<2><sin(phi1-phi2-phi3)>>:
3936 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(6.5,
3937 fIntFlowCorrelationsEBE->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3938 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)
3939 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3940 // <<4><cos(phi1)>>:
3941 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(7.5,
3942 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1),
3943 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3944 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
3945 // <<4><sin(phi1)>>:
3946 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(8.5,
3947 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1),
3948 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3949 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
3950 // <<4><cos(phi1+phi2)>>:
3951 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(9.5,
3952 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3953 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3954 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3955 // <<4><sin(phi1+phi2)>>:
3956 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(10.5,
3957 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3958 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3959 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3960 // <<4><cos(phi1-phi2-phi3)>>:
3961 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(11.5,
3962 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3963 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3964 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3965 // <<4><sin(phi1-phi2-phi3)>>:
3966 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(12.5,
3967 fIntFlowCorrelationsEBE->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3968 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)
3969 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3970 // <<cos(phi1)><cos(phi1+phi2)>>:
3971 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(13.5,
3972 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3973 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3974 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3975 // <<cos(phi1)><sin(phi1+phi2)>>:
3976 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(14.5,
3977 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3978 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3979 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
3980 // <<cos(phi1)><cos(phi1-phi2-phi3)>>:
3981 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(15.5,
3982 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
3983 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3984 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
3985 // <<cos(phi1)><sin(phi1-phi2-phi3)>>:
3986 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(16.5,
3987 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
3988 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)
3989 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
3990 // <<sin(phi1)><cos(phi1+phi2)>>:
3991 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(17.5,
3992 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2),
3993 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3994 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
3995 // <<sin(phi1)><sin(phi1+phi2)>>:
3996 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(18.5,
3997 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
3998 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
3999 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
4000 // <<sin(phi1)><cos(phi1-phi2-phi3)>>:
4001 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(19.5,
4002 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
4003 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
4004 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
4005 // <<sin(phi1)><sin(phi1-phi2-phi3)>>:
4006 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(20.5,
4007 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(1)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
4008 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)
4009 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
4010 // <<cos(phi1+phi2)><sin(phi1+phi2)>>:
4011 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(21.5,
4012 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2),
4013 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
4014 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
4015 // <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>:
4016 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(22.5,
4017 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
4018 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
4019 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
4020 // <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>:
4021 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(23.5,
4022 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
4023 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)
4024 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
4025 // <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>:
4026 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(24.5,
4027 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3),
4028 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)
4029 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
4030 // <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>:
4031 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(25.5,
4032 fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(2)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
4033 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)
4034 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
4035 // <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>:
4036 fIntFlowProductOfCorrectionTermsForNUAPro->Fill(26.5,
4037 fIntFlowCorrectionTermsForNUAEBE[1]->GetBinContent(3)*fIntFlowCorrectionTermsForNUAEBE[0]->GetBinContent(3),
4038 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3)
4039 *fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
4040
4041} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrectionTermsForNUA()
4042
0328db2d 4043//================================================================================================================================
4044
489d5531 4045void AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()
4046{
4047 // a) Calculate unbiased estimators Cov(<2>,<4>), Cov(<2>,<6>), Cov(<2>,<8>), Cov(<4>,<6>), Cov(<4>,<8>) and Cov(<6>,<8>)
4048 // for covariances V_(<2>,<4>), V_(<2>,<6>), V_(<2>,<8>), V_(<4>,<6>), V_(<4>,<8>) and V_(<6>,<8>).
4049 // b) Store in histogram fIntFlowCovariances for instance the following:
4050 //
4051 // 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)]
4052 //
4053 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<4>} is event weight for <4>.
4054 // c) Binning of fIntFlowCovariances is organized as follows:
4055 //
4056 // 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)]
4057 // 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)]
4058 // 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)]
4059 // 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)]
4060 // 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)]
4061 // 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 4062 //
489d5531 4063
b3dacf6b 4064 // Average 2-, 4-, 6- and 8-particle correlations for all events:
489d5531 4065 Double_t correlation[4] = {0.};
4066 for(Int_t ci=0;ci<4;ci++)
4067 {
4068 correlation[ci] = fIntFlowCorrelationsPro->GetBinContent(ci+1);
4069 }
b3dacf6b 4070 // Average products of 2-, 4-, 6- and 8-particle correlations:
489d5531 4071 Double_t productOfCorrelations[4][4] = {{0.}};
4072 Int_t productOfCorrelationsLabel = 1;
b3dacf6b 4073 // Denominators in the expressions for the unbiased estimator for covariance:
489d5531 4074 Double_t denominator[4][4] = {{0.}};
4075 Int_t sumOfProductOfEventWeightsLabel1 = 1;
b3dacf6b 4076 // Weight dependent prefactor which multiply unbiased estimators for covariances:
489d5531 4077 Double_t wPrefactor[4][4] = {{0.}};
4078 Int_t sumOfProductOfEventWeightsLabel2 = 1;
4079 for(Int_t c1=0;c1<4;c1++)
4080 {
4081 for(Int_t c2=c1+1;c2<4;c2++)
4082 {
4083 productOfCorrelations[c1][c2] = fIntFlowProductOfCorrelationsPro->GetBinContent(productOfCorrelationsLabel);
b3dacf6b 4084 if(TMath::Abs(fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)) > 1.e-44 && TMath::Abs(fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1)) > 1.e-44)
4085 {
4086 denominator[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel1))
4087 / (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)
4088 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));
4089 wPrefactor[c1][c2] = fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel2)
4090 / (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)
4091 * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));
489d5531 4092 }
b3dacf6b 4093 productOfCorrelationsLabel++; // to be improved - do I need here all 3 counters?
489d5531 4094 sumOfProductOfEventWeightsLabel1++;
4095 sumOfProductOfEventWeightsLabel2++;
b3dacf6b 4096 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4097 } // end of for(Int_t c1=0;c1<4;c1++)
489d5531 4098
489d5531 4099 Int_t covarianceLabel = 1;
4100 for(Int_t c1=0;c1<4;c1++)
4101 {
4102 for(Int_t c2=c1+1;c2<4;c2++)
4103 {
b3dacf6b 4104 if(TMath::Abs(denominator[c1][c2]) > 1.e-44)
489d5531 4105 {
b3dacf6b 4106 // Covariances:
489d5531 4107 Double_t cov = (productOfCorrelations[c1][c2]-correlation[c1]*correlation[c2])/denominator[c1][c2];
b3dacf6b 4108 // Covariances multiplied with weight dependent prefactor:
489d5531 4109 Double_t wCov = cov * wPrefactor[c1][c2];
4110 fIntFlowCovariances->SetBinContent(covarianceLabel,wCov);
4111 }
4112 covarianceLabel++;
b3dacf6b 4113 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4114 } // end of for(Int_t c1=0;c1<4;c1++)
489d5531 4115
b3dacf6b 4116 // Versus multiplicity:
4117 if(!fCalculateCumulantsVsM){return;}
9da1a4f3 4118 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
4119 for(Int_t b=1;b<=nBins;b++)
4120 {
b3dacf6b 4121 // Average 2-, 4-, 6- and 8-particle correlations for all events:
9da1a4f3 4122 Double_t correlationVsM[4] = {0.};
4123 for(Int_t ci=0;ci<4;ci++)
4124 {
4125 correlationVsM[ci] = fIntFlowCorrelationsVsMPro[ci]->GetBinContent(b);
4126 } // end of for(Int_t ci=0;ci<4;ci++)
b3dacf6b 4127 // Average products of 2-, 4-, 6- and 8-particle correlations:
9da1a4f3 4128 Double_t productOfCorrelationsVsM[4][4] = {{0.}};
4129 Int_t productOfCorrelationsLabelVsM = 1;
b3dacf6b 4130 // Denominators in the expressions for the unbiased estimator for covariance:
9da1a4f3 4131 Double_t denominatorVsM[4][4] = {{0.}};
4132 Int_t sumOfProductOfEventWeightsLabel1VsM = 1;
b3dacf6b 4133 // Weight dependent prefactor which multiply unbiased estimators for covariances:
9da1a4f3 4134 Double_t wPrefactorVsM[4][4] = {{0.}};
4135 Int_t sumOfProductOfEventWeightsLabel2VsM = 1;
4136 for(Int_t c1=0;c1<4;c1++)
4137 {
4138 for(Int_t c2=c1+1;c2<4;c2++)
4139 {
4140 productOfCorrelationsVsM[c1][c2] = fIntFlowProductOfCorrelationsVsMPro[productOfCorrelationsLabelVsM-1]->GetBinContent(b);
b3dacf6b 4141 if(TMath::Abs(fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)) > 1.e-44 && TMath::Abs(fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b)) > 1.e-44)
4142 {
4143 denominatorVsM[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeightsVsM[sumOfProductOfEventWeightsLabel1VsM-1]->GetBinContent(b))
4144 / (fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)
4145 * fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b));
4146 wPrefactorVsM[c1][c2] = fIntFlowSumOfProductOfEventWeightsVsM[sumOfProductOfEventWeightsLabel2VsM-1]->GetBinContent(b)
4147 / (fIntFlowSumOfEventWeightsVsM[c1][0]->GetBinContent(b)
4148 * fIntFlowSumOfEventWeightsVsM[c2][0]->GetBinContent(b));
9da1a4f3 4149 }
4150 productOfCorrelationsLabelVsM++;
4151 sumOfProductOfEventWeightsLabel1VsM++;
4152 sumOfProductOfEventWeightsLabel2VsM++;
4153 } // end of for(Int_t c1=0;c1<4;c1++)
4154 } // end of for(Int_t c2=c1+1;c2<4;c2++)
b3dacf6b 4155
9da1a4f3 4156 Int_t covarianceLabelVsM = 1;
4157 for(Int_t c1=0;c1<4;c1++)
4158 {
4159 for(Int_t c2=c1+1;c2<4;c2++)
4160 {
b3dacf6b 4161 if(TMath::Abs(denominatorVsM[c1][c2]) > 1.e-44)
9da1a4f3 4162 {
b3dacf6b 4163 // Covariances:
9da1a4f3 4164 Double_t covVsM = (productOfCorrelationsVsM[c1][c2]-correlationVsM[c1]*correlationVsM[c2])/denominatorVsM[c1][c2];
b3dacf6b 4165 // Covariances multiplied with weight dependent prefactor:
9da1a4f3 4166 Double_t wCovVsM = covVsM * wPrefactorVsM[c1][c2];
4167 fIntFlowCovariancesVsM[covarianceLabelVsM-1]->SetBinContent(b,wCovVsM);
4168 }
4169 covarianceLabelVsM++;
b3dacf6b 4170 } // end of for(Int_t c2=c1+1;c2<4;c2++)
4171 } // end of for(Int_t c1=0;c1<4;c1++)
9da1a4f3 4172 } // end of for(Int_t b=1;b<=nBins;b++)
4173
489d5531 4174} // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()
4175
489d5531 4176//================================================================================================================================
4177
0328db2d 4178void AliFlowAnalysisWithQCumulants::CalculateCovariancesNUAIntFlow()
4179{
4180 // a) Calculate unbiased estimators Cov(*,*) for true covariances V_(*,*) for NUA terms.
4181 // b) Store in histogram fIntFlowCovariancesNUA for instance the following:
4182 //
4183 // 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)]
4184 //
4185 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<cos(phi)>} is event weight for <cos(phi)>.
4186 // c) Binning of fIntFlowCovariancesNUA is organized as follows:
4187 //
4188 // 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)]
4189 // 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)]
4190 // 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)]
4191 // ...
4192
4193 // Cov(<2>,<cos(phi)>):
4194 Double_t product1 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(1); // <<2><cos(phi)>>
4195 Double_t term1st1 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4196 Double_t term2nd1 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi)>>
4197 Double_t sumOfW1st1 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4198 Double_t sumOfW2nd1 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi)>}
4199 Double_t sumOfWW1 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(1); // W_{<2>} * W_{<cos(phi)>}
4200 // numerator in the expression for the the unbiased estimator for covariance:
4201 Double_t numerator1 = product1 - term1st1*term2nd1;
4202 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4203 Double_t denominator1 = 0.;
4204 if(TMath::Abs(sumOfW1st1*sumOfW2nd1)>0.)
4205 {
4206 denominator1 = 1.-sumOfWW1/(sumOfW1st1*sumOfW2nd1);
4207 if(TMath::Abs(denominator1)>0.)
4208 {
4209 // covariance:
4210 Double_t covariance1 = numerator1/denominator1;
4211 // weight dependent prefactor for covariance:
4212 Double_t wPrefactor1 = sumOfWW1/(sumOfW1st1*sumOfW2nd1);
4213 // finally, store "weighted" covariance:
4214 fIntFlowCovariancesNUA->SetBinContent(1,wPrefactor1*covariance1);
4215 } // end of if(TMath::Abs(denominator)>0.)
4216 } // end of if(TMath::Abs(sumOfW1st1*sumOfW2nd1)>0.)
4217
0328db2d 4218 // Cov(<2>,<sin(phi)>):
4219 Double_t product2 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(2); // <<2><sin(phi)>>
4220 Double_t term1st2 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4221 Double_t term2nd2 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi)>>
4222 Double_t sumOfW1st2 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4223 Double_t sumOfW2nd2 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi)>}
4224 Double_t sumOfWW2 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(2); // W_{<2>} * W_{<sin(phi)>}
4225 // numerator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4226 Double_t numerator2 = product2 - term1st2*term2nd2;
0328db2d 4227 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4228 Double_t denominator2 = 0.;
4229 if(TMath::Abs(sumOfW1st2*sumOfW2nd2)>0.)
4230 {
4231 denominator2 = 1.-sumOfWW2/(sumOfW1st2*sumOfW2nd2);
4232 if(TMath::Abs(denominator2)>0.)
4233 {
4234 // covariance:
4235 Double_t covariance2 = numerator2/denominator2;
4236 // weight dependent prefactor for covariance:
4237 Double_t wPrefactor2 = sumOfWW2/(sumOfW1st2*sumOfW2nd2);
4238 // finally, store "weighted" covariance:
4239 fIntFlowCovariancesNUA->SetBinContent(2,wPrefactor2*covariance2);
4240 } // end of if(TMath::Abs(denominator2)>0.)
4241 } // end of if(TMath::Abs(sumOfW1st2*sumOfW2nd2)>0.)
0328db2d 4242
4243 // Cov(<cos(phi)>,<sin(phi)>):
4244 Double_t product3 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(3); // <<cos(phi)><sin(phi)>>
4245 Double_t term1st3 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi)>>
4246 Double_t term2nd3 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi)>>
4247 Double_t sumOfW1st3 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi)>}
4248 Double_t sumOfW2nd3 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi)>}
4249 Double_t sumOfWW3 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(3); // W_{<cos(phi)>} * W_{<sin(phi)>}
4250 // numerator in the expression for the the unbiased estimator for covariance:
4251 Double_t numerator3 = product3 - term1st3*term2nd3;
4252 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4253 Double_t denominator3 = 0;
4254 if(TMath::Abs(sumOfW1st3*sumOfW2nd3)>0.)
4255 {
4256 denominator3 = 1.-sumOfWW3/(sumOfW1st3*sumOfW2nd3);
4257 if(TMath::Abs(denominator3)>0.)
4258 {
4259 // covariance:
4260 Double_t covariance3 = numerator3/denominator3;
4261 // weight dependent prefactor for covariance:
4262 Double_t wPrefactor3 = sumOfWW3/(sumOfW1st3*sumOfW2nd3);
4263 // finally, store "weighted" covariance:
4264 fIntFlowCovariancesNUA->SetBinContent(3,wPrefactor3*covariance3);
4265 } // end of if(TMath::Abs(denominator3)>0.)
4266 } // end of if(TMath::Abs(sumOfW1st3*sumOfW2nd3)>0.)
0328db2d 4267
4268 // Cov(<2>,<cos(phi1+phi2)>):
4269 Double_t product4 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(4); // <<2><cos(phi1+phi2)>>
4270 Double_t term1st4 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4271 Double_t term2nd4 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4272 Double_t sumOfW1st4 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4273 Double_t sumOfW2nd4 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4274 Double_t sumOfWW4 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(4); // W_{<2>} * W_{<cos(phi1+phi2)>}
4275 // numerator in the expression for the the unbiased estimator for covariance:
4276 Double_t numerator4 = product4 - term1st4*term2nd4;
4277 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4278 Double_t denominator4 = 0.;
4279 if(TMath::Abs(sumOfW1st4*sumOfW2nd4)>0.)
4280 {
4281 denominator4 = 1.-sumOfWW4/(sumOfW1st4*sumOfW2nd4);
4282 if(TMath::Abs(denominator4)>0.)
4283 {
4284 // covariance:
4285 Double_t covariance4 = numerator4/denominator4;
4286 // weight dependent prefactor for covariance:
4287 Double_t wPrefactor4 = sumOfWW4/(sumOfW1st4*sumOfW2nd4);
4288 // finally, store "weighted" covariance:
4289 fIntFlowCovariancesNUA->SetBinContent(4,wPrefactor4*covariance4);
4290 } // end of if(TMath::Abs(denominator4)>0.)
4291 } // end of if(TMath::Abs(sumOfW1st4*sumOfW2nd4)>0.)
4292
0328db2d 4293 // Cov(<2>,<sin(phi1+phi2)>):
4294 Double_t product5 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(5); // <<2><sin(phi1+phi2)>>
4295 Double_t term1st5 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4296 Double_t term2nd5 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4297 Double_t sumOfW1st5 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4298 Double_t sumOfW2nd5 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4299 Double_t sumOfWW5 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(5); // W_{<2>} * W_{<sin(phi1+phi2)>}
4300 // numerator in the expression for the the unbiased estimator for covariance:
4301 Double_t numerator5 = product5 - term1st5*term2nd5;
4302 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4303 Double_t denominator5 = 0.;
4304 if(TMath::Abs(sumOfW1st5*sumOfW2nd5)>0.)
4305 {
4306 denominator5 = 1.-sumOfWW5/(sumOfW1st5*sumOfW2nd5);
4307 if(TMath::Abs(denominator5)>0.)
4308 {
4309 // covariance:
4310 Double_t covariance5 = numerator5/denominator5;
4311 // weight dependent prefactor for covariance:
4312 Double_t wPrefactor5 = sumOfWW5/(sumOfW1st5*sumOfW2nd5);
4313 // finally, store "weighted" covariance:
4314 fIntFlowCovariancesNUA->SetBinContent(5,wPrefactor5*covariance5);
4315 } // end of if(TMath::Abs(denominator5)>0.)
4316 } // end of if(TMath::Abs(sumOfW1st5*sumOfW2nd5)>0.)
4317
0328db2d 4318 // Cov(<2>,<cos(phi1-phi2-phi3)>):
4319 Double_t product6 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(6); // <<2><cos(phi1-phi2-phi3)>>
4320 Double_t term1st6 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4321 Double_t term2nd6 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4322 Double_t sumOfW1st6 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4323 Double_t sumOfW2nd6 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4324 Double_t sumOfWW6 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(6); // W_{<2>} * W_{<cos(phi1-phi2-phi3)>}
4325 // numerator in the expression for the the unbiased estimator for covariance:
4326 Double_t numerator6 = product6 - term1st6*term2nd6;
4327 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4328 Double_t denominator6 = 0.;
4329 if(TMath::Abs(sumOfW1st6*sumOfW2nd6)>0.)
4330 {
4331 denominator6 = 1.-sumOfWW6/(sumOfW1st6*sumOfW2nd6);
4332 if(TMath::Abs(denominator6)>0.)
4333 {
4334 // covariance:
4335 Double_t covariance6 = numerator6/denominator6;
4336 // weight dependent prefactor for covariance:
4337 Double_t wPrefactor6 = sumOfWW6/(sumOfW1st6*sumOfW2nd6);
4338 // finally, store "weighted" covariance:
4339 fIntFlowCovariancesNUA->SetBinContent(6,wPrefactor6*covariance6);
4340 } // end of if(TMath::Abs(denominator6)>0.)
4341 } // end of if(TMath::Abs(sumOfW1st6*sumOfW2nd6)>0.)
4342
0328db2d 4343 // Cov(<2>,<sin(phi1-phi2-phi3)>):
4344 Double_t product7 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(7); // <<2><sin(phi1-phi2-phi3)>>
4345 Double_t term1st7 = fIntFlowCorrelationsPro->GetBinContent(1); // <<2>>
4346 Double_t term2nd7 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4347 Double_t sumOfW1st7 = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // W_{<2>}
4348 Double_t sumOfW2nd7 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4349 Double_t sumOfWW7 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(7); // W_{<2>} * W_{<sin(phi1-phi2-phi3)>}
4350 // numerator in the expression for the the unbiased estimator for covariance:
4351 Double_t numerator7 = product7 - term1st7*term2nd7;
4352 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4353 Double_t denominator7 = 0.;
4354 if(TMath::Abs(sumOfW1st7*sumOfW2nd7)>0.)
4355 {
4356 denominator7 = 1.-sumOfWW7/(sumOfW1st7*sumOfW2nd7);
4357 if(TMath::Abs(denominator7)>0.)
4358 {
4359 // covariance:
4360 Double_t covariance7 = numerator7/denominator7;
4361 // weight dependent prefactor for covariance:
4362 Double_t wPrefactor7 = sumOfWW7/(sumOfW1st7*sumOfW2nd7);
4363 // finally, store "weighted" covariance:
4364 fIntFlowCovariancesNUA->SetBinContent(7,wPrefactor7*covariance7);
4365 } // end of if(TMath::Abs(denominator7)>0.)
4366 } // end of if(TMath::Abs(sumOfW1st7*sumOfW2nd7)>0.)
4367
0328db2d 4368 // Cov(<4>,<cos(phi1>):
4369 Double_t product8 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(8); // <<4><cos(phi1)>>
4370 Double_t term1st8 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4371 Double_t term2nd8 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4372 Double_t sumOfW1st8 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4373 Double_t sumOfW2nd8 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4374 Double_t sumOfWW8 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(8); // W_{<4>} * W_{<cos(phi1)>}
4375 // numerator in the expression for the the unbiased estimator for covariance:
4376 Double_t numerator8 = product8 - term1st8*term2nd8;
4377 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4378 Double_t denominator8 = 0.;
4379 if(TMath::Abs(sumOfW1st8*sumOfW2nd8)>0.)
4380 {
4381 denominator8 = 1.-sumOfWW8/(sumOfW1st8*sumOfW2nd8);
4382 if(TMath::Abs(denominator8)>0.)
4383 {
4384 // covariance:
4385 Double_t covariance8 = numerator8/denominator8;
4386 // weight dependent prefactor for covariance:
4387 Double_t wPrefactor8 = sumOfWW8/(sumOfW1st8*sumOfW2nd8);
4388 // finally, store "weighted" covariance:
4389 fIntFlowCovariancesNUA->SetBinContent(8,wPrefactor8*covariance8);
4390 } // end of if(TMath::Abs(denominator8)>0.)
4391 } // end of if(TMath::Abs(sumOfW1st8*sumOfW2nd8)>0.)
4392
0328db2d 4393 // Cov(<4>,<sin(phi1)>):
4394 Double_t product9 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(9); // <<4><sin(phi1)>>
4395 Double_t term1st9 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4396 Double_t term2nd9 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4397 Double_t sumOfW1st9 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4398 Double_t sumOfW2nd9 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4399 Double_t sumOfWW9 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(9); // W_{<4>} * W_{<sin(phi1)>}
4400 // numerator in the expression for the the unbiased estimator for covariance:
4401 Double_t numerator9 = product9 - term1st9*term2nd9;
4402 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4403 Double_t denominator9 = 0.;
4404 if(TMath::Abs(sumOfW1st9*sumOfW2nd9)>0.)
4405 {
4406 denominator9 = 1.-sumOfWW9/(sumOfW1st9*sumOfW2nd9);
4407 if(TMath::Abs(denominator9)>0.)
4408 {
4409 // covariance:
4410 Double_t covariance9 = numerator9/denominator9;
4411 // weight dependent prefactor for covariance:
4412 Double_t wPrefactor9 = sumOfWW9/(sumOfW1st9*sumOfW2nd9);
4413 // finally, store "weighted" covariance:
4414 fIntFlowCovariancesNUA->SetBinContent(9,wPrefactor9*covariance9);
4415 }
4416 } // end of if(TMath::Abs(sumOfW1st9*sumOfW2nd9)>0.)
4417
0328db2d 4418 // Cov(<4>,<cos(phi1+phi2)>):
4419 Double_t product10 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(10); // <<4><cos(phi1+phi2)>>
4420 Double_t term1st10 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4421 Double_t term2nd10 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4422 Double_t sumOfW1st10 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4423 Double_t sumOfW2nd10 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4424 Double_t sumOfWW10 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(10); // W_{<4>} * W_{<cos(phi1+phi2)>}
4425 // numerator in the expression for the the unbiased estimator for covariance:
4426 Double_t numerator10 = product10 - term1st10*term2nd10;
4427 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4428 Double_t denominator10 = 0.;
4429 if(TMath::Abs(sumOfW1st10*sumOfW2nd10)>0.)
4430 {
4431 denominator10 = 1.-sumOfWW10/(sumOfW1st10*sumOfW2nd10);
4432 if(TMath::Abs(denominator10)>0.)
4433 {
4434 // covariance:
4435 Double_t covariance10 = numerator10/denominator10;
4436 // weight dependent prefactor for covariance:
4437 Double_t wPrefactor10 = sumOfWW10/(sumOfW1st10*sumOfW2nd10);
4438 // finally, store "weighted" covariance:
4439 fIntFlowCovariancesNUA->SetBinContent(10,wPrefactor10*covariance10);
4440 } // end of if(TMath::Abs(denominator10)>0.)
4441 } // end of if(TMath::Abs(sumOfW1st10*sumOfW2nd10)>0.)
4442
0328db2d 4443 // Cov(<4>,<sin(phi1+phi2)>):
4444 Double_t product11 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(11); // <<4><sin(phi1+phi2)>>
4445 Double_t term1st11 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4446 Double_t term2nd11 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4447 Double_t sumOfW1st11 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4448 Double_t sumOfW2nd11 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4449 Double_t sumOfWW11 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(11); // W_{<4>} * W_{<sin(phi1+phi2)>}
4450 // numerator in the expression for the the unbiased estimator for covariance:
4451 Double_t numerator11 = product11 - term1st11*term2nd11;
4452 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4453 Double_t denominator11 = 0.;
4454 if(TMath::Abs(sumOfW1st11*sumOfW2nd11)>0.)
4455 {
4456 denominator11 = 1.-sumOfWW11/(sumOfW1st11*sumOfW2nd11);
4457 if(TMath::Abs(denominator11)>0.)
4458 {
4459 // covariance:
4460 Double_t covariance11 = numerator11/denominator11;
4461 // weight dependent prefactor for covariance:
4462 Double_t wPrefactor11 = sumOfWW11/(sumOfW1st11*sumOfW2nd11);
4463 // finally, store "weighted" covariance:
4464 fIntFlowCovariancesNUA->SetBinContent(11,wPrefactor11*covariance11);
4465 } // end of if(TMath::Abs(denominator11)>0.)
4466 } // end of if(TMath::Abs(sumOfW1st11*sumOfW2nd11)>0.)
0328db2d 4467
4468 // Cov(<4>,<cos(phi1-phi2-phi3)>):
4469 Double_t product12 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(12); // <<4><cos(phi1-phi2-phi3)>>
4470 Double_t term1st12 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4471 Double_t term2nd12 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4472 Double_t sumOfW1st12 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4473 Double_t sumOfW2nd12 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4474 Double_t sumOfWW12 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(12); // W_{<4>} * W_{<cos(phi1-phi2-phi3)>}
4475 // numerator in the expression for the the unbiased estimator for covariance:
4476 Double_t numerator12 = product12 - term1st12*term2nd12;
4477 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4478 Double_t denominator12 = 0.;
4479 if(TMath::Abs(sumOfW1st12*sumOfW2nd12)>0.)
4480 {
4481 denominator12 = 1.-sumOfWW12/(sumOfW1st12*sumOfW2nd12);
4482 if(TMath::Abs(denominator12)>0.)
4483 {
4484 // covariance:
4485 Double_t covariance12 = numerator12/denominator12;
4486 // weight dependent prefactor for covariance:
4487 Double_t wPrefactor12 = sumOfWW12/(sumOfW1st12*sumOfW2nd12);
4488 // finally, store "weighted" covariance:
4489 fIntFlowCovariancesNUA->SetBinContent(12,wPrefactor12*covariance12);
4490 } // end of if(TMath::Abs(denominator12)>0.)
4491 } // end of if(TMath::Abs(sumOfW1st12*sumOfW2nd12)>0.)
0328db2d 4492
4493 // Cov(<4>,<sin(phi1-phi2-phi3)>):
4494 Double_t product13 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(13); // <<4><sin(phi1-phi2-phi3)>>
4495 Double_t term1st13 = fIntFlowCorrelationsPro->GetBinContent(2); // <<4>>
4496 Double_t term2nd13 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4497 Double_t sumOfW1st13 = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // W_{<4>}
4498 Double_t sumOfW2nd13 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4499 Double_t sumOfWW13 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(13); // W_{<4>} * W_{<sin(phi1-phi2-phi3)>}
4500 // numerator in the expression for the the unbiased estimator for covariance:
4501 Double_t numerator13 = product13 - term1st13*term2nd13;
4502 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4503 Double_t denominator13 = 0.;
4504 if(TMath::Abs(sumOfW1st13*sumOfW2nd13)>0.)
4505 {
4506 denominator13 = 1.-sumOfWW13/(sumOfW1st13*sumOfW2nd13);
4507 if(TMath::Abs(denominator13)>0.)
4508 {
4509 // covariance:
4510 Double_t covariance13 = numerator13/denominator13;
4511 // weight dependent prefactor for covariance:
4512 Double_t wPrefactor13 = sumOfWW13/(sumOfW1st13*sumOfW2nd13);
4513 // finally, store "weighted" covariance:
4514 fIntFlowCovariancesNUA->SetBinContent(13,wPrefactor13*covariance13);
4515 } // end of if(TMath::Abs(denominator13)>0.)
4516 } // end of if(TMath::Abs(sumOfW1st13*sumOfW2nd13)>0.)
0328db2d 4517
4518 // Cov(<cos(phi1)>,<cos(phi1+phi2)>):
4519 Double_t product14 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(14); // <<cos(phi1)><cos(phi1+phi2)>>
4520 Double_t term1st14 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4521 Double_t term2nd14 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4522 Double_t sumOfW1st14 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4523 Double_t sumOfW2nd14 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4524 Double_t sumOfWW14 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(14); // W_{<cos(phi1)>} * W_{<cos(phi1+phi2)>}
4525 // numerator in the expression for the the unbiased estimator for covariance:
4526 Double_t numerator14 = product14 - term1st14*term2nd14;
4527 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4528 Double_t denominator14 = 0.;
4529 if(TMath::Abs(sumOfW1st14*sumOfW2nd14)>0.)
4530 {
4531 denominator14 = 1.-sumOfWW14/(sumOfW1st14*sumOfW2nd14);
4532 if(TMath::Abs(denominator14)>0.)
4533 {
4534 // covariance:
4535 Double_t covariance14 = numerator14/denominator14;
4536 // weight dependent prefactor for covariance:
4537 Double_t wPrefactor14 = sumOfWW14/(sumOfW1st14*sumOfW2nd14);
4538 // finally, store "weighted" covariance:
4539 fIntFlowCovariancesNUA->SetBinContent(14,wPrefactor14*covariance14);
4540 } // end of if(TMath::Abs(denominator14)>0.)
4541 } // end of if(TMath::Abs(sumOfW1st14*sumOfW2nd14)>0.)
0328db2d 4542
4543 // Cov(<cos(phi1)>,<sin(phi1+phi2)>):
4544 Double_t product15 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(15); // <<cos(phi1)><sin(phi1+phi2)>>
4545 Double_t term1st15 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4546 Double_t term2nd15 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4547 Double_t sumOfW1st15 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4548 Double_t sumOfW2nd15 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4549 Double_t sumOfWW15 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(15); // W_{<cos(phi1)>} * W_{<sin(phi1+phi2)>}
4550 // numerator in the expression for the the unbiased estimator for covariance:
4551 Double_t numerator15 = product15 - term1st15*term2nd15;
4552 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4553 Double_t denominator15 = 0.;
4554 if(TMath::Abs(sumOfW1st15*sumOfW2nd15)>0.)
4555 {
4556 denominator15 = 1.-sumOfWW15/(sumOfW1st15*sumOfW2nd15);
4557 if(TMath::Abs(denominator15)>0.)
4558 {
4559 // covariance:
4560 Double_t covariance15 = numerator15/denominator15;
4561 // weight dependent prefactor for covariance:
4562 Double_t wPrefactor15 = sumOfWW15/(sumOfW1st15*sumOfW2nd15);
4563 // finally, store "weighted" covariance:
4564 fIntFlowCovariancesNUA->SetBinContent(15,wPrefactor15*covariance15);
4565 } // end of if(TMath::Abs(denominator15)>0.)
4566 } // end of if(TMath::Abs(sumOfW1st15*sumOfW2nd15)>0.)
4567
0328db2d 4568 // Cov(<cos(phi1)>,<cos(phi1-phi2-phi3)>):
4569 Double_t product16 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(16); // <<cos(phi1)><cos(phi1-phi2-phi3)>>
4570 Double_t term1st16 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4571 Double_t term2nd16 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4572 Double_t sumOfW1st16 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4573 Double_t sumOfW2nd16 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4574 Double_t sumOfWW16 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(16); // W_{<cos(phi1)>} * W_{<cos(phi1-phi2-phi3)>}
4575 // numerator in the expression for the the unbiased estimator for covariance:
4576 Double_t numerator16 = product16 - term1st16*term2nd16;
4577 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4578 Double_t denominator16 = 0.;
4579 if(TMath::Abs(sumOfW1st16*sumOfW2nd16)>0.)
4580 {
4581 denominator16 = 1.-sumOfWW16/(sumOfW1st16*sumOfW2nd16);
4582 if(TMath::Abs(denominator16)>0.)
4583 {
4584 // covariance:
4585 Double_t covariance16 = numerator16/denominator16;
4586 // weight dependent prefactor for covariance:
4587 Double_t wPrefactor16 = sumOfWW16/(sumOfW1st16*sumOfW2nd16);
4588 // finally, store "weighted" covariance:
4589 fIntFlowCovariancesNUA->SetBinContent(16,wPrefactor16*covariance16);
4590 } // end of if(TMath::Abs(denominator16)>0.)
4591 } // end ofif(TMath::Abs(sumOfW1st16*sumOfW2nd16)>0.)
4592
0328db2d 4593 // Cov(<cos(phi1)>,<sin(phi1-phi2-phi3)>):
4594 Double_t product17 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(17); // <<cos(phi1)><sin(phi1-phi2-phi3)>>
4595 Double_t term1st17 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(1); // <<cos(phi1)>>
4596 Double_t term2nd17 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4597 Double_t sumOfW1st17 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(1); // W_{<cos(phi1)>}
4598 Double_t sumOfW2nd17 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4599 Double_t sumOfWW17 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(17); // W_{<cos(phi1)>} * W_{<sin(phi1-phi2-phi3)>}
4600 // numerator in the expression for the the unbiased estimator for covariance:
4601 Double_t numerator17 = product17 - term1st17*term2nd17;
4602 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4603 Double_t denominator17 = 0.;
4604 if(TMath::Abs(sumOfW1st17*sumOfW2nd17)>0.)
4605 {
4606 denominator17 = 1.-sumOfWW17/(sumOfW1st17*sumOfW2nd17);
4607 if(TMath::Abs(denominator17)>0.)
4608 {
4609 // covariance:
4610 Double_t covariance17 = numerator17/denominator17;
4611 // weight dependent prefactor for covariance:
4612 Double_t wPrefactor17 = sumOfWW17/(sumOfW1st17*sumOfW2nd17);
4613 // finally, store "weighted" covariance:
4614 fIntFlowCovariancesNUA->SetBinContent(17,wPrefactor17*covariance17);
4615 } // end of if(TMath::Abs(denominator17)>0.)
4616 } // end of if(TMath::Abs(sumOfW1st17*sumOfW2nd17)>0.)
0328db2d 4617
4618 // Cov(<sin(phi1)>,<cos(phi1+phi2)>):
4619 Double_t product18 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(18); // <<sin(phi1)><cos(phi1+phi2)>>
4620 Double_t term1st18 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4621 Double_t term2nd18 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4622 Double_t sumOfW1st18 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4623 Double_t sumOfW2nd18 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4624 Double_t sumOfWW18 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(18); // W_{<sin(phi1)>} * W_{<cos(phi1+phi2)>}
4625 // numerator in the expression for the the unbiased estimator for covariance:
4626 Double_t numerator18 = product18 - term1st18*term2nd18;
4627 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4628 Double_t denominator18 = 0.;
4629 if(TMath::Abs(sumOfW1st18*sumOfW2nd18)>0.)
4630 {
4631 denominator18 = 1.-sumOfWW18/(sumOfW1st18*sumOfW2nd18);
4632 if(TMath::Abs(denominator18)>0.)
4633 {
4634 // covariance:
4635 Double_t covariance18 = numerator18/denominator18;
4636 // weight dependent prefactor for covariance:
4637 Double_t wPrefactor18 = sumOfWW18/(sumOfW1st18*sumOfW2nd18);
4638 // finally, store "weighted" covariance:
4639 fIntFlowCovariancesNUA->SetBinContent(18,wPrefactor18*covariance18);
4640 } // end of if(TMath::Abs(denominator18)>0.)
4641 } // end of if(TMath::Abs(sumOfW1st18*sumOfW2nd18)>0.)
0328db2d 4642
4643 // Cov(<sin(phi1)>,<sin(phi1+phi2)>):
4644 Double_t product19 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(19); // <<sin(phi1)><sin(phi1+phi2)>>
4645 Double_t term1st19 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4646 Double_t term2nd19 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4647 Double_t sumOfW1st19 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4648 Double_t sumOfW2nd19 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4649 Double_t sumOfWW19 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(19); // W_{<sin(phi1)>} * W_{<sin(phi1+phi2)>}
4650 // numerator in the expression for the the unbiased estimator for covariance:
4651 Double_t numerator19 = product19 - term1st19*term2nd19;
4652 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4653 Double_t denominator19 = 0.;
4654 if(TMath::Abs(sumOfW1st19*sumOfW2nd19)>0.)
4655 {
4656 denominator19 = 1.-sumOfWW19/(sumOfW1st19*sumOfW2nd19);
4657 if(TMath::Abs(denominator19)>0.)
4658 {
4659 // covariance:
4660 Double_t covariance19 = numerator19/denominator19;
4661 // weight dependent prefactor for covariance:
4662 Double_t wPrefactor19 = sumOfWW19/(sumOfW1st19*sumOfW2nd19);
4663 // finally, store "weighted" covariance:
4664 fIntFlowCovariancesNUA->SetBinContent(19,wPrefactor19*covariance19);
4665 } // end of if(TMath::Abs(denominator19)>0.)
4666 } // end of if(TMath::Abs(sumOfW1st19*sumOfW2nd19)>0.)
4667
0328db2d 4668 // Cov(<sin(phi1)>,<cos(phi1-phi2-phi3)>):
4669 Double_t product20 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(20); // <<sin(phi1)><cos(phi1-phi2-phi3)>>
4670 Double_t term1st20 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4671 Double_t term2nd20 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4672 Double_t sumOfW1st20 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4673 Double_t sumOfW2nd20 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4674 Double_t sumOfWW20 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(20); // W_{<sin(phi1)>} * W_{<cos(phi1-phi2-phi3)>}
4675 // numerator in the expression for the the unbiased estimator for covariance:
4676 Double_t numerator20 = product20 - term1st20*term2nd20;
4677 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4678 Double_t denominator20 = 0.;
4679 if(TMath::Abs(sumOfW1st20*sumOfW2nd20)>0.)
4680 {
4681 denominator20 = 1.-sumOfWW20/(sumOfW1st20*sumOfW2nd20);
4682 if(TMath::Abs(denominator20)>0.)
4683 {
4684 // covariance:
4685 Double_t covariance20 = numerator20/denominator20;
4686 // weight dependent prefactor for covariance:
4687 Double_t wPrefactor20 = sumOfWW20/(sumOfW1st20*sumOfW2nd20);
4688 // finally, store "weighted" covariance:
4689 fIntFlowCovariancesNUA->SetBinContent(20,wPrefactor20*covariance20);
4690 } // end of if(TMath::Abs(denominator20)>0.)
4691 } // end of if(TMath::Abs(sumOfW1st20*sumOfW2nd20)>0.)
0328db2d 4692
4693 // Cov(<sin(phi1)>,<sin(phi1-phi2-phi3)>):
4694 Double_t product21 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(21); // <<sin(phi1)><sin(phi1-phi2-phi3)>>
4695 Double_t term1st21 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(1); // <<sin(phi1)>>
4696 Double_t term2nd21 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4697 Double_t sumOfW1st21 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(1); // W_{<sin(phi1)>}
4698 Double_t sumOfW2nd21 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4699 Double_t sumOfWW21 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(21); // W_{<sin(phi1)>} * W_{<sin(phi1-phi2-phi3)>}
4700 // numerator in the expression for the the unbiased estimator for covariance:
4701 Double_t numerator21 = product21 - term1st21*term2nd21;
4702 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4703 Double_t denominator21 = 0.;
4704 if(TMath::Abs(sumOfW1st21*sumOfW2nd21)>0.)
4705 {
4706 denominator21 = 1.-sumOfWW21/(sumOfW1st21*sumOfW2nd21);
4707 if(TMath::Abs(denominator21)>0.)
4708 {
4709 // covariance:
4710 Double_t covariance21 = numerator21/denominator21;
4711 // weight dependent prefactor for covariance:
4712 Double_t wPrefactor21 = sumOfWW21/(sumOfW1st21*sumOfW2nd21);
4713 // finally, store "weighted" covariance:
4714 fIntFlowCovariancesNUA->SetBinContent(21,wPrefactor21*covariance21);
4715 } // end of if(TMath::Abs(denominator21)>0.)
4716 } // end of if(TMath::Abs(sumOfW1st21*sumOfW2nd21)>0.)
0328db2d 4717
4718 // Cov(<cos(phi1+phi2)>,<sin(phi1+phi2)>):
4719 Double_t product22 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(22); // <<cos(phi1+phi2)><sin(phi1+phi2)>>
4720 Double_t term1st22 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4721 Double_t term2nd22 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4722 Double_t sumOfW1st22 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4723 Double_t sumOfW2nd22 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4724 Double_t sumOfWW22 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(22); // W_{<cos(phi1+phi2)>} * W_{<sin(phi1+phi2)>}
4725 // numerator in the expression for the the unbiased estimator for covariance:
4726 Double_t numerator22 = product22 - term1st22*term2nd22;
4727 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4728 Double_t denominator22 = 0.;
4729 if(TMath::Abs(sumOfW1st22*sumOfW2nd22)>0.)
4730 {
4731 denominator22 = 1.-sumOfWW22/(sumOfW1st22*sumOfW2nd22);
4732 if(TMath::Abs(denominator22)>0.)
4733 {
4734 // covariance:
4735 Double_t covariance22 = numerator22/denominator22;
4736 // weight dependent prefactor for covariance:
4737 Double_t wPrefactor22 = sumOfWW22/(sumOfW1st22*sumOfW2nd22);
4738 // finally, store "weighted" covariance:
4739 fIntFlowCovariancesNUA->SetBinContent(22,wPrefactor22*covariance22);
4740 } // end of if(TMath::Abs(denominator22)>0.)
4741 } // end of if(TMath::Abs(sumOfW1st22*sumOfW2nd22)>0.)
0328db2d 4742
4743 // Cov(<cos(phi1+phi2)>,<cos(phi1-phi2-phi3)>):
4744 Double_t product23 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(23); // <<cos(phi1+phi2)><cos(phi1-phi2-phi3)>>
4745 Double_t term1st23 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4746 Double_t term2nd23 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4747 Double_t sumOfW1st23 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4748 Double_t sumOfW2nd23 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4749 Double_t sumOfWW23 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(23); // W_{<cos(phi1+phi2)>} * W_{<cos(phi1-phi2-phi3)>}
4750 // numerator in the expression for the the unbiased estimator for covariance:
4751 Double_t numerator23 = product23 - term1st23*term2nd23;
4752 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4753 Double_t denominator23 = 0.;
4754 if(TMath::Abs(sumOfW1st23*sumOfW2nd23)>0.)
4755 {
4756 denominator23 = 1.-sumOfWW23/(sumOfW1st23*sumOfW2nd23);
4757 if(TMath::Abs(denominator23)>0.)
4758 {
4759 // covariance:
4760 Double_t covariance23 = numerator23/denominator23;
4761 // weight dependent prefactor for covariance:
4762 Double_t wPrefactor23 = sumOfWW23/(sumOfW1st23*sumOfW2nd23);
4763 // finally, store "weighted" covariance:
4764 fIntFlowCovariancesNUA->SetBinContent(23,wPrefactor23*covariance23);
4765 } // end of if(TMath::Abs(denominator23)>0.)
4766 } // end of if(TMath::Abs(sumOfW1st23*sumOfW2nd23)>0.)
4767
0328db2d 4768 // Cov(<cos(phi1+phi2)>,<sin(phi1-phi2-phi3)>):
4769 Double_t product24 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(24); // <<cos(phi1+phi2)><sin(phi1-phi2-phi3)>>
4770 Double_t term1st24 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(2); // <<cos(phi1+phi2)>>
4771 Double_t term2nd24 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4772 Double_t sumOfW1st24 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(2); // W_{<cos(phi1+phi2)>}
4773 Double_t sumOfW2nd24 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4774 Double_t sumOfWW24 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(24); // W_{<cos(phi1+phi2)>} * W_{<sin(phi1-phi2-phi3)>}
4775 // numerator in the expression for the the unbiased estimator for covariance:
4776 Double_t numerator24 = product24 - term1st24*term2nd24;
4777 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4778 Double_t denominator24 = 0.;
4779 if(TMath::Abs(sumOfW1st24*sumOfW2nd24)>0.)
4780 {
4781 denominator24 = 1.-sumOfWW24/(sumOfW1st24*sumOfW2nd24);
4782 if(TMath::Abs(denominator24)>0.)
4783 {
4784 // covariance:
4785 Double_t covariance24 = numerator24/denominator24;
4786 // weight dependent prefactor for covariance:
4787 Double_t wPrefactor24 = sumOfWW24/(sumOfW1st24*sumOfW2nd24);
4788 // finally, store "weighted" covariance:
4789 fIntFlowCovariancesNUA->SetBinContent(24,wPrefactor24*covariance24);
4790 } // end of if(TMath::Abs(denominator24)>0.)
4791 } // end of if(TMath::Abs(sumOfW1st24*sumOfW2nd24)>0.)
0328db2d 4792
4793 // Cov(<sin(phi1+phi2)>,<cos(phi1-phi2-phi3)>):
4794 Double_t product25 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(25); // <<sin(phi1+phi2)><cos(phi1-phi2-phi3)>>
4795 Double_t term1st25 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4796 Double_t term2nd25 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
4797 Double_t sumOfW1st25 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4798 Double_t sumOfW2nd25 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
4799 Double_t sumOfWW25 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(25); // W_{<sin(phi1+phi2)>} * W_{<cos(phi1-phi2-phi3)>}
4800 // numerator in the expression for the the unbiased estimator for covariance:
4801 Double_t numerator25 = product25 - term1st25*term2nd25;
4802 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4803 Double_t denominator25 = 0.;
4804 if(TMath::Abs(sumOfW1st25*sumOfW2nd25)>0.)
4805 {
4806 denominator25 = 1.-sumOfWW25/(sumOfW1st25*sumOfW2nd25);
4807 if(TMath::Abs(denominator25)>0.)
4808 {
4809 // covariance:
4810 Double_t covariance25 = numerator25/denominator25;
4811 // weight dependent prefactor for covariance:
4812 Double_t wPrefactor25 = sumOfWW25/(sumOfW1st25*sumOfW2nd25);
4813 // finally, store "weighted" covariance:
4814 fIntFlowCovariancesNUA->SetBinContent(25,wPrefactor25*covariance25);
4815 } // end of if(TMath::Abs(denominator25)>0.)
4816 } // end of if(TMath::Abs(sumOfW1st25*sumOfW2nd25)>0.)
4817
0328db2d 4818 // Cov(<sin(phi1+phi2)>,<sin(phi1-phi2-phi3)>):
4819 Double_t product26 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(26); // <<sin(phi1+phi2)><sin(phi1-phi2-phi3)>>
4820 Double_t term1st26 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(2); // <<sin(phi1+phi2)>>
4821 Double_t term2nd26 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
4822 Double_t sumOfW1st26 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(2); // W_{<sin(phi1+phi2)>}
4823 Double_t sumOfW2nd26 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4824 Double_t sumOfWW26 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(26); // W_{<sin(phi1+phi2)>} * W_{<sin(phi1-phi2-phi3)>}
4825 // numerator in the expression for the the unbiased estimator for covariance:
4826 Double_t numerator26 = product26 - term1st26*term2nd26;
4827 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4828 Double_t denominator26 = 0.;
4829 if(TMath::Abs(sumOfW1st26*sumOfW2nd26)>0.)
4830 {
4831 denominator26 = 1.-sumOfWW26/(sumOfW1st26*sumOfW2nd26);
4832 if(TMath::Abs(denominator26)>0.)
4833 {
4834 // covariance:
4835 Double_t covariance26 = numerator26/denominator26;
4836 // weight dependent prefactor for covariance:
4837 Double_t wPrefactor26 = sumOfWW26/(sumOfW1st26*sumOfW2nd26);
4838 // finally, store "weighted" covariance:
4839 fIntFlowCovariancesNUA->SetBinContent(26,wPrefactor26*covariance26);
4840 } // end of if(TMath::Abs(denominator26)>0.)
4841 } // end of if(TMath::Abs(sumOfW1st26*sumOfW2nd26)>0.)
4842
0328db2d 4843 // Cov(<cos(phi1-phi2-phi3)>,<sin(phi1-phi2-phi3)>):
4844 Double_t product27 = fIntFlowProductOfCorrectionTermsForNUAPro->GetBinContent(27); // <<cos(phi1-phi2-phi3)><sin(phi1-phi2-phi3)>>
b92ea2b9 4845 Double_t term1st27 = fIntFlowCorrectionTermsForNUAPro[1]->GetBinContent(3); // <<cos(phi1-phi2-phi3)>>
0328db2d 4846 Double_t term2nd27 = fIntFlowCorrectionTermsForNUAPro[0]->GetBinContent(3); // <<sin(phi1-phi2-phi3)>>
b92ea2b9 4847 Double_t sumOfW1st27 = fIntFlowSumOfEventWeightsNUA[1][0]->GetBinContent(3); // W_{<cos(phi1-phi2-phi3)>}
0328db2d 4848 Double_t sumOfW2nd27 = fIntFlowSumOfEventWeightsNUA[0][0]->GetBinContent(3); // W_{<sin(phi1-phi2-phi3)>}
4849 Double_t sumOfWW27 = fIntFlowSumOfProductOfEventWeightsNUA->GetBinContent(27); // W_{<cos(phi1-phi2-phi3)>} * W_{<sin(phi1-phi2-phi3)>}
4850 // numerator in the expression for the the unbiased estimator for covariance:
4851 Double_t numerator27 = product27 - term1st27*term2nd27;
4852 // denominator in the expression for the the unbiased estimator for covariance:
b92ea2b9 4853 Double_t denominator27 = 0.;
4854 if(TMath::Abs(sumOfW1st27*sumOfW2nd27)>0.)
4855 {
4856 denominator27 = 1.-sumOfWW27/(sumOfW1st27*sumOfW2nd27);
4857 if(TMath::Abs(denominator27)>0.)
4858 {
4859 // covariance:
4860 Double_t covariance27 = numerator27/denominator27;
4861 // weight dependent prefactor for covariance:
4862 Double_t wPrefactor27 = sumOfWW27/(sumOfW1st27*sumOfW2nd27);
4863 // finally, store "weighted" covariance:
4864 fIntFlowCovariancesNUA->SetBinContent(27,wPrefactor27*covariance27);
4865 } // end of if(TMath::Abs(denominator27)>0.)
4866 } // end of if(TMath::Abs(sumOfW1st27*sumOfW2nd27)>0.)
4867
0328db2d 4868} // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesNUAIntFlow()
4869
0328db2d 4870//================================================================================================================================
4871
489d5531 4872void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()
4873{
4874 // From profile fIntFlowCorrelationsPro access measured correlations and spread,
4875 // correctly calculate the statistical errors and store the final results and
4876 // statistical errors for correlations in histogram fIntFlowCorrelationsHist.
4877 //
4878 // Remark: Statistical error of correlation is calculated as:
4879 //
4880 // statistical error = termA * spread * termB:
4881 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)
4882 // termB = 1/sqrt(1-termA^2)
b3dacf6b 4883 //
4884
489d5531 4885 for(Int_t ci=1;ci<=4;ci++) // correlation index
4886 {
b40a910e 4887 if(fIntFlowCorrelationsPro->GetBinEffectiveEntries(ci) < 2 || fIntFlowSquaredCorrelationsPro->GetBinEffectiveEntries(ci) < 2)
4888 {
4889 fIntFlowCorrelationsPro->SetBinError(ci,0.);
4890 fIntFlowSquaredCorrelationsPro->SetBinError(ci,0.);
4891 continue;
4892 }
489d5531 4893 Double_t correlation = fIntFlowCorrelationsPro->GetBinContent(ci);
b40a910e 4894 Double_t squaredCorrelation = fIntFlowSquaredCorrelationsPro->GetBinContent(ci);
4895 Double_t spread = 0.;
4896 if(squaredCorrelation-correlation*correlation >= 0.)
4897 {
4898 spread = pow(squaredCorrelation-correlation*correlation,0.5);
4899 } else
4900 {
4901 cout<<endl;
4902 cout<<Form(" WARNING: Imaginary 'spread' for %d-particle correlation!!!! ",2*ci)<<endl;
4903 cout<<endl;
4904 }
489d5531 4905 Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);
4906 Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);
4907 Double_t termA = 0.;
4908 Double_t termB = 0.;
b3dacf6b 4909 if(TMath::Abs(sumOfLinearEventWeights) > 0.) // to be improved - shall I omitt here Abs() ?
489d5531 4910 {
4911 termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;
4912 } else
4913 {
b3dacf6b 4914 cout<<endl;
4915 cout<<" WARNING (QC): sumOfLinearEventWeights == 0 in method FinalizeCorrelationsIntFlow() !!!!"<<endl;
4916 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;
4917 cout<<endl;
489d5531 4918 }
4919 if(1.-pow(termA,2.) > 0.)
4920 {
4921 termB = 1./pow(1-pow(termA,2.),0.5);
4922 } else
4923 {
b3dacf6b 4924 cout<<endl;
4925 cout<<" WARNING (QC): 1.-pow(termA,2.) <= 0 in method FinalizeCorrelationsIntFlow() !!!!"<<endl;
4926 cout<<" (for "<<2*ci<<"-particle correlation)"<<endl;
4927 cout<<endl;
489d5531 4928 }
4929 Double_t statisticalError = termA * spread * termB;
4930 fIntFlowCorrelationsHist->SetBinContent(ci,correlation);
4931 fIntFlowCorrelationsHist->SetBinError(ci,statisticalError);
ff70ca91 4932 } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index
4933
b3dacf6b 4934 // Versus multiplicity:
4935 if(!fCalculateCumulantsVsM){return;}
ff70ca91 4936 for(Int_t ci=0;ci<=3;ci++) // correlation index
4937 {
4938 Int_t nBins = fIntFlowCorrelationsVsMPro[ci]->GetNbinsX();
4939 for(Int_t b=1;b<=nBins;b++) // looping over multiplicity bins
4940 {
b40a910e 4941 if(fIntFlowCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b) < 2 || fIntFlowSquaredCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b) < 2)
4942 {
4943 fIntFlowCorrelationsVsMPro[ci]->SetBinError(b,0.);
4944 fIntFlowSquaredCorrelationsVsMPro[ci]->SetBinError(b,0.);
4945 continue;
4946 }
ff70ca91 4947 Double_t correlationVsM = fIntFlowCorrelationsVsMPro[ci]->GetBinContent(b);
b40a910e 4948 Double_t squaredCorrelationVsM = fIntFlowSquaredCorrelationsVsMPro[ci]->GetBinContent(b);
4949 Double_t spreadVsM = 0.;
4950 if(squaredCorrelationVsM-correlationVsM*correlationVsM >= 0.)
4951 {
4952 spreadVsM = pow(squaredCorrelationVsM-correlationVsM*correlationVsM,0.5);
4953 } else
4954 {
4955 cout<<endl;
4956 cout<<Form(" WARNING (QC): Imaginary 'spreadVsM' for ci = %d, bin = %d, entries = %f !!!!",
4957 ci,b,fIntFlowCorrelationsVsMPro[ci]->GetBinEffectiveEntries(b))<<endl;
4958 cout<<endl;
4959 }
ff70ca91 4960 Double_t sumOfLinearEventWeightsVsM = fIntFlowSumOfEventWeightsVsM[ci][0]->GetBinContent(b);
4961 Double_t sumOfQuadraticEventWeightsVsM = fIntFlowSumOfEventWeightsVsM[ci][1]->GetBinContent(b);
4962 Double_t termAVsM = 0.;
4963 Double_t termBVsM = 0.;
b40a910e 4964 if(sumOfLinearEventWeightsVsM > 0.)
ff70ca91 4965 {
4966 termAVsM = pow(sumOfQuadraticEventWeightsVsM,0.5)/sumOfLinearEventWeightsVsM;
b3dacf6b 4967 }
ff70ca91 4968 if(1.-pow(termAVsM,2.) > 0.)
4969 {
4970 termBVsM = 1./pow(1-pow(termAVsM,2.),0.5);
b3dacf6b 4971 }
ff70ca91 4972 Double_t statisticalErrorVsM = termAVsM * spreadVsM * termBVsM;
4973 fIntFlowCorrelationsVsMHist[ci]->SetBinContent(b,correlationVsM);
4974 fIntFlowCorrelationsVsMHist[ci]->SetBinError(b,statisticalErrorVsM);
4975 } // end of for(Int_t b=1;b<=nBins;b++)
4976 } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index
4977
489d5531 4978} // end of AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()
4979
489d5531 4980//================================================================================================================================
4981
489d5531 4982void AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(Int_t nRP)
4983{
b77b6434 4984 // Fill profile fAverageMultiplicity to hold average multiplicities and
4985 // number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8
489d5531 4986
4987 // Binning of fAverageMultiplicity is organized as follows:
4988 // 1st bin: all events (including the empty ones)
4989 // 2nd bin: event with # of RPs greater or equal to 1
4990 // 3rd bin: event with # of RPs greater or equal to 2
4991 // 4th bin: event with # of RPs greater or equal to 3
4992 // 5th bin: event with # of RPs greater or equal to 4
4993 // 6th bin: event with # of RPs greater or equal to 5
4994 // 7th bin: event with # of RPs greater or equal to 6
4995 // 8th bin: event with # of RPs greater or equal to 7
4996 // 9th bin: event with # of RPs greater or equal to 8
4997
489d5531 4998 if(nRP<0)
4999 {
b77b6434 5000 cout<<endl;
5001 cout<<" WARNING (QC): nRP<0 in in AFAWQC::FAM() !!!!"<<endl;
5002 cout<<endl;
489d5531 5003 exit(0);
5004 }
5005
5006 for(Int_t i=0;i<9;i++)
5007 {
b77b6434 5008 if(nRP>=i){fAvMultiplicity->Fill(i+0.5,nRP,1);}
489d5531 5009 }
5010
5011} // end of AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(nRP)
5012
489d5531 5013//================================================================================================================================
5014
489d5531 5015void AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()
b3dacf6b 5016{
b92ea2b9 5017 // a) Calculate Q-cumulants from the measured multiparticle correlations;
5018 // b) Propagate the statistical errors from measured multiparticle correlations to statistical errors of Q-cumulants;
5019 // c) Remark: Q-cumulants calculated in this method are biased by non-uniform acceptance of detector !!!!
5020 // Method CalculateQcumulantsCorrectedForNUAIntFlow() is called afterwards to correct for this bias;
5021 // d) Store the results and statistical error of Q-cumulants in histogram fIntFlowQcumulants.
5022 // Binning of fIntFlowQcumulants is organized as follows:
489d5531 5023 //
b3dacf6b 5024 // 1st bin: QC{2}
5025 // 2nd bin: QC{4}
5026 // 3rd bin: QC{6}
5027 // 4th bin: QC{8}
5028 //
489d5531 5029
b3dacf6b 5030 // Correlations:
489d5531 5031 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
5032 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
5033 Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
5034 Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
b3dacf6b 5035 // Statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:
489d5531 5036 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2>
5037 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4>
5038 Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6>
5039 Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8>
b3dacf6b 5040 // Covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):
8e1cefdd 5041 Double_t wCov24 = 0.; // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
5042 Double_t wCov26 = 0.; // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
5043 Double_t wCov28 = 0.; // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
5044 Double_t wCov46 = 0.; // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
5045 Double_t wCov48 = 0.; // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
5046 Double_t wCov68 = 0.; // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
5047 if(!fForgetAboutCovariances)
5048 {
5049 wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
5050 wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
5051 wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
5052 wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
5053 wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
5054 wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
5055 }
489d5531 5056 // Q-cumulants:
5057 Double_t qc2 = 0.; // QC{2}
5058 Double_t qc4 = 0.; // QC{4}
5059 Double_t qc6 = 0.; // QC{6}
5060 Double_t qc8 = 0.; // QC{8}
b3dacf6b 5061 if(TMath::Abs(two) > 0.){qc2 = two;}
5062 if(TMath::Abs(four) > 0.){qc4 = four-2.*pow(two,2.);}
5063 if(TMath::Abs(six) > 0.){qc6 = six-9.*two*four+12.*pow(two,3.);}
5064 if(TMath::Abs(eight) > 0.){qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.);}
5065 // Statistical errors of Q-cumulants:
489d5531 5066 Double_t qc2Error = 0.;
5067 Double_t qc4Error = 0.;
5068 Double_t qc6Error = 0.;
b3dacf6b 5069 Double_t qc8Error = 0.;
5070 // Squared statistical errors of Q-cumulants:
489d5531 5071 //Double_t qc2ErrorSquared = 0.;
5072 Double_t qc4ErrorSquared = 0.;
5073 Double_t qc6ErrorSquared = 0.;
b3dacf6b 5074 Double_t qc8ErrorSquared = 0.;
5075 // Statistical error of QC{2}:
5076 qc2Error = twoError;
5077 // Statistical error of QC{4}:
489d5531 5078 qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)
5079 - 8.*two*wCov24;
5080 if(qc4ErrorSquared>0.)
5081 {
5082 qc4Error = pow(qc4ErrorSquared,0.5);
5083 } else
5084 {
b3dacf6b 5085 cout<<" WARNING (QC): Statistical error of QC{4} is imaginary !!!!"<<endl;
5086 }
5087 // Statistical error of QC{6}:
489d5531 5088 qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)
5089 + 81.*pow(two,2.)*pow(fourError,2.)
5090 + pow(sixError,2.)
5091 - 162.*two*(4.*pow(two,2.)-four)*wCov24
5092 + 18.*(4.*pow(two,2.)-four)*wCov26
b3dacf6b 5093 - 18.*two*wCov46;
489d5531 5094 if(qc6ErrorSquared>0.)
5095 {
5096 qc6Error = pow(qc6ErrorSquared,0.5);
5097 } else
5098 {
b3dacf6b 5099 cout<<" WARNING (QC): Statistical error of QC{6} is imaginary !!!!"<<endl;
5100 }
5101 // Statistical error of QC{8}:
489d5531 5102 qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)
5103 + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)
5104 + 256.*pow(two,2.)*pow(sixError,2.)
5105 + pow(eightError,2.)
5106 - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24
5107 + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26
5108 - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28
5109 - 1152.*two*(4.*pow(two,2.)-four)*wCov46
5110 + 72.*(4.*pow(two,2.)-four)*wCov48
5111 - 32.*two*wCov68;
5112 if(qc8ErrorSquared>0.)
5113 {
5114 qc8Error = pow(qc8ErrorSquared,0.5);
5115 } else
5116 {
b3dacf6b 5117 cout<<"WARNING (QC): Statistical error of QC{8} is imaginary !!!!"<<endl;
489d5531 5118 }
b3dacf6b 5119 // Store the results and statistical errors for Q-cumulants:
5120 if(TMath::Abs(qc2)>0.)
5121 {
5122 fIntFlowQcumulants->SetBinContent(1,qc2);
5123 fIntFlowQcumulants->SetBinError(1,qc2Error);
5124 }
5125 if(TMath::Abs(qc4)>0.)
5126 {
5127 fIntFlowQcumulants->SetBinContent(2,qc4);
5128 fIntFlowQcumulants->SetBinError(2,qc4Error);
5129 }
5130 if(TMath::Abs(qc6)>0.)
5131 {
5132 fIntFlowQcumulants->SetBinContent(3,qc6);
5133 fIntFlowQcumulants->SetBinError(3,qc6Error);
5134 }
5135 if(TMath::Abs(qc8)>0.)
5136 {
5137 fIntFlowQcumulants->SetBinContent(4,qc8);
5138 fIntFlowQcumulants->SetBinError(4,qc8Error);
5139 }
5140
5141 // Versus multiplicity:
5142 if(!fCalculateCumulantsVsM){return;}
9da1a4f3 5143 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
b3dacf6b 5144 Double_t value[4] = {0.}; // QCs vs M
5145 Double_t error[4] = {0.}; // error of QCs vs M
5146 Double_t dSum1[4] = {0.}; // sum value_i/(error_i)^2
5147 Double_t dSum2[4] = {0.}; // sum 1/(error_i)^2
9da1a4f3 5148 for(Int_t b=1;b<=nBins;b++)
5149 {
b3dacf6b 5150 // Correlations:
9da1a4f3 5151 two = fIntFlowCorrelationsVsMHist[0]->GetBinContent(b); // <<2>>
5152 four = fIntFlowCorrelationsVsMHist[1]->GetBinContent(b); // <<4>>
5153 six = fIntFlowCorrelationsVsMHist[2]->GetBinContent(b); // <<6>>
5154 eight = fIntFlowCorrelationsVsMHist[3]->GetBinContent(b); // <<8>>
b3dacf6b 5155 // Statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:
9da1a4f3 5156 twoError = fIntFlowCorrelationsVsMHist[0]->GetBinError(b); // statistical error of <2>
5157 fourError = fIntFlowCorrelationsVsMHist[1]->GetBinError(b); // statistical error of <4>
5158 sixError = fIntFlowCorrelationsVsMHist[2]->GetBinError(b); // statistical error of <6>
5159 eightError = fIntFlowCorrelationsVsMHist[3]->GetBinError(b); // statistical error of <8>
b3dacf6b 5160 // Covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):
8e1cefdd 5161 if(!fForgetAboutCovariances)
5162 {
5163 wCov24 = fIntFlowCovariancesVsM[0]->GetBinContent(b); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)
5164 wCov26 = fIntFlowCovariancesVsM[1]->GetBinContent(b); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)
5165 wCov28 = fIntFlowCovariancesVsM[2]->GetBinContent(b); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)
5166 wCov46 = fIntFlowCovariancesVsM[3]->GetBinContent(b); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)
5167 wCov48 = fIntFlowCovariancesVsM[4]->GetBinContent(b); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)
5168 wCov68 = fIntFlowCovariancesVsM[5]->GetBinContent(b); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)
5169 }
9da1a4f3 5170 // Q-cumulants:
5171 qc2 = 0.; // QC{2}
5172 qc4 = 0.; // QC{4}
5173 qc6 = 0.; // QC{6}
5174 qc8 = 0.; // QC{8}
b3dacf6b 5175 if(TMath::Abs(two) > 0.){qc2 = two;}
5176 if(TMath::Abs(four) > 0.){qc4 = four-2.*pow(two,2.);}
5177 if(TMath::Abs(six) > 0.){qc6 = six-9.*two*four+12.*pow(two,3.);}
5178 if(TMath::Abs(eight) > 0.){qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.);}
5179 // Statistical errors of Q-cumulants:
9da1a4f3 5180 qc2Error = 0.;
5181 qc4Error = 0.;
5182 qc6Error = 0.;
b3dacf6b 5183 qc8Error = 0.;
5184 // Squared statistical errors of Q-cumulants:
9da1a4f3 5185 //Double_t qc2ErrorSquared = 0.;
5186 qc4ErrorSquared = 0.;
5187 qc6ErrorSquared = 0.;
b3dacf6b 5188 qc8ErrorSquared = 0.;
5189 // Statistical error of QC{2}:
5190 qc2Error = twoError;
5191 // Statistical error of QC{4}:
9da1a4f3 5192 qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)
5193 - 8.*two*wCov24;
5194 if(qc4ErrorSquared>0.)
5195 {
5196 qc4Error = pow(qc4ErrorSquared,0.5);
5197 } else
5198 {
5199 // cout<<"WARNING: Statistical error of QC{4} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
b3dacf6b 5200 }
5201 // Statistical error of QC{6}:
9da1a4f3 5202 qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)
5203 + 81.*pow(two,2.)*pow(fourError,2.)
5204 + pow(sixError,2.)
5205 - 162.*two*(4.*pow(two,2.)-four)*wCov24
5206 + 18.*(4.*pow(two,2.)-four)*wCov26
b3dacf6b 5207 - 18.*two*wCov46;
9da1a4f3 5208 if(qc6ErrorSquared>0.)
5209 {
5210 qc6Error = pow(qc6ErrorSquared,0.5);
5211 } else
5212 {
5213 // cout<<"WARNING: Statistical error of QC{6} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
b3dacf6b 5214 }
5215 // Statistical error of QC{8}:
9da1a4f3 5216 qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)
5217 + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)
5218 + 256.*pow(two,2.)*pow(sixError,2.)
5219 + pow(eightError,2.)
5220 - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24
5221 + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26
5222 - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28
5223 - 1152.*two*(4.*pow(two,2.)-four)*wCov46
5224 + 72.*(4.*pow(two,2.)-four)*wCov48
5225 - 32.*two*wCov68;
5226 if(qc8ErrorSquared>0.)
5227 {
5228 qc8Error = pow(qc8ErrorSquared,0.5);
5229 } else
5230 {
5231 // cout<<"WARNING: Statistical error of QC{8} is imaginary in multiplicity bin "<<b<<" !!!!"<<endl;
5232 }
b3dacf6b 5233 // Store the results and statistical errors for Q-cumulants:
5234 if(TMath::Abs(qc2)>0.)
5235 {
5236 fIntFlowQcumulantsVsM[0]->SetBinContent(b,qc2);
5237 fIntFlowQcumulantsVsM[0]->SetBinError(b,qc2Error);
5238 }
5239 if(TMath::Abs(qc4)>0.)
5240 {
5241 fIntFlowQcumulantsVsM[1]->SetBinContent(b,qc4);
5242 fIntFlowQcumulantsVsM[1]->SetBinError(b,qc4Error);
5243 }
5244 if(TMath::Abs(qc6)>0.)
5245 {
5246 fIntFlowQcumulantsVsM[2]->SetBinContent(b,qc6);
5247 fIntFlowQcumulantsVsM[2]->SetBinError(b,qc6Error);
5248 }
5249 if(TMath::Abs(qc8)>0.)
5250 {
5251 fIntFlowQcumulantsVsM[3]->SetBinContent(b,qc8);
5252 fIntFlowQcumulantsVsM[3]->SetBinError(b,qc8Error);
5253 }
5254 // Rebin in M:
5255 for(Int_t co=0;co<4;co++)
5256 {
b40a910e 5257 if(fIntFlowCorrelationsVsMPro[co]->GetBinEffectiveEntries(b)<2){continue;}
b3dacf6b 5258 value[co] = fIntFlowQcumulantsVsM[co]->GetBinContent(b);
5259 error[co] = fIntFlowQcumulantsVsM[co]->GetBinError(b);
5260 if(error[co]>0.)
5261 {
5262 dSum1[co]+=value[co]/(error[co]*error[co]);
5263 dSum2[co]+=1./(error[co]*error[co]);
5264 }
5265 } // end of for(Int_t co=0;co<4;co++)
9da1a4f3 5266 } // end of for(Int_t b=1;b<=nBins;b++)
b3dacf6b 5267 // Store rebinned Q-cumulants:
5268 for(Int_t co=0;co<4;co++)
5269 {
5270 if(dSum2[co]>0.)
5271 {
5272 fIntFlowQcumulantsRebinnedInM->SetBinContent(co+1,dSum1[co]/dSum2[co]);
5273 fIntFlowQcumulantsRebinnedInM->SetBinError(co+1,pow(1./dSum2[co],0.5));
5274 }
5275 } // end of for(Int_t co=0;co<4;co++)
5276
489d5531 5277} // end of AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()
5278
489d5531 5279//================================================================================================================================
5280
b92ea2b9 5281void AliFlowAnalysisWithQCumulants::CalculateReferenceFlow()
489d5531 5282{
b92ea2b9 5283 // a) Calculate the final results for reference flow estimates from Q-cumulants;
5284 // b) Propagate the statistical errors to reference flow estimates from statistical error of Q-cumulants;
0328db2d 5285 // c) Store the results and statistical errors of reference flow estimates in histogram fIntFlow.
489d5531 5286 // Binning of fIntFlow is organized as follows:
5287 //
b3dacf6b 5288 // 1st bin: v{2,QC}
5289 // 2nd bin: v{4,QC}
5290 // 3rd bin: v{6,QC}
5291 // 4th bin: v{8,QC}
5292 //
489d5531 5293
b3dacf6b 5294 // Reference flow estimates:
489d5531 5295 Double_t v2 = 0.; // v{2,QC}
5296 Double_t v4 = 0.; // v{4,QC}
5297 Double_t v6 = 0.; // v{6,QC}
5298 Double_t v8 = 0.; // v{8,QC}
b3dacf6b 5299 // Reference flow's statistical errors:
5300 Double_t v2Error = 0.; // v{2,QC} stat. error
5301 Double_t v4Error = 0.; // v{4,QC} stat. error
5302 Double_t v6Error = 0.; // v{6,QC} stat. error
5303 Double_t v8Error = 0.; // v{8,QC} stat. error
5304
b92ea2b9 5305 // Q-cumulants:
5306 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}
5307 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}
5308 Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6}
5309 Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}
5310 // Q-cumulants's statistical errors:
5311 Double_t qc2Error = fIntFlowQcumulants->GetBinError(1); // QC{2} stat. error
5312 Double_t qc4Error = fIntFlowQcumulants->GetBinError(2); // QC{4} stat. error
5313 Double_t qc6Error = fIntFlowQcumulants->GetBinError(3); // QC{6} stat. error
5314 Double_t qc8Error = fIntFlowQcumulants->GetBinError(4); // QC{8} stat. error
5315 // Calculate reference flow estimates from Q-cumulants:
1268c371 5316 if(qc2>=0.){v2 = pow(qc2,0.5);}
b92ea2b9 5317 if(qc4<=0.){v4 = pow(-1.*qc4,1./4.);}
5318 if(qc6>=0.){v6 = pow((1./4.)*qc6,1./6.);}
5319 if(qc8<=0.){v8 = pow((-1./33.)*qc8,1./8.);}
5320 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5321 if(qc2>0.){v2Error = (1./2.)*pow(qc2,-0.5)*qc2Error;}
b92ea2b9 5322 if(qc4<0.){v4Error = (1./4.)*pow(-qc4,-3./4.)*qc4Error;}
5323 if(qc6>0.){v6Error = (1./6.)*pow(2.,-1./3.)*pow(qc6,-5./6.)*qc6Error;}
5324 if(qc8<0.){v8Error = (1./8.)*pow(33.,-1./8.)*pow(-qc8,-7./8.)*qc8Error;}
5325 // Print warnings for the 'wrong sign' cumulants:
5326 if(TMath::Abs(v2) < 1.e-44)
5327 {
5328 cout<<" WARNING: Wrong sign QC{2}, couldn't calculate v{2,QC} !!!!"<<endl;
5329 }
5330 if(TMath::Abs(v4) < 1.e-44)
5331 {
5332 cout<<" WARNING: Wrong sign QC{4}, couldn't calculate v{4,QC} !!!!"<<endl;
5333 }
5334 if(TMath::Abs(v6) < 1.e-44)
5335 {
5336 cout<<" WARNING: Wrong sign QC{6}, couldn't calculate v{6,QC} !!!!"<<endl;
5337 }
5338 if(TMath::Abs(v8) < 1.e-44)
5339 {
5340 cout<<" WARNING: Wrong sign QC{8}, couldn't calculate v{8,QC} !!!!"<<endl;
5341 }
5342 // Store the results and statistical errors of integrated flow estimates:
5343 fIntFlow->SetBinContent(1,v2);
5344 fIntFlow->SetBinError(1,v2Error);
5345 fIntFlow->SetBinContent(2,v4);
5346 fIntFlow->SetBinError(2,v4Error);
5347 fIntFlow->SetBinContent(3,v6);
5348 fIntFlow->SetBinError(3,v6Error);
5349 fIntFlow->SetBinContent(4,v8);
5350 fIntFlow->SetBinError(4,v8Error);
5351
5352 // Versus multiplicity:
5353 if(!fCalculateCumulantsVsM){return;}
5354 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
5355 for(Int_t b=1;b<=nBins;b++)
9da1a4f3 5356 {
5357 // Q-cumulants:
b92ea2b9 5358 Double_t qc2VsM = fIntFlowQcumulantsVsM[0]->GetBinContent(b); // QC{2}
5359 Double_t qc4VsM = fIntFlowQcumulantsVsM[1]->GetBinContent(b); // QC{4}
5360 Double_t qc6VsM = fIntFlowQcumulantsVsM[2]->GetBinContent(b); // QC{6}
5361 Double_t qc8VsM = fIntFlowQcumulantsVsM[3]->GetBinContent(b); // QC{8}
b3dacf6b 5362 // Q-cumulants's statistical errors:
b92ea2b9 5363 Double_t qc2ErrorVsM = fIntFlowQcumulantsVsM[0]->GetBinError(b); // QC{2} stat. error
5364 Double_t qc4ErrorVsM = fIntFlowQcumulantsVsM[1]->GetBinError(b); // QC{4} stat. error
5365 Double_t qc6ErrorVsM = fIntFlowQcumulantsVsM[2]->GetBinError(b); // QC{6} stat. error
5366 Double_t qc8ErrorVsM = fIntFlowQcumulantsVsM[3]->GetBinError(b); // QC{8} stat. error
b3dacf6b 5367 // Reference flow estimates:
b92ea2b9 5368 Double_t v2VsM = 0.; // v{2,QC}
5369 Double_t v4VsM = 0.; // v{4,QC}
5370 Double_t v6VsM = 0.; // v{6,QC}
5371 Double_t v8VsM = 0.; // v{8,QC}
5372 // Reference flow estimates errors:
5373 Double_t v2ErrorVsM = 0.; // v{2,QC} stat. error
5374 Double_t v4ErrorVsM = 0.; // v{4,QC} stat. error
5375 Double_t v6ErrorVsM = 0.; // v{6,QC} stat. error
5376 Double_t v8ErrorVsM = 0.; // v{8,QC} stat. error
b3dacf6b 5377 // Calculate reference flow estimates from Q-cumulants:
1268c371 5378 if(qc2VsM>=0.){v2VsM = pow(qc2VsM,0.5);}
b92ea2b9 5379 if(qc4VsM<=0.){v4VsM = pow(-1.*qc4VsM,1./4.);}
5380 if(qc6VsM>=0.){v6VsM = pow((1./4.)*qc6VsM,1./6.);}
5381 if(qc8VsM<=0.){v8VsM = pow((-1./33.)*qc8VsM,1./8.);}
b3dacf6b 5382 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5383 if(qc2VsM>0.){v2ErrorVsM = (1./2.)*pow(qc2VsM,-0.5)*qc2ErrorVsM;}
b92ea2b9 5384 if(qc4VsM<0.){v4ErrorVsM = (1./4.)*pow(-qc4VsM,-3./4.)*qc4ErrorVsM;}
5385 if(qc6VsM>0.){v6ErrorVsM = (1./6.)*pow(2.,-1./3.)*pow(qc6VsM,-5./6.)*qc6ErrorVsM;}
5386 if(qc8VsM<0.){v8ErrorVsM = (1./8.)*pow(33.,-1./8.)*pow(-qc8VsM,-7./8.)*qc8ErrorVsM;}
b3dacf6b 5387 // Store the results and statistical errors of integrated flow estimates:
b92ea2b9 5388 fIntFlowVsM[0]->SetBinContent(b,v2VsM);
5389 fIntFlowVsM[0]->SetBinError(b,v2ErrorVsM);
5390 fIntFlowVsM[1]->SetBinContent(b,v4VsM);
5391 fIntFlowVsM[1]->SetBinError(b,v4ErrorVsM);
5392 fIntFlowVsM[2]->SetBinContent(b,v6VsM);
5393 fIntFlowVsM[2]->SetBinError(b,v6ErrorVsM);
5394 fIntFlowVsM[3]->SetBinContent(b,v8VsM);
5395 fIntFlowVsM[3]->SetBinError(b,v8ErrorVsM);
5396 } // end of for(Int_t b=1;b<=nBins;b++)
5397
5398 // 'Rebinned in M' calculation: // to be improved - this can be implemented better:
5399 // Reference flow estimates:
5400 Double_t v2RebinnedInM = 0.; // v{2,QC}
5401 Double_t v4RebinnedInM = 0.; // v{4,QC}
5402 Double_t v6RebinnedInM = 0.; // v{6,QC}
5403 Double_t v8RebinnedInM = 0.; // v{8,QC}
5404 // Reference flow's statistical errors:
5405 Double_t v2ErrorRebinnedInM = 0.; // v{2,QC} stat. error
5406 Double_t v4ErrorRebinnedInM = 0.; // v{4,QC} stat. error
5407 Double_t v6ErrorRebinnedInM = 0.; // v{6,QC} stat. error
5408 Double_t v8ErrorRebinnedInM = 0.; // v{8,QC} stat. error
5409 // Q-cumulants:
5410 Double_t qc2RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(1); // QC{2}
5411 Double_t qc4RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(2); // QC{4}
5412 Double_t qc6RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(3); // QC{6}
5413 Double_t qc8RebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinContent(4); // QC{8}
5414 // Q-cumulants's statistical errors:
5415 Double_t qc2ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(1); // QC{2} stat. error
5416 Double_t qc4ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(2); // QC{4} stat. error
5417 Double_t qc6ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(3); // QC{6} stat. error
5418 Double_t qc8ErrorRebinnedInM = fIntFlowQcumulantsRebinnedInM->GetBinError(4); // QC{8} stat. error
5419 // Calculate reference flow estimates from Q-cumulants:
1268c371 5420 if(qc2RebinnedInM>=0.){v2RebinnedInM = pow(qc2RebinnedInM,0.5);}
b92ea2b9 5421 if(qc4RebinnedInM<=0.){v4RebinnedInM = pow(-1.*qc4RebinnedInM,1./4.);}
5422 if(qc6RebinnedInM>=0.){v6RebinnedInM = pow((1./4.)*qc6RebinnedInM,1./6.);}
5423 if(qc8RebinnedInM<=0.){v8RebinnedInM = pow((-1./33.)*qc8RebinnedInM,1./8.);}
5424 // Calculate stat. error for reference flow estimates from stat. error of Q-cumulants:
1268c371 5425 if(qc2RebinnedInM>0.){v2ErrorRebinnedInM = (1./2.)*pow(qc2RebinnedInM,-0.5)*qc2ErrorRebinnedInM;}
b92ea2b9 5426 if(qc4RebinnedInM<0.){v4ErrorRebinnedInM = (1./4.)*pow(-qc4RebinnedInM,-3./4.)*qc4ErrorRebinnedInM;}
5427 if(qc6RebinnedInM>0.){v6ErrorRebinnedInM = (1./6.)*pow(2.,-1./3.)*pow(qc6RebinnedInM,-5./6.)*qc6ErrorRebinnedInM;}
5428 if(qc8RebinnedInM<0.){v8ErrorRebinnedInM = (1./8.)*pow(33.,-1./8.)*pow(-qc8RebinnedInM,-7./8.)*qc8ErrorRebinnedInM;}
5429 // Print warnings for the 'wrong sign' cumulants:
5430 if(TMath::Abs(v2RebinnedInM) < 1.e-44)
5431 {
5432 cout<<" WARNING: Wrong sign QC{2} rebinned in M, couldn't calculate v{2,QC} !!!!"<<endl;
5433 }
5434 if(TMath::Abs(v4RebinnedInM) < 1.e-44)
5435 {
5436 cout<<" WARNING: Wrong sign QC{4} rebinned in M, couldn't calculate v{4,QC} !!!!"<<endl;
5437 }
5438 if(TMath::Abs(v6RebinnedInM) < 1.e-44)
5439 {
5440 cout<<" WARNING: Wrong sign QC{6} rebinned in M, couldn't calculate v{6,QC} !!!!"<<endl;
5441 }
5442 if(TMath::Abs(v8RebinnedInM) < 1.e-44)
5443 {
5444 cout<<" WARNING: Wrong sign QC{8} rebinned in M, couldn't calculate v{8,QC} !!!!"<<endl;
5445 }
5446 // Store the results and statistical errors of integrated flow estimates:
5447 fIntFlowRebinnedInM->SetBinContent(1,v2RebinnedInM);
5448 fIntFlowRebinnedInM->SetBinError(1,v2ErrorRebinnedInM);
5449 fIntFlowRebinnedInM->SetBinContent(2,v4RebinnedInM);
5450 fIntFlowRebinnedInM->SetBinError(2,v4ErrorRebinnedInM);
5451 fIntFlowRebinnedInM->SetBinContent(3,v6RebinnedInM);
5452 fIntFlowRebinnedInM->SetBinError(3,v6ErrorRebinnedInM);
5453 fIntFlowRebinnedInM->SetBinContent(4,v8RebinnedInM);
5454 fIntFlowRebinnedInM->SetBinError(4,v8ErrorRebinnedInM);
5455
5456} // end of AliFlowAnalysisWithQCumulants::CalculateReferenceFlow()
489d5531 5457
489d5531 5458//================================================================================================================================
5459
489d5531 5460void AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()
5461{
0dd3b008 5462 // Fill in AliFlowCommonHistResults histograms relevant for reference flow.
489d5531 5463
0dd3b008 5464 // There are two possibilities here:
5465 // a) Store minimum bias reference flow - use SetMinimumBiasReferenceFlow(kTRUE). This result is
5466 // biased by the interplay between nonflow correlations and multiplicity fluctuations and is
5467 // also stored in local histogram fIntFlow;
5468 // b) Store reference flow obtained from flow analysis performed at fixed multiplicity and
5469 // rebinned only at the end of the day - use SetMinimumBiasReferenceFlow(kFALSE). This result
5470 // is also stored in local histogram fIntFlowRebinnedInM.
489d5531 5471
0dd3b008 5472 // Reference flow estimates:
5473 Double_t v[4] = {0.};
5474 // Statistical errors of reference flow estimates:
5475 Double_t vError[4] = {0.};
489d5531 5476
0dd3b008 5477 for(Int_t b=0;b<4;b++)
5478 {
5479 if(fMinimumBiasReferenceFlow)
5480 {
5481 v[b] = fIntFlow->GetBinContent(b+1);
5482 vError[b] = fIntFlow->GetBinError(b+1);
5483 } else
5484 {
5485 v[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
5486 vError[b] = fIntFlowRebinnedInM->GetBinError(b+1);
5487 }
5488 } // end of for(Int_t b=0;b<4;b++)
5489
5490 // Fill AliFlowCommonHistResults histogram:
5491 fCommonHistsResults2nd->FillIntegratedFlow(v[0],vError[0]); // to be improved (hardwired 2nd in the name)
5492 fCommonHistsResults4th->FillIntegratedFlow(v[1],vError[1]); // to be improved (hardwired 4th in the name)
403e3389 5493 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)) // to be improved (calculate also 6th and 8th order)
489d5531 5494 {
0dd3b008 5495 fCommonHistsResults6th->FillIntegratedFlow(v[2],vError[2]); // to be improved (hardwired 6th in the name)
5496 fCommonHistsResults8th->FillIntegratedFlow(v[3],vError[3]); // to be improved (hardwired 8th in the name)
489d5531 5497 }
5498
5499} // end of AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()
5500
489d5531 5501//================================================================================================================================
5502
489d5531 5503void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()
5504{
5505 // Calculate all correlations needed for integrated flow using particle weights.
5506
5507 // Remark 1: When particle weights are used the binning of fIntFlowCorrelationAllPro is organized as follows:
5508 //
5509 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>
5510 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>
5511 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))>
5512 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>
5513 // 5th bin: ---- EMPTY ----
5514 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
5515 // 7th bin: <3>_{3n|2n,1n} = ...
5516 // 8th bin: <3>_{4n|2n,2n} = ...
5517 // 9th bin: <3>_{4n|3n,1n} = ...
5518 // 10th bin: ---- EMPTY ----
5519 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
5520 // 12th bin: <4>_{2n,1n|2n,1n} = ...
5521 // 13th bin: <4>_{2n,2n|2n,2n} = ...
5522 // 14th bin: <4>_{3n|1n,1n,1n} = ...
5523 // 15th bin: <4>_{3n,1n|3n,1n} = ...
5524 // 16th bin: <4>_{3n,1n|2n,2n} = ...
5525 // 17th bin: <4>_{4n|2n,1n,1n} = ...
5526 // 18th bin: ---- EMPTY ----
5527 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...
5528 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...
5529 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...
5530 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...
5531 // 23rd bin: ---- EMPTY ----
5532 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...
5533 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...
5534 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...
5535 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...
5536 // 28th bin: ---- EMPTY ----
5537 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...
5538 // 30th bin: ---- EMPTY ----
5539 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...
5540
5541 // Remark 2: When particle weights are used there are some extra correlations. They are stored in
5542 // fIntFlowExtraCorrelationsPro binning of which is organized as follows:
5543
5544 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>
5545 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>
5546
5547 // multiplicity (number of particles used to determine the reaction plane)
1268c371 5548 Double_t dMult = (*fSpk)(0,0);
489d5531 5549
5550 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
5551 Double_t dReQ1n1k = (*fReQ)(0,1);
5552 Double_t dReQ2n2k = (*fReQ)(1,2);
5553 Double_t dReQ3n3k = (*fReQ)(2,3);
5554 Double_t dReQ4n4k = (*fReQ)(3,4);
5555 Double_t dReQ1n3k = (*fReQ)(0,3);
5556 Double_t dImQ1n1k = (*fImQ)(0,1);
5557 Double_t dImQ2n2k = (*fImQ)(1,2);
5558 Double_t dImQ3n3k = (*fImQ)(2,3);
5559 Double_t dImQ4n4k = (*fImQ)(3,4);
5560 Double_t dImQ1n3k = (*fImQ)(0,3);
5561
5562 // dMs are variables introduced in order to simplify some Eqs. bellow:
5563 //..............................................................................................
1268c371 5564 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
5565 Double_t dM22 = (*fSpk)(1,2)-(*fSpk)(0,4); // dM22 = sum_{i,j=1,i!=j}^M w_i^2 w_j^2
5566 Double_t dM33 = (*fSpk)(1,3)-(*fSpk)(0,6); // dM33 = sum_{i,j=1,i!=j}^M w_i^3 w_j^3
5567 Double_t dM44 = (*fSpk)(1,4)-(*fSpk)(0,8); // dM44 = sum_{i,j=1,i!=j}^M w_i^4 w_j^4
5568 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
5569 Double_t dM211 = (*fSpk)(0,2)*(*fSpk)(1,1)-2.*(*fSpk)(0,3)*(*fSpk)(0,1)
5570 - (*fSpk)(1,2)+2.*(*fSpk)(0,4); // dM211 = sum_{i,j,k=1,i!=j!=k}^M w_i^2 w_j w_k
5571 Double_t dM1111 = (*fSpk)(3,1)-6.*(*fSpk)(0,2)*(*fSpk)(1,1)
5572 + 8.*(*fSpk)(0,3)*(*fSpk)(0,1)
5573 + 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 5574 //..............................................................................................
5575
5576 // 2-particle correlations:
5577 Double_t two1n1nW1W1 = 0.; // <w1 w2 cos(n*(phi1-phi2))>
5578 Double_t two2n2nW2W2 = 0.; // <w1^2 w2^2 cos(2n*(phi1-phi2))>
5579 Double_t two3n3nW3W3 = 0.; // <w1^3 w2^3 cos(3n*(phi1-phi2))>
5580 Double_t two4n4nW4W4 = 0.; // <w1^4 w2^4 cos(4n*(phi1-phi2))>
5581 if(dMult>1)
5582 {
5583 if(dM11)
5584 {
1268c371 5585 two1n1nW1W1 = (pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSpk)(0,2))/dM11;
489d5531 5586 // average correlation <w1 w2 cos(n*(phi1-phi2))> for single event:
5587 fIntFlowCorrelationsEBE->SetBinContent(1,two1n1nW1W1);
5588 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,dM11);
5589 // average correlation <w1 w2 cos(n*(phi1-phi2))> for all events:
b40a910e 5590 fIntFlowCorrelationsPro->Fill(0.5,two1n1nW1W1,dM11);
5591 // average squared correlation <w1 w2 cos(n*(phi1-phi2))> for all events:
5592 fIntFlowSquaredCorrelationsPro->Fill(0.5,two1n1nW1W1*two1n1nW1W1,dM11);
489d5531 5593 fIntFlowCorrelationsAllPro->Fill(0.5,two1n1nW1W1,dM11);
5594 }
5595 if(dM22)
5596 {
1268c371 5597 two2n2nW2W2 = (pow(dReQ2n2k,2)+pow(dImQ2n2k,2)-(*fSpk)(0,4))/dM22;
489d5531 5598 // ...
5599 // average correlation <w1^2 w2^2 cos(2n*(phi1-phi2))> for all events:
5600 fIntFlowCorrelationsAllPro->Fill(1.5,two2n2nW2W2,dM22);
5601 }
5602 if(dM33)
5603 {
1268c371 5604 two3n3nW3W3 = (pow(dReQ3n3k,2)+pow(dImQ3n3k,2)-(*fSpk)(0,6))/dM33;
489d5531 5605 // ...
5606 // average correlation <w1^3 w2^3 cos(3n*(phi1-phi2))> for all events:
5607 fIntFlowCorrelationsAllPro->Fill(2.5,two3n3nW3W3,dM33);
5608 }
5609 if(dM44)
5610 {
1268c371 5611 two4n4nW4W4 = (pow(dReQ4n4k,2)+pow(dImQ4n4k,2)-(*fSpk)(0,8))/dM44;
489d5531 5612 // ...
5613 // average correlation <w1^4 w2^4 cos(4n*(phi1-phi2))> for all events:
5614 fIntFlowCorrelationsAllPro->Fill(3.5,two4n4nW4W4,dM44);
5615 }
5616 } // end of if(dMult>1)
5617
5618 // extra 2-particle correlations:
5619 Double_t two1n1nW3W1 = 0.; // <w1^3 w2 cos(n*(phi1-phi2))>
5620 Double_t two1n1nW1W1W2 = 0.; // <w1 w2 w3^2 cos(n*(phi1-phi2))>
5621 if(dMult>1)
5622 {
5623 if(dM31)
5624 {
1268c371 5625 two1n1nW3W1 = (dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k-(*fSpk)(0,4))/dM31;
489d5531 5626 fIntFlowExtraCorrelationsPro->Fill(0.5,two1n1nW3W1,dM31);
5627 }
5628 if(dM211)
5629 {
1268c371 5630 two1n1nW1W1W2 = ((*fSpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSpk)(0,2))
489d5531 5631 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k
1268c371 5632 - (*fSpk)(0,4)))/dM211;
489d5531 5633 fIntFlowExtraCorrelationsPro->Fill(1.5,two1n1nW1W1W2,dM211);
5634 }
5635 } // end of if(dMult>1)
5636 //..............................................................................................
5637
5638 //..............................................................................................
5639 // 3-particle correlations:
5640 Double_t three2n1n1nW2W1W1 = 0.; // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
5641
5642 if(dMult>2)
5643 {
5644 if(dM211)
5645 {
5646 three2n1n1nW2W1W1 = (pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k
5647 - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)
5648 - pow(dReQ2n2k,2)-pow(dImQ2n2k,2)
1268c371 5649 + 2.*(*fSpk)(0,4))/dM211;
489d5531 5650 fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1nW2W1W1,dM211);
5651 }
5652 } // end of if(dMult>2)
5653 //..............................................................................................
5654
5655 //..............................................................................................
5656 // 4-particle correlations:
5657 Double_t four1n1n1n1nW1W1W1W1 = 0.; // <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
5658 if(dMult>3)
5659 {
5660 if(dM1111)
5661 {
5662 four1n1n1n1nW1W1W1W1 = (pow(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.),2)
5663 - 2.*(pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k)
5664 + 8.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)
5665 + (pow(dReQ2n2k,2)+pow(dImQ2n2k,2))
1268c371 5666 - 4.*(*fSpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
5667 - 6.*(*fSpk)(0,4)+2.*(*fSpk)(1,2))/dM1111;
489d5531 5668
5669 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for single event:
5670 fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1nW1W1W1W1);
5671 fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,dM1111);
5672 // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:
5673 fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1,dM1111);
b40a910e 5674 // average squared correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:
5675 fIntFlowSquaredCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1*four1n1n1n1nW1W1W1W1,dM1111);
489d5531 5676 fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1nW1W1W1W1,dM1111);
5677 }
5678 } // end of if(dMult>3)
5679 //..............................................................................................
5680
5681} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()
5682
489d5531 5683//================================================================================================================================
5684
489d5531 5685void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()
5686{
5687 // Initialize all arrays used to calculate integrated flow.
5688
5689 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5690 {
5691 fIntFlowCorrectionTermsForNUAEBE[sc] = NULL;
0328db2d 5692 fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc] = NULL;
489d5531 5693 fIntFlowCorrectionTermsForNUAPro[sc] = NULL;
5694 fIntFlowCorrectionTermsForNUAHist[sc] = NULL;
b92ea2b9 5695 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2001bc3a 5696 {
5697 fIntFlowCorrectionTermsForNUAVsMPro[sc][ci] = NULL;
5698 }
0328db2d 5699 for(Int_t power=0;power<2;power++) // linear or quadratic
5700 {
5701 fIntFlowSumOfEventWeightsNUA[sc][power] = NULL;
5702 }
489d5531 5703 }
5704 for(Int_t power=0;power<2;power++) // linear or quadratic
5705 {
5706 fIntFlowSumOfEventWeights[power] = NULL;
5707 }
b3dacf6b 5708 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 5709 {
5710 fPrintFinalResults[i] = kTRUE;
5711 }
ff70ca91 5712 for(Int_t ci=0;ci<4;ci++) // correlation index or cumulant order
5713 {
5714 fIntFlowCorrelationsVsMPro[ci] = NULL;
b40a910e 5715 fIntFlowSquaredCorrelationsVsMPro[ci] = NULL;
ff70ca91 5716 fIntFlowCorrelationsVsMHist[ci] = NULL;
5717 fIntFlowQcumulantsVsM[ci] = NULL;
5718 fIntFlowVsM[ci] = NULL;
2001bc3a 5719 fIntFlowDetectorBiasVsM[ci] = NULL;
ff70ca91 5720 for(Int_t lc=0;lc<2;lc++)
5721 {
5722 fIntFlowSumOfEventWeightsVsM[ci][lc] = NULL;
5723 }
5724 }
5725 for(Int_t pi=0;pi<6;pi++) // product or covariance index
5726 {
5727 fIntFlowProductOfCorrelationsVsMPro[pi] = NULL;
5728 fIntFlowCovariancesVsM[pi] = NULL;
5729 fIntFlowSumOfProductOfEventWeightsVsM[pi] = NULL;
5730 }
403e3389 5731 for(Int_t ci=0;ci<64;ci++) // correlation index for all correlations vs M profiles (to be improved - hardwired 64)
3435cacb 5732 {
5733 fIntFlowCorrelationsAllVsMPro[ci] = NULL;
5734 }
5735
489d5531 5736} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()
5737
489d5531 5738//================================================================================================================================
5739
489d5531 5740void AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()
5741{
5742 // Initialize all arrays needed to calculate differential flow.
5743 // a) Initialize lists holding profiles;
5744 // b) Initialize lists holding histograms;
5745 // c) Initialize event-by-event quantities;
5746 // d) Initialize profiles;
5747 // e) Initialize histograms holding final results.
5748
5749 // a) Initialize lists holding profiles;
5750 for(Int_t t=0;t<2;t++) // type (RP, POI)
5751 {
5752 for(Int_t pe=0;pe<2;pe++) // pt or eta
5753 {
5754 fDiffFlowCorrelationsProList[t][pe] = NULL;
5755 fDiffFlowProductOfCorrelationsProList[t][pe] = NULL;
5756 fDiffFlowCorrectionsProList[t][pe] = NULL;
5757 }
1268c371 5758 // 2D:
5759 f2DDiffFlowCorrelationsProList[t] = NULL;
489d5531 5760 }
5761
5762 // b) Initialize lists holding histograms;
5763 for(Int_t t=0;t<2;t++) // type (RP, POI)
5764 {
5765 for(Int_t pe=0;pe<2;pe++) // pt or eta
5766 {
5767 fDiffFlowCorrelationsHistList[t][pe] = NULL;
5768 for(Int_t power=0;power<2;power++)
5769 {
5770 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = NULL;
5771 } // end of for(Int_t power=0;power<2;power++)
5772 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = NULL;
5773 fDiffFlowCorrectionsHistList[t][pe] = NULL;
5774 fDiffFlowCovariancesHistList[t][pe] = NULL;
5775 fDiffFlowCumulantsHistList[t][pe] = NULL;
1268c371 5776 fDiffFlowDetectorBiasHistList[t][pe] = NULL;
489d5531 5777 fDiffFlowHistList[t][pe] = NULL;
5778 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
5779 } // enf of for(Int_t t=0;t<2;t++) // type (RP, POI)
5780
5781 // c) Initialize event-by-event quantities:
5782 // 1D:
5783 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
5784 {
5785 for(Int_t pe=0;pe<2;pe++) // pt or eta
5786 {
5787 for(Int_t m=0;m<4;m++) // multiple of harmonic
5788 {
5789 for(Int_t k=0;k<9;k++) // power of weight
5790 {
5791 fReRPQ1dEBE[t][pe][m][k] = NULL;
5792 fImRPQ1dEBE[t][pe][m][k] = NULL;
5793 fs1dEBE[t][pe][k] = NULL; // to be improved (this doesn't need to be within loop over m)
5794 }
5795 }
5796 }
5797 }
5798 // 1D:
5799 for(Int_t t=0;t<2;t++) // type (RP or POI)
5800 {
5801 for(Int_t pe=0;pe<2;pe++) // pt or eta
5802 {
5803 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5804 {
5805 for(Int_t cti=0;cti<9;cti++) // correction term index
5806 {
5807 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = NULL;
5808 }
5809 }
5810 }
5811 }
5812 // 2D:
5813 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
5814 {
5815 for(Int_t m=0;m<4;m++) // multiple of harmonic
5816 {
5817 for(Int_t k=0;k<9;k++) // power of weight
5818 {
5819 fReRPQ2dEBE[t][m][k] = NULL;
5820 fImRPQ2dEBE[t][m][k] = NULL;
5821 fs2dEBE[t][k] = NULL; // to be improved (this doesn't need to be within loop over m)
5822 }
5823 }
5824 }
5825
5826 // d) Initialize profiles:
5827 for(Int_t t=0;t<2;t++) // type: RP or POI
5828 {
5829 for(Int_t pe=0;pe<2;pe++) // pt or eta
5830 {
5831 for(Int_t ci=0;ci<4;ci++) // correlation index
5832 {
5833 fDiffFlowCorrelationsPro[t][pe][ci] = NULL;
b40a910e 5834 fDiffFlowSquaredCorrelationsPro[t][pe][ci] = NULL;
489d5531 5835 } // end of for(Int_t ci=0;ci<4;ci++)
5836 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5837 {
5838 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5839 {
5840 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = NULL;
5841 } // end of for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5842 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5843 // correction terms for nua:
5844 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5845 {
5846 for(Int_t cti=0;cti<9;cti++) // correction term index
5847 {
5848 fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = NULL;
5849 }
5850 }
64e500e3 5851 // other differential correlators:
5852 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5853 {
5854 for(Int_t ci=0;ci<1;ci++) // correction term index
5855 {
5856 fOtherDiffCorrelators[t][pe][sc][ci] = NULL;
5857 }
5858 }
489d5531 5859 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
1268c371 5860 for(Int_t ci=0;ci<4;ci++) // correlation index
5861 {
5862 f2DDiffFlowCorrelationsPro[t][ci] = NULL;
5863 }
489d5531 5864 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
5865
5866 // e) Initialize histograms holding final results.
5867 for(Int_t t=0;t<2;t++) // type: RP or POI
5868 {
5869 for(Int_t pe=0;pe<2;pe++) // pt or eta
5870 {
5871 for(Int_t ci=0;ci<4;ci++) // correlation index
5872 {
5873 fDiffFlowCorrelationsHist[t][pe][ci] = NULL;
5874 fDiffFlowCumulants[t][pe][ci] = NULL;
1268c371 5875 fDiffFlowDetectorBias[t][pe][ci] = NULL;
489d5531 5876 fDiffFlow[t][pe][ci] = NULL;
5877 } // end of for(Int_t ci=0;ci<4;ci++)
5878 for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++)
5879 {
5880 fDiffFlowCovariances[t][pe][covarianceIndex] = NULL;
5881 } // end of for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++)
5882 // correction terms for nua:
5883 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
5884 {
5885 for(Int_t cti=0;cti<9;cti++) // correction term index
5886 {
5887 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = NULL;
5888 }
5889 }
5890 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
1268c371 5891 for(Int_t ci=0;ci<4;ci++) // correlation index
5892 {
5893 f2DDiffFlowCumulants[t][ci] = NULL;
5894 f2DDiffFlow[t][ci] = NULL;
5895 }
489d5531 5896 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
5897
5898 // sum of event weights for reduced correlations:
5899 for(Int_t t=0;t<2;t++) // type = RP or POI
5900 {
5901 for(Int_t pe=0;pe<2;pe++) // pt or eta
5902 {
5903 for(Int_t p=0;p<2;p++) // power of weight is 1 or 2
5904 {
5905 for(Int_t ew=0;ew<4;ew++) // event weight index for reduced correlations
5906 {
5907 fDiffFlowSumOfEventWeights[t][pe][p][ew] = NULL;
5908 }
5909 }
5910 }
5911 }
5912 // product of event weights for both types of correlations:
5913 for(Int_t t=0;t<2;t++) // type = RP or POI
5914 {
5915 for(Int_t pe=0;pe<2;pe++) // pt or eta
5916 {
5917 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
5918 {
5919 for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index
5920 {
5921 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = NULL;
5922 }
5923 }
5924 }
5925 }
1268c371 5926
5927} // end of AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()
5928
5929//================================================================================================================================
489d5531 5930
1268c371 5931void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, TString ptOrEta)
5932{
5933 // Calculate differential flow cumulants from measured multiparticle correlations.
489d5531 5934
1268c371 5935 // REMARK: Cumulants calculated in this method are NOT corrected for non-uniform acceptance.
5936 // This correction, if enabled via setter SetApplyCorrectionForNUA(Bool_t), is applied
5937 // in the method CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
489d5531 5938
1268c371 5939 Int_t t = 0;
5940 Int_t pe = 0;
5941
5942 if(type == "RP")
5943 {
5944 t = 0;
5945 } else if(type == "POI")
5946 {
5947 t = 1;
5948 }
5949
5950 if(ptOrEta == "Pt")
5951 {
5952 pe = 0;
5953 } else if(ptOrEta == "Eta")
5954 {
5955 pe = 1;
5956 }
5957
5958 // Common:
5959 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 5960
1268c371 5961 // Correlation <<2>>:
5962 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);
5963 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);
489d5531 5964
1268c371 5965 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
489d5531 5966 {
1268c371 5967 // Reduced correlations:
5968 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>
5969 Double_t twoPrimeError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b); // stat. error of <<2'>>
5970 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>
5971 Double_t fourPrimeError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b); // stat. error of <<4'>>
5972 // Covariances:
5973 Double_t wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b); // Cov(<2>,<2'>) * prefactor(<2>,<2'>)
5974 Double_t wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b); // Cov(<2>,<4'>) * prefactor(<2>,<4'>)
5975 Double_t wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b); // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)
5976 // QC{2'}:
5977 Double_t qc2Prime = twoPrime; // QC{2'}
5978 Double_t qc2PrimeError = twoPrimeError; // stat. error of QC{2'}
5979 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);
5980 fDiffFlowCumulants[t][pe][0]->SetBinError(b,qc2PrimeError);
5981 // QC{4'}:
5982 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>
5983 Double_t qc4PrimeError = 0.; // stat. error of QC{4'}
5984 Double_t qc4PrimeErrorSquared = 4.*pow(twoPrime,2.)*pow(twoError,2.)
5985 + 4.*pow(two,2.)*pow(twoPrimeError,2.)
5986 + pow(fourPrimeError,2.)
5987 + 8.*two*twoPrime*wCovTwoTwoReduced
5988 - 4.*twoPrime*wCovTwoFourReduced
5989 - 4.*two*wCovTwoReducedFourReduced;
5990 if(qc4PrimeErrorSquared>0.)
5991 {
5992 qc4PrimeError = pow(qc4PrimeErrorSquared,0.5);
489d5531 5993 }
1268c371 5994 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime);
5995 fDiffFlowCumulants[t][pe][1]->SetBinError(b,qc4PrimeError);
489d5531 5996 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 5997
1268c371 5998} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, Bool_t useParticleWeights, TString eventWeights);
489d5531 5999
6000//================================================================================================================================
6001
1268c371 6002void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCumulants(TString type)
489d5531 6003{
1268c371 6004 // Calculate 2D differential cumulants.
489d5531 6005
1268c371 6006 // Remark: correction for detector effects and error propagation not implemented yet for 2D differential cumulants.
489d5531 6007
1268c371 6008 Int_t t = 0;
489d5531 6009
6010 if(type == "RP")
6011 {
1268c371 6012 t = 0;
489d5531 6013 } else if(type == "POI")
6014 {
1268c371 6015 t = 1;
6016 }
6017
6018 // Reference correlation <<2>>:
6019 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);
489d5531 6020
1268c371 6021 // Looping over all (pt,eta) bins and calculating differential flow cumulants:
6022 for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 6023 {
6024 for(Int_t e=1;e<=fnBinsEta;e++)
6025 {
1268c371 6026 // Reduced correlations:
6027 Double_t twoPrime = f2DDiffFlowCorrelationsPro[t][0]->GetBinContent(f2DDiffFlowCorrelationsPro[t][0]->GetBin(p,e)); // <<2'>>(pt,eta)
6028 Double_t fourPrime = f2DDiffFlowCorrelationsPro[t][1]->GetBinContent(f2DDiffFlowCorrelationsPro[t][1]->GetBin(p,e)); // <<4'>>(pt,eta)
6029 // Cumulants:
6030 Double_t qc2Prime = twoPrime; // QC{2'} = <<2'>>
6031 f2DDiffFlowCumulants[t][0]->SetBinContent(f2DDiffFlowCumulants[t][0]->GetBin(p,e),qc2Prime);
6032 Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>
6033 f2DDiffFlowCumulants[t][1]->SetBinContent(f2DDiffFlowCumulants[t][1]->GetBin(p,e),qc4Prime);
489d5531 6034 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
489d5531 6035 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
6036
1268c371 6037} // end of void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCumulants(TString type)
489d5531 6038
489d5531 6039//================================================================================================================================
6040
489d5531 6041void AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)
6042{
1268c371 6043 // Calculate final results for integrated flow of RPs and POIs.
489d5531 6044
1268c371 6045 // to be improved - check if the integrated flow calculation here is actually correct
6046
6047 Int_t t = 0; // RP = 0, POI = 1
489d5531 6048
6049 if(type == "RP")
6050 {
1268c371 6051 t = 0;
489d5531 6052 } else if(type == "POI")
6053 {
1268c371 6054 t = 1;
6055 }
489d5531 6056
489d5531 6057 // pt yield:
6058 TH1F *yield2ndPt = NULL;
6059 TH1F *yield4thPt = NULL;
6060 TH1F *yield6thPt = NULL;
6061 TH1F *yield8thPt = NULL;
6062
6063 if(type == "POI")
6064 {
dd442cd2 6065 if(fFillMultipleControlHistograms)
6066 {
6067 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtPOI())->Clone();
6068 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtPOI())->Clone();
6069 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtPOI())->Clone();
6070 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtPOI())->Clone();
6071 } else
6072 {
6073 yield2ndPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
6074 yield4thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
6075 yield6thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
6076 yield8thPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
6077 }
489d5531 6078 }
6079 else if(type == "RP")
6080 {
dd442cd2 6081 if(fFillMultipleControlHistograms)
6082 {
6083 yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtRP())->Clone();
6084 yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtRP())->Clone();
6085 yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtRP())->Clone();
6086 yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtRP())->Clone();
6087 } else
6088 {
6089 yield2ndPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6090 yield4thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6091 yield6thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6092 yield8thPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
6093 }
489d5531 6094 }
6095
0d11c335 6096 if(!yield2ndPt){return;}
6097 if(!yield4thPt){return;}
6098 if(!yield6thPt){return;}
6099 if(!yield8thPt){return;}
6100
489d5531 6101 Int_t nBinsPt = yield2ndPt->GetNbinsX();
6102
6103 TH1D *flow2ndPt = NULL;
6104 TH1D *flow4thPt = NULL;
6105 TH1D *flow6thPt = NULL;
6106 TH1D *flow8thPt = NULL;
6107
6108 // to be improved (hardwired pt index)
6109 flow2ndPt = (TH1D*)fDiffFlow[t][0][0]->Clone();
6110 flow4thPt = (TH1D*)fDiffFlow[t][0][1]->Clone();
6111 flow6thPt = (TH1D*)fDiffFlow[t][0][2]->Clone();
6112 flow8thPt = (TH1D*)fDiffFlow[t][0][3]->Clone();
0d11c335 6113
6114 if(!flow2ndPt){return;}
6115 if(!flow4thPt){return;}
6116 if(!flow6thPt){return;}
6117 if(!flow8thPt){return;}
489d5531 6118
6119 Double_t dvn2nd = 0., dvn4th = 0., dvn6th = 0., dvn8th = 0.; // differential flow
6120 Double_t dErrvn2nd = 0., dErrvn4th = 0., dErrvn6th = 0., dErrvn8th = 0.; // error on differential flow
6121
6122 Double_t dVn2nd = 0., dVn4th = 0., dVn6th = 0., dVn8th = 0.; // integrated flow
6123 Double_t dErrVn2nd = 0., dErrVn4th = 0., dErrVn6th = 0., dErrVn8th = 0.; // error on integrated flow
6124
6125 Double_t dYield2nd = 0., dYield4th = 0., dYield6th = 0., dYield8th = 0.; // pt yield
6126 Double_t dSum2nd = 0., dSum4th = 0., dSum6th = 0., dSum8th = 0.; // needed for normalizing integrated flow
6127
6128 // looping over pt bins:
6129 for(Int_t p=1;p<nBinsPt+1;p++)
6130 {
6131 dvn2nd = flow2ndPt->GetBinContent(p);
6132 dvn4th = flow4thPt->GetBinContent(p);
6133 dvn6th = flow6thPt->GetBinContent(p);
6134 dvn8th = flow8thPt->GetBinContent(p);
6135
6136 dErrvn2nd = flow2ndPt->GetBinError(p);
6137 dErrvn4th = flow4thPt->GetBinError(p);
6138 dErrvn6th = flow6thPt->GetBinError(p);
6139 dErrvn8th = flow8thPt->GetBinError(p);
6140
6141 dYield2nd = yield2ndPt->GetBinContent(p);
6142 dYield4th = yield4thPt->GetBinContent(p);
6143 dYield6th = yield6thPt->GetBinContent(p);
6144 dYield8th = yield8thPt->GetBinContent(p);
6145
6146 dVn2nd += dvn2nd*dYield2nd;
6147 dVn4th += dvn4th*dYield4th;
6148 dVn6th += dvn6th*dYield6th;
6149 dVn8th += dvn8th*dYield8th;
6150
6151 dSum2nd += dYield2nd;
6152 dSum4th += dYield4th;
6153 dSum6th += dYield6th;
6154 dSum8th += dYield8th;
6155
6156 dErrVn2nd += dYield2nd*dYield2nd*dErrvn2nd*dErrvn2nd; // ro be improved (check this relation)
6157 dErrVn4th += dYield4th*dYield4th*dErrvn4th*dErrvn4th;
6158 dErrVn6th += dYield6th*dYield6th*dErrvn6th*dErrvn6th;
6159 dErrVn8th += dYield8th*dYield8th*dErrvn8th*dErrvn8th;
6160
6161 } // end of for(Int_t p=1;p<nBinsPt+1;p++)
6162
6163 // normalizing the results for integrated flow:
6164 if(dSum2nd)
6165 {
6166 dVn2nd /= dSum2nd;
6167 dErrVn2nd /= (dSum2nd*dSum2nd);
6168 dErrVn2nd = TMath::Sqrt(dErrVn2nd);
6169 }
6170 if(dSum4th)
6171 {
6172 dVn4th /= dSum4th;
6173 dErrVn4th /= (dSum4th*dSum4th);
6174 dErrVn4th = TMath::Sqrt(dErrVn4th);
6175 }
6176 //if(dSum6th) dVn6th/=dSum6th;
6177 //if(dSum8th) dVn8th/=dSum8th;
6178
6179 // storing the results for integrated flow in common histos: (to be improved: new method for this?)
6180 if(type == "POI")
6181 {
6182 fCommonHistsResults2nd->FillIntegratedFlowPOI(dVn2nd,dErrVn2nd);
6183 fCommonHistsResults4th->FillIntegratedFlowPOI(dVn4th,dErrVn4th);
6184 fCommonHistsResults6th->FillIntegratedFlowPOI(dVn6th,0.); // to be improved (errors)
6185 fCommonHistsResults8th->FillIntegratedFlowPOI(dVn8th,0.); // to be improved (errors)
6186 }
6187 else if (type == "RP")
6188 {
6189 fCommonHistsResults2nd->FillIntegratedFlowRP(dVn2nd,dErrVn2nd);
6190 fCommonHistsResults4th->FillIntegratedFlowRP(dVn4th,dErrVn4th);
6191 fCommonHistsResults6th->FillIntegratedFlowRP(dVn6th,0.); // to be improved (errors)
6192 fCommonHistsResults8th->FillIntegratedFlowRP(dVn8th,0.); // to be improved (errors)
6193 }
6194
6195 delete flow2ndPt;
6196 delete flow4thPt;
6197 //delete flow6thPt;
6198 //delete flow8thPt;
6199
6200 delete yield2ndPt;
6201 delete yield4thPt;
6202 delete yield6thPt;
6203 delete yield8thPt;
6204
6205} // end of AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)
6206
489d5531 6207//================================================================================================================================
6208
489d5531 6209void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()
6210{
6211 // Initialize all arrays used for distributions.
6212
6213 // a) Initialize arrays of histograms used to hold distributions of correlations;
6214 // b) Initialize array to hold min and max values of correlations.
6215
6216 // a) Initialize arrays of histograms used to hold distributions of correlations:
6217 for(Int_t di=0;di<4;di++) // distribution index
6218 {
6219 fDistributions[di] = NULL;
6220 }
6221
6222 // b) Initialize default min and max values of correlations:
6223 // (Remark: The default values bellow were chosen for v2=5% and M=500)
6224 fMinValueOfCorrelation[0] = -0.01; // <2>_min
6225 fMaxValueOfCorrelation[0] = 0.04; // <2>_max
6226 fMinValueOfCorrelation[1] = -0.00002; // <4>_min
6227 fMaxValueOfCorrelation[1] = 0.00015; // <4>_max
6228 fMinValueOfCorrelation[2] = -0.0000003; // <6>_min
6229 fMaxValueOfCorrelation[2] = 0.0000006; // <6>_max
6230 fMinValueOfCorrelation[3] = -0.000000006; // <8>_min
6231 fMaxValueOfCorrelation[3] = 0.000000003; // <8>_max
6232
6233} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()
6234
489d5531 6235//================================================================================================================================
6236
e5834fcb 6237void AliFlowAnalysisWithQCumulants::InitializeArraysForVarious()
6238{
6239 // Initialize all arrays used for various unclassified objects.
6240
6241 for(Int_t p=0;p<4;p++) // [v_min,v_max,refMult_min,refMult_max]
6242 {
6243 fPhiDistributionForOneEventSettings[p] = 0.;
6244 }
6245
6246} // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForVarious()
6247
6248//================================================================================================================================
489d5531 6249
6250void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()
6251{
6252 // a) Book profile to hold all flags for distributions of correlations;
6253 // b) Book all histograms to hold distributions of correlations.
6254
6255 TString correlationIndex[4] = {"<2>","<4>","<6>","<8>"}; // to be improved (should I promote this to data members?)
6256
6257 // a) Book profile to hold all flags for distributions of correlations:
6258 TString distributionsFlagsName = "fDistributionsFlags";
6259 distributionsFlagsName += fAnalysisLabel->Data();
6260 fDistributionsFlags = new TProfile(distributionsFlagsName.Data(),"Flags for Distributions of Correlations",9,0,9);
6261 fDistributionsFlags->SetTickLength(-0.01,"Y");
6262 fDistributionsFlags->SetMarkerStyle(25);
6263 fDistributionsFlags->SetLabelSize(0.05);
6264 fDistributionsFlags->SetLabelOffset(0.02,"Y");
6265 fDistributionsFlags->GetXaxis()->SetBinLabel(1,"Store or not?");
6266 fDistributionsFlags->GetXaxis()->SetBinLabel(2,"<2>_{min}");
6267 fDistributionsFlags->GetXaxis()->SetBinLabel(3,"<2>_{max}");
6268 fDistributionsFlags->GetXaxis()->SetBinLabel(4,"<4>_{min}");
6269 fDistributionsFlags->GetXaxis()->SetBinLabel(5,"<4>_{max}");
6270 fDistributionsFlags->GetXaxis()->SetBinLabel(6,"<6>_{min}");
6271 fDistributionsFlags->GetXaxis()->SetBinLabel(7,"<6>_{max}");
6272 fDistributionsFlags->GetXaxis()->SetBinLabel(8,"<8>_{min}");
6273 fDistributionsFlags->GetXaxis()->SetBinLabel(9,"<8>_{max}");
6274 fDistributionsList->Add(fDistributionsFlags);
6275
6276 // b) Book all histograms to hold distributions of correlations.
6277 if(fStoreDistributions)
6278 {
6279 TString distributionsName = "fDistributions";
6280 distributionsName += fAnalysisLabel->Data();
6281 for(Int_t di=0;di<4;di++) // distribution index
6282 {
6283 fDistributions[di] = new TH1D(Form("Distribution of %s",correlationIndex[di].Data()),Form("Distribution of %s",correlationIndex[di].Data()),10000,fMinValueOfCorrelation[di],fMaxValueOfCorrelation[di]);
6284 fDistributions[di]->SetXTitle(correlationIndex[di].Data());
6285 fDistributionsList->Add(fDistributions[di]);
6286 } // end of for(Int_t di=0;di<4;di++) // distribution index
6287 } // end of if(fStoreDistributions)
6288
6289} // end of void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()
6290
489d5531 6291//================================================================================================================================
6292
e5834fcb 6293void AliFlowAnalysisWithQCumulants::BookEverythingForVarious()
6294{
6295 // Book all objects for various unclassified quantities.
6296
6297 if(!fStorePhiDistributionForOneEvent){return;}
6298
6299 // a) Book histogram holding phi distribution for single event to illustrate flow.
6300
6301 // a) Book histogram holding phi distribution for single event to illustrate flow:
6302 fPhiDistributionForOneEvent = new TH1D("fPhiDistributionForOneEvent","",360,0.,TMath::TwoPi());
6303 fPhiDistributionForOneEvent->GetXaxis()->SetTitle("#phi");
6304 fVariousList->Add(fPhiDistributionForOneEvent);
6305
6306} // end of void AliFlowAnalysisWithQCumulants::BookEverythingForVarious()
6307
6308//================================================================================================================================
489d5531 6309
6310void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()
6311{
6312 // Store all flags for distributiuons of correlations in profile fDistributionsFlags.
6313
6314 if(!fDistributionsFlags)
6315 {
6316 cout<<"WARNING: fDistributionsFlags is NULL in AFAWQC::SDF() !!!!"<<endl;
6317 exit(0);
6318 }
6319
6320 fDistributionsFlags->Fill(0.5,(Int_t)fStoreDistributions); // histos with distributions of correlations stored or not in the output file
6321 // store min and max values of correlations:
6322 for(Int_t di=0;di<4;di++) // distribution index
6323 {
6324 fDistributionsFlags->Fill(1.5+2.*(Double_t)di,fMinValueOfCorrelation[di]);
6325 fDistributionsFlags->Fill(2.5+2.*(Double_t)di,fMaxValueOfCorrelation[di]);
6326 }
6327
6328} // end of void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()
6329
489d5531 6330//================================================================================================================================
6331
489d5531 6332void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
6333{
6334 // Store distributions of correlations.
6335
6336 if(!(fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE))
6337 {
6338 cout<<"WARNING: fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE"<<endl;
6339 cout<<" is NULL in AFAWQC::SDOC() !!!!"<<endl;
6340 exit(0);
6341 }
6342
6343 for(Int_t di=0;di<4;di++) // distribution index
6344 {
6345 if(!fDistributions[di])
6346 {
6347 cout<<"WARNING: fDistributions[di] is NULL in AFAWQC::SDOC() !!!!"<<endl;
6348 cout<<"di = "<<di<<endl;
6349 exit(0);
6350 } else
6351 {
6352 fDistributions[di]->Fill(fIntFlowCorrelationsEBE->GetBinContent(di+1),fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(di+1));
6353 }
6354 } // end of for(Int_t di=0;di<4;di++) // distribution index
6355
6356} // end of void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
6357
489d5531 6358//================================================================================================================================
6359
489d5531 6360void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()
6361{
6362 // Book and nest all lists nested in the base list fHistList.
6363 // a) Book and nest lists for integrated flow;
6364 // b) Book and nest lists for differential flow;
6365 // c) Book and nest list for particle weights;
6366 // d) Book and nest list for distributions;
e5834fcb 6367 // e) Book and nest list for various unclassified objects;
6368 // f) Book and nest list for nested loops.
489d5531 6369
6370 // a) Book and nest all lists for integrated flow:
1268c371 6371 // Base list for integrated flow:
489d5531 6372 fIntFlowList = new TList();
6373 fIntFlowList->SetName("Integrated Flow");
6374 fIntFlowList->SetOwner(kTRUE);
6375 fHistList->Add(fIntFlowList);
1268c371 6376 // List holding profiles:
489d5531 6377 fIntFlowProfiles = new TList();
6378 fIntFlowProfiles->SetName("Profiles");
6379 fIntFlowProfiles->SetOwner(kTRUE);
6380 fIntFlowList->Add(fIntFlowProfiles);
3435cacb 6381 // List holding all profiles with results for correlations vs M:
6382 if(fCalculateAllCorrelationsVsM)
6383 {
6384 fIntFlowAllCorrelationsVsM = new TList();
6385 fIntFlowAllCorrelationsVsM->SetName("Correlations vs M");
6386 fIntFlowAllCorrelationsVsM->SetOwner(kTRUE);
6387 fIntFlowProfiles->Add(fIntFlowAllCorrelationsVsM);
6388 } // end of if(fCalculateAllCorrelationsVsM)
1268c371 6389 // List holding histograms with results:
489d5531 6390 fIntFlowResults = new TList();
6391 fIntFlowResults->SetName("Results");
6392 fIntFlowResults->SetOwner(kTRUE);
6393 fIntFlowList->Add(fIntFlowResults);
6394
1268c371 6395 // b) Book and nest lists for differential flow:
6396 this->BookAndNestListsForDifferentialFlow();
6397
6398 // c) Book and nest list for particle weights:
6399 fWeightsList->SetName("Weights");
6400 fWeightsList->SetOwner(kTRUE);
6401 fHistList->Add(fWeightsList);
6402
6403 // d) Book and nest list for distributions:
6404 fDistributionsList = new TList();
6405 fDistributionsList->SetName("Distributions");
6406 fDistributionsList->SetOwner(kTRUE);
6407 fHistList->Add(fDistributionsList);
6408
6409 // e) Book and nest list for various unclassified objects:
6410 if(fStorePhiDistributionForOneEvent)
6411 {
6412 fVariousList = new TList();
6413 fVariousList->SetName("Various");
6414 fVariousList->SetOwner(kTRUE);
6415 fHistList->Add(fVariousList);
6416 }
6417
64e500e3 6418 // f) Book and nest list for other differential correlators:
6419 fOtherDiffCorrelatorsList = new TList();
6420 fOtherDiffCorrelatorsList->SetName("Other differential correlators");
6421 fOtherDiffCorrelatorsList->SetOwner(kTRUE);
62e36168 6422 if(fCalculateDiffFlow){fHistList->Add(fOtherDiffCorrelatorsList);} // TBI: Use another flag here instead of fCalculateDiffFlow
64e500e3 6423
6424 // g) Book and nest list for nested loops:
1268c371 6425 fNestedLoopsList = new TList();
6426 fNestedLoopsList->SetName("Nested Loops");
6427 fNestedLoopsList->SetOwner(kTRUE);
6428 fHistList->Add(fNestedLoopsList);
6429
6430} // end of void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()
6431
6432//================================================================================================================================
6433
6434void AliFlowAnalysisWithQCumulants::BookAndNestListsForDifferentialFlow()
6435{
6436 // Book and nest lists for differential flow.
6437
6438 // Base list for differential flow objects:
489d5531 6439 fDiffFlowList = new TList();
6440 fDiffFlowList->SetName("Differential Flow");
6441 fDiffFlowList->SetOwner(kTRUE);
6442 fHistList->Add(fDiffFlowList);
1268c371 6443
6444 // Local flags:
6445 TString typeFlag[2] = {"RP","POI"};
6446 TString ptEtaFlag[2] = {"p_{T}","#eta"};
6447 TString powerFlag[2] = {"linear","quadratic"};
6448
6449 // 2D:
6450 if(fCalculate2DDiffFlow)
6451 {
6452 fDiffFlow2D = new TList();
6453 fDiffFlow2D->SetName("2D");
6454 fDiffFlow2D->SetOwner(kTRUE);
6455 fDiffFlowList->Add(fDiffFlow2D);
6456 for(Int_t t=0;t<2;t++)
6457 {
6458 f2DDiffFlowCorrelationsProList[t] = new TList();
6459 f2DDiffFlowCorrelationsProList[t]->SetOwner(kTRUE);
6460 f2DDiffFlowCorrelationsProList[t]->SetName(Form("Profiles with 2D correlations (%s)",typeFlag[t].Data()));
6461 fDiffFlow2D->Add(f2DDiffFlowCorrelationsProList[t]);
6462 } // end of for(Int_t t=0;t<2;t++)
6463 } // end of if(fCalculate2DDiffFlow)
6464
6465 // What follows bellow in this method is relevant only for 1D differential flow:
6466 if(!fCalculateDiffFlow){return;}
6467
6468 // List holding profiles:
489d5531 6469 fDiffFlowProfiles = new TList();
6470 fDiffFlowProfiles->SetName("Profiles");
6471 fDiffFlowProfiles->SetOwner(kTRUE);
6472 fDiffFlowList->Add(fDiffFlowProfiles);
1268c371 6473 // List holding histograms with results:
489d5531 6474 fDiffFlowResults = new TList();
6475 fDiffFlowResults->SetName("Results");
6476 fDiffFlowResults->SetOwner(kTRUE);
6477 fDiffFlowList->Add(fDiffFlowResults);
1268c371 6478 // Flags used for naming nested lists in list fDiffFlowProfiles and fDiffFlowResults:
489d5531 6479 TList list;
6480 list.SetOwner(kTRUE);
1268c371 6481 // Nested lists in fDiffFlowProfiles (~/Differential Flow/Profiles):
489d5531 6482 for(Int_t t=0;t<2;t++) // type: RP or POI
6483 {
62e36168 6484 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 6485 {
6486 // list holding profiles with correlations:
6487 fDiffFlowCorrelationsProList[t][pe] = (TList*)list.Clone();
6488 fDiffFlowCorrelationsProList[t][pe]->SetName(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6489 fDiffFlowProfiles->Add(fDiffFlowCorrelationsProList[t][pe]);
6490 // list holding profiles with products of correlations:
6491 fDiffFlowProductOfCorrelationsProList[t][pe] = (TList*)list.Clone();
6492 fDiffFlowProductOfCorrelationsProList[t][pe]->SetName(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6493 fDiffFlowProfiles->Add(fDiffFlowProductOfCorrelationsProList[t][pe]);
6494 // list holding profiles with corrections:
6495 fDiffFlowCorrectionsProList[t][pe] = (TList*)list.Clone();
6496 fDiffFlowCorrectionsProList[t][pe]->SetName(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6497 fDiffFlowProfiles->Add(fDiffFlowCorrectionsProList[t][pe]);
6498 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
6499 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
6500 // nested lists in fDiffFlowResults (~/Differential Flow/Results):
6501 for(Int_t t=0;t<2;t++) // type: RP or POI
6502 {
62e36168 6503 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 6504 {
6505 // list holding histograms with correlations:
6506 fDiffFlowCorrelationsHistList[t][pe] = (TList*)list.Clone();
6507 fDiffFlowCorrelationsHistList[t][pe]->SetName(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6508 fDiffFlowResults->Add(fDiffFlowCorrelationsHistList[t][pe]);
6509 // list holding histograms with corrections:
6510 fDiffFlowCorrectionsHistList[t][pe] = (TList*)list.Clone();
6511 fDiffFlowCorrectionsHistList[t][pe]->SetName(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6512 fDiffFlowResults->Add(fDiffFlowCorrectionsHistList[t][pe]);
6513 for(Int_t power=0;power<2;power++)
6514 {
6515 // list holding histograms with sums of event weights:
6516 fDiffFlowSumOfEventWeightsHistList[t][pe][power] = (TList*)list.Clone();
6517 fDiffFlowSumOfEventWeightsHistList[t][pe][power]->SetName(Form("Sum of %s event weights (%s, %s)",powerFlag[power].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6518 fDiffFlowResults->Add(fDiffFlowSumOfEventWeightsHistList[t][pe][power]);
6519 } // end of for(Int_t power=0;power<2;power++)
6520 // list holding histograms with sums of products of event weights:
6521 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = (TList*)list.Clone();
6522 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->SetName(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6523 fDiffFlowResults->Add(fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]);
6524 // list holding histograms with covariances of correlations:
6525 fDiffFlowCovariancesHistList[t][pe] = (TList*)list.Clone();
6526 fDiffFlowCovariancesHistList[t][pe]->SetName(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6527 fDiffFlowResults->Add(fDiffFlowCovariancesHistList[t][pe]);
6528 // list holding histograms with differential Q-cumulants:
6529 fDiffFlowCumulantsHistList[t][pe] = (TList*)list.Clone();
6530 fDiffFlowCumulantsHistList[t][pe]->SetName(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6531 fDiffFlowResults->Add(fDiffFlowCumulantsHistList[t][pe]);
1268c371 6532 // list holding histograms which quantify detector bias to differential Q-cumulants:
6533 fDiffFlowDetectorBiasHistList[t][pe] = (TList*)list.Clone();
6534 fDiffFlowDetectorBiasHistList[t][pe]->SetName(Form("Detector bias (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6535 fDiffFlowResults->Add(fDiffFlowDetectorBiasHistList[t][pe]);
489d5531 6536 // list holding histograms with differential flow estimates from Q-cumulants:
6537 fDiffFlowHistList[t][pe] = (TList*)list.Clone();
6538 fDiffFlowHistList[t][pe]->SetName(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));
6539 fDiffFlowResults->Add(fDiffFlowHistList[t][pe]);
6540 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
6541 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
6542
1268c371 6543} // end of void AliFlowAnalysisWithQCumulants::BookAndNestListsForDifferentialFlow()
489d5531 6544
6545//================================================================================================================================
6546
489d5531 6547void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type)
6548{
1268c371 6549 // Fill common result histograms for differential flow.
489d5531 6550
1268c371 6551 Int_t t = 0;
489d5531 6552
6553 if(type == "RP")
6554 {
1268c371 6555 t = 0;
489d5531 6556 } else if(type == "POI")
6557 {
1268c371 6558 t = 1;
489d5531 6559 }
1268c371 6560
6561 // to be improved - check all pointers used in this method
489d5531 6562
6563 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))
6564 {
6565 cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl;
6566 cout<<" is NULL in AFAWQC::FCHRIF() !!!!"<<endl;
6567 exit(0);
6568 }
6569
6570 // pt:
6571 for(Int_t p=1;p<=fnBinsPt;p++)
6572 {
6573 Double_t v2 = fDiffFlow[t][0][0]->GetBinContent(p);
6574 Double_t v4 = fDiffFlow[t][0][1]->GetBinContent(p);
6575 Double_t v6 = fDiffFlow[t][0][2]->GetBinContent(p);
6576 Double_t v8 = fDiffFlow[t][0][3]->GetBinContent(p);
6577
6578 Double_t v2Error = fDiffFlow[t][0][0]->GetBinError(p);
6579 Double_t v4Error = fDiffFlow[t][0][1]->GetBinError(p);
6580 //Double_t v6Error = fFinalFlow1D[t][pW][nua][0][2]->GetBinError(p);
6581 //Double_t v8Error = fFinalFlow1D[t][pW][nua][0][3]->GetBinError(p);
6582
6583 if(type == "RP")
6584 {
6585 fCommonHistsResults2nd->FillDifferentialFlowPtRP(p,v2,v2Error);
6586 fCommonHistsResults4th->FillDifferentialFlowPtRP(p,v4,v4Error);
6587 fCommonHistsResults6th->FillDifferentialFlowPtRP(p,v6,0.);
6588 fCommonHistsResults8th->FillDifferentialFlowPtRP(p,v8,0.);
6589 } else if(type == "POI")
6590 {
6591 fCommonHistsResults2nd->FillDifferentialFlowPtPOI(p,v2,v2Error);
6592 fCommonHistsResults4th->FillDifferentialFlowPtPOI(p,v4,v4Error);
6593 fCommonHistsResults6th->FillDifferentialFlowPtPOI(p,v6,0.);
6594 fCommonHistsResults8th->FillDifferentialFlowPtPOI(p,v8,0.);
6595 }
6596 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
6597
6598 // eta:
62e36168 6599 if(!fCalculateDiffFlowVsEta){return;}
489d5531 6600 for(Int_t e=1;e<=fnBinsEta;e++)
6601 {
6602 Double_t v2 = fDiffFlow[t][1][0]->GetBinContent(e);
6603 Double_t v4 = fDiffFlow[t][1][1]->GetBinContent(e);
6604 Double_t v6 = fDiffFlow[t][1][2]->GetBinContent(e);
6605 Double_t v8 = fDiffFlow[t][1][3]->GetBinContent(e);
6606
6607 Double_t v2Error = fDiffFlow[t][1][0]->GetBinError(e);
6608 Double_t v4Error = fDiffFlow[t][1][1]->GetBinError(e);
6609 //Double_t v6Error = fDiffFlow[t][1][2]->GetBinError(e);
6610 //Double_t v8Error = fDiffFlow[t][1][3]->GetBinError(e);
6611
6612 if(type == "RP")
6613 {
6614 fCommonHistsResults2nd->FillDifferentialFlowEtaRP(e,v2,v2Error);
6615 fCommonHistsResults4th->FillDifferentialFlowEtaRP(e,v4,v4Error);
6616 fCommonHistsResults6th->FillDifferentialFlowEtaRP(e,v6,0.);
6617 fCommonHistsResults8th->FillDifferentialFlowEtaRP(e,v8,0.);
6618 } else if(type == "POI")
6619 {
6620 fCommonHistsResults2nd->FillDifferentialFlowEtaPOI(e,v2,v2Error);
6621 fCommonHistsResults4th->FillDifferentialFlowEtaPOI(e,v4,v4Error);
6622 fCommonHistsResults6th->FillDifferentialFlowEtaPOI(e,v6,0.);
6623 fCommonHistsResults8th->FillDifferentialFlowEtaPOI(e,v8,0.);
6624 }
6625 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
6626
6627} // end of void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights, Bool_t correctedForNUA)
6628
489d5531 6629//================================================================================================================================
6630
1268c371 6631void AliFlowAnalysisWithQCumulants::CommonConstants(TString method)
489d5531 6632{
1268c371 6633 // Access and store common constants.
6634
6635 // a) If this method was called in Init() access common constants from AliFlowCommonConstants;
6636 // b) If this method was called in Init() book and fill TProfile to hold constants accessed in a);
6637 // c) If this method was called in Finish() access common constants from TProfile booked and filled in b).
6638
6639 if(method == "Init")
6640 {
6641 // a) If this method was called in Init() access common constants from AliFlowCommonConstants:
6642 fnBinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();
6643 fPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin();
6644 fPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();
6645 if(fnBinsPhi){fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;}
6646 fnBinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();
6647 fPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin();
6648 fPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();
6649 if(fnBinsPt){fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;}
6650 fnBinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();
6651 fEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin();
6652 fEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();
6653 if(fnBinsEta){fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;}
6654
6655 // b) If this method was called in Init() book and fill TProfile to hold constants accessed in a):
6656 TString fCommonConstantsName = "fCommonConstants";
6657 fCommonConstantsName += fAnalysisLabel->Data();
6658 fCommonConstants = new TProfile(fCommonConstantsName.Data(),"Common constants",9,0.,9.);
6659 fCommonConstants->SetLabelSize(0.05);
6660 fCommonConstants->GetXaxis()->SetBinLabel(1,"nBins (#phi)");
6661 fCommonConstants->Fill(0.5,fnBinsPhi);
6662 fCommonConstants->GetXaxis()->SetBinLabel(2,"#phi_{min}");
6663 fCommonConstants->Fill(1.5,fPhiMin);
6664 fCommonConstants->GetXaxis()->SetBinLabel(3,"#phi_{max}");
6665 fCommonConstants->Fill(2.5,fPhiMax);
6666 fCommonConstants->GetXaxis()->SetBinLabel(4,"nBins (p_{t})");
6667 fCommonConstants->Fill(3.5,fnBinsPt);
6668 fCommonConstants->GetXaxis()->SetBinLabel(5,"(p_{t})_{min}");
6669 fCommonConstants->Fill(4.5,fPtMin);
6670 fCommonConstants->GetXaxis()->SetBinLabel(6,"(p_{t})_{max}");
6671 fCommonConstants->Fill(5.5,fPtMax);
6672 fCommonConstants->GetXaxis()->SetBinLabel(7,"nBins (#eta)");
6673 fCommonConstants->Fill(6.5,fnBinsEta);
6674 fCommonConstants->GetXaxis()->SetBinLabel(8,"#eta_{min}");
6675 fCommonConstants->Fill(7.5,fEtaMin);
6676 fCommonConstants->GetXaxis()->SetBinLabel(9,"#eta_{max}");
6677 fCommonConstants->Fill(8.5,fEtaMax);
6678 fHistList->Add(fCommonConstants);
6679 } // end of if(method == "Init")
6680 else if(method == "Finish")
6681 {
6682 // c) If this method was called in Finish() access common constants from TProfile booked and filled in b):
6683 if(!fCommonConstants)
6684 {
6685 printf("\n WARNING (QC): fCommonConstants is NULL in AFAWQC::AC(\"%s\") !!!!\n\n",method.Data());
6686 exit(0);
6687 }
6688 fnBinsPhi = (Int_t)fCommonConstants->GetBinContent(1);
6689 fPhiMin = fCommonConstants->GetBinContent(2);
6690 fPhiMax = fCommonConstants->GetBinContent(3);
6691 if(fnBinsPhi){fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;}
6692 fnBinsPt = (Int_t)fCommonConstants->GetBinContent(4);
6693 fPtMin = fCommonConstants->GetBinContent(5);
6694 fPtMax = fCommonConstants->GetBinContent(6);
6695 if(fnBinsPt){fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;}
6696 fnBinsEta = (Int_t)fCommonConstants->GetBinContent(7);
6697 fEtaMin = fCommonConstants->GetBinContent(8);
6698 fEtaMax = fCommonConstants->GetBinContent(9);
6699 if(fnBinsEta){fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;}
6700 } // end of else if(method == "Finish")
6701
6702} // end of void AliFlowAnalysisWithQCumulants::CommonConstants(TString method)
489d5531 6703
489d5531 6704//================================================================================================================================
6705
489d5531 6706void AliFlowAnalysisWithQCumulants::CrossCheckSettings()
6707{
1268c371 6708 // a) Cross check if the choice for multiplicity weights make sense.
489d5531 6709
6710 // a) Cross check if the choice for multiplicity weights make sense:
6711 if(strcmp(fMultiplicityWeight->Data(),"combinations") &&
6712 strcmp(fMultiplicityWeight->Data(),"unit") &&
6713 strcmp(fMultiplicityWeight->Data(),"multiplicity"))
6714 {
6715 cout<<"WARNING (QC): Multiplicity weight can be either \"combinations\", \"unit\""<<endl;
6716 cout<<" or \"multiplicity\". Certainly not \""<<fMultiplicityWeight->Data()<<"\"."<<endl;
6717 exit(0);
6718 }
6719
6720} // end of void AliFlowAnalysisWithQCumulants::CrossCheckSettings()
6721
489d5531 6722//================================================================================================================================
6723
489d5531 6724void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()
6725{
0328db2d 6726 // Calculate sum of linear and quadratic event weights for correlations.
2001bc3a 6727
6728 // multiplicity:
1268c371 6729 Double_t dMult = (*fSpk)(0,0);
9f33751d 6730
489d5531 6731 for(Int_t p=0;p<2;p++) // power-1
6732 {
6733 for(Int_t ci=0;ci<4;ci++) // correlation index
6734 {
6735 fIntFlowSumOfEventWeights[p]->Fill(ci+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1));
b3dacf6b 6736 if(fCalculateCumulantsVsM)
6737 {
6738 fIntFlowSumOfEventWeightsVsM[ci][p]->Fill(dMult+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1)); // to be improved: dMult => sum of weights?
6739 }
489d5531 6740 }
6741 }
6742
6743} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()
6744
489d5531 6745//================================================================================================================================
6746
0328db2d 6747void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeightsNUA()
489d5531 6748{
0328db2d 6749 // Calculate sum of linear and quadratic event weights for NUA terms.
6750
6751 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
489d5531 6752 {
0328db2d 6753 for(Int_t p=0;p<2;p++) // power-1
6754 {
b92ea2b9 6755 for(Int_t ci=0;ci<4;ci++) // nua term index
0328db2d 6756 {
6757 fIntFlowSumOfEventWeightsNUA[sc][p]->Fill(ci+0.5,pow(fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc]->GetBinContent(ci+1),p+1));
489d5531 6758 }
0328db2d 6759 }
6760 }
6761
6762} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeightsNUA()
489d5531 6763
0328db2d 6764//================================================================================================================================
6765
0328db2d 6766void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()
6767{
ff70ca91 6768 // Calculate sum of product of event weights for correlations.
2001bc3a 6769
6770 // multiplicity:
1268c371 6771 Double_t dMult = (*fSpk)(0,0);
2001bc3a 6772
489d5531 6773 Int_t counter = 0;
6774
6775 for(Int_t ci1=1;ci1<4;ci1++)
6776 {
6777 for(Int_t ci2=ci1+1;ci2<=4;ci2++)
6778 {
ff70ca91 6779 fIntFlowSumOfProductOfEventWeights->Fill(0.5+counter,
6780 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
b3dacf6b 6781 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
6782 if(fCalculateCumulantsVsM)
6783 {
6784 fIntFlowSumOfProductOfEventWeightsVsM[counter]->Fill(dMult+0.5, // to be improved: dMult => sum of weights?
6785 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*
6786 fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));
6787 } // end of if(fCalculateCumulantsVsM)
ff70ca91 6788 counter++;
489d5531 6789 }
6790 }
6791
0328db2d 6792} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()
6793
0328db2d 6794//================================================================================================================================
6795
0328db2d 6796void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeightsNUA()
6797{
6798 // Calculate sum of product of event weights for NUA terms.
6799
6800 // w_{<2>} * w_{<cos(#phi)>}:
6801 fIntFlowSumOfProductOfEventWeightsNUA->Fill(0.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6802 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
6803 // w_{<2>} * w_{<sin(#phi)>}:
6804 fIntFlowSumOfProductOfEventWeightsNUA->Fill(1.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6805 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6806 // w_{<cos(#phi)> * w_{<sin(#phi)>}:
6807 fIntFlowSumOfProductOfEventWeightsNUA->Fill(2.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6808 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6809 // w_{<2>} * w{<cos(phi1+phi2)>}
6810 fIntFlowSumOfProductOfEventWeightsNUA->Fill(3.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6811 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6812 // w_{<2>} * w{<sin(phi1+phi2)>}
6813 fIntFlowSumOfProductOfEventWeightsNUA->Fill(4.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6814 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6815 // w_{<2>} * w{<cos(phi1-phi2-phi3)>}
6816 fIntFlowSumOfProductOfEventWeightsNUA->Fill(5.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6817 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6818 // w_{<2>} * w{<sin(phi1-phi2-phi3)>}
6819 fIntFlowSumOfProductOfEventWeightsNUA->Fill(6.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1)*
6820 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6821 // w_{<4>} * w{<cos(phi1)>}
6822 fIntFlowSumOfProductOfEventWeightsNUA->Fill(7.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6823 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1));
6824 // w_{<4>} * w{<sin(phi1)>}
6825 fIntFlowSumOfProductOfEventWeightsNUA->Fill(8.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6826 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1));
6827 // w_{<4>} * w{<cos(phi1+phi2)>}
6828 fIntFlowSumOfProductOfEventWeightsNUA->Fill(9.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6829 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6830 // w_{<4>} * w{<sin(phi1+phi2)>}
6831 fIntFlowSumOfProductOfEventWeightsNUA->Fill(10.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6832 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6833 // w_{<4>} * w{<cos(phi1-phi2-phi3)>}
6834 fIntFlowSumOfProductOfEventWeightsNUA->Fill(11.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6835 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6836 // w_{<4>} * w{<sin(phi1-phi2-phi3)>}
6837 fIntFlowSumOfProductOfEventWeightsNUA->Fill(12.5,fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2)*
6838 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6839 // w_{<cos(phi1)>} * w{<cos(phi1+phi2)>}
6840 fIntFlowSumOfProductOfEventWeightsNUA->Fill(13.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6841 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6842 // w_{<cos(phi1)>} * w{<sin(phi1+phi2)>}
6843 fIntFlowSumOfProductOfEventWeightsNUA->Fill(14.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6844 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6845 // w_{<cos(phi1)>} * w{<cos(phi1-phi2-phi3)>}
6846 fIntFlowSumOfProductOfEventWeightsNUA->Fill(15.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6847 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6848 // w_{<cos(phi1)>} * w{<sin(phi1-phi2-phi3)>}
6849 fIntFlowSumOfProductOfEventWeightsNUA->Fill(16.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(1)*
6850 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6851 // w_{<sin(phi1)>} * w{<cos(phi1+phi2)>}
6852 fIntFlowSumOfProductOfEventWeightsNUA->Fill(17.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6853 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2));
6854 // w_{<sin(phi1)>} * w{<sin(phi1+phi2)>}
6855 fIntFlowSumOfProductOfEventWeightsNUA->Fill(18.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6856 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6857 // w_{<sin(phi1)>} * w{<cos(phi1-phi2-phi3)>}
6858 fIntFlowSumOfProductOfEventWeightsNUA->Fill(19.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6859 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6860 // w_{<sin(phi1)>} * w{<sin(phi1-phi2-phi3)>}
6861 fIntFlowSumOfProductOfEventWeightsNUA->Fill(20.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(1)*
6862 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6863 // w_{<cos(phi1+phi2)>} * w{<sin(phi1+phi2))>}
6864 fIntFlowSumOfProductOfEventWeightsNUA->Fill(21.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6865 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2));
6866 // w_{<cos(phi1+phi2)>} * w{<cos(phi1-phi2-phi3)>}
6867 fIntFlowSumOfProductOfEventWeightsNUA->Fill(22.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6868 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6869 // w_{<cos(phi1+phi2)>} * w{<sin(phi1-phi2-phi3)>}
6870 fIntFlowSumOfProductOfEventWeightsNUA->Fill(23.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(2)*
6871 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6872 // w_{<sin(phi1+phi2)>} * w{<cos(phi1-phi2-phi3)>}
6873 fIntFlowSumOfProductOfEventWeightsNUA->Fill(24.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)*
6874 fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3));
6875 // w_{<sin(phi1+phi2)>} * w{<sin(phi1-phi2-phi3)>}
6876 fIntFlowSumOfProductOfEventWeightsNUA->Fill(25.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(2)*
6877 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6878 // w_{<cos(phi1-phi2-phi3)>} * w{<sin(phi1-phi2-phi3)>}
6879 fIntFlowSumOfProductOfEventWeightsNUA->Fill(26.5,fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->GetBinContent(3)*
6880 fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->GetBinContent(3));
6881
6882} // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowIntFlowSumOfProductOfEventWeightsNUA()
489d5531 6883
489d5531 6884//================================================================================================================================
6885
489d5531 6886void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta)
6887{
1268c371 6888 // Calculate reduced correlations for RPs or POIs for all pt and eta bins.
489d5531 6889
1268c371 6890 // Multiplicity:
6891 Double_t dMult = (*fSpk)(0,0);
489d5531 6892
6893 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
6894 Double_t dReQ1n = (*fReQ)(0,0);
6895 Double_t dReQ2n = (*fReQ)(1,0);
6896 //Double_t dReQ3n = (*fReQ)(2,0);
6897 //Double_t dReQ4n = (*fReQ)(3,0);
6898 Double_t dImQ1n = (*fImQ)(0,0);
6899 Double_t dImQ2n = (*fImQ)(1,0);
6900 //Double_t dImQ3n = (*fImQ)(2,0);
6901 //Double_t dImQ4n = (*fImQ)(3,0);
6902
6903 // reduced correlations are stored in fDiffFlowCorrelationsPro[0=RP,1=POI][0=pt,1=eta][correlation index]. Correlation index runs as follows:
6904 //
6905 // 0: <<2'>>
6906 // 1: <<4'>>
6907 // 2: <<6'>>
6908 // 3: <<8'>>
6909
ea239361 6910 //Int_t t = 0; // type flag
2a98ceb8 6911 Int_t pe = 0; // ptEta flag
489d5531 6912
6913 if(type == "RP")
6914 {
ea239361 6915 //t = 0;
489d5531 6916 } else if(type == "POI")
6917 {
ea239361 6918 //t = 1;
489d5531 6919 }
6920
6921 if(ptOrEta == "Pt")
6922 {
6923 pe = 0;
6924 } else if(ptOrEta == "Eta")
6925 {
6926 pe = 1;
6927 }
6928
6929 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
6930 Double_t minPtEta[2] = {fPtMin,fEtaMin};
6931 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
6932 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
6933
6934 // looping over all bins and calculating reduced correlations:
6935 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
6936 {
6937 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
6938 Double_t p1n0kRe = 0.;
6939 Double_t p1n0kIm = 0.;
6940
6941 // number of POIs in particular pt or eta bin:
6942 Double_t mp = 0.;
6943
6944 // 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):
6945 Double_t q1n0kRe = 0.;
6946 Double_t q1n0kIm = 0.;
6947 Double_t q2n0kRe = 0.;
6948 Double_t q2n0kIm = 0.;
6949
6950 // number of particles which are both RPs and POIs in particular pt or eta bin:
6951 Double_t mq = 0.;
6952
6953 if(type == "POI")
6954 {
6955 // q_{m*n,0}:
6956 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
6957 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
6958 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
6959 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
6960 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
6961 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
6962 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
6963 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
6964
6965 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6966 }
6967 else if(type == "RP")
6968 {
6969 // q_{m*n,0}:
6970 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
6971 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
6972 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
6973 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
6974 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
6975 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
6976 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
6977 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
6978
6979 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6980 }
6981
6982 if(type == "POI")
6983 {
6984 // p_{m*n,0}:
6985 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
6986 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
6987 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
6988 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
6989
6990 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
6991
ea239361 6992 //t = 1; // typeFlag = RP or POI
489d5531 6993 }
6994 else if(type == "RP")
6995 {
6996 // p_{m*n,0} = q_{m*n,0}:
6997 p1n0kRe = q1n0kRe;
6998 p1n0kIm = q1n0kIm;
6999
7000 mp = mq;
7001
ea239361 7002 //t = 0; // typeFlag = RP or POI
489d5531 7003 }
7004
1268c371 7005 // 2'-particle correlation for particular pt or eta bin:
489d5531 7006 Double_t two1n1nPtEta = 0.;
b40a910e 7007 Double_t mWeight2pPrime = 0.; // multiplicity weight for <2'>
489d5531 7008 if(mp*dMult-mq)
7009 {
7010 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)
7011 / (mp*dMult-mq);
b40a910e 7012 // determine multiplicity weight:
7013 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7014 {
7015 mWeight2pPrime = mp*dMult-mq;
7016 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7017 {
7018 mWeight2pPrime = 1.;
7019 }
489d5531 7020 if(type == "POI") // to be improved (I do not this if)
7021 {
7022 // fill profile to get <<2'>> for POIs
b40a910e 7023 fDiffFlowCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mWeight2pPrime);
7024 // fill profile to get <<2'>^2> for POIs
7025 fDiffFlowSquaredCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta*two1n1nPtEta,mWeight2pPrime);
489d5531 7026 // histogram to store <2'> for POIs e-b-e (needed in some other methods):
7027 fDiffFlowCorrelationsEBE[1][pe][0]->SetBinContent(b,two1n1nPtEta);
b40a910e 7028 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][0]->SetBinContent(b,mWeight2pPrime);
489d5531 7029 }
7030 else if(type == "RP") // to be improved (I do not this if)
7031 {
7032 // profile to get <<2'>> for RPs:
b40a910e 7033 fDiffFlowCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mWeight2pPrime);
7034 // profile to get <<2'>^2> for RPs:
7035 fDiffFlowSquaredCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta*two1n1nPtEta,mWeight2pPrime);
489d5531 7036 // histogram to store <2'> for RPs e-b-e (needed in some other methods):
7037 fDiffFlowCorrelationsEBE[0][pe][0]->SetBinContent(b,two1n1nPtEta);
b40a910e 7038 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][0]->SetBinContent(b,mWeight2pPrime);
489d5531 7039 }
7040 } // end of if(mp*dMult-mq)
7041
7042 // 4'-particle correlation:
7043 Double_t four1n1n1n1nPtEta = 0.;
b40a910e 7044 Double_t mWeight4pPrime = 0.; // multiplicity weight for <4'>
489d5531 7045 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7046 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)
7047 {
7048 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7049 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))
7050 - 2.*q2n0kIm*dReQ1n*dImQ1n
7051 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)
7052 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)
7053 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7054 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq
7055 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)
7056 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)
7057 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7058 + 2.*mq*dMult
7059 - 6.*mq)
7060 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7061 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));
b40a910e 7062 // determine multiplicity weight:
7063 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7064 {
7065 mWeight4pPrime = (mp-mq)*dMult*(dMult-1.)*(dMult-2.) + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7066 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7067 {
7068 mWeight4pPrime = 1.;
7069 }
489d5531 7070 if(type == "POI")
7071 {
7072 // profile to get <<4'>> for POIs:
b40a910e 7073 fDiffFlowCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,mWeight4pPrime);
7074 // profile to get <<4'>^2> for POIs:
7075 fDiffFlowSquaredCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta*four1n1n1n1nPtEta,mWeight4pPrime);
489d5531 7076 // histogram to store <4'> for POIs e-b-e (needed in some other methods):
7077 fDiffFlowCorrelationsEBE[1][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);
b40a910e 7078 fDiffFlowEventWeightsForCorrelationsEBE[1][pe][1]->SetBinContent(b,mWeight4pPrime);
489d5531 7079 }
7080 else if(type == "RP")
7081 {
7082 // profile to get <<4'>> for RPs:
b40a910e 7083 fDiffFlowCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,mWeight4pPrime);
7084 // profile to get <<4'>^2> for RPs:
7085 fDiffFlowSquaredCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta*four1n1n1n1nPtEta,mWeight4pPrime);
489d5531 7086 // histogram to store <4'> for RPs e-b-e (needed in some other methods):
7087 fDiffFlowCorrelationsEBE[0][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);
b40a910e 7088 fDiffFlowEventWeightsForCorrelationsEBE[0][pe][1]->SetBinContent(b,mWeight4pPrime);
489d5531 7089 }
7090 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7091 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))
7092
7093 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7094
7095
7096} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta);
7097
489d5531 7098//================================================================================================================================
7099
64e500e3 7100void AliFlowAnalysisWithQCumulants::CalculateOtherDiffCorrelators(TString type, TString ptOrEta)
7101{
7102 // Calculate other differential correlators for RPs or POIs for all pt and eta bins.
7103
7104 // Multiplicity:
7105 Double_t dMult = (*fSpk)(0,0);
7106
7107 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
7108 Double_t dReQ1n = (*fReQ)(0,0);
7109 Double_t dReQ2n = (*fReQ)(1,0);
7110 Double_t dReQ3n = (*fReQ)(2,0);
7111 //Double_t dReQ4n = (*fReQ)(3,0);
7112 Double_t dImQ1n = (*fImQ)(0,0);
7113 Double_t dImQ2n = (*fImQ)(1,0);
7114 Double_t dImQ3n = (*fImQ)(2,0);
7115 //Double_t dImQ4n = (*fImQ)(3,0);
7116
7117 // 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]
7118 // Correlation index runs as follows:
7119 //
7120 // 0: <exp[in(psi1-3phi2+2phi3)]>
7121
7122 Int_t t = 0; // type flag
7123 Int_t pe = 0; // ptEta flag
7124
7125 if(type == "RP")
7126 {
7127 t = 0;
7128 } else if(type == "POI")
7129 {
7130 t = 1;
7131 }
7132
7133 if(ptOrEta == "Pt")
7134 {
7135 pe = 0;
7136 } else if(ptOrEta == "Eta")
7137 {
7138 pe = 1;
7139 }
7140
7141 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7142 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7143 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7144 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7145
7146 // looping over all bins and calculating reduced correlations:
7147 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7148 {
7149 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
7150 Double_t p1n0kRe = 0.;
7151 Double_t p1n0kIm = 0.;
7152
7153 // number of POIs in particular pt or eta bin:
7154 Double_t mp = 0.;
7155
7156 // 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):
7157 Double_t q1n0kRe = 0.;
7158 Double_t q1n0kIm = 0.;
7159 Double_t q2n0kRe = 0.;
7160 Double_t q2n0kIm = 0.;
7161 Double_t q3n0kRe = 0.;
7162 Double_t q3n0kIm = 0.;
7163
7164 // number of particles which are both RPs and POIs in particular pt or eta bin:
7165 Double_t mq = 0.;
7166
7167 if(type == "POI")
7168 {
7169 // q_{m*n,0}:
7170 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
7171 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
7172 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
7173 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
7174 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
7175 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
7176 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
7177 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
7178 q3n0kRe = fReRPQ1dEBE[2][pe][2][0]->GetBinContent(fReRPQ1dEBE[2][pe][2][0]->GetBin(b))
7179 * fReRPQ1dEBE[2][pe][2][0]->GetBinEntries(fReRPQ1dEBE[2][pe][2][0]->GetBin(b));
7180 q3n0kIm = fImRPQ1dEBE[2][pe][2][0]->GetBinContent(fImRPQ1dEBE[2][pe][2][0]->GetBin(b))
7181 * fImRPQ1dEBE[2][pe][2][0]->GetBinEntries(fImRPQ1dEBE[2][pe][2][0]->GetBin(b));
7182
7183 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7184 }
7185 else if(type == "RP")
7186 {
7187 // q_{m*n,0}:
7188 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
7189 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
7190 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
7191 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
7192 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
7193 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
7194 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
7195 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
7196 q3n0kRe = fReRPQ1dEBE[0][pe][2][0]->GetBinContent(fReRPQ1dEBE[0][pe][2][0]->GetBin(b))
7197 * fReRPQ1dEBE[0][pe][2][0]->GetBinEntries(fReRPQ1dEBE[0][pe][2][0]->GetBin(b));
7198 q3n0kIm = fImRPQ1dEBE[0][pe][2][0]->GetBinContent(fImRPQ1dEBE[0][pe][2][0]->GetBin(b))
7199 * fImRPQ1dEBE[0][pe][2][0]->GetBinEntries(fImRPQ1dEBE[0][pe][2][0]->GetBin(b));
7200
7201 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7202 }
7203
7204 if(type == "POI")
7205 {
7206 // p_{m*n,0}:
7207 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
7208 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
7209 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
7210 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
7211
7212 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
7213
7214 t = 1; // typeFlag = RP or POI
7215 }
7216 else if(type == "RP")
7217 {
7218 // p_{m*n,0} = q_{m*n,0}:
7219 p1n0kRe = q1n0kRe;
7220 p1n0kIm = q1n0kIm;
7221
7222 mp = mq;
7223
7224 t = 0; // typeFlag = RP or POI
7225 }
7226
7227 // 3'-particle correlators:
7228 // Taeney-Yan correlator:
7229 Double_t dTaeneyYan = 0.;
7230 Double_t mWeightTaeneyYan = 0.; // multiplicity weight for Taeney-Yan correlator
7231 if((mp*dMult-2.*mq)*(dMult-1.) > 0.) // to be improved - is this condition fully justified?
7232 {
7233 dTaeneyYan = (dReQ3n*(p1n0kRe*dReQ2n-p1n0kIm*dImQ2n)+dImQ3n*(p1n0kIm*dReQ2n+p1n0kRe*dImQ2n)
7234 - p1n0kRe*dReQ1n - p1n0kIm*dImQ1n
7235 - q2n0kRe*dReQ2n - q2n0kIm*dImQ2n
7236 - q3n0kRe*dReQ3n - q3n0kIm*dImQ3n
7237 + 2.*mq)
7238 / ((mp*dMult-2.*mq)*(dMult-1.));
7239 // determine multiplicity weight:
7240 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7241 {
7242 mWeightTaeneyYan = (mp*dMult-2.*mq)*(dMult-1.);
7243 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7244 {
7245 mWeightTaeneyYan = 1.;
7246 }
7247 // Fill profiles:
7248 fOtherDiffCorrelators[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dTaeneyYan,mWeightTaeneyYan);
7249 } // end of if((mp*dMult-2.*mq)*(dMult-1.) > 0.)
7250
7251 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7252
7253} // end of void AliFlowAnalysisWithQCumulants::CalculateOtherDiffCorrelators(TString type, TString ptOrEta)
7254
7255//================================================================================================================================
7256
1268c371 7257void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCorrelations(TString type)
7258{
7259 // Calculate all reduced correlations needed for 2D differential flow for each (pt,eta) bin.
7260
7261 // Multiplicity:
7262 Double_t dMult = (*fSpk)(0,0);
7263 // Real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
7264 Double_t dReQ1n = (*fReQ)(0,0);
7265 Double_t dReQ2n = (*fReQ)(1,0);
7266 //Double_t dReQ3n = (*fReQ)(2,0);
7267 //Double_t dReQ4n = (*fReQ)(3,0);
7268 Double_t dImQ1n = (*fImQ)(0,0);
7269 Double_t dImQ2n = (*fImQ)(1,0);
7270 //Double_t dImQ3n = (*fImQ)(2,0);
7271 //Double_t dImQ4n = (*fImQ)(3,0);
7272
7273 // 2D reduced correlations are stored in TProfile2D f2DDiffFlowCorrelationsPro[0=RP,1=POI][correlation index].
7274 // Correlation index runs as follows:
7275 // 0: <<2'>>
7276 // 1: <<4'>>
7277 // 2: <<6'>>
7278 // 3: <<8'>>
7279
7280 Int_t t = 0; // type flag
7281 if(type == "RP")
7282 {
7283 t = 0;
7284 } else if(type == "POI")
7285 {
7286 t = 1;
7287 }
7288
7289 // Looping over all (pt,eta) bins and calculating correlations needed for differential flow:
7290 for(Int_t p=1;p<=fnBinsPt;p++)
7291 {
7292 for(Int_t e=1;e<=fnBinsEta;e++)
7293 {
7294 // Real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):
7295 Double_t p1n0kRe = 0.;
7296 Double_t p1n0kIm = 0.;
7297 // Number of POIs in particular pt or eta bin:
7298 Double_t mp = 0.;
7299 // Real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for 'RP && POI particles' in particular pt or eta bin):
7300 Double_t q1n0kRe = 0.;
7301 Double_t q1n0kIm = 0.;
7302 Double_t q2n0kRe = 0.;
7303 Double_t q2n0kIm = 0.;
7304 // Number of 'RP && POI particles' in particular pt or eta bin:
7305 Double_t mq = 0.;
7306 if(type == "POI")
7307 {
7308 // q_{m*n,0}:
7309 q1n0kRe = fReRPQ2dEBE[2][0][0]->GetBinContent(fReRPQ2dEBE[2][0][0]->GetBin(p,e))
7310 * fReRPQ2dEBE[2][0][0]->GetBinEntries(fReRPQ2dEBE[2][0][0]->GetBin(p,e));
7311 q1n0kIm = fImRPQ2dEBE[2][0][0]->GetBinContent(fImRPQ2dEBE[2][0][0]->GetBin(p,e))
7312 * fImRPQ2dEBE[2][0][0]->GetBinEntries(fImRPQ2dEBE[2][0][0]->GetBin(p,e));
7313 q2n0kRe = fReRPQ2dEBE[2][1][0]->GetBinContent(fReRPQ2dEBE[2][1][0]->GetBin(p,e))
7314 * fReRPQ2dEBE[2][1][0]->GetBinEntries(fReRPQ2dEBE[2][1][0]->GetBin(p,e));
7315 q2n0kIm = fImRPQ2dEBE[2][1][0]->GetBinContent(fImRPQ2dEBE[2][1][0]->GetBin(p,e))
7316 * fImRPQ2dEBE[2][1][0]->GetBinEntries(fImRPQ2dEBE[2][1][0]->GetBin(p,e));
7317 // m_{q}:
7318 mq = fReRPQ2dEBE[2][0][0]->GetBinEntries(fReRPQ2dEBE[2][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7319 } // end of if(type == "POI")
7320 else if(type == "RP")
7321 {
7322 // q_{m*n,0}:
7323 q1n0kRe = fReRPQ2dEBE[0][0][0]->GetBinContent(fReRPQ2dEBE[0][0][0]->GetBin(p,e))
7324 * fReRPQ2dEBE[0][0][0]->GetBinEntries(fReRPQ2dEBE[0][0][0]->GetBin(p,e));
7325 q1n0kIm = fImRPQ2dEBE[0][0][0]->GetBinContent(fImRPQ2dEBE[0][0][0]->GetBin(p,e))
7326 * fImRPQ2dEBE[0][0][0]->GetBinEntries(fImRPQ2dEBE[0][0][0]->GetBin(p,e));
7327 q2n0kRe = fReRPQ2dEBE[0][1][0]->GetBinContent(fReRPQ2dEBE[0][1][0]->GetBin(p,e))
7328 * fReRPQ2dEBE[0][1][0]->GetBinEntries(fReRPQ2dEBE[0][1][0]->GetBin(p,e));
7329 q2n0kIm = fImRPQ2dEBE[0][1][0]->GetBinContent(fImRPQ2dEBE[0][1][0]->GetBin(p,e))
7330 * fImRPQ2dEBE[0][1][0]->GetBinEntries(fImRPQ2dEBE[0][1][0]->GetBin(p,e));
7331 // m_{q}:
7332 mq = fReRPQ2dEBE[0][0][0]->GetBinEntries(fReRPQ2dEBE[0][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7333 } // end of else if(type == "RP")
7334 if(type == "POI")
7335 {
7336 // p_{m*n,0}:
7337 p1n0kRe = fReRPQ2dEBE[1][0][0]->GetBinContent(fReRPQ2dEBE[1][0][0]->GetBin(p,e))
7338 * fReRPQ2dEBE[1][0][0]->GetBinEntries(fReRPQ2dEBE[1][0][0]->GetBin(p,e));
7339 p1n0kIm = fImRPQ2dEBE[1][0][0]->GetBinContent(fImRPQ2dEBE[1][0][0]->GetBin(p,e))
7340 * fImRPQ2dEBE[1][0][0]->GetBinEntries(fImRPQ2dEBE[1][0][0]->GetBin(p,e));
7341 // m_{p}
7342 mp = fReRPQ2dEBE[1][0][0]->GetBinEntries(fReRPQ2dEBE[1][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)
7343
7344 t = 1; // typeFlag = RP or POI
7345 } // end of if(type == "POI")
7346 else if(type == "RP")
7347 {
7348 // p_{m*n,0} = q_{m*n,0}:
7349 p1n0kRe = q1n0kRe;
7350 p1n0kIm = q1n0kIm;
7351 // m_{p} = m_{q}:
7352 mp = mq;
7353
7354 t = 0; // typeFlag = RP or POI
7355 } // end of if(type == "RP")
7356
7357 // 2'-particle correlation for particular (pt,eta) bin:
7358 Double_t two1n1nPtEta = 0.;
7359 Double_t mWeight2pPrime = 0.; // multiplicity weight for <2'>
7360 if(mp*dMult-mq)
7361 {
7362 two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)
7363 / (mp*dMult-mq);
7364 // Determine multiplicity weight:
7365 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7366 {
7367 mWeight2pPrime = mp*dMult-mq;
7368 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7369 {
7370 mWeight2pPrime = 1.;
7371 }
7372 // Fill 2D profile holding <<2'>>:
7373 f2DDiffFlowCorrelationsPro[t][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mWeight2pPrime);
7374 } // end of if(mp*dMult-mq)
7375
7376 // 4'-particle correlation:
7377 Double_t four1n1n1n1nPtEta = 0.;
7378 Double_t mWeight4pPrime = 0.; // multiplicity weight for <4'>
7379 if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7380 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)
7381 {
7382 four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7383 - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))
7384 - 2.*q2n0kIm*dReQ1n*dImQ1n
7385 - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)
7386 + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)
7387 - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7388 - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq
7389 + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)
7390 + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)
7391 + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)
7392 + 2.*mq*dMult
7393 - 6.*mq)
7394 / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7395 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));
7396 // Determine multiplicity weight:
7397 if(!strcmp(fMultiplicityWeight->Data(),"combinations"))
7398 {
7399 mWeight4pPrime = (mp-mq)*dMult*(dMult-1.)*(dMult-2.) + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7400 } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))
7401 {
7402 mWeight4pPrime = 1.;
7403 }
7404 // Fill 2D profile holding <<4'>>:
7405 f2DDiffFlowCorrelationsPro[t][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,mWeight4pPrime);
7406 } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7407 // +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))
7408 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
7409 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
7410
7411} // end of AliFlowAnalysisWithQCumulants::Calculate2DDiffFlowCorrelations(TString type)
7412
7413//================================================================================================================================
7414
489d5531 7415void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights(TString type, TString ptOrEta)
7416{
7417 // Calculate sums of various event weights for reduced correlations.
7418 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)
7419
2a98ceb8 7420 Int_t typeFlag = 0;
7421 Int_t ptEtaFlag = 0;
489d5531 7422
7423 if(type == "RP")
7424 {
7425 typeFlag = 0;
7426 } else if(type == "POI")
7427 {
7428 typeFlag = 1;
7429 }
7430
7431 if(ptOrEta == "Pt")
7432 {
7433 ptEtaFlag = 0;
7434 } else if(ptOrEta == "Eta")
7435 {
7436 ptEtaFlag = 1;
7437 }
7438
7439 // shortcuts:
7440 Int_t t = typeFlag;
7441 Int_t pe = ptEtaFlag;
7442
7443 // binning:
7444 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7445 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7446 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7447 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7448
7449 for(Int_t rpq=0;rpq<3;rpq++)
7450 {
7451 for(Int_t m=0;m<4;m++)
7452 {
7453 for(Int_t k=0;k<9;k++)
7454 {
7455 if(!fReRPQ1dEBE[rpq][pe][m][k])
7456 {
7457 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;
7458 cout<<"pe = "<<pe<<endl;
7459 cout<<"rpq = "<<rpq<<endl;
7460 cout<<"m = "<<m<<endl;
7461 cout<<"k = "<<k<<endl;
7462 exit(0);
7463 }
7464 }
7465 }
7466 }
7467
7468 // multiplicities:
1268c371 7469 Double_t dMult = (*fSpk)(0,0); // total event multiplicity
489d5531 7470 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7471 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7472 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7473
7474 // event weights for reduced correlations:
7475 Double_t dw2 = 0.; // event weight for <2'>
7476 Double_t dw4 = 0.; // event weight for <4'>
7477 //Double_t dw6 = 0.; // event weight for <6'>
7478 //Double_t dw8 = 0.; // event weight for <8'>
7479
7480 // looping over bins:
7481 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7482 {
7483 if(type == "RP")
7484 {
7485 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7486 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7487 } else if(type == "POI")
7488 {
7489 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7490 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7491 }
7492
7493 // event weight for <2'>:
7494 dw2 = mp*dMult-mq;
7495 fDiffFlowSumOfEventWeights[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2);
7496 fDiffFlowSumOfEventWeights[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw2,2.));
7497
7498 // event weight for <4'>:
7499 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7500 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7501 fDiffFlowSumOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4);
7502 fDiffFlowSumOfEventWeights[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw4,2.));
7503
7504 // event weight for <6'>:
7505 //dw6 = ...;
7506 //fDiffFlowSumOfEventWeights[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6);
7507 //fDiffFlowSumOfEventWeights[t][pe][t][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw6,2.));
7508
7509 // event weight for <8'>:
7510 //dw8 = ...;
7511 //fDiffFlowSumOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw8);
7512 //fDiffFlowSumOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw8,2.));
7513 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7514
7515} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights()
7516
7517
7518//================================================================================================================================
7519
7520
7521void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)
7522{
7523 // Calculate sum of products of various event weights for both types of correlations (the ones for int. and diff. flow).
7524 // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)
7525 //
7526 // Important: To fill fDiffFlowSumOfProductOfEventWeights[][][][] use bellow table (i,j) with following constraints:
7527 // 1.) i<j
7528 // 2.) do not store terms which DO NOT include reduced correlations;
7529 // Table:
7530 // [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'>]
7531
2a98ceb8 7532 Int_t typeFlag = 0;
7533 Int_t ptEtaFlag = 0;
489d5531 7534
7535 if(type == "RP")
7536 {
7537 typeFlag = 0;
7538 } else if(type == "POI")
7539 {
7540 typeFlag = 1;
7541 }
7542
7543 if(ptOrEta == "Pt")
7544 {
7545 ptEtaFlag = 0;
7546 } else if(ptOrEta == "Eta")
7547 {
7548 ptEtaFlag = 1;
7549 }
7550
7551 // shortcuts:
7552 Int_t t = typeFlag;
7553 Int_t pe = ptEtaFlag;
7554
7555 // binning:
7556 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7557 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7558 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7559 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7560
7561 // protection:
7562 for(Int_t rpq=0;rpq<3;rpq++)
7563 {
7564 for(Int_t m=0;m<4;m++)
7565 {
7566 for(Int_t k=0;k<9;k++)
7567 {
7568 if(!fReRPQ1dEBE[rpq][pe][m][k])
7569 {
7570 cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;
7571 cout<<"pe = "<<pe<<endl;
7572 cout<<"rpq = "<<rpq<<endl;
7573 cout<<"m = "<<m<<endl;
7574 cout<<"k = "<<k<<endl;
7575 exit(0);
7576 }
7577 }
7578 }
7579 }
7580
7581 // multiplicities:
1268c371 7582 Double_t dMult = (*fSpk)(0,0); // total event multiplicity
489d5531 7583 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7584 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7585 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7586
7587 // event weights for correlations:
7588 Double_t dW2 = dMult*(dMult-1); // event weight for <2>
7589 Double_t dW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4>
7590 Double_t dW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6>
7591 Double_t dW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8>
7592
7593 // event weights for reduced correlations:
7594 Double_t dw2 = 0.; // event weight for <2'>
7595 Double_t dw4 = 0.; // event weight for <4'>
7596 //Double_t dw6 = 0.; // event weight for <6'>
7597 //Double_t dw8 = 0.; // event weight for <8'>
7598
7599 // looping over bins:
7600 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7601 {
7602 if(type == "RP")
7603 {
7604 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7605 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7606 } else if(type == "POI")
7607 {
7608 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7609 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7610 }
7611
7612 // event weight for <2'>:
7613 dw2 = mp*dMult-mq;
7614 fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw2); // storing product of even weights for <2> and <2'>
7615 fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW4); // storing product of even weights for <4> and <2'>
7616 fDiffFlowSumOfProductOfEventWeights[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW6); // storing product of even weights for <6> and <2'>
7617 fDiffFlowSumOfProductOfEventWeights[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW8); // storing product of even weights for <8> and <2'>
7618
7619 // event weight for <4'>:
7620 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7621 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);
7622 fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw4); // storing product of even weights for <2> and <4'>
7623 fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw4); // storing product of even weights for <2'> and <4'>
7624 fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw4); // storing product of even weights for <4> and <4'>
7625 fDiffFlowSumOfProductOfEventWeights[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW6); // storing product of even weights for <6> and <4'>
7626 fDiffFlowSumOfProductOfEventWeights[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW8); // storing product of even weights for <8> and <4'>
7627
7628 // event weight for <6'>:
7629 //dw6 = ...;
7630 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw6); // storing product of even weights for <2> and <6'>
7631 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw6); // storing product of even weights for <2'> and <6'>
7632 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw6); // storing product of even weights for <4> and <6'>
7633 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw6); // storing product of even weights for <4'> and <6'>
7634 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw6); // storing product of even weights for <6> and <6'>
7635 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dW8); // storing product of even weights for <6'> and <8>
7636 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>
7637
7638 // event weight for <8'>:
7639 //dw8 = ...;
7640 //fDiffFlowSumOfProductOfEventWeights[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw8); // storing product of even weights for <2> and <8'>
7641 //fDiffFlowSumOfProductOfEventWeights[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw8); // storing product of even weights for <2'> and <8'>
7642 //fDiffFlowSumOfProductOfEventWeights[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw8); // storing product of even weights for <4> and <8'>
7643 //fDiffFlowSumOfProductOfEventWeights[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw8); // storing product of even weights for <4'> and <8'>
7644 //fDiffFlowSumOfProductOfEventWeights[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw8); // storing product of even weights for <6> and <8'>
7645 //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>
7646 //fDiffFlowSumOfProductOfEventWeights[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW8*dw8); // storing product of even weights for <8> and <8'>
7647
7648 // Table:
7649 // [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'>]
7650
7651 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7652
7653
7654
7655} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)
7656
489d5531 7657//================================================================================================================================
7658
489d5531 7659void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)
7660{
7661 // Transfer profiles into histograms and calculate statistical errors correctly.
7662
1268c371 7663 Int_t t = 0; // RP or POI
7664 Int_t pe = 0; // pt or eta
489d5531 7665
7666 if(type == "RP")
7667 {
1268c371 7668 t = 0;
489d5531 7669 } else if(type == "POI")
7670 {
1268c371 7671 t = 1;
489d5531 7672 }
7673
7674 if(ptOrEta == "Pt")
7675 {
1268c371 7676 pe = 0;
489d5531 7677 } else if(ptOrEta == "Eta")
7678 {
1268c371 7679 pe = 1;
489d5531 7680 }
1268c371 7681
7682 for(Int_t rci=0;rci<4;rci++) // to be improved - moved into the method CheckPointersUsedInFinish()
489d5531 7683 {
7684 if(!fDiffFlowCorrelationsPro[t][pe][rci])
7685 {
7686 cout<<"WARNING: fDiffFlowCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7687 cout<<"t = "<<t<<endl;
7688 cout<<"pe = "<<pe<<endl;
7689 cout<<"rci = "<<rci<<endl;
7690 exit(0);
7691 }
b40a910e 7692 if(!fDiffFlowSquaredCorrelationsPro[t][pe][rci])
7693 {
7694 cout<<"WARNING: fDiffFlowSquaredCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7695 cout<<"t = "<<t<<endl;
7696 cout<<"pe = "<<pe<<endl;
7697 cout<<"rci = "<<rci<<endl;
7698 exit(0);
7699 }
489d5531 7700 for(Int_t power=0;power<2;power++)
7701 {
7702 if(!fDiffFlowSumOfEventWeights[t][pe][power][rci])
7703 {
7704 cout<<"WARNING: fDiffFlowSumOfEventWeights[t][pe][power][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;
7705 cout<<"t = "<<t<<endl;
7706 cout<<"pe = "<<pe<<endl;
7707 cout<<"power = "<<power<<endl;
7708 cout<<"rci = "<<rci<<endl;
7709 exit(0);
7710 }
7711 } // end of for(Int_t power=0;power<2;power++)
7712 } // end of for(Int_t rci=0;rci<4;rci++)
7713
7714 // common:
b40a910e 7715 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 7716 // transfer 1D profile into 1D histogram:
7717 Double_t correlation = 0.;
b40a910e 7718 Double_t squaredCorrelation = 0.;
489d5531 7719 Double_t spread = 0.;
7720 Double_t sumOfWeights = 0.; // sum of weights for particular reduced correlations for particular pt or eta bin
7721 Double_t sumOfSquaredWeights = 0.; // sum of squared weights for particular reduced correlations for particular pt or eta bin
7722 Double_t error = 0.; // error = termA * spread * termB
7723 // termA = (sqrt(sumOfSquaredWeights)/sumOfWeights)
7724 // termB = 1/pow(1-termA^2,0.5)
7725 Double_t termA = 0.;
7726 Double_t termB = 0.;
7727 for(Int_t rci=0;rci<4;rci++) // index of reduced correlation
7728 {
7729 for(Int_t b=1;b<=nBinsPtEta[pe];b++) // number of pt or eta bins
7730 {
b40a910e 7731 if(fDiffFlowCorrelationsPro[t][pe][rci]->GetBinEffectiveEntries(b) < 2 ||
7732 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->GetBinEffectiveEntries(b) < 2)
7733 {
7734 fDiffFlowCorrelationsPro[t][pe][rci]->SetBinError(b,0.);
7735 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->SetBinError(b,0.);
7736 continue; // to be improved - should I ignore results in pt bins with one entry for reduced correlations or not?
7737 }
489d5531 7738 correlation = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(b);
b40a910e 7739 squaredCorrelation = fDiffFlowSquaredCorrelationsPro[t][pe][rci]->GetBinContent(b);
7740 if(squaredCorrelation-correlation*correlation >= 0.)
7741 {
7742 spread = pow(squaredCorrelation-correlation*correlation,0.5);
7743 } else
7744 {
7745 cout<<endl;
7746 cout<<Form(" WARNING: Imaginary 'spread' for rci = %d, pe = %d, bin = %d !!!!",rci,pe,b)<<endl;
7747 cout<<endl;
7748 }
489d5531 7749 sumOfWeights = fDiffFlowSumOfEventWeights[t][pe][0][rci]->GetBinContent(b);
7750 sumOfSquaredWeights = fDiffFlowSumOfEventWeights[t][pe][1][rci]->GetBinContent(b);
1268c371 7751 if(TMath::Abs(sumOfWeights)>0.){termA = (pow(sumOfSquaredWeights,0.5)/sumOfWeights);}
7752 if(1.-pow(termA,2.)>0.){termB = 1./pow(1.-pow(termA,2.),0.5);}
489d5531 7753 error = termA*spread*termB; // final error (unbiased estimator for standard deviation)
7754 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinContent(b,correlation);
7755 fDiffFlowCorrelationsHist[t][pe][rci]->SetBinError(b,error);
7756 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7757 } // end of for(Int_t rci=0;rci<4;rci++)
7758
7759} // end of void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)
7760
489d5531 7761//================================================================================================================================
7762
489d5531 7763void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)
7764{
7765 // store products: <2><2'>, <2><4'>, <2><6'>, <2><8'>, <2'><4>,
7766 // <2'><4'>, <2'><6>, <2'><6'>, <2'><8>, <2'><8'>,
7767 // <4><4'>, <4><6'>, <4><8'>, <4'><6>, <4'><6'>,
7768 // <4'><8>, <4'><8'>, <6><6'>, <6><8'>, <6'><8>,
7769 // <6'><8'>, <8><8'>.
7770
2a98ceb8 7771 Int_t typeFlag = 0;
7772 Int_t ptEtaFlag = 0;
489d5531 7773
7774 if(type == "RP")
7775 {
7776 typeFlag = 0;
7777 } else if(type == "POI")
7778 {
7779 typeFlag = 1;
7780 }
7781
7782 if(ptOrEta == "Pt")
7783 {
7784 ptEtaFlag = 0;
7785 } else if(ptOrEta == "Eta")
7786 {
7787 ptEtaFlag = 1;
7788 }
7789
7790 // shortcuts:
7791 Int_t t = typeFlag;
7792 Int_t pe = ptEtaFlag;
7793
7794 // common:
7795 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7796 Double_t minPtEta[2] = {fPtMin,fEtaMin};
7797 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7798
7799 // protections // to be improved (add protection for all pointers in this method)
7800 if(!fIntFlowCorrelationsEBE)
7801 {
7802 cout<<"WARNING: fIntFlowCorrelationsEBE is NULL in AFAWQC::CDFPOC() !!!!"<<endl;
7803 exit(0);
7804 }
7805
7806 /*
1268c371 7807 Double_t dMult = (*fSpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)
489d5531 7808 //Double_t mr = 0.; // number of RPs in particular pt or eta bin
7809 Double_t mp = 0.; // number of POIs in particular pt or eta bin
7810 Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin
7811 */
7812
7813 // e-b-e correlations:
7814 Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>
7815 Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>
7816 Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>
7817 Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>
7818
7819 // event weights for correlations:
7820 Double_t dW2 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1); // event weight for <2>
7821 Double_t dW4 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2); // event weight for <4>
7822 Double_t dW6 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(3); // event weight for <6>
7823 Double_t dW8 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(4); // event weight for <8>
7824
7825 // e-b-e reduced correlations:
7826 Double_t twoReducedEBE = 0.; // <2'>
7827 Double_t fourReducedEBE = 0.; // <4'>
ea239361 7828 //Double_t sixReducedEBE = 0.; // <6'>
7829 //Double_t eightReducedEBE = 0.; // <8'>
489d5531 7830
7831 // event weights for reduced correlations:
7832 Double_t dw2 = 0.; // event weight for <2'>
7833 Double_t dw4 = 0.; // event weight for <4'>
7834 //Double_t dw6 = 0.; // event weight for <6'>
7835 //Double_t dw8 = 0.; // event weight for <8'>
7836
7837 // looping over bins:
7838 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
7839 {
7840 // e-b-e reduced correlations:
7841 twoReducedEBE = fDiffFlowCorrelationsEBE[t][pe][0]->GetBinContent(b);
7842 fourReducedEBE = fDiffFlowCorrelationsEBE[t][pe][1]->GetBinContent(b);
ea239361 7843 //sixReducedEBE = fDiffFlowCorrelationsEBE[t][pe][2]->GetBinContent(b);
7844 //eightReducedEBE = fDiffFlowCorrelationsEBE[t][pe][3]->GetBinContent(b);
489d5531 7845
7846 /*
7847 // to be improved (I should not do this here again)
7848 if(type == "RP")
7849 {
7850 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);
7851 mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow
7852 } else if(type == "POI")
7853 {
7854 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);
7855 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);
7856 }
7857
7858 // event weights for reduced correlations:
7859 dw2 = mp*dMult-mq; // weight for <2'>
7860 dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)
7861 + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); // weight for <4'>
7862 //dw6 = ...
7863 //dw8 = ...
7864
7865 */
7866
7867 dw2 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->GetBinContent(b);
7868 dw4 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->GetBinContent(b);
7869
7870 // storing all products:
7871 fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*twoReducedEBE,dW2*dw2); // storing <2><2'>
7872 fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*twoReducedEBE,dW4*dw2); // storing <4><2'>
7873 fDiffFlowProductOfCorrelationsPro[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*twoReducedEBE,dW6*dw2); // storing <6><2'>
7874 fDiffFlowProductOfCorrelationsPro[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*twoReducedEBE,dW8*dw2); // storing <8><2'>
7875
7876 // event weight for <4'>:
7877 fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*fourReducedEBE,dW2*dw4); // storing <2><4'>
7878 fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*fourReducedEBE,dw2*dw4); // storing <2'><4'>
7879 fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*fourReducedEBE,dW4*dw4); // storing <4><4'>
7880 fDiffFlowProductOfCorrelationsPro[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*fourReducedEBE,dW6*dw4); // storing <6><4'>
7881 fDiffFlowProductOfCorrelationsPro[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*fourReducedEBE,dW8*dw4); // storing <8><4'>
7882
7883 // event weight for <6'>:
7884 //dw6 = ...;
7885 //fDiffFlowProductOfCorrelationsPro[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*sixReducedEBE,dW2*dw6); // storing <2><6'>
7886 //fDiffFlowProductOfCorrelationsPro[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*sixReducedEBE,dw2*dw6); // storing <2'><6'>
7887 //fDiffFlowProductOfCorrelationsPro[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*sixReducedEBE,dW4*dw6); // storing <4><6'>
7888 //fDiffFlowProductOfCorrelationsPro[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*sixReducedEBE,dw4*dw6); // storing <4'><6'>
7889 //fDiffFlowProductOfCorrelationsPro[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*sixReducedEBE,dW6*dw6); // storing <6><6'>
7890 //fDiffFlowProductOfCorrelationsPro[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightEBE,dw6*dW8); // storing <6'><8>
7891 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>
7892
7893 // event weight for <8'>:
7894 //dw8 = ...;
7895 //fDiffFlowProductOfCorrelationsPro[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*eightReducedEBE,dW2*dw8); // storing <2><8'>
7896 //fDiffFlowProductOfCorrelationsPro[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*eightReducedEBE,dw2*dw8); // storing <2'><8'>
7897 //fDiffFlowProductOfCorrelationsPro[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*eightReducedEBE,dW4*dw8); // storing <4><8'>
7898 //fDiffFlowProductOfCorrelationsPro[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*eightReducedEBE,dw4*dw8); // storing <4'><8'>
7899 //fDiffFlowProductOfCorrelationsPro[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*eightReducedEBE,dW6*dw8); // storing <6><8'>
7900 //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>
7901 //fDiffFlowProductOfCorrelationsPro[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*eightReducedEBE,dW8*dw8); // storing <8><8'>
7902 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++
7903
7904} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)
7905
489d5531 7906//================================================================================================================================
7907
489d5531 7908void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta) // to be improved (reimplemented)
7909{
7910 // a) Calculate unbiased estimators Cov(<2>,<2'>), Cov(<2>,<4'>), Cov(<4>,<2'>), Cov(<4>,<4'>) and Cov(<2'>,<4'>)
7911 // for covariances V(<2>,<2'>), V(<2>,<4'>), V(<4>,<2'>), V(<4>,<4'>) and V(<2'>,<4'>).
7912 // b) Store in histogram fDiffFlowCovariances[t][pe][index] for instance the following:
7913 //
7914 // 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)]
7915 //
7916 // where N is the number of events, w_{<2>} is event weight for <2> and w_{<2'>} is event weight for <2'>.
7917 // c) Binning of fDiffFlowCovariances[t][pe][index] is organized as follows:
7918 //
7919 // 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)]
7920 // 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)]
7921 // 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)]
7922 // 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)]
7923 // 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)]
7924 // ...
7925
2a98ceb8 7926 Int_t typeFlag = 0;
7927 Int_t ptEtaFlag = 0;
489d5531 7928
7929 if(type == "RP")
7930 {
7931 typeFlag = 0;
7932 } else if(type == "POI")
7933 {
7934 typeFlag = 1;
7935 }
7936
7937 if(ptOrEta == "Pt")
7938 {
7939 ptEtaFlag = 0;
7940 } else if(ptOrEta == "Eta")
7941 {
7942 ptEtaFlag = 1;
7943 }
7944
7945 // shortcuts:
7946 Int_t t = typeFlag;
7947 Int_t pe = ptEtaFlag;
7948
7949 // common:
7950 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
7951 //Double_t minPtEta[2] = {fPtMin,fEtaMin};
7952 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
7953 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
7954
7955 // average correlations:
7956 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
7957 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
7958 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
7959 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
7960
7961 // sum of weights for correlation:
7962 Double_t sumOfWeightsForTwo = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // sum_{i=1}^{N} w_{<2>}
7963 Double_t sumOfWeightsForFour = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // sum_{i=1}^{N} w_{<4>}
7964 //Double_t sumOfWeightsForSix = fIntFlowSumOfEventWeights[0]->GetBinContent(3); // sum_{i=1}^{N} w_{<6>}
7965 //Double_t sumOfWeightsForEight = fIntFlowSumOfEventWeights[0]->GetBinContent(4); // sum_{i=1}^{N} w_{<8>}
7966
7967 // average reduced correlations:
7968 Double_t twoReduced = 0.; // <<2'>>
7969 Double_t fourReduced = 0.; // <<4'>>
7970 //Double_t sixReduced = 0.; // <<6'>>
7971 //Double_t eightReduced = 0.; // <<8'>>
7972
7973 // sum of weights for reduced correlation:
7974 Double_t sumOfWeightsForTwoReduced = 0.; // sum_{i=1}^{N} w_{<2'>}
7975 Double_t sumOfWeightsForFourReduced = 0.; // sum_{i=1}^{N} w_{<4'>}
7976 //Double_t sumOfWeightsForSixReduced = 0.; // sum_{i=1}^{N} w_{<6'>}
7977 //Double_t sumOfWeightsForEightReduced = 0.; // sum_{i=1}^{N} w_{<8'>}
7978
7979 // product of weights for reduced correlation:
7980 Double_t productOfWeightsForTwoTwoReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<2'>}
7981 Double_t productOfWeightsForTwoFourReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<4'>}
7982 Double_t productOfWeightsForFourTwoReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<2'>}
7983 Double_t productOfWeightsForFourFourReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<4'>}
7984 Double_t productOfWeightsForTwoReducedFourReduced = 0.; // sum_{i=1}^{N} w_{<2'>}w_{<4'>}
7985 // ...
7986
7987 // products for differential flow:
7988 Double_t twoTwoReduced = 0; // <<2><2'>>
7989 Double_t twoFourReduced = 0; // <<2><4'>>
7990 Double_t fourTwoReduced = 0; // <<4><2'>>
7991 Double_t fourFourReduced = 0; // <<4><4'>>
7992 Double_t twoReducedFourReduced = 0; // <<2'><4'>>
7993
7994 // denominators in the expressions for the unbiased estimators for covariances:
7995 // denominator = 1 - term1/(term2*term3)
7996 // prefactor = term1/(term2*term3)
7997 Double_t denominator = 0.;
7998 Double_t prefactor = 0.;
7999 Double_t term1 = 0.;
8000 Double_t term2 = 0.;
8001 Double_t term3 = 0.;
8002
8003 // unbiased estimators for covariances for differential flow:
8004 Double_t covTwoTwoReduced = 0.; // Cov(<2>,<2'>)
8005 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(w_{<2>},w_{<2'>})
8006 Double_t covTwoFourReduced = 0.; // Cov(<2>,<4'>)
8007 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(w_{<2>},w_{<4'>})
8008 Double_t covFourTwoReduced = 0.; // Cov(<4>,<2'>)
8009 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(w_{<4>},w_{<2'>})
8010 Double_t covFourFourReduced = 0.; // Cov(<4>,<4'>)
8011 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(w_{<4>},w_{<4'>})
8012 Double_t covTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>)
8013 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(w_{<2'>},w_{<4'>})
8014
8015 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
8016 {
8017 // average reduced corelations:
8018 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);
8019 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);
8020 // average products:
8021 twoTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->GetBinContent(b);
8022 twoFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->GetBinContent(b);
8023 fourTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->GetBinContent(b);
8024 fourFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->GetBinContent(b);
8025 twoReducedFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->GetBinContent(b);
8026 // sum of weights for reduced correlations:
8027 sumOfWeightsForTwoReduced = fDiffFlowSumOfEventWeights[t][pe][0][0]->GetBinContent(b);
8028 sumOfWeightsForFourReduced = fDiffFlowSumOfEventWeights[t][pe][0][1]->GetBinContent(b);
8029 // products of weights for correlations:
8030 productOfWeightsForTwoTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->GetBinContent(b);
8031 productOfWeightsForTwoFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->GetBinContent(b);
8032 productOfWeightsForFourTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->GetBinContent(b);
8033 productOfWeightsForFourFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->GetBinContent(b);
8034 productOfWeightsForTwoReducedFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->GetBinContent(b);
8035 // denominator for the unbiased estimator for covariances: 1 - term1/(term2*term3)
8036 // prefactor (multiplies Cov's) = term1/(term2*term3)
8037 // <2>,<2'>:
8038 term1 = productOfWeightsForTwoTwoReduced;
8039 term2 = sumOfWeightsForTwo;
8040 term3 = sumOfWeightsForTwoReduced;
8041 if(term2*term3>0.)
8042 {
8043 denominator = 1.-term1/(term2*term3);
8044 prefactor = term1/(term2*term3);
1268c371 8045 if(TMath::Abs(denominator)>1.e-6)
489d5531 8046 {
8047 covTwoTwoReduced = (twoTwoReduced-two*twoReduced)/denominator;
8048 wCovTwoTwoReduced = covTwoTwoReduced*prefactor;
8049 fDiffFlowCovariances[t][pe][0]->SetBinContent(b,wCovTwoTwoReduced);
8050 }
8051 }
8052 // <2>,<4'>:
8053 term1 = productOfWeightsForTwoFourReduced;
8054 term2 = sumOfWeightsForTwo;
8055 term3 = sumOfWeightsForFourReduced;
8056 if(term2*term3>0.)
8057 {
8058 denominator = 1.-term1/(term2*term3);
8059 prefactor = term1/(term2*term3);
1268c371 8060 if(TMath::Abs(denominator)>1.e-6)
489d5531 8061 {
8062 covTwoFourReduced = (twoFourReduced-two*fourReduced)/denominator;
8063 wCovTwoFourReduced = covTwoFourReduced*prefactor;
8064 fDiffFlowCovariances[t][pe][1]->SetBinContent(b,wCovTwoFourReduced);
8065 }
8066 }
8067 // <4>,<2'>:
8068 term1 = productOfWeightsForFourTwoReduced;
8069 term2 = sumOfWeightsForFour;
8070 term3 = sumOfWeightsForTwoReduced;
8071 if(term2*term3>0.)
8072 {
8073 denominator = 1.-term1/(term2*term3);
8074 prefactor = term1/(term2*term3);
1268c371 8075 if(TMath::Abs(denominator)>1.e-6)
489d5531 8076 {
8077 covFourTwoReduced = (fourTwoReduced-four*twoReduced)/denominator;
8078 wCovFourTwoReduced = covFourTwoReduced*prefactor;
8079 fDiffFlowCovariances[t][pe][2]->SetBinContent(b,wCovFourTwoReduced);
8080 }
8081 }
8082 // <4>,<4'>:
8083 term1 = productOfWeightsForFourFourReduced;
8084 term2 = sumOfWeightsForFour;
8085 term3 = sumOfWeightsForFourReduced;
8086 if(term2*term3>0.)
8087 {
8088 denominator = 1.-term1/(term2*term3);
8089 prefactor = term1/(term2*term3);
1268c371 8090 if(TMath::Abs(denominator)>1.e-6)
489d5531 8091 {
8092 covFourFourReduced = (fourFourReduced-four*fourReduced)/denominator;
8093 wCovFourFourReduced = covFourFourReduced*prefactor;
8094 fDiffFlowCovariances[t][pe][3]->SetBinContent(b,wCovFourFourReduced);
8095 }
8096 }
8097 // <2'>,<4'>:
8098 term1 = productOfWeightsForTwoReducedFourReduced;
8099 term2 = sumOfWeightsForTwoReduced;
8100 term3 = sumOfWeightsForFourReduced;
8101 if(term2*term3>0.)
8102 {
8103 denominator = 1.-term1/(term2*term3);
8104 prefactor = term1/(term2*term3);
1268c371 8105 if(TMath::Abs(denominator)>1.e-6)
489d5531 8106 {
8107 covTwoReducedFourReduced = (twoReducedFourReduced-twoReduced*fourReduced)/denominator;
8108 wCovTwoReducedFourReduced = covTwoReducedFourReduced*prefactor;
8109 fDiffFlowCovariances[t][pe][4]->SetBinContent(b,wCovTwoReducedFourReduced);
8110 }
8111 }
8112 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
8113
8114} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta)
8115
489d5531 8116//================================================================================================================================
8117
489d5531 8118void AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, TString ptOrEta)
8119{
1268c371 8120 // Calculate final results for differential flow.
489d5531 8121
1268c371 8122 // REMARK: Differential flow calculated in this method is NOT corrected for non-uniform acceptance.
8123 // This correction, if enabled via setter SetApplyCorrectionForNUA(Bool_t), is applied in the method
8124 // CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)
8125
8126 Int_t t = 0; // RP or POI
8127 Int_t pe = 0; // pt or eta
489d5531 8128
8129 if(type == "RP")
8130 {
1268c371 8131 t = 0;
489d5531 8132 } else if(type == "POI")
8133 {
1268c371 8134 t = 1;
489d5531 8135 }
8136
8137 if(ptOrEta == "Pt")
8138 {
1268c371 8139 pe = 0;
489d5531 8140 } else if(ptOrEta == "Eta")
8141 {
1268c371 8142 pe = 1;
489d5531 8143 }
1268c371 8144
8145 // Common:
489d5531 8146 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
1268c371 8147 // Correlations:
489d5531 8148 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
1268c371 8149 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
8150 // Statistical errors of correlations:
489d5531 8151 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);
8152 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2);
1268c371 8153 // Reduced correlations:
489d5531 8154 Double_t twoReduced = 0.; // <<2'>>
8155 Double_t fourReduced = 0.; // <<4'>>
1268c371 8156 // Statistical errors of reduced correlations:
489d5531 8157 Double_t twoReducedError = 0.;
8158 Double_t fourReducedError = 0.;
1268c371 8159 // Covariances:
8e1cefdd 8160 Double_t wCovTwoFour = 0.; // Cov(<2>,<4>) * prefactor(<2>,<4>)
8161 if(!fForgetAboutCovariances)
8162 {
8163 wCovTwoFour = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(<2>,<4>)
8164 }
489d5531 8165 Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(<2>,<2'>)
8166 Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(<2>,<4'>)
8167 Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(<4>,<2'>)
8168 Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(<4>,<4'>)
8169 Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)
1268c371 8170 // Differential flow:
489d5531 8171 Double_t v2Prime = 0.; // v'{2}
8172 Double_t v4Prime = 0.; // v'{4}
1268c371 8173 // Statistical error of differential flow:
489d5531 8174 Double_t v2PrimeError = 0.;
8175 Double_t v4PrimeError = 0.;
1268c371 8176 // Squared statistical error of differential flow:
489d5531 8177 Double_t v2PrimeErrorSquared = 0.;
8178 Double_t v4PrimeErrorSquared = 0.;
1268c371 8179 // Loop over pt or eta bins:
489d5531 8180 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
8181 {
1268c371 8182 // Reduced correlations and statistical errors:
489d5531 8183 twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);
8184 twoReducedError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b);
8185 fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);
8186 fourReducedError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b);
1268c371 8187 // Covariances:
8e1cefdd 8188 if(!fForgetAboutCovariances)
8189 {
8190 wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b);
8191 wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b);
8192 wCovFourTwoReduced = fDiffFlowCovariances[t][pe][2]->GetBinContent(b);
8193 wCovFourFourReduced = fDiffFlowCovariances[t][pe][3]->GetBinContent(b);
8194 wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b);
8195 }
1268c371 8196 // Differential flow:
489d5531 8197 // v'{2}:
8198 if(two>0.)
8199 {
8200 v2Prime = twoReduced/pow(two,0.5);
1268c371 8201 v2PrimeErrorSquared = (1./4.)*pow(two,-3.)*(pow(twoReduced,2.)*pow(twoError,2.)
8202 + 4.*pow(two,2.)*pow(twoReducedError,2.)
8203 - 4.*two*twoReduced*wCovTwoTwoReduced);
8204 if(v2PrimeErrorSquared>0.){v2PrimeError = pow(v2PrimeErrorSquared,0.5);}
8205 if(TMath::Abs(v2Prime)>0.)
8206 {
8207 fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime);
8208 fDiffFlow[t][pe][0]->SetBinError(b,v2PrimeError);
8209 }
8210 } // end of if(two>0.)
489d5531 8211 // differential flow:
8212 // v'{4}
8213 if(2.*pow(two,2.)-four > 0.)
8214 {
8215 v4Prime = (2.*two*twoReduced-fourReduced)/pow(2.*pow(two,2.)-four,3./4.);
1268c371 8216 v4PrimeErrorSquared = pow(2.*pow(two,2.)-four,-7./2.)
8217 * (pow(2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced,2.)*pow(twoError,2.)
8218 + (9./16.)*pow(2.*two*twoReduced-fourReduced,2.)*pow(fourError,2.)
8219 + 4.*pow(two,2.)*pow(2.*pow(two,2.)-four,2.)*pow(twoReducedError,2.)
8220 + pow(2.*pow(two,2.)-four,2.)*pow(fourReducedError,2.)
8221 - (3./2.)*(2.*two*twoReduced-fourReduced)
8222 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFour
8223 - 4.*two*(2.*pow(two,2.)-four)
8224 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoTwoReduced
8225 + 2.*(2.*pow(two,2.)-four)
8226 * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFourReduced
8227 + 3.*two*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourTwoReduced
8228 - (3./2.)*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourFourReduced
8229 - 4.*two*pow(2.*pow(two,2.)-four,2.)*wCovTwoReducedFourReduced);
8230 if(v4PrimeErrorSquared>0.){v4PrimeError = pow(v4PrimeErrorSquared,0.5);}
8231 if(TMath::Abs(v4Prime)>0.)
8232 {
8233 fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);
8234 fDiffFlow[t][pe][1]->SetBinError(b,v4PrimeError);
8235 }
8236 } // end of if(2.*pow(two,2.)-four > 0.)
489d5531 8237 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)
1268c371 8238
8239} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, Bool_t useParticleWeights)
8240
8241//================================================================================================================================
8242
8243void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlow(TString type)
8244{
8245 // Calculate final results for 2D diferential flow.
8246
8247 // to be improved - check pointers used in this method
8248
8249 Int_t t = 0; // RP or POI
8250
8251 if(type == "RP")
8252 {
8253 t = 0;
8254 } else if(type == "POI")
8255 {
8256 t = 1;
8257 }
489d5531 8258
1268c371 8259 // Differential flow:
8260 Double_t v2Prime = 0.; // v'{2}
8261 Double_t v4Prime = 0.; // v'{4}
8262 // Differential cumulants:
8263 Double_t qc2Prime = 0.; // QC{2'}
8264 Double_t qc4Prime = 0.; // QC{4'}
8265 // Looping over all (pt,eta) bins and calculating differential flow:
8266 for(Int_t p=1;p<=fnBinsPt;p++)
489d5531 8267 {
1268c371 8268 for(Int_t e=1;e<=fnBinsEta;e++)
489d5531 8269 {
1268c371 8270 // QC{2'}:
8271 qc2Prime = f2DDiffFlowCumulants[t][0]->GetBinContent(f2DDiffFlowCumulants[t][0]->GetBin(p,e));
8272 if(qc2Prime>=0.)
8273 {
8274 v2Prime = pow(qc2Prime,0.5);
8275 f2DDiffFlow[t][0]->SetBinContent(f2DDiffFlow[t][0]->GetBin(p,e),v2Prime);
8276 }
8277 // QC{4'}:
8278 qc4Prime = f2DDiffFlowCumulants[t][1]->GetBinContent(f2DDiffFlowCumulants[t][1]->GetBin(p,e));
8279 if(qc4Prime<=0.)
8280 {
8281 v4Prime = pow(-1.*qc4Prime,1./4.);
8282 f2DDiffFlow[t][1]->SetBinContent(f2DDiffFlow[t][1]->GetBin(p,e),v4Prime);
8283 }
8284 } // end of for(Int_t e=1;e<=fnBinsEta;e++)
8285 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
8286
8287} // end of void AliFlowAnalysisWithQCumulants::Calculate2DDiffFlow(TString type)
489d5531 8288
489d5531 8289//================================================================================================================================
8290
489d5531 8291void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()
8292{
8293 // a) Store all flags for integrated flow in profile fIntFlowFlags.
8294
8295 if(!fIntFlowFlags)
8296 {
8297 cout<<"WARNING: fIntFlowFlags is NULL in AFAWQC::SFFIF() !!!!"<<endl;
8298 exit(0);
8299 }
8300
8301 // particle weights used or not:
403e3389 8302 fIntFlowFlags->Fill(0.5,(Int_t)fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights);
489d5531 8303 // which event weights were used:
8304 if(strcmp(fMultiplicityWeight->Data(),"combinations"))
8305 {
8306 fIntFlowFlags->Fill(1.5,0); // 0 = "combinations" (default)
8307 } else if(strcmp(fMultiplicityWeight->Data(),"unit"))
8308 {
8309 fIntFlowFlags->Fill(1.5,1); // 1 = "unit"
8310 } else if(strcmp(fMultiplicityWeight->Data(),"multiplicity"))
8311 {
8312 fIntFlowFlags->Fill(1.5,2); // 2 = "multiplicity"
8313 }
489d5531 8314 fIntFlowFlags->Fill(2.5,(Int_t)fApplyCorrectionForNUA);
8315 fIntFlowFlags->Fill(3.5,(Int_t)fPrintFinalResults[0]);
8316 fIntFlowFlags->Fill(4.5,(Int_t)fPrintFinalResults[1]);
8317 fIntFlowFlags->Fill(5.5,(Int_t)fPrintFinalResults[2]);
b3dacf6b 8318 fIntFlowFlags->Fill(6.5,(Int_t)fPrintFinalResults[3]);
8319 fIntFlowFlags->Fill(7.5,(Int_t)fApplyCorrectionForNUAVsM);
b77b6434 8320 fIntFlowFlags->Fill(8.5,(Int_t)fPropagateErrorAlsoFromNIT);
b3dacf6b 8321 fIntFlowFlags->Fill(9.5,(Int_t)fCalculateCumulantsVsM);
0dd3b008 8322 fIntFlowFlags->Fill(10.5,(Int_t)fMinimumBiasReferenceFlow);
8e1cefdd 8323 fIntFlowFlags->Fill(11.5,(Int_t)fForgetAboutCovariances);
e5834fcb 8324 fIntFlowFlags->Fill(12.5,(Int_t)fStorePhiDistributionForOneEvent);
dd442cd2 8325 fIntFlowFlags->Fill(13.5,(Int_t)fFillMultipleControlHistograms);
3435cacb 8326 fIntFlowFlags->Fill(14.5,(Int_t)fCalculateAllCorrelationsVsM);
489d5531 8327} // end of void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()
8328
489d5531 8329//================================================================================================================================
8330
489d5531 8331void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()
8332{
8333 // Store all flags for differential flow in the profile fDiffFlowFlags.
8334
8335 if(!fDiffFlowFlags)
8336 {
1268c371 8337 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::SDFF() !!!!\n\n");
489d5531 8338 exit(0);
8339 }
8340
1268c371 8341 fDiffFlowFlags->Fill(0.5,fCalculateDiffFlow); // calculate differential flow
403e3389 8342 fDiffFlowFlags->Fill(1.5,fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights); // particle weights used or not?
1268c371 8343 //fDiffFlowFlags->Fill(2.5,""); // which event weight was used? ("combinations", "unit" or "multiplicity") to be improved - finalized
8344 fDiffFlowFlags->Fill(3.5,fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not
8345 fDiffFlowFlags->Fill(4.5,fCalculate2DDiffFlow); // calculate also 2D differential flow vs (pt,eta)
62e36168 8346 fDiffFlowFlags->Fill(5.5,fCalculateDiffFlowVsEta); // if you set kFALSE only differential flow vs pt is calculated
1268c371 8347
489d5531 8348} // end of void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()
8349
489d5531 8350//================================================================================================================================
8351
489d5531 8352void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms()
8353{
8354 // Access all pointers to common control and common result histograms and profiles.
8355
1268c371 8356 TString sCommonConstantsName = "fCommonConstants";
8357 sCommonConstantsName += fAnalysisLabel->Data();
8358 fCommonConstants = dynamic_cast<TProfile*>(fHistList->FindObject(sCommonConstantsName.Data()));
8359 if(!fCommonConstants)
8360 {
8361 printf("\n WARNING (QC): fCommonConstants is NULL in AFAWQC::GPFCH() !!!!\n\n");
8362 exit(0);
8363 }
8364
8365 // to be improved - lines bellow can be implemented better.
8366
489d5531 8367 TString commonHistsName = "AliFlowCommonHistQC";
8368 commonHistsName += fAnalysisLabel->Data();
8369 AliFlowCommonHist *commonHist = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHistsName.Data()));
b77b6434 8370 if(commonHist)
8371 {
8372 this->SetCommonHists(commonHist);
8373 if(fCommonHists->GetHarmonic())
8374 {
8375 fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
8376 }
8377 } // end of if(commonHist)
489d5531 8378 TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
8379 commonHists2ndOrderName += fAnalysisLabel->Data();
8380 AliFlowCommonHist *commonHist2nd = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists2ndOrderName.Data()));
8381 if(commonHist2nd) this->SetCommonHists2nd(commonHist2nd);
8382 TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
8383 commonHists4thOrderName += fAnalysisLabel->Data();
8384 AliFlowCommonHist *commonHist4th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists4thOrderName.Data()));
8385 if(commonHist4th) this->SetCommonHists4th(commonHist4th);
8386 TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
8387 commonHists6thOrderName += fAnalysisLabel->Data();
8388 AliFlowCommonHist *commonHist6th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists6thOrderName.Data()));
8389 if(commonHist6th) this->SetCommonHists6th(commonHist6th);
8390 TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
8391 commonHists8thOrderName += fAnalysisLabel->Data();
8392 AliFlowCommonHist *commonHist8th = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHists8thOrderName.Data()));
dd442cd2 8393 if(commonHist8th) this->SetCommonHists8th(commonHist8th);
8394
489d5531 8395 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
8396 commonHistResults2ndOrderName += fAnalysisLabel->Data();
b77b6434 8397 AliFlowCommonHistResults *commonHistRes2nd = dynamic_cast<AliFlowCommonHistResults*>
8398 (fHistList->FindObject(commonHistResults2ndOrderName.Data()));
489d5531 8399 if(commonHistRes2nd) this->SetCommonHistsResults2nd(commonHistRes2nd);
8400 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
8401 commonHistResults4thOrderName += fAnalysisLabel->Data();
8402 AliFlowCommonHistResults *commonHistRes4th = dynamic_cast<AliFlowCommonHistResults*>
8403 (fHistList->FindObject(commonHistResults4thOrderName.Data()));
8404 if(commonHistRes4th) this->SetCommonHistsResults4th(commonHistRes4th);
8405 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
8406 commonHistResults6thOrderName += fAnalysisLabel->Data();
8407 AliFlowCommonHistResults *commonHistRes6th = dynamic_cast<AliFlowCommonHistResults*>
8408 (fHistList->FindObject(commonHistResults6thOrderName.Data()));
8409 if(commonHistRes6th) this->SetCommonHistsResults6th(commonHistRes6th);
8410 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
8411 commonHistResults8thOrderName += fAnalysisLabel->Data();
8412 AliFlowCommonHistResults *commonHistRes8th = dynamic_cast<AliFlowCommonHistResults*>
8413 (fHistList->FindObject(commonHistResults8thOrderName.Data()));
8414 if(commonHistRes8th) this->SetCommonHistsResults8th(commonHistRes8th);
8415
8416} // end of void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms()
8417
489d5531 8418//================================================================================================================================
8419
489d5531 8420void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms()
8421{
8422 // Get pointers for histograms with particle weights.
8423
8424 TList *weightsList = dynamic_cast<TList*>(fHistList->FindObject("Weights"));
ca5f47e7 8425 if(!weightsList){printf("\n WARNING (QC): weightsList is NULL in AFAWQC::GPFPWH() !!!!\n");exit(0);}
8426 this->SetWeightsList(weightsList);
489d5531 8427 TString fUseParticleWeightsName = "fUseParticleWeightsQC"; // to be improved (hirdwired label QC)
8428 fUseParticleWeightsName += fAnalysisLabel->Data();
8429 TProfile *useParticleWeights = dynamic_cast<TProfile*>(weightsList->FindObject(fUseParticleWeightsName.Data()));
8430 if(useParticleWeights)
8431 {
8432 this->SetUseParticleWeights(useParticleWeights);
8433 fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1);
8434 fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2);
8435 fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3);
403e3389 8436 fUseTrackWeights = (Int_t)fUseParticleWeights->GetBinContent(4);
489d5531 8437 }
8438} // end of void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms();
8439
489d5531 8440//================================================================================================================================
8441
489d5531 8442void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms()
8443{
8444 // Get pointers for histograms and profiles relevant for integrated flow:
8445 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults.
8446 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow.
8447 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds.
8448 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds.
8449
8450 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data member?)
8451 TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data member?)
b40a910e 8452 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?)
8453 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 8454
8455 // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults:
8456 TList *intFlowList = NULL;
8457 intFlowList = dynamic_cast<TList*>(fHistList->FindObject("Integrated Flow"));
8458 if(!intFlowList)
8459 {
8460 cout<<"WARNING: intFlowList is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8461 exit(0);
8462 }
8463
b92ea2b9 8464 // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow:
8465 TString intFlowFlagsName = "fIntFlowFlags";
8466 intFlowFlagsName += fAnalysisLabel->Data();
8467 TProfile *intFlowFlags = dynamic_cast<TProfile*>(intFlowList->FindObject(intFlowFlagsName.Data()));
8468 if(intFlowFlags)
8469 {
8470 this->SetIntFlowFlags(intFlowFlags);
8471 fApplyCorrectionForNUA = (Bool_t)intFlowFlags->GetBinContent(3);
8472 fApplyCorrectionForNUAVsM = (Bool_t)intFlowFlags->GetBinContent(8);
8473 fCalculateCumulantsVsM = (Bool_t)intFlowFlags->GetBinContent(10);
8474 } else
8475 {
8476 cout<<"WARNING: intFlowFlags is NULL in FAWQC::GPFIFH() !!!!"<<endl;
8477 }
489d5531 8478
8479 // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds:
8480 TList *intFlowProfiles = NULL;
8481 intFlowProfiles = dynamic_cast<TList*>(intFlowList->FindObject("Profiles"));
8482 if(intFlowProfiles)
8483 {
8484 // average multiplicities:
8485 TString avMultiplicityName = "fAvMultiplicity";
8486 avMultiplicityName += fAnalysisLabel->Data();
8487 TProfile *avMultiplicity = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(avMultiplicityName.Data()));
8488 if(avMultiplicity)
8489 {
8490 this->SetAvMultiplicity(avMultiplicity);
8491 } else
8492 {
8493 cout<<"WARNING: avMultiplicity is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8494 }
8495 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with wrong errors!):
8496 TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
8497 intFlowCorrelationsProName += fAnalysisLabel->Data();
8498 TProfile *intFlowCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsProName.Data()));
8499 if(intFlowCorrelationsPro)
8500 {
8501 this->SetIntFlowCorrelationsPro(intFlowCorrelationsPro);
8502 } else
8503 {
8504 cout<<"WARNING: intFlowCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8505 }
b40a910e 8506 // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8^2>>:
8507 TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
8508 intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
8509 TProfile *intFlowSquaredCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowSquaredCorrelationsProName.Data()));
8510 if(intFlowSquaredCorrelationsPro)
8511 {
8512 this->SetIntFlowSquaredCorrelationsPro(intFlowSquaredCorrelationsPro);
8513 } else
8514 {
8515 cout<<"WARNING: intFlowSquaredCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8516 }
b3dacf6b 8517 if(fCalculateCumulantsVsM)
ff70ca91 8518 {
b40a910e 8519 // Average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (error is wrong here):
b3dacf6b 8520 TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
8521 intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
8522 for(Int_t ci=0;ci<4;ci++) // correlation index
ff70ca91 8523 {
b3dacf6b 8524 TProfile *intFlowCorrelationsVsMPro = dynamic_cast<TProfile*>
8525 (intFlowProfiles->FindObject(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data())));
8526 if(intFlowCorrelationsVsMPro)
8527 {
8528 this->SetIntFlowCorrelationsVsMPro(intFlowCorrelationsVsMPro,ci);
8529 } else
8530 {
8531 cout<<"WARNING: "<<Form("intFlowCorrelationsVsMPro[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8532 }
8533 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b40a910e 8534 // Average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
8535 TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
8536 intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
8537 for(Int_t ci=0;ci<4;ci++) // correlation index
8538 {
8539 TProfile *intFlowSquaredCorrelationsVsMPro = dynamic_cast<TProfile*>
8540 (intFlowProfiles->FindObject(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data())));
8541 if(intFlowSquaredCorrelationsVsMPro)
8542 {
8543 this->SetIntFlowSquaredCorrelationsVsMPro(intFlowSquaredCorrelationsVsMPro,ci);
8544 } else
8545 {
8546 cout<<"WARNING: "<<Form("intFlowSquaredCorrelationsVsMPro[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8547 }
8548 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b3dacf6b 8549 } // end of if(fCalculateCumulantsVsM)
489d5531 8550 // average all correlations for integrated flow (with wrong errors!):
8551 TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
8552 intFlowCorrelationsAllProName += fAnalysisLabel->Data();
8553 TProfile *intFlowCorrelationsAllPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsAllProName.Data()));
8554 if(intFlowCorrelationsAllPro)
8555 {
8556 this->SetIntFlowCorrelationsAllPro(intFlowCorrelationsAllPro);
8557 } else
8558 {
8559 cout<<"WARNING: intFlowCorrelationsAllPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8560 }
8561 // average extra correlations for integrated flow (which appear only when particle weights are used):
8562 // (to be improved: Weak point in implementation, I am assuming here that method GetPointersForParticleWeightsHistograms() was called)
403e3389 8563 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 8564 {
8565 TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
8566 intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
8567 TProfile *intFlowExtraCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowExtraCorrelationsProName.Data()));
8568 if(intFlowExtraCorrelationsPro)
8569 {
8570 this->SetIntFlowExtraCorrelationsPro(intFlowExtraCorrelationsPro);
8571 } else
8572 {
8573 cout<<"WARNING: intFlowExtraCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8574 }
403e3389 8575 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 8576 // average products of correlations <2>, <4>, <6> and <8>:
8577 TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
8578 intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
8579 TProfile *intFlowProductOfCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrelationsProName.Data()));
8580 if(intFlowProductOfCorrelationsPro)
8581 {
8582 this->SetIntFlowProductOfCorrelationsPro(intFlowProductOfCorrelationsPro);
8583 } else
8584 {
8585 cout<<"WARNING: intFlowProductOfCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8586 }
8587 // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
8588 // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
b3dacf6b 8589 if(fCalculateCumulantsVsM)
8590 {
8591 TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
8592 intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
403e3389 8593 TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
8594 "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
b3dacf6b 8595 for(Int_t pi=0;pi<6;pi++)
8596 {
8597 TProfile *intFlowProductOfCorrelationsVsMPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data())));
8598 if(intFlowProductOfCorrelationsVsMPro)
8599 {
8600 this->SetIntFlowProductOfCorrelationsVsMPro(intFlowProductOfCorrelationsVsMPro,pi);
8601 } else
8602 {
8603 cout<<"WARNING: "<<Form("intFlowProductOfCorrelationsVsMPro[%d]",pi)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8604 }
8605 } // end of for(Int_t pi=0;pi<6;pi++)
8606 } // end of if(fCalculateCumulantsVsM)
489d5531 8607 // average correction terms for non-uniform acceptance (with wrong errors!):
8608 for(Int_t sc=0;sc<2;sc++)
8609 {
8610 TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
8611 intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
8612 TProfile *intFlowCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAProName.Data(),sinCosFlag[sc].Data()))));
8613 if(intFlowCorrectionTermsForNUAPro)
8614 {
8615 this->SetIntFlowCorrectionTermsForNUAPro(intFlowCorrectionTermsForNUAPro,sc);
8616 } else
8617 {
8618 cout<<"WARNING: intFlowCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8619 cout<<"sc = "<<sc<<endl;
8620 }
2001bc3a 8621 // versus multiplicity:
b3dacf6b 8622 if(fCalculateCumulantsVsM)
2001bc3a 8623 {
b3dacf6b 8624 TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
8625 TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
8626 intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
8627 for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2001bc3a 8628 {
b3dacf6b 8629 TProfile *intFlowCorrectionTermsForNUAVsMPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(Form("%s: #LT#LT%s%s#GT#GT",intFlowCorrectionTermsForNUAVsMProName.Data(),sinCosFlag[sc].Data(),correctionTermFlag[ci].Data())));
8630 if(intFlowCorrectionTermsForNUAVsMPro)
8631 {
8632 this->SetIntFlowCorrectionTermsForNUAVsMPro(intFlowCorrectionTermsForNUAVsMPro,sc,ci);
8633 } else
8634 {
8635 cout<<"WARNING: intFlowCorrectionTermsForNUAVsMPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8636 cout<<"sc = "<<sc<<endl;
8637 cout<<"ci = "<<ci<<endl;
8638 }
8639 } // end of for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
8640 } // end of if(fCalculateCumulantsVsM)
489d5531 8641 } // end of for(Int_t sc=0;sc<2;sc++)
0328db2d 8642 // average products of correction terms for NUA:
8643 TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
8644 intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
8645 TProfile *intFlowProductOfCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrectionTermsForNUAProName.Data()));
8646 if(intFlowProductOfCorrectionTermsForNUAPro)
8647 {
8648 this->SetIntFlowProductOfCorrectionTermsForNUAPro(intFlowProductOfCorrectionTermsForNUAPro);
8649 } else
8650 {
8651 cout<<"WARNING: intFlowProductOfCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8652 }
489d5531 8653 } else // to if(intFlowProfiles)
8654 {
8655 cout<<"WARNING: intFlowProfiles is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8656 }
8657
8658 // d) Get pointer to list fIntFlowResults and pointers to all objects that she holds.
8659 TList *intFlowResults = NULL;
8660 intFlowResults = dynamic_cast<TList*>(intFlowList->FindObject("Results"));
8661 if(intFlowResults)
8662 {
8663 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!):
8664 TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
8665 intFlowCorrelationsHistName += fAnalysisLabel->Data();
8666 TH1D *intFlowCorrelationsHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsHistName.Data()));
8667 if(intFlowCorrelationsHist)
8668 {
8669 this->SetIntFlowCorrelationsHist(intFlowCorrelationsHist);
8670 } else
8671 {
8672 cout<<"WARNING: intFlowCorrelationsHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8673 }
ff70ca91 8674 // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!) vs M:
b3dacf6b 8675 if(fCalculateCumulantsVsM)
ff70ca91 8676 {
b3dacf6b 8677 TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
8678 intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
8679 for(Int_t ci=0;ci<4;ci++) // correlation index
ff70ca91 8680 {
b3dacf6b 8681 TH1D *intFlowCorrelationsVsMHist = dynamic_cast<TH1D*>
8682 (intFlowResults->FindObject(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data())));
8683 if(intFlowCorrelationsVsMHist)
8684 {
8685 this->SetIntFlowCorrelationsVsMHist(intFlowCorrelationsVsMHist,ci);
8686 } else
8687 {
8688 cout<<"WARNING: "<<Form("intFlowCorrelationsVsMHist[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8689 }
8690 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
8691 } // end of if(fCalculateCumulantsVsM)
489d5531 8692 // average all correlations for integrated flow (with correct errors!):
8693 TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
8694 intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
8695 TH1D *intFlowCorrelationsAllHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsAllHistName.Data()));
8696 if(intFlowCorrelationsAllHist)
8697 {
8698 this->SetIntFlowCorrelationsAllHist(intFlowCorrelationsAllHist);
8699 } else
8700 {
8701 cout<<"WARNING: intFlowCorrelationsAllHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8702 }
8703 // average correction terms for non-uniform acceptance (with correct errors!):
8704 TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
8705 intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
8706 for(Int_t sc=0;sc<2;sc++)
8707 {
8708 TH1D *intFlowCorrectionTermsForNUAHist = dynamic_cast<TH1D*>(intFlowResults->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAHistName.Data(),sinCosFlag[sc].Data()))));
8709 if(intFlowCorrectionTermsForNUAHist)
8710 {
8711 this->SetIntFlowCorrectionTermsForNUAHist(intFlowCorrectionTermsForNUAHist,sc);
8712 } else
8713 {
8714 cout<<"WARNING: intFlowCorrectionTermsForNUAHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8715 cout<<"sc = "<<sc<<endl;
8716 }
8717 } // end of for(Int_t sc=0;sc<2;sc++)
8718 // covariances (multiplied with weight dependent prefactor):
8719 TString intFlowCovariancesName = "fIntFlowCovariances";
8720 intFlowCovariancesName += fAnalysisLabel->Data();
8721 TH1D *intFlowCovariances = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesName.Data()));
8722 if(intFlowCovariances)
8723 {
8724 this->SetIntFlowCovariances(intFlowCovariances);
8725 } else
8726 {
8727 cout<<"WARNING: intFlowCovariances is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8728 }
8729 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
8730 TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
8731 intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
8732 for(Int_t power=0;power<2;power++)
8733 {
8734 TH1D *intFlowSumOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s",intFlowSumOfEventWeightsName.Data(),powerFlag[power].Data())));
8735 if(intFlowSumOfEventWeights)
8736 {
8737 this->SetIntFlowSumOfEventWeights(intFlowSumOfEventWeights,power);
8738 } else
8739 {
8740 cout<<"WARNING: intFlowSumOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8741 cout<<"power = "<<power<<endl;
8742 }
8743 } // end of for(Int_t power=0;power<2;power++)
8744 // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
8745 TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
8746 intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
8747 TH1D *intFlowSumOfProductOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsName.Data()));
8748 if(intFlowSumOfProductOfEventWeights)
8749 {
8750 this->SetIntFlowSumOfProductOfEventWeights(intFlowSumOfProductOfEventWeights);
8751 } else
8752 {
8753 cout<<"WARNING: intFlowSumOfProductOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8754 }
ff70ca91 8755 // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
8756 // [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 8757 if(fCalculateCumulantsVsM)
ff70ca91 8758 {
b3dacf6b 8759 TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
8760 intFlowCovariancesVsMName += fAnalysisLabel->Data();
8761 TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
8762 for(Int_t ci=0;ci<6;ci++)
8763 {
8764 TH1D *intFlowCovariancesVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data())));
8765 if(intFlowCovariancesVsM)
ff70ca91 8766 {
b3dacf6b 8767 this->SetIntFlowCovariancesVsM(intFlowCovariancesVsM,ci);
ff70ca91 8768 } else
8769 {
b3dacf6b 8770 cout<<"WARNING: "<<Form("intFlowCovariancesVsM[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8771 }
b3dacf6b 8772 } // end of for(Int_t ci=0;ci<6;ci++)
8773 } // end of if(fCalculateCumulantsVsM)
8774 // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
8775 // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
8776 if(fCalculateCumulantsVsM)
8777 {
8778 TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
8779 intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
8780 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>}"},
8781 {"#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}"}};
8782 for(Int_t si=0;si<4;si++)
8783 {
8784 for(Int_t power=0;power<2;power++)
8785 {
8786 TH1D *intFlowSumOfEventWeightsVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data())));
8787 if(intFlowSumOfEventWeightsVsM)
8788 {
8789 this->SetIntFlowSumOfEventWeightsVsM(intFlowSumOfEventWeightsVsM,si,power);
8790 } else
8791 {
8792 cout<<"WARNING: "<<Form("intFlowSumOfEventWeightsVsM[%d][%d]",si,power)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8793 }
8794 } // end of for(Int_t power=0;power<2;power++)
8795 } // end of for(Int_t si=0;si<4;si++)
8796 } // end of if(fCalculateCumulantsVsM)
ff70ca91 8797 // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
8798 // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
8799 // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
b3dacf6b 8800 if(fCalculateCumulantsVsM)
ff70ca91 8801 {
b3dacf6b 8802 TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
8803 intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
8804 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>}",
8805 "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
8806 for(Int_t pi=0;pi<6;pi++)
ff70ca91 8807 {
b3dacf6b 8808 TH1D *intFlowSumOfProductOfEventWeightsVsM = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data())));
8809 if(intFlowSumOfProductOfEventWeightsVsM)
8810 {
8811 this->SetIntFlowSumOfProductOfEventWeightsVsM(intFlowSumOfProductOfEventWeightsVsM,pi);
8812 } else
8813 {
8814 cout<<"WARNING: "<<Form("intFlowSumOfProductOfEventWeightsVsM[%d]",pi)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8815 }
8816 } // end of for(Int_t pi=0;pi<6;pi++)
8817 } // end of if(fCalculateCumulantsVsM)
0328db2d 8818 // covariances for NUA (multiplied with weight dependent prefactor):
8819 TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
8820 intFlowCovariancesNUAName += fAnalysisLabel->Data();
8821 TH1D *intFlowCovariancesNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesNUAName.Data()));
8822 if(intFlowCovariancesNUA)
8823 {
8824 this->SetIntFlowCovariancesNUA(intFlowCovariancesNUA);
8825 } else
8826 {
8827 cout<<"WARNING: intFlowCovariancesNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8828 }
8829 // sum of linear and quadratic event weights NUA terms:
8830 TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
8831 intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
8832 for(Int_t sc=0;sc<2;sc++)
8833 {
8834 for(Int_t power=0;power<2;power++)
8835 {
8836 TH1D *intFlowSumOfEventWeightsNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s, %s",intFlowSumOfEventWeightsNUAName.Data(),powerFlag[power].Data(),sinCosFlag[sc].Data())));
8837 if(intFlowSumOfEventWeightsNUA)
8838 {
8839 this->SetIntFlowSumOfEventWeightsNUA(intFlowSumOfEventWeightsNUA,sc,power);
8840 } else
8841 {
8842 cout<<"WARNING: intFlowSumOfEventWeightsNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8843 cout<<"sc = "<<sc<<endl;
8844 cout<<"power = "<<power<<endl;
8845 }
8846 } // end of for(Int_t power=0;power<2;power++)
8847 } // end of for(Int_t sc=0;sc<2;sc++)
8848 // sum of products of event weights for NUA terms:
8849 TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
8850 intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
8851 TH1D *intFlowSumOfProductOfEventWeightsNUA = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsNUAName.Data()));
8852 if(intFlowSumOfProductOfEventWeightsNUA)
8853 {
8854 this->SetIntFlowSumOfProductOfEventWeightsNUA(intFlowSumOfProductOfEventWeightsNUA);
8855 } else
8856 {
8857 cout<<"WARNING: intFlowSumOfProductOfEventWeightsNUA is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8858 }
b3dacf6b 8859 // Final results for reference Q-cumulants:
489d5531 8860 TString intFlowQcumulantsName = "fIntFlowQcumulants";
8861 intFlowQcumulantsName += fAnalysisLabel->Data();
8862 TH1D *intFlowQcumulants = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsName.Data()));
8863 if(intFlowQcumulants)
8864 {
8865 this->SetIntFlowQcumulants(intFlowQcumulants);
8866 } else
8867 {
8868 cout<<"WARNING: intFlowQcumulants is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8869 }
b3dacf6b 8870 // Final results for reference Q-cumulants rebinned in M:
8871 if(fCalculateCumulantsVsM)
8872 {
8873 TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
8874 intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
8875 TH1D *intFlowQcumulantsRebinnedInM = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsRebinnedInMName.Data()));
8876 if(intFlowQcumulantsRebinnedInM)
8877 {
8878 this->SetIntFlowQcumulantsRebinnedInM(intFlowQcumulantsRebinnedInM);
8879 } else
8880 {
8881 cout<<"WARNING: intFlowQcumulantsRebinnedInM is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8882 }
8883 } // end of if(fCalculateCumulantsVsM)
b92ea2b9 8884 // Ratio between error squared: with/without non-isotropic terms:
8885 TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
8886 intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
8887 TH1D *intFlowQcumulantsErrorSquaredRatio = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsErrorSquaredRatioName.Data()));
8888 if(intFlowQcumulantsErrorSquaredRatio)
8889 {
8890 this->SetIntFlowQcumulantsErrorSquaredRatio(intFlowQcumulantsErrorSquaredRatio);
8891 } else
8892 {
8893 cout<<" WARNING: intntFlowQcumulantsErrorSquaredRatio is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8894 }
ff70ca91 8895 // final results for integrated Q-cumulants versus multiplicity:
ff70ca91 8896 TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
b3dacf6b 8897 if(fCalculateCumulantsVsM)
ff70ca91 8898 {
b3dacf6b 8899 TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
8900 intFlowQcumulantsVsMName += fAnalysisLabel->Data();
8901 for(Int_t co=0;co<4;co++) // cumulant order
ff70ca91 8902 {
b3dacf6b 8903 TH1D *intFlowQcumulantsVsM = dynamic_cast<TH1D*>
8904 (intFlowResults->FindObject(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data())));
8905 if(intFlowQcumulantsVsM)
8906 {
8907 this->SetIntFlowQcumulantsVsM(intFlowQcumulantsVsM,co);
8908 } else
8909 {
8910 cout<<"WARNING: "<<Form("intFlowQcumulantsVsM[%d]",co)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8911 }
8912 } // end of for(Int_t co=0;co<4;co++) // cumulant order
8913 } // end of if(fCalculateCumulantsVsM)
8914 // Final reference flow estimates from Q-cumulants:
489d5531 8915 TString intFlowName = "fIntFlow";
8916 intFlowName += fAnalysisLabel->Data();
8917 TH1D *intFlow = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowName.Data()));
8918 if(intFlow)
8919 {
8920 this->SetIntFlow(intFlow);
8921 } else
8922 {
8923 cout<<"WARNING: intFlow is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
ff70ca91 8924 }
b3dacf6b 8925 // Final reference flow estimates from Q-cumulants vs M rebinned in M:
8926 if(fCalculateCumulantsVsM)
ff70ca91 8927 {
b3dacf6b 8928 TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
8929 intFlowRebinnedInMName += fAnalysisLabel->Data();
8930 TH1D *intFlowRebinnedInM = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowRebinnedInMName.Data()));
8931 if(intFlowRebinnedInM)
ff70ca91 8932 {
b3dacf6b 8933 this->SetIntFlowRebinnedInM(intFlowRebinnedInM);
8934 } else
ff70ca91 8935 {
b3dacf6b 8936 cout<<"WARNING: intFlowRebinnedInM is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8937 }
8938 } // end of if(fCalculateCumulantsVsM)
8939 // integrated flow from Q-cumulants versus multiplicity:
8940 if(fCalculateCumulantsVsM)
8941 {
8942 TString intFlowVsMName = "fIntFlowVsM";
8943 intFlowVsMName += fAnalysisLabel->Data();
b77b6434 8944 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 8945 for(Int_t co=0;co<4;co++) // cumulant order
8946 {
8947 TH1D *intFlowVsM = dynamic_cast<TH1D*>
b77b6434 8948 (intFlowResults->FindObject(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data())));
b3dacf6b 8949 if(intFlowVsM)
8950 {
8951 this->SetIntFlowVsM(intFlowVsM,co);
8952 } else
8953 {
8954 cout<<"WARNING: "<<Form("intFlowVsM[%d]",co)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8955 }
8956 } // end of for(Int_t co=0;co<4;co++) // cumulant order
8957 } // end of if(fCalculateCumulantsVsM)
2001bc3a 8958 // quantifying detector effects effects to correlations:
8959 TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
8960 intFlowDetectorBiasName += fAnalysisLabel->Data();
8961 TH1D *intFlowDetectorBias = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowDetectorBiasName.Data()));
8962 if(intFlowDetectorBias)
8963 {
8964 this->SetIntFlowDetectorBias(intFlowDetectorBias);
8965 } else
8966 {
8967 cout<<"WARNING: intFlowDetectorBias is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8968 }
8969 // quantifying detector effects effects to correlations vs multiplicity:
b77b6434 8970 if(fCalculateCumulantsVsM)
2001bc3a 8971 {
3c5d5752 8972 TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
8973 intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
8974 for(Int_t ci=0;ci<4;ci++) // correlation index
2001bc3a 8975 {
3c5d5752 8976 TH1D *intFlowDetectorBiasVsM = dynamic_cast<TH1D*>
8977 (intFlowResults->FindObject(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data())));
8978 if(intFlowDetectorBiasVsM)
8979 {
8980 this->SetIntFlowDetectorBiasVsM(intFlowDetectorBiasVsM,ci);
8981 } else
8982 {
8983 cout<<"WARNING: "<<Form("intFlowDetectorBiasVsM[%d]",ci)<<" is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8984 }
8985 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
b77b6434 8986 } // end of if(fCalculateCumulantsVsM)
489d5531 8987 } else // to if(intFlowResults)
8988 {
8989 cout<<"WARNING: intFlowResults is NULL in AFAWQC::GPFIFH() !!!!"<<endl;
8990 }
ff70ca91 8991
489d5531 8992} // end of void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms()
8993
489d5531 8994//================================================================================================================================
8995
1268c371 8996void AliFlowAnalysisWithQCumulants::GetPointersFor2DDiffFlowHistograms()
8997{
8998 // Get pointers for 2D differential flow histograms.
8999 // a) Check pointers used in this method;
9000 // b) Get pointers to 2D differential flow lists;
9001 // c) Get pointers to 2D differential flow profiles;
9002 // d) Get pointers to 2D differential flow histograms.
9003
9004 // a) Check pointers used in this method:
9005 if(!fDiffFlowList)
9006 {
9007 printf("\n WARNING (QC): fDiffFlowList is NULL in AFAWQC::GPF2DDFH() !!!!\n");
9008 printf(" Call method GetPointersForDiffFlowHistograms() first.\n\n");
9009 exit(0);
9010 }
9011 if(!fDiffFlowFlags)
9012 {
9013 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::GPF2DDFH() !!!!\n\n");
9014 printf(" Call method GetPointersForDiffFlowHistograms() first.\n\n");
9015 exit(0);
9016 }
9017
9018 // b) Get pointers to 2D differential flow lists:
9019 this->SetCalculate2DDiffFlow((Bool_t)fDiffFlowFlags->GetBinContent(5)); // to be improved - hardwired 5
9020 if(!fCalculate2DDiffFlow){return;}
9021 TString typeFlag[2] = {"RP","POI"};
9022 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
9023 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9024 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9025 // Base list:
9026 TString diffFlow2DListName = "2D";
9027 diffFlow2DListName += fAnalysisLabel->Data();
9028 fDiffFlow2D = dynamic_cast<TList*>(fDiffFlowList->FindObject(diffFlow2DListName.Data()));
9029 if(!fDiffFlow2D)
9030 {
9031 printf("\n WARNING (QC): fDiffFlow2D is NULL in AFAWQC::GPFDFH() !!!!\n\n");
9032 exit(0);
9033 }
9034 // Lists holding profiles with 2D correlations:
9035 TString s2DDiffFlowCorrelationsProListName = "Profiles with 2D correlations";
9036 s2DDiffFlowCorrelationsProListName += fAnalysisLabel->Data(); // to be improved
9037 for(Int_t t=0;t<2;t++)
9038 {
9039 f2DDiffFlowCorrelationsProList[t] = dynamic_cast<TList*>(fDiffFlow2D->FindObject(Form("Profiles with 2D correlations (%s)",typeFlag[t].Data())));
9040 if(!f2DDiffFlowCorrelationsProList[t])
9041 {
9042 printf("\n WARNING (QC): f2DDiffFlowCorrelationsProList[%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t);
9043 exit(0);
9044 }
9045 } // end of for(Int_t t=0;t<2;t++)
9046
9047 // c) Get pointers to 2D differential flow profiles:
9048 TString s2DDiffFlowCorrelationsProName = "f2DDiffFlowCorrelationsPro";
9049 s2DDiffFlowCorrelationsProName += fAnalysisLabel->Data();
9050 for(Int_t t=0;t<2;t++) // type: RP or POI
9051 {
9052 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9053 {
9054 f2DDiffFlowCorrelationsPro[t][rci] = dynamic_cast<TProfile2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowCorrelationsProName.Data(),typeFlag[t].Data(),reducedCorrelationIndex[rci].Data())));
9055 if(!f2DDiffFlowCorrelationsPro[t][rci])
9056 {
9057 printf("\n WARNING (QC): f2DDiffFlowCorrelationsPro[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
9058 exit(0);
9059 } else
9060 {
9061 this->Set2DDiffFlowCorrelationsPro(f2DDiffFlowCorrelationsPro[t][rci],t,rci);
9062 }
9063 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9064 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9065
9066 // d) Get pointers to 2D differential flow histograms:
9067 TString s2DDiffFlowCumulantsName = "f2DDiffFlowCumulants";
9068 s2DDiffFlowCumulantsName += fAnalysisLabel->Data();
9069 TString s2DDiffFlowName = "f2DDiffFlow";
9070 s2DDiffFlowName += fAnalysisLabel->Data();
9071 for(Int_t t=0;t<2;t++) // type: RP or POI
9072 {
9073 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9074 {
9075 // 2D differential cumulants:
9076 f2DDiffFlowCumulants[t][rci] = dynamic_cast<TH2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowCumulantsName.Data(),typeFlag[t].Data(),differentialCumulantIndex[rci].Data())));
9077 if(!f2DDiffFlowCumulants[t][rci])
9078 {
9079 printf("\n WARNING (QC): f2DDiffFlowCumulants[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
9080 exit(0);
9081 } else
9082 {
9083 this->Set2DDiffFlowCumulants(f2DDiffFlowCumulants[t][rci],t,rci);
9084 }
9085 // 2D differential flow:
9086 f2DDiffFlow[t][rci] = dynamic_cast<TH2D*>(f2DDiffFlowCorrelationsProList[t]->FindObject(Form("%s, %s, %s",s2DDiffFlowName.Data(),typeFlag[t].Data(),differentialFlowIndex[rci].Data())));
9087 if(!f2DDiffFlow[t][rci])
9088 {
9089 printf("\n WARNING (QC): f2DDiffFlow[%i][%i] is NULL in AFAWQC::GPF2DFH() !!!!\n\n",t,rci);
9090 exit(0);
9091 } else
9092 {
9093 this->Set2DDiffFlow(f2DDiffFlow[t][rci],t,rci);
9094 }
9095 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9096 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9097
9098} // end of void AliFlowAnalysisWithQCumulants::GetPointersFor2DDiffFlowHistograms()
9099
9100//================================================================================================================================
9101
64e500e3 9102void AliFlowAnalysisWithQCumulants::GetPointersForOtherDiffCorrelators()
9103{
9104 // Get pointers for other differential correlators.
9105 // a) Get pointer to list with other differential correlators;
9106 // b) Declare local flags;
9107 // c) Get pointers to other differential profiles.
9108
62e36168 9109 if(!fCalculateDiffFlow){return;} // TBI: This must eventually be moved somewhere else
9110
64e500e3 9111 // a) Get pointer to list with other differential correlators:
9112 fOtherDiffCorrelatorsList = dynamic_cast<TList*>(fHistList->FindObject("Other differential correlators"));
9113 if(!fOtherDiffCorrelatorsList)
9114 {
9115 printf("\n WARNING (QC): fOtherDiffCorrelatorsList is NULL in AFAWQC::GPFDFH() !!!!\n\n");
9116 exit(0);
9117 }
9118
9119 // b) Declare local flags: // (to be improved - promoted to data members)
9120 TString typeFlag[2] = {"RP","POI"};
9121 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9122 TString sinCosFlag[2] = {"sin","cos"};
9123
9124 // c) Get pointers to other differential profiles:
9125 TString otherDiffCorrelatorsName = "fOtherDiffCorrelators";
9126 otherDiffCorrelatorsName += fAnalysisLabel->Data();
9127 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9128 {
62e36168 9129 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 9130 {
9131 for(Int_t sc=0;sc<2;sc++) // sin or cos
9132 {
9133 for(Int_t ci=0;ci<1;ci++) // correlator index
9134 {
9135 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)));
9136 if(!fOtherDiffCorrelators[t][pe][sc][ci])
9137 {
9138 printf("\n WARNING (QC): fOtherDiffCorrelators[%i][%i][%i][%i] is NULL in AFAWQC::GPFODC() !!!!\n\n",t,pe,sc,ci);
9139 exit(0);
9140 } else
9141 {
9142 this->SetOtherDiffCorrelators(fOtherDiffCorrelators[t][pe][sc][ci],t,pe,sc,ci);
9143 }
9144 } // end of for(Int_t ci=0;ci<1;ci++) // correlator index
9145 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9146 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9147 } // end of for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9148
9149} // end of void AliFlowAnalysisWithQCumulants::GetPointersForOtherDiffCorrelators()
9150
9151//================================================================================================================================
9152
489d5531 9153void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms()
9154{
9155 // Get pointer to all objects relevant for differential flow.
1268c371 9156 // a) Get pointer to base list for differential flow fDiffFlowList;
9157 // b) Get pointer to profile fDiffFlowFlags holding all flags for differential flow. Access and set some flags;
9158 // c) Get pointers to nested lists fDiffFlowListProfiles and fDiffFlowListResults;
9159 // d) Define flags locally (to be improved: should I promote these flags to data members?);
9160 // e) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;
9161 // f) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.
9162
9163 // a) Get pointer to base list for differential flow fDiffFlowList:
9164 fDiffFlowList = dynamic_cast<TList*>(fHistList->FindObject("Differential Flow"));
9165 if(!fDiffFlowList)
489d5531 9166 {
1268c371 9167 printf("\n WARNING (QC): fDiffFlowList is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9168 exit(0);
9169 }
1268c371 9170
9171 // b) Get pointer to profile fDiffFlowFlags holding all flags for differential flow. Access and set some flags:
9172 TString diffFlowFlagsName = "fDiffFlowFlags";
9173 diffFlowFlagsName += fAnalysisLabel->Data();
9174 fDiffFlowFlags = dynamic_cast<TProfile*>(fDiffFlowList->FindObject(diffFlowFlagsName.Data()));
9175 if(fDiffFlowFlags)
9176 {
62d19320 9177 this->SetCalculateDiffFlow((Bool_t)fDiffFlowFlags->GetBinContent(1)); // to be improved - hardwired 1
62e36168 9178 this->SetCalculateDiffFlowVsEta((Bool_t)fDiffFlowFlags->GetBinContent(6)); // to be improved - hardwired 6
1268c371 9179 } else
9180 {
9181 printf("\n WARNING (QC): fDiffFlowFlags is NULL in AFAWQC::GPFDFH() !!!!\n\n");
9182 printf("\n Flags in method Finish() are wrong.\n\n");
9183 exit(0);
9184 }
9185
9186 if(!fCalculateDiffFlow){return;} // IMPORTANT: do not move this anywhere above in this method (to be improved)
9187
9188 // c) Get pointers to nested lists fDiffFlowListProfiles and fDiffFlowListResults:
9189 // List holding nested lists holding profiles:
489d5531 9190 TList *diffFlowListProfiles = NULL;
1268c371 9191 diffFlowListProfiles = dynamic_cast<TList*>(fDiffFlowList->FindObject("Profiles"));
489d5531 9192 if(!diffFlowListProfiles)
9193 {
1268c371 9194 printf("\n WARNING (QC): diffFlowListProfiles is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9195 exit(0);
9196 }
1268c371 9197 // List holding nested lists holding histograms with final results:
489d5531 9198 TList *diffFlowListResults = NULL;
1268c371 9199 diffFlowListResults = dynamic_cast<TList*>(fDiffFlowList->FindObject("Results"));
489d5531 9200 if(!diffFlowListResults)
9201 {
1268c371 9202 printf("\n WARNING (QC): diffFlowListResults is NULL in AFAWQC::GPFDFH() !!!!\n\n");
489d5531 9203 exit(0);
9204 }
9205
1268c371 9206 // d) Define flags locally (to be improved: should I promote these flags to data members?):
9207 TString typeFlag[2] = {"RP","POI"};
9208 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9209 TString powerFlag[2] = {"linear","quadratic"};
9210 TString sinCosFlag[2] = {"sin","cos"};
9211 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9212 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9213 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
9214 TString reducedSquaredCorrelationIndex[4] = {"<2'>^{2}","<4'>^{2}","<6'>^{2}","<8'>^{2}"};
9215 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};
9216 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"};
489d5531 9217
1268c371 9218 // e) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold:
489d5531 9219 // correlations:
9220 TList *diffFlowCorrelationsProList[2][2] = {{NULL}};
9221 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";
9222 diffFlowCorrelationsProName += fAnalysisLabel->Data();
b40a910e 9223 TProfile *diffFlowCorrelationsPro[2][2][4] = {{{NULL}}};
9224 // squared correlations:
9225 TString diffFlowSquaredCorrelationsProName = "fDiffFlowSquaredCorrelationsPro";
9226 diffFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
9227 TProfile *diffFlowSquaredCorrelationsPro[2][2][4] = {{{NULL}}};
489d5531 9228 // products of correlations:
9229 TList *diffFlowProductOfCorrelationsProList[2][2] = {{NULL}};
9230 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";
9231 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
9232 TProfile *diffFlowProductOfCorrelationsPro[2][2][8][8] = {{{{NULL}}}};
9233 // corrections:
9234 TList *diffFlowCorrectionsProList[2][2] = {{NULL}};
9235 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";
9236 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
9237 TProfile *diffFlowCorrectionTermsForNUAPro[2][2][2][10] = {{{{NULL}}}};
9238 for(Int_t t=0;t<2;t++)
9239 {
62e36168 9240 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++)
489d5531 9241 {
9242 diffFlowCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9243 if(!diffFlowCorrelationsProList[t][pe])
9244 {
9245 cout<<"WARNING: diffFlowCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9246 cout<<"t = "<<t<<endl;
9247 cout<<"pe = "<<pe<<endl;
9248 exit(0);
9249 }
9250 for(Int_t ci=0;ci<4;ci++) // correlation index
9251 {
b40a910e 9252 // reduced correlations:
489d5531 9253 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())));
9254 if(diffFlowCorrelationsPro[t][pe][ci])
9255 {
9256 this->SetDiffFlowCorrelationsPro(diffFlowCorrelationsPro[t][pe][ci],t,pe,ci);
9257 } else
9258 {
9259 cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9260 cout<<"t = "<<t<<endl;
9261 cout<<"pe = "<<pe<<endl;
9262 cout<<"ci = "<<ci<<endl;
9263 }
b40a910e 9264 // reduced squared correlations:
9265 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())));
9266 if(diffFlowSquaredCorrelationsPro[t][pe][ci])
9267 {
9268 this->SetDiffFlowSquaredCorrelationsPro(diffFlowSquaredCorrelationsPro[t][pe][ci],t,pe,ci);
9269 } else
9270 {
9271 cout<<"WARNING: diffFlowSquaredCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9272 cout<<"t = "<<t<<endl;
9273 cout<<"pe = "<<pe<<endl;
9274 cout<<"ci = "<<ci<<endl;
9275 }
489d5531 9276 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9277 // products of correlations:
9278 diffFlowProductOfCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9279 if(!diffFlowProductOfCorrelationsProList[t][pe])
9280 {
9281 cout<<"WARNING: ddiffFlowProductOfCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9282 cout<<"t = "<<t<<endl;
9283 cout<<"pe = "<<pe<<endl;
9284 exit(0);
9285 }
9286 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9287 {
9288 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9289 {
9290 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())));
9291 if(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2])
9292 {
9293 this->SetDiffFlowProductOfCorrelationsPro(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2],t,pe,mci1,mci2);
9294 } else
9295 {
b40a910e 9296 cout<<"WARNING: diffFlowProductOfCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
489d5531 9297 cout<<"t = "<<t<<endl;
9298 cout<<"pe = "<<pe<<endl;
9299 cout<<"mci1 = "<<mci1<<endl;
9300 cout<<"mci2 = "<<mci2<<endl;
9301 }
9302 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9303 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9304 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9305 // corrections:
9306 diffFlowCorrectionsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9307 if(!diffFlowCorrectionsProList[t][pe])
9308 {
9309 cout<<"WARNING: diffFlowCorrectionsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9310 cout<<"t = "<<t<<endl;
9311 cout<<"pe = "<<pe<<endl;
9312 exit(0);
9313 }
9314 // correction terms for NUA:
9315 for(Int_t sc=0;sc<2;sc++) // sin or cos
9316 {
9317 for(Int_t cti=0;cti<9;cti++) // correction term index
9318 {
9319 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)));
9320 if(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti])
9321 {
9322 this->SetDiffFlowCorrectionTermsForNUAPro(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti],t,pe,sc,cti);
9323 } else
9324 {
9325 cout<<"WARNING: diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9326 cout<<"t = "<<t<<endl;
9327 cout<<"pe = "<<pe<<endl;
9328 cout<<"sc = "<<sc<<endl;
9329 cout<<"cti = "<<cti<<endl;
9330 }
9331 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
9332 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9333 // ...
9334 } // end of for(Int_t pe=0;pe<2;pe++)
9335 } // end of for(Int_t t=0;t<2;t++)
9336
1268c371 9337 // f) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold:
489d5531 9338 // reduced correlations:
9339 TList *diffFlowCorrelationsHistList[2][2] = {{NULL}};
9340 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";
9341 diffFlowCorrelationsHistName += fAnalysisLabel->Data();
9342 TH1D *diffFlowCorrelationsHist[2][2][4] = {{{NULL}}};
9343 // corrections for NUA:
9344 TList *diffFlowCorrectionsHistList[2][2] = {{NULL}};
9345 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";
9346 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
9347 TH1D *diffFlowCorrectionTermsForNUAHist[2][2][2][10] = {{{{NULL}}}};
9348 // differential Q-cumulants:
9349 TList *diffFlowCumulantsHistList[2][2] = {{NULL}};
9350 TString diffFlowCumulantsName = "fDiffFlowCumulants";
9351 diffFlowCumulantsName += fAnalysisLabel->Data();
9352 TH1D *diffFlowCumulants[2][2][4] = {{{NULL}}};
1268c371 9353 // detector bias to differential Q-cumulants:
9354 TList *diffFlowDetectorBiasHistList[2][2] = {{NULL}};
9355 TString diffFlowDetectorBiasName = "fDiffFlowDetectorBias";
9356 diffFlowDetectorBiasName += fAnalysisLabel->Data();
9357 TH1D *diffFlowDetectorBias[2][2][4] = {{{NULL}}};
489d5531 9358 // differential flow estimates from Q-cumulants:
9359 TList *diffFlowHistList[2][2] = {{NULL}};
9360 TString diffFlowName = "fDiffFlow";
9361 diffFlowName += fAnalysisLabel->Data();
9362 TH1D *diffFlow[2][2][4] = {{{NULL}}};
9363 // differential covariances:
9364 TList *diffFlowCovariancesHistList[2][2] = {{NULL}};
9365 TString diffFlowCovariancesName = "fDiffFlowCovariances";
9366 diffFlowCovariancesName += fAnalysisLabel->Data();
9367 TH1D *diffFlowCovariances[2][2][5] = {{{NULL}}};
9368 for(Int_t t=0;t<2;t++) // type: RP or POI
9369 {
62e36168 9370 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9371 {
9372 // reduced correlations:
9373 diffFlowCorrelationsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9374 if(!diffFlowCorrelationsHistList[t][pe])
9375 {
9376 cout<<"WARNING: diffFlowCorrelationsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9377 cout<<"t = "<<t<<endl;
9378 cout<<"pe = "<<pe<<endl;
9379 exit(0);
9380 }
9381 for(Int_t index=0;index<4;index++)
9382 {
9383 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())));
9384 if(diffFlowCorrelationsHist[t][pe][index])
9385 {
9386 this->SetDiffFlowCorrelationsHist(diffFlowCorrelationsHist[t][pe][index],t,pe,index);
9387 } else
9388 {
9389 cout<<"WARNING: diffFlowCorrelationsHist[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9390 cout<<"t = "<<t<<endl;
9391 cout<<"pe = "<<pe<<endl;
9392 cout<<"index = "<<index<<endl;
9393 exit(0);
9394 }
9395 } // end of for(Int_t index=0;index<4;index++)
9396 // corrections:
9397 diffFlowCorrectionsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9398 if(!diffFlowCorrectionsHistList[t][pe])
9399 {
9400 cout<<"WARNING: diffFlowCorrectionsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9401 cout<<"t = "<<t<<endl;
9402 cout<<"pe = "<<pe<<endl;
9403 exit(0);
9404 }
9405 // correction terms for NUA:
9406 for(Int_t sc=0;sc<2;sc++) // sin or cos
9407 {
9408 for(Int_t cti=0;cti<9;cti++) // correction term index
9409 {
9410 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)));
9411 if(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti])
9412 {
9413 this->SetDiffFlowCorrectionTermsForNUAHist(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti],t,pe,sc,cti);
9414 } else
9415 {
9416 cout<<"WARNING: diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9417 cout<<"t = "<<t<<endl;
9418 cout<<"pe = "<<pe<<endl;
9419 cout<<"sc = "<<sc<<endl;
9420 cout<<"cti = "<<cti<<endl;
9421 }
9422 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
9423 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
9424 // ...
9425 // differential Q-cumulants:
9426 diffFlowCumulantsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9427 if(!diffFlowCumulantsHistList[t][pe])
9428 {
9429 cout<<"WARNING: diffFlowCumulantsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9430 cout<<"t = "<<t<<endl;
9431 cout<<"pe = "<<pe<<endl;
9432 exit(0);
9433 }
9434 for(Int_t index=0;index<4;index++)
9435 {
9436 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())));
9437 if(diffFlowCumulants[t][pe][index])
9438 {
9439 this->SetDiffFlowCumulants(diffFlowCumulants[t][pe][index],t,pe,index);
9440 } else
9441 {
9442 cout<<"WARNING: diffFlowCumulants[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9443 cout<<"t = "<<t<<endl;
9444 cout<<"pe = "<<pe<<endl;
9445 cout<<"index = "<<index<<endl;
9446 exit(0);
9447 }
9448 } // end of for(Int_t index=0;index<4;index++)
1268c371 9449 // Detector bias to differential Q-cumulants:
9450 diffFlowDetectorBiasHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Detector bias (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9451 if(!diffFlowDetectorBiasHistList[t][pe])
9452 {
9453 cout<<"WARNING: diffFlowDetectorBiasHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9454 cout<<"t = "<<t<<endl;
9455 cout<<"pe = "<<pe<<endl;
9456 exit(0);
9457 }
9458 for(Int_t index=0;index<4;index++)
9459 {
9460 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())));
9461 if(diffFlowDetectorBias[t][pe][index])
9462 {
9463 this->SetDiffFlowDetectorBias(diffFlowDetectorBias[t][pe][index],t,pe,index);
9464 } else
9465 {
9466 cout<<"WARNING: diffFlowDetectorBias[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9467 cout<<"t = "<<t<<endl;
9468 cout<<"pe = "<<pe<<endl;
9469 cout<<"index = "<<index<<endl;
9470 exit(0);
9471 }
9472 } // end of for(Int_t index=0;index<4;index++)
489d5531 9473 // differential flow estimates from Q-cumulants:
9474 diffFlowHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9475 if(!diffFlowHistList[t][pe])
9476 {
9477 cout<<"WARNING: diffFlowHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9478 cout<<"t = "<<t<<endl;
9479 cout<<"pe = "<<pe<<endl;
9480 exit(0);
9481 }
9482 for(Int_t index=0;index<4;index++)
9483 {
9484 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())));
9485 if(diffFlow[t][pe][index])
9486 {
9487 this->SetDiffFlow(diffFlow[t][pe][index],t,pe,index);
9488 } else
9489 {
9490 cout<<"WARNING: diffFlow[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9491 cout<<"t = "<<t<<endl;
9492 cout<<"pe = "<<pe<<endl;
9493 cout<<"index = "<<index<<endl;
9494 exit(0);
9495 }
9496 } // end of for(Int_t index=0;index<4;index++)
9497 // differential covariances:
9498 diffFlowCovariancesHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9499 if(!diffFlowCovariancesHistList[t][pe])
9500 {
9501 cout<<"WARNING: diffFlowCovariancesHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9502 cout<<"t = "<<t<<endl;
9503 cout<<"pe = "<<pe<<endl;
9504 exit(0);
9505 }
9506 for(Int_t covIndex=0;covIndex<5;covIndex++)
9507 {
9508 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())));
9509 if(diffFlowCovariances[t][pe][covIndex])
9510 {
9511 this->SetDiffFlowCovariances(diffFlowCovariances[t][pe][covIndex],t,pe,covIndex);
9512 } else
9513 {
9514 cout<<"WARNING: diffFlowCovariances[t][pe][covIndex] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9515 cout<<"t = "<<t<<endl;
9516 cout<<"pe = "<<pe<<endl;
9517 cout<<"covIndex = "<<covIndex<<endl;
9518 exit(0);
9519 }
9520 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9521 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9522 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9523 // sum of event weights for reduced correlations:
9524 TList *diffFlowSumOfEventWeightsHistList[2][2][2] = {{{NULL}}};
9525 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";
9526 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();
9527 TH1D *diffFlowSumOfEventWeights[2][2][2][4] = {{{{NULL}}}};
9528 for(Int_t t=0;t<2;t++) // type is RP or POI
9529 {
62e36168 9530 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9531 {
9532 for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2
9533 {
9534 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())));
9535 if(!diffFlowSumOfEventWeightsHistList[t][pe][p])
9536 {
9537 cout<<"WARNING: diffFlowSumOfEventWeightsHistList[t][pe][p] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9538 cout<<"t = "<<t<<endl;
9539 cout<<"pe = "<<pe<<endl;
9540 cout<<"power = "<<p<<endl;
9541 exit(0);
9542 }
9543 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation
9544 {
9545 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())));
9546 if(diffFlowSumOfEventWeights[t][pe][p][ew])
9547 {
9548 this->SetDiffFlowSumOfEventWeights(diffFlowSumOfEventWeights[t][pe][p][ew],t,pe,p,ew);
9549 } else
9550 {
9551 cout<<"WARNING: diffFlowSumOfEventWeights[t][pe][p][ew] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9552 cout<<"t = "<<t<<endl;
9553 cout<<"pe = "<<pe<<endl;
9554 cout<<"power = "<<p<<endl;
9555 cout<<"ew = "<<ew<<endl;
9556 exit(0);
9557 }
9558 }
9559 } // end of for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2
9560 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9561 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI
9562 //
9563 TList *diffFlowSumOfProductOfEventWeightsHistList[2][2] = {{NULL}};
9564 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";
9565 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
9566 TH1D *diffFlowSumOfProductOfEventWeights[2][2][8][8] = {{{{NULL}}}};
9567 for(Int_t t=0;t<2;t++) // type is RP or POI
9568 {
62e36168 9569 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9570 {
9571 diffFlowSumOfProductOfEventWeightsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));
9572 if(!diffFlowSumOfProductOfEventWeightsHistList[t][pe])
9573 {
9574 cout<<"WARNING: diffFlowSumOfProductOfEventWeightsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9575 cout<<"t = "<<t<<endl;
9576 cout<<"pe = "<<pe<<endl;
9577 exit(0);
9578 }
9579 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9580 {
9581 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9582 {
9583 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())));
9584 if(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2])
9585 {
9586 this->SetDiffFlowSumOfProductOfEventWeights(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2],t,pe,mci1,mci2);
9587 } else
9588 {
9589 cout<<"WARNING: diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
9590 cout<<"t = "<<t<<endl;
9591 cout<<"pe = "<<pe<<endl;
9592 cout<<"mci1 = "<<mci1<<endl;
9593 cout<<"mci2 = "<<mci2<<endl;
9594 exit(0);
9595 }
9596 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9597 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9598 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9599 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9600 } // end of for(Int_t t=0;t<2;t++) // type is RP or POI
9601
9602} // end void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms()
9603
489d5531 9604//================================================================================================================================
9605
1268c371 9606void AliFlowAnalysisWithQCumulants::BookEverythingFor2DDifferentialFlow()
9607{
9608 // Book all objects needed for 2D differential flow.
9609 // a) Define flags locally (to be improved: should I promote flags to data members?);
9610 // b) Book e-b-e quantities;
9611 // c) Book 2D profiles;
9612 // d) Book 2D histograms.
9613
9614 if(!fCalculate2DDiffFlow){return;}
9615
9616 // a) Define flags locally (to be improved: should I promote flags to data members?):
9617 TString typeFlag[2] = {"RP","POI"};
9618 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
9619 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9620 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9621
9622 // b) Book e-b-e quantities:
9623 TProfile2D styleRe("typeMultiplePowerRe","typeMultiplePowerRe",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9624 TProfile2D styleIm("typeMultiplePowerIm","typeMultiplePowerIm",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9625 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9626 {
9627 for(Int_t m=0;m<4;m++)
9628 {
9629 for(Int_t k=0;k<9;k++)
9630 {
9631 fReRPQ2dEBE[t][m][k] = (TProfile2D*)styleRe.Clone(Form("typeFlag%dmultiple%dpower%dRe",t,m,k));
9632 fImRPQ2dEBE[t][m][k] = (TProfile2D*)styleIm.Clone(Form("typeFlag%dmultiple%dpower%dIm",t,m,k));
9633 }
9634 }
9635 }
9636 TProfile2D styleS("typePower","typePower",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);
9637 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9638 {
9639 for(Int_t k=0;k<9;k++)
9640 {
9641 fs2dEBE[t][k] = (TProfile2D*)styleS.Clone(Form("typeFlag%dpower%d",t,k));
9642 }
9643 }
9644
9645 // c) Book 2D profiles:
9646 TString s2DDiffFlowCorrelationsProName = "f2DDiffFlowCorrelationsPro";
9647 s2DDiffFlowCorrelationsProName += fAnalysisLabel->Data();
9648 for(Int_t t=0;t<2;t++) // type: RP or POI
9649 {
9650 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9651 {
9652 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,"");
9653 f2DDiffFlowCorrelationsPro[t][rci]->Sumw2();
9654 f2DDiffFlowCorrelationsPro[t][rci]->SetXTitle("p_{t}");
9655 f2DDiffFlowCorrelationsPro[t][rci]->SetYTitle("#eta");
9656 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlowCorrelationsPro[t][rci]);
9657 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9658 } // end of for(Int_t t=0;t<2;t++) // type: RP or POIs
9659
9660 // d) Book 2D histograms:
9661 TString s2DDiffFlowCumulantsName = "f2DDiffFlowCumulants";
9662 s2DDiffFlowCumulantsName += fAnalysisLabel->Data();
9663 TString s2DDiffFlowName = "f2DDiffFlow";
9664 s2DDiffFlowName += fAnalysisLabel->Data();
9665 for(Int_t t=0;t<2;t++) // type: RP or POI
9666 {
9667 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9668 {
9669 // 2D diferential cumulants:
9670 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);
9671 f2DDiffFlowCumulants[t][rci]->SetXTitle("p_{t}");
9672 f2DDiffFlowCumulants[t][rci]->SetYTitle("#eta");
9673 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlowCumulants[t][rci]); // to be improved - moved to another list
9674 // 2D differential flow:
9675 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);
9676 f2DDiffFlow[t][rci]->SetXTitle("p_{t}");
9677 f2DDiffFlow[t][rci]->SetYTitle("#eta");
9678 f2DDiffFlowCorrelationsProList[t]->Add(f2DDiffFlow[t][rci]); // to be improved - moved to another list
9679 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9680 } // end of for(Int_t t=0;t<2;t++) // type: RP or POIs
9681
9682} // void AliFlowAnalysisWithQCumulants::BookEverythingFor2DDifferentialFlow()
9683
9684//================================================================================================================================
489d5531 9685
9686void AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()
9687{
9688 // Book all histograms and profiles needed for differential flow.
1268c371 9689 // a) Book profile to hold all flags for differential flow;
9690 // b) Define flags locally (to be improved: should I promote flags to data members?);
489d5531 9691 // c) Book e-b-e quantities;
9692 // d) Book profiles;
9693 // e) Book histograms holding final results.
9694
1268c371 9695 // a) Book profile to hold all flags for differential flow:
9696 TString diffFlowFlagsName = "fDiffFlowFlags";
9697 diffFlowFlagsName += fAnalysisLabel->Data();
62e36168 9698 fDiffFlowFlags = new TProfile(diffFlowFlagsName.Data(),"Flags for differential flow",6,0,6);
1268c371 9699 fDiffFlowFlags->SetTickLength(-0.01,"Y");
9700 fDiffFlowFlags->SetMarkerStyle(25);
9701 fDiffFlowFlags->SetLabelSize(0.04,"X");
9702 fDiffFlowFlags->SetLabelOffset(0.02,"Y");
9703 fDiffFlowFlags->GetXaxis()->SetBinLabel(1,"Calculate diff. flow");
9704 fDiffFlowFlags->GetXaxis()->SetBinLabel(2,"Particle weights");
9705 fDiffFlowFlags->GetXaxis()->SetBinLabel(3,"Event weights");
9706 fDiffFlowFlags->GetXaxis()->SetBinLabel(4,"Correct for NUA");
9707 fDiffFlowFlags->GetXaxis()->SetBinLabel(5,"Calculate 2D diff. flow");
62e36168 9708 fDiffFlowFlags->GetXaxis()->SetBinLabel(6,"Calculate diff. flow vs eta");
1268c371 9709 fDiffFlowList->Add(fDiffFlowFlags);
9710
9711 if(!fCalculateDiffFlow){return;}
9712
9713 // b) Define flags locally (to be improved: should I promote flags to data members?):
489d5531 9714 TString typeFlag[2] = {"RP","POI"};
9715 TString ptEtaFlag[2] = {"p_{T}","#eta"};
9716 TString powerFlag[2] = {"linear","quadratic"};
9717 TString sinCosFlag[2] = {"sin","cos"};
9718 TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};
9719 TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};
9720 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};
b40a910e 9721 TString reducedSquaredCorrelationIndex[4] = {"<2'>^{2}","<4'>^{2}","<6'>^{2}","<8'>^{2}"};
489d5531 9722 TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};
9723 TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"};
9724 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
9725 Double_t minPtEta[2] = {fPtMin,fEtaMin};
9726 Double_t maxPtEta[2] = {fPtMax,fEtaMax};
1268c371 9727
489d5531 9728 // c) Book e-b-e quantities:
9729 // Event-by-event r_{m*n,k}(pt,eta), p_{m*n,k}(pt,eta) and q_{m*n,k}(pt,eta)
9730 // Explanantion of notation:
9731 // 1.) n is harmonic, m is multiple of harmonic;
9732 // 2.) k is power of particle weight;
9733 // 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);
9734 // 4.) p_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for POIs in particular (pt,eta) bin
9735 // (if i-th POI is also RP, than it is weighted with w_i^k);
9736 // 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
9737 // (i-th RP&&POI is weighted with w_i^k)
9738
9739 // 1D:
9740 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP && POI )
9741 {
62e36168 9742 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9743 {
9744 for(Int_t m=0;m<4;m++) // multiple of harmonic
9745 {
9746 for(Int_t k=0;k<9;k++) // power of particle weight
9747 {
9748 fReRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),
9749 Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9750 fImRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),
9751 Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9752 }
9753 }
9754 }
9755 }
9756 // to be improved (add explanation of fs1dEBE[t][pe][k]):
9757 for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )
9758 {
62e36168 9759 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9760 {
9761 for(Int_t k=0;k<9;k++) // power of particle weight
9762 {
9763 fs1dEBE[t][pe][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),
9764 Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9765 }
9766 }
9767 }
9768 // correction terms for nua:
9769 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9770 {
62e36168 9771 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9772 {
9773 for(Int_t sc=0;sc<2;sc++) // sin or cos
9774 {
9775 for(Int_t cti=0;cti<9;cti++) // correction term index
9776 {
9777 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = new TH1D(Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),
9778 Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
9779 }
9780 }
9781 }
9782 }
489d5531 9783 // reduced correlations e-b-e:
9784 TString diffFlowCorrelationsEBEName = "fDiffFlowCorrelationsEBE";
9785 diffFlowCorrelationsEBEName += fAnalysisLabel->Data();
9786 for(Int_t t=0;t<2;t++) // type: RP or POI
9787 {
62e36168 9788 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9789 {
9790 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9791 {
9792 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]);
9793 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9794 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9795 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9796 // event weights for reduced correlations e-b-e:
9797 TString diffFlowEventWeightsForCorrelationsEBEName = "fDiffFlowEventWeightsForCorrelationsEBE";
9798 diffFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
9799 for(Int_t t=0;t<2;t++) // type: RP or POI
9800 {
62e36168 9801 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9802 {
9803 for(Int_t rci=0;rci<4;rci++) // event weight for reduced correlation index
9804 {
9805 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]);
9806 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
9807 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9808 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9809
9810 // d) Book profiles;
9811 // reduced correlations:
9812 TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";
9813 diffFlowCorrelationsProName += fAnalysisLabel->Data();
b40a910e 9814 // reduced squared correlations:
9815 TString diffFlowSquaredCorrelationsProName = "fDiffFlowSquaredCorrelationsPro";
9816 diffFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
489d5531 9817 // corrections terms:
9818 TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";
9819 diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
b40a910e 9820 // reduced correlations:
489d5531 9821 for(Int_t t=0;t<2;t++) // type: RP or POI
9822 {
62e36168 9823 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9824 {
9825 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9826 {
489d5531 9827 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 9828 fDiffFlowCorrelationsPro[t][pe][rci]->Sumw2();
489d5531 9829 fDiffFlowCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
9830 fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
9831 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9832 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9833 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
b40a910e 9834 // reduced squared correlations:
9835 for(Int_t t=0;t<2;t++) // type: RP or POI
9836 {
62e36168 9837 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
b40a910e 9838 {
9839 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
9840 {
9841 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");
9842 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->Sumw2();
9843 fDiffFlowSquaredCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());
9844 fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowSquaredCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)
9845 } // end of for(Int_t rci=0;rci<4;rci++) // correlation index
9846 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9847 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
489d5531 9848 // correction terms for nua:
9849 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9850 {
62e36168 9851 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9852 {
9853 for(Int_t sc=0;sc<2;sc++) // sin or cos
9854 {
9855 for(Int_t cti=0;cti<9;cti++) // correction term index
9856 {
9857 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]);
9858 fDiffFlowCorrectionsProList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]);
9859 }
9860 }
9861 }
9862 }
64e500e3 9863 // Other differential correlators:
9864 TString otherDiffCorrelatorsName = "fOtherDiffCorrelators";
9865 otherDiffCorrelatorsName += fAnalysisLabel->Data();
9866 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9867 {
62e36168 9868 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
64e500e3 9869 {
9870 for(Int_t sc=0;sc<2;sc++) // sin or cos
9871 {
9872 for(Int_t ci=0;ci<1;ci++) // correlator index
9873 {
9874 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]);
9875 fOtherDiffCorrelators[t][pe][sc][ci]->Sumw2();
9876 fOtherDiffCorrelatorsList->Add(fOtherDiffCorrelators[t][pe][sc][ci]);
9877 }
9878 }
9879 }
9880 }
489d5531 9881 // e) Book histograms holding final results.
9882 // reduced correlations:
9883 TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";
9884 diffFlowCorrelationsHistName += fAnalysisLabel->Data();
9885 // corrections terms:
9886 TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";
9887 diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
9888 // differential covariances:
9889 TString diffFlowCovariancesName = "fDiffFlowCovariances";
9890 diffFlowCovariancesName += fAnalysisLabel->Data();
9891 // differential Q-cumulants:
9892 TString diffFlowCumulantsName = "fDiffFlowCumulants";
9893 diffFlowCumulantsName += fAnalysisLabel->Data();
1268c371 9894 // Detector bias to differential Q-cumulants:
9895 TString diffFlowDetectorBiasName = "fDiffFlowDetectorBias";
9896 diffFlowDetectorBiasName += fAnalysisLabel->Data();
489d5531 9897 // differential flow:
9898 TString diffFlowName = "fDiffFlow";
9899 diffFlowName += fAnalysisLabel->Data();
9900 for(Int_t t=0;t<2;t++) // type: RP or POI
9901 {
62e36168 9902 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9903 {
9904 for(Int_t index=0;index<4;index++)
9905 {
9906 // reduced correlations:
9907 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]);
9908 fDiffFlowCorrelationsHist[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9909 fDiffFlowCorrelationsHistList[t][pe]->Add(fDiffFlowCorrelationsHist[t][pe][index]);
9910 // differential Q-cumulants:
9911 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]);
9912 fDiffFlowCumulants[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9913 fDiffFlowCumulantsHistList[t][pe]->Add(fDiffFlowCumulants[t][pe][index]);
1268c371 9914 // Detector bias to differential Q-cumulants:
9915 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]);
9916 fDiffFlowDetectorBias[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9917 fDiffFlowDetectorBias[t][pe][index]->SetTitle(Form("#frac{corrected}{measured} %s",differentialCumulantIndex[index].Data()));
9918 fDiffFlowDetectorBiasHistList[t][pe]->Add(fDiffFlowDetectorBias[t][pe][index]);
489d5531 9919 // differential flow estimates from Q-cumulants:
9920 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]);
9921 fDiffFlow[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());
9922 fDiffFlowHistList[t][pe]->Add(fDiffFlow[t][pe][index]);
9923 } // end of for(Int_t index=0;index<4;index++)
9924 for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9925 {
9926 // differential covariances:
9927 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]);
9928 fDiffFlowCovariances[t][pe][covIndex]->SetXTitle(ptEtaFlag[pe].Data());
9929 fDiffFlowCovariancesHistList[t][pe]->Add(fDiffFlowCovariances[t][pe][covIndex]);
9930 } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index
9931 // products of both types of correlations:
9932 TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";
9933 diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
9934 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9935 {
9936 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9937 {
9938 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]);
9939 fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());
9940 fDiffFlowProductOfCorrelationsProList[t][pe]->Add(fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]);
9941 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9942 } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9943 } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9944 } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
9945 } // end of for(Int_t t=0;t<2;t++) // type: RP or POI
9946 // sums of event weights for reduced correlations:
9947 TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";
9948 diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();
9949 for(Int_t t=0;t<2;t++) // type is RP or POI
9950 {
62e36168 9951 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9952 {
9953 for(Int_t p=0;p<2;p++) // power of weights is either 1 or 2
9954 {
9955 for(Int_t ew=0;ew<4;ew++) // index of reduced correlation
9956 {
9957 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]);
9958 fDiffFlowSumOfEventWeights[t][pe][p][ew]->SetXTitle(ptEtaFlag[pe].Data());
9959 fDiffFlowSumOfEventWeightsHistList[t][pe][p]->Add(fDiffFlowSumOfEventWeights[t][pe][p][ew]); // to be improved (add dedicated list to hold all this)
9960 }
9961 }
9962 }
9963 }
9964 // sum of products of event weights for both types of correlations:
9965 TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";
9966 diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
9967 for(Int_t t=0;t<2;t++) // type is RP or POI
9968 {
62e36168 9969 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9970 {
9971 for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index
9972 {
9973 for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index
9974 {
9975 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]);
9976 fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());
9977 fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->Add(fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]);
9978 if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here
9979 }
9980 }
9981 }
9982 }
9983 // correction terms for nua:
9984 for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)
9985 {
62e36168 9986 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 9987 {
9988 for(Int_t sc=0;sc<2;sc++) // sin or cos
9989 {
9990 for(Int_t cti=0;cti<9;cti++) // correction term index
9991 {
9992 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]);
9993 fDiffFlowCorrectionsHistList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]);
9994 }
9995 }
9996 }
9997 }
9998
9999} // end of AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()
10000
489d5531 10001//================================================================================================================================
10002
489d5531 10003void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()
10004{
10005 // Calculate generalized Q-cumulants (cumulants corrected for non-unifom acceptance).
10006
b92ea2b9 10007 // Isotropic cumulants:
53884472 10008 Double_t QC2 = fIntFlowQcumulants->GetBinContent(1);
10009 Double_t QC2Error = fIntFlowQcumulants->GetBinError(1);
10010 Double_t QC4 = fIntFlowQcumulants->GetBinContent(2);
10011 Double_t QC4Error = fIntFlowQcumulants->GetBinError(2);
10012 //Double_t QC6 = fIntFlowQcumulants->GetBinContent(3);
10013 //Double_t QC6Error = fIntFlowQcumulants->GetBinError(3);
10014 //Double_t QC8 = fIntFlowQcumulants->GetBinContent(4);
10015 //Double_t QC8Error = fIntFlowQcumulants->GetBinError(4);
b92ea2b9 10016
10017 // Measured 2-, 4-, 6- and 8-particle correlations:
489d5531 10018 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
b92ea2b9 10019 Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <<2>>
489d5531 10020 Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>
b92ea2b9 10021 Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <<4>>
489d5531 10022 //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>
489d5531 10023 //Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <<6>>
b92ea2b9 10024 //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>
489d5531 10025 //Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <<8>>
b92ea2b9 10026
10027 // Non-isotropic terms:
10028 Double_t c1 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>
10029 Double_t c1Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(1); // statistical error of <<cos(n*phi1)>>
10030 Double_t c2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>
10031 Double_t c2Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(2); // statistical error of <<cos(n*(phi1+phi2))>>
10032 Double_t c3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>
10033 Double_t c3Error = fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(3); // statistical error of <<cos(n*(phi1-phi2-phi3))>>
10034 Double_t s1 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>
10035 Double_t s1Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(1); // statistical error of <<sin(n*phi1)>>
10036 Double_t s2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>
10037 Double_t s2Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(2); // statistical error of <<sin(n*(phi1+phi2))>>
10038 Double_t s3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>
10039 Double_t s3Error = fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(3); // statistical error of <<sin(n*(phi1-phi2-phi3))>>
10040
10041 // Shortcuts:
10042 Double_t a1 = 2.*pow(c1,2.)+2.*pow(s1,2.)-two;
10043 Double_t a2 = 6.*pow(c1,3.)-2.*c1*c2+c3+6.*c1*pow(s1,2.)-2.*s1*s2-4.*c1*two;
10044 Double_t a3 = 2.*pow(s1,2.)-2.*pow(c1,2.)+c2;
10045 Double_t a4 = 6.*pow(s1,3.)+6.*pow(c1,2.)*s1+2.*c2*s1-2.*c1*s2-s3-4.*s1*two;
10046 Double_t a5 = 4.*c1*s1-s2;
10047
10048 // Covariances (including weight dependent prefactor):
8e1cefdd 10049 Double_t wCov1 = 0.; // w*Cov(<2>,<cos(phi))
10050 Double_t wCov2 = 0.; // w*Cov(<2>,<sin(phi))
10051 Double_t wCov3 = 0.; // w*Cov(<cos(phi),<sin(phi))
10052 Double_t wCov4 = 0.; // w*Cov(<2>,<4>)
10053 Double_t wCov5 = 0.; // w*Cov(<2>,<cos(#phi_{1}+#phi_{2})>)
10054 Double_t wCov6 = 0.; // w*Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10055 Double_t wCov7 = 0.; // w*Cov(<2>,<sin(#phi_{1}+#phi_{2})>)
10056 Double_t wCov8 = 0.; // w*Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10057 Double_t wCov9 = 0.; // w*Cov(<4>,<cos(#phi)>
10058 Double_t wCov10 = 0.; // w*Cov(<4>,<cos(#phi_{1}+#phi_{2})>)
10059 Double_t wCov11 = 0.; // w*Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10060 Double_t wCov12 = 0.; // w*Cov(<4>,<sin(#phi)>
10061 Double_t wCov13 = 0.; // w*Cov(<4>,<sin(#phi_{1}+#phi_{2})>)
10062 Double_t wCov14 = 0.; // w*Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10063 Double_t wCov15 = 0.; // w*Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10064 Double_t wCov16 = 0.; // w*Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10065 Double_t wCov17 = 0.; // w*Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10066 Double_t wCov18 = 0.; // w*Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10067 Double_t wCov19 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10068 Double_t wCov20 = 0.; // w*Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10069 Double_t wCov21 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)
10070 Double_t wCov22 = 0.; // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10071 Double_t wCov23 = 0.; // w*Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10072 Double_t wCov24 = 0.; // w*Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10073 Double_t wCov25 = 0.; // w*Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)
10074 Double_t wCov26 = 0.; // w*Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10075 Double_t wCov27 = 0.; // w*Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10076 Double_t wCov28 = 0.; // w*Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10077 if(!fForgetAboutCovariances)
10078 {
10079 wCov1 = fIntFlowCovariancesNUA->GetBinContent(1); // w*Cov(<2>,<cos(phi))
10080 wCov2 = fIntFlowCovariancesNUA->GetBinContent(2); // w*Cov(<2>,<sin(phi))
10081 wCov3 = fIntFlowCovariancesNUA->GetBinContent(3); // w*Cov(<cos(phi),<sin(phi))
10082 wCov4 = fIntFlowCovariances->GetBinContent(1); // w*Cov(<2>,<4>)
10083 wCov5 = fIntFlowCovariancesNUA->GetBinContent(4); // w*Cov(<2>,<cos(#phi_{1}+#phi_{2})>)
10084 wCov6 = fIntFlowCovariancesNUA->GetBinContent(6); // w*Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10085 wCov7 = fIntFlowCovariancesNUA->GetBinContent(5); // w*Cov(<2>,<sin(#phi_{1}+#phi_{2})>)
10086 wCov8 = fIntFlowCovariancesNUA->GetBinContent(7); // w*Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10087 wCov9 = fIntFlowCovariancesNUA->GetBinContent(8); // w*Cov(<4>,<cos(#phi)>
10088 wCov10 = fIntFlowCovariancesNUA->GetBinContent(10); // w*Cov(<4>,<cos(#phi_{1}+#phi_{2})>)
10089 wCov11 = fIntFlowCovariancesNUA->GetBinContent(12); // w*Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10090 wCov12 = fIntFlowCovariancesNUA->GetBinContent(9); // w*Cov(<4>,<sin(#phi)>
10091 wCov13 = fIntFlowCovariancesNUA->GetBinContent(11); // w*Cov(<4>,<sin(#phi_{1}+#phi_{2})>)
10092 wCov14 = fIntFlowCovariancesNUA->GetBinContent(13); // w*Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10093 wCov15 = fIntFlowCovariancesNUA->GetBinContent(14); // w*Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10094 wCov16 = fIntFlowCovariancesNUA->GetBinContent(16); // w*Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10095 wCov17 = fIntFlowCovariancesNUA->GetBinContent(15); // w*Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10096 wCov18 = fIntFlowCovariancesNUA->GetBinContent(17); // w*Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10097 wCov19 = fIntFlowCovariancesNUA->GetBinContent(23); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10098 wCov20 = fIntFlowCovariancesNUA->GetBinContent(18); // w*Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)
10099 wCov21 = fIntFlowCovariancesNUA->GetBinContent(22); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)
10100 wCov22 = fIntFlowCovariancesNUA->GetBinContent(24); // w*Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10101 wCov23 = fIntFlowCovariancesNUA->GetBinContent(20); // w*Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10102 wCov24 = fIntFlowCovariancesNUA->GetBinContent(25); // w*Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)
10103 wCov25 = fIntFlowCovariancesNUA->GetBinContent(27); // w*Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)
10104 wCov26 = fIntFlowCovariancesNUA->GetBinContent(19); // w*Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)
10105 wCov27 = fIntFlowCovariancesNUA->GetBinContent(21); // w*Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10106 wCov28 = fIntFlowCovariancesNUA->GetBinContent(26); // w*Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)
10107 } // end of if(!fForgetAboutCovariances)
10108
b92ea2b9 10109 // Calculating generalized QC{2}:
10110 // Generalized QC{2}:
10111 Double_t gQC2 = two - pow(c1,2.) - pow(s1,2.);
10112 if(fApplyCorrectionForNUA){fIntFlowQcumulants->SetBinContent(1,gQC2);}
10113 // Statistical error of generalized QC{2}:
10114 Double_t gQC2ErrorSquared = pow(twoError,2.)+4.*pow(c1,2.)*pow(c1Error,2.)
10115 + 4.*pow(s1,2.)*pow(s1Error,2.)
10116 - 4*c1*wCov1-4*s1*wCov2
10117 + 8.*c1*s1*wCov3;
10118 // Store ratio of error squared - with/without NUA terms:
10119 Double_t ratioErrorSquaredQC2 = 0.;
10120 if(fIntFlowQcumulants->GetBinError(1)>0.)
10121 {
10122 ratioErrorSquaredQC2 = (gQC2ErrorSquared/pow(fIntFlowQcumulants->GetBinError(1),2.));
10123 fIntFlowQcumulantsErrorSquaredRatio->SetBinContent(1,ratioErrorSquaredQC2);
10124 }
10125 // If enabled, store error by including non-isotropic terms:
b77b6434 10126 if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10127 {
10128 if(gQC2ErrorSquared>=0.)
10129 {
10130 fIntFlowQcumulants->SetBinError(1,pow(gQC2ErrorSquared,0.5));
10131 } else
10132 {
10133 fIntFlowQcumulants->SetBinError(1,0.);
10134 cout<<endl;
10135 cout<<" WARNING (QC): Statistical error of generalized QC{2} is imaginary !!!!"<<endl;
10136 cout<<endl;
10137 }
b77b6434 10138 } // end of if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10139 // Quantify detector bias to QC{2}:
53884472 10140 if(TMath::Abs(QC2)>0.)
b92ea2b9 10141 {
53884472 10142 fIntFlowDetectorBias->SetBinContent(1,gQC2/QC2);
10143 if(QC2Error>0.)
b92ea2b9 10144 {
53884472 10145 Double_t errorSquared = gQC2ErrorSquared/pow(QC2,2.)+pow(gQC2,2.)*pow(QC2Error,2.)/pow(QC2,4.);
b92ea2b9 10146 if(errorSquared>0.)
10147 {
10148 fIntFlowDetectorBias->SetBinError(1,pow(errorSquared,0.5));
10149 }
10150 }
53884472 10151 } // end of if(TMath::Abs(QC2)>0.)
b92ea2b9 10152
10153 // Calculating generalized QC{4}:
10154 // Generalized QC{4}:
10155 Double_t gQC4 = four-2.*pow(two,2.)
10156 - 4.*c1*c3+4.*s1*s3-pow(c2,2.)-pow(s2,2.)
10157 + 4.*c2*(pow(c1,2.)-pow(s1,2.))+8.*s2*s1*c1
10158 + 8.*two*(pow(c1,2.)+pow(s1,2.))-6.*pow((pow(c1,2.)+pow(s1,2.)),2.);
10159 if(fApplyCorrectionForNUA){fIntFlowQcumulants->SetBinContent(2,gQC4);}
10160 // Statistical error of generalized QC{4}:
10161 Double_t gQC4ErrorSquared = 16.*pow(a1,2.)*pow(twoError,2.)+pow(fourError,2.)+16.*pow(a2,2.)*pow(c1Error,2.)
10162 + 4.*pow(a3,2.)*pow(c2Error,2.)+16.*pow(c1,2.)*pow(c3Error,2.)
10163 + 16.*pow(a4,2.)*pow(s1Error,2.)+4.*pow(a5,2.)*pow(s2Error,2.)
10164 + 16.*pow(s1,2.)*pow(s3Error,2.)+8.*a1*wCov4-32.*a1*a2*wCov1
10165 - 16.*a3*a1*wCov5-32.*c1*a1*wCov6-32.*a1*a4*wCov2+16.*a5*a1*wCov7
10166 + 32.*s1*a1*wCov8-8.*a2*wCov9-4.*a3*wCov10-8.*c1*wCov11-8.*a4*wCov12
10167 + 4.*a5*wCov13+8.*s1*wCov14+16.*a3*a2*wCov15+32.*c1*a2*wCov16+32.*a2*a4*wCov3
10168 - 16.*a5*a2*wCov17-32.*s1*a2*wCov18+16.*c1*a3*wCov19+16.*a3*a4*wCov20
10169 - 8.*a3*a5*wCov21-16.*s1*a3*wCov22+32.*c1*a4*wCov23-16.*c1*a5*wCov24
10170 - 32.*c1*s1*wCov25-16.*a5*a4*wCov26-32.*s1*a4*wCov27+16.*s1*a5*wCov28;
10171 // Store ratio of error squared - with/without NUA terms:
10172 Double_t ratioErrorSquaredQC4 = 0.;
10173 if(fIntFlowQcumulants->GetBinError(2)>0.)
10174 {
10175 ratioErrorSquaredQC4 = (gQC4ErrorSquared/pow(fIntFlowQcumulants->GetBinError(2),2.));
10176 fIntFlowQcumulantsErrorSquaredRatio->SetBinContent(2,ratioErrorSquaredQC4);
10177 }
b77b6434 10178 if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10179 {
10180 if(gQC4ErrorSquared>=0.)
10181 {
10182 fIntFlowQcumulants->SetBinError(2,pow(gQC4ErrorSquared,0.5));
10183 } else
10184 {
10185 fIntFlowQcumulants->SetBinError(2,0.);
10186 cout<<endl;
10187 cout<<" WARNING (QC): Statistical error of generalized QC{4} is imaginary !!!!"<<endl;
10188 cout<<endl;
10189 }
b77b6434 10190 } // end of if(fApplyCorrectionForNUA && fPropagateErrorAlsoFromNIT)
b92ea2b9 10191 // Quantify detector bias to QC{4}:
53884472 10192 if(TMath::Abs(QC4)>0.)
b92ea2b9 10193 {
53884472 10194 fIntFlowDetectorBias->SetBinContent(2,gQC4/QC4);
10195 if(QC4Error>0.)
b92ea2b9 10196 {
53884472 10197 Double_t errorSquared = gQC4ErrorSquared/pow(QC4,2.)+pow(gQC4,2.)*pow(QC4Error,2.)/pow(QC4,4.);
b92ea2b9 10198 if(errorSquared>0.)
10199 {
10200 fIntFlowDetectorBias->SetBinError(2,pow(errorSquared,0.5));
10201 }
10202 }
53884472 10203 } // end of if(TMath::Abs(QC4)>0.)
489d5531 10204
b92ea2b9 10205
10206 // .... to be improved (continued for 6th and 8th order) ....
10207
10208
2001bc3a 10209 // versus multiplicity:
b77b6434 10210 if(fCalculateCumulantsVsM) // to be improved - propagate error for nua terms vs M
2001bc3a 10211 {
10212 Int_t nBins = fIntFlowCorrelationsVsMPro[0]->GetNbinsX(); // to be improved (hardwired 0)
b77b6434 10213 Double_t value[4] = {0.}; // QCs vs M
10214 Double_t error[4] = {0.}; // error of QCs vs M
10215 Double_t dSum1[4] = {0.}; // sum value_i/(error_i)^2
10216 Double_t dSum2[4] = {0.}; // sum 1/(error_i)^2
2001bc3a 10217 for(Int_t b=1;b<=nBins;b++)
10218 {
b92ea2b9 10219 // Measured correlations:
2001bc3a 10220 two = fIntFlowCorrelationsVsMHist[0]->GetBinContent(b); // <<2>> vs M
10221 four = fIntFlowCorrelationsVsMHist[1]->GetBinContent(b); // <<4>> vs M
b92ea2b9 10222 // Isotropic cumulants:
53884472 10223 QC2 = two;
10224 QC4 = four-2.*pow(two,2.);
b92ea2b9 10225 // Non-isotropic terms:
10226 c1 = fIntFlowCorrectionTermsForNUAVsMPro[1][0]->GetBinContent(b); // <<cos(n*phi1)>>
10227 c2 = fIntFlowCorrectionTermsForNUAVsMPro[1][1]->GetBinContent(b); // <<cos(n*(phi1+phi2))>>
10228 c3 = fIntFlowCorrectionTermsForNUAVsMPro[1][2]->GetBinContent(b); // <<cos(n*(phi1-phi2-phi3))>>
10229 s1 = fIntFlowCorrectionTermsForNUAVsMPro[0][0]->GetBinContent(b); // <<sin(n*phi1)>>
10230 s2 = fIntFlowCorrectionTermsForNUAVsMPro[0][1]->GetBinContent(b); // <<sin(n*(phi1+phi2))>>
10231 s3 = fIntFlowCorrectionTermsForNUAVsMPro[0][2]->GetBinContent(b); // <<sin(n*(phi1-phi2-phi3))>>
10232 // Generalized QC{2} vs M:
10233 gQC2 = two - pow(c1,2.) - pow(s1,2.);
b77b6434 10234 if(fApplyCorrectionForNUAVsM){fIntFlowQcumulantsVsM[0]->SetBinContent(b,gQC2);}
b92ea2b9 10235 // Generalized QC{4} vs M:
10236 gQC4 = four-2.*pow(two,2.)
10237 - 4.*c1*c3+4.*s1*s3-pow(c2,2.)-pow(s2,2.)
10238 + 4.*c2*(pow(c1,2.)-pow(s1,2.))+8.*s2*s1*c1
10239 + 8.*two*(pow(c1,2.)+pow(s1,2.))-6.*pow((pow(c1,2.)+pow(s1,2.)),2.);
b77b6434 10240 if(fApplyCorrectionForNUAVsM){fIntFlowQcumulantsVsM[1]->SetBinContent(b,gQC4);}
b92ea2b9 10241 // Detector bias vs M:
53884472 10242 if(TMath::Abs(QC2)>0.)
b92ea2b9 10243 {
53884472 10244 fIntFlowDetectorBiasVsM[0]->SetBinContent(b,gQC2/QC2);
10245 } // end of if(TMath::Abs(QC2)>0.)
10246 if(TMath::Abs(QC4)>0.)
b92ea2b9 10247 {
53884472 10248 fIntFlowDetectorBiasVsM[1]->SetBinContent(b,gQC4/QC4);
10249 } // end of if(TMath::Abs(QC4)>0.)
b77b6434 10250 // Rebin in M:
10251 for(Int_t co=0;co<4;co++)
10252 {
10253 value[co] = fIntFlowQcumulantsVsM[co]->GetBinContent(b);
10254 error[co] = fIntFlowQcumulantsVsM[co]->GetBinError(b);
10255 if(error[co]>0.)
10256 {
10257 dSum1[co]+=value[co]/(error[co]*error[co]);
10258 dSum2[co]+=1./(error[co]*error[co]);
10259 }
10260 } // end of for(Int_t co=0;co<4;co++)
10261 } // end of for(Int_t b=1;b<=nBins;b++)
10262 // Store rebinned Q-cumulants:
10263 if(fApplyCorrectionForNUAVsM)
10264 {
10265 for(Int_t co=0;co<4;co++)
10266 {
10267 if(dSum2[co]>0.)
10268 {
10269 fIntFlowQcumulantsRebinnedInM->SetBinContent(co+1,dSum1[co]/dSum2[co]);
10270 fIntFlowQcumulantsRebinnedInM->SetBinError(co+1,pow(1./dSum2[co],0.5));
10271 }
10272 } // end of for(Int_t co=0;co<4;co++)
10273 } // end of if(fApplyCorrectionForNUAVsM)
10274 } // end of if(fCalculateCumulantsVsM)
2001bc3a 10275
489d5531 10276} // end of void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()
0328db2d 10277
489d5531 10278//================================================================================================================================
10279
489d5531 10280void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()
10281{
0328db2d 10282 // From profile fIntFlowCorrectionTermsForNUAPro[sc] access measured correction terms for NUA
489d5531 10283 // and their spread, correctly calculate the statistical errors and store the final
0328db2d 10284 // results and statistical errors for correction terms for NUA in histogram fIntFlowCorrectionTermsForNUAHist[sc].
489d5531 10285 //
10286 // Remark: Statistical error of correction temrs is calculated as:
10287 //
10288 // statistical error = termA * spread * termB:
10289 // termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)
10290 // termB = 1/sqrt(1-termA^2)
10291
b92ea2b9 10292 TString sinCosFlag[2] = {"sin","cos"}; // to be improved - promore this to data member?
10293 TString nonisotropicTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
10294
489d5531 10295 for(Int_t sc=0;sc<2;sc++) // sin or cos correction terms
10296 {
b92ea2b9 10297 for(Int_t ci=1;ci<=4;ci++) // correction term index (to be improved - hardwired 4)
489d5531 10298 {
10299 Double_t correction = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci);
0328db2d 10300 Double_t spread = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinError(ci);
10301 Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeightsNUA[sc][0]->GetBinContent(ci);
10302 Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeightsNUA[sc][1]->GetBinContent(ci);
10303 Double_t termA = 0.;
10304 Double_t termB = 0.;
b92ea2b9 10305 if(TMath::Abs(sumOfLinearEventWeights)>1.e-44)
0328db2d 10306 {
10307 termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;
10308 } else
10309 {
b92ea2b9 10310 cout<<" WARNING (QC): sumOfLinearEventWeights == 0 in AFAWQC::FCTFNIF() !!!!"<<endl;
10311 cout<<Form(" (for <<%s[%s]>> non-isotropic term)",sinCosFlag[sc].Data(),nonisotropicTermFlag[ci-1].Data())<<endl;
0328db2d 10312 }
489d5531 10313 if(1.-pow(termA,2.) > 0.)
10314 {
10315 termB = 1./pow(1-pow(termA,2.),0.5);
10316 } else
10317 {
b92ea2b9 10318 cout<<" WARNING (QC): 1.-pow(termA,2.) <= 0 in AFAWQC::FCTFNIF() !!!!"<<endl;
10319 cout<<Form(" (for <<%s[%s]>> non-isotropic term)",sinCosFlag[sc].Data(),nonisotropicTermFlag[ci-1].Data())<<endl;
489d5531 10320 }
10321 Double_t statisticalError = termA * spread * termB;
489d5531 10322 fIntFlowCorrectionTermsForNUAHist[sc]->SetBinContent(ci,correction);
0328db2d 10323 fIntFlowCorrectionTermsForNUAHist[sc]->SetBinError(ci,statisticalError);
b92ea2b9 10324 } // end of for(Int_t ci=1;ci<=4;ci++) // correction term index
489d5531 10325 } // end of for(Int sc=0;sc<2;sc++) // sin or cos correction terms
10326
10327} // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()
10328
489d5531 10329//================================================================================================================================
10330
489d5531 10331void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms()
10332{
10333 // Get pointers to all objects relevant for calculations with nested loops.
10334
10335 TList *nestedLoopsList = dynamic_cast<TList*>(fHistList->FindObject("Nested Loops"));
10336 if(nestedLoopsList)
10337 {
10338 this->SetNestedLoopsList(nestedLoopsList);
10339 } else
10340 {
10341 cout<<"WARNING: nestedLoopsList is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10342 exit(0);
10343 }
10344
10345 TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
10346 TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)
10347 TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)
10348 TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)
10349
10350 TString evaluateNestedLoopsName = "fEvaluateNestedLoops";
10351 evaluateNestedLoopsName += fAnalysisLabel->Data();
10352 TProfile *evaluateNestedLoops = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(evaluateNestedLoopsName.Data()));
10353 Bool_t bEvaluateIntFlowNestedLoops = kFALSE;
10354 Bool_t bEvaluateDiffFlowNestedLoops = kFALSE;
10355 if(evaluateNestedLoops)
10356 {
10357 this->SetEvaluateNestedLoops(evaluateNestedLoops);
10358 bEvaluateIntFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(1);
10359 bEvaluateDiffFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(2);
10360 }
10361 // nested loops relevant for integrated flow:
10362 if(bEvaluateIntFlowNestedLoops)
10363 {
10364 // correlations:
10365 TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";
10366 intFlowDirectCorrelationsName += fAnalysisLabel->Data();
10367 TProfile *intFlowDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowDirectCorrelationsName.Data()));
10368 if(intFlowDirectCorrelations)
10369 {
10370 this->SetIntFlowDirectCorrelations(intFlowDirectCorrelations);
10371 } else
10372 {
10373 cout<<"WARNING: intFlowDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10374 exit(0);
10375 }
403e3389 10376 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 10377 {
10378 TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";
10379 intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();
10380 TProfile *intFlowExtraDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowExtraDirectCorrelationsName.Data()));
10381 if(intFlowExtraDirectCorrelations)
10382 {
10383 this->SetIntFlowExtraDirectCorrelations(intFlowExtraDirectCorrelations);
10384 } else
10385 {
10386 cout<<"WARNING: intFlowExtraDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10387 exit(0);
10388 }
403e3389 10389 } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 10390 // correction terms for non-uniform acceptance:
10391 TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";
10392 intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
10393 TProfile *intFlowDirectCorrectionTermsForNUA[2] = {NULL};
10394 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
10395 {
10396 intFlowDirectCorrectionTermsForNUA[sc] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data())));
10397 if(intFlowDirectCorrectionTermsForNUA[sc])
10398 {
10399 this->SetIntFlowDirectCorrectionTermsForNUA(intFlowDirectCorrectionTermsForNUA[sc],sc);
10400 } else
10401 {
10402 cout<<"WARNING: intFlowDirectCorrectionTermsForNUA[sc] is NULL in AFAWQC::GPFNLH() !!!!"<<endl;
10403 cout<<"sc = "<<sc<<endl;
10404 exit(0);
10405 }
10406 } // end of for(Int_t sc=0;sc<2;sc++)
10407 } // end of if(bEvaluateIntFlowNestedLoops)
10408
10409 // nested loops relevant for differential flow:
10410 if(bEvaluateDiffFlowNestedLoops)
10411 {
10412 // correlations:
10413 TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";
10414 diffFlowDirectCorrelationsName += fAnalysisLabel->Data();
10415 TProfile *diffFlowDirectCorrelations[2][2][4] = {{{NULL}}};
10416 for(Int_t t=0;t<2;t++)
10417 {
10418 for(Int_t pe=0;pe<2;pe++)
10419 {
10420 for(Int_t ci=0;ci<4;ci++) // correlation index
10421 {
10422 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())));
10423 if(diffFlowDirectCorrelations[t][pe][ci])
10424 {
10425 this->SetDiffFlowDirectCorrelations(diffFlowDirectCorrelations[t][pe][ci],t,pe,ci);
10426 } else
10427 {
10428 cout<<"WARNING: diffFlowDirectCorrelations[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10429 cout<<"t = "<<t<<endl;
10430 cout<<"pe = "<<pe<<endl;
10431 cout<<"ci = "<<ci<<endl;
10432 }
10433 } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
10434 } // end of for(Int_t pe=0;pe<2;pe++)
10435 } // end of for(Int_t t=0;t<2;t++)
10436 // correction terms for non-uniform acceptance:
10437 TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";
10438 diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();
10439 TProfile *diffFlowDirectCorrectionTermsForNUA[2][2][2][10] = {{{{NULL}}}};
10440 for(Int_t t=0;t<2;t++)
10441 {
10442 for(Int_t pe=0;pe<2;pe++)
10443 {
10444 // correction terms for NUA:
10445 for(Int_t sc=0;sc<2;sc++) // sin or cos
10446 {
10447 for(Int_t cti=0;cti<9;cti++) // correction term index
10448 {
10449 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)));
10450 if(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti])
10451 {
10452 this->SetDiffFlowDirectCorrectionTermsForNUA(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti],t,pe,sc,cti);
10453 } else
10454 {
10455 cout<<"WARNING: diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10456 cout<<"t = "<<t<<endl;
10457 cout<<"pe = "<<pe<<endl;
10458 cout<<"sc = "<<sc<<endl;
10459 cout<<"cti = "<<cti<<endl;
10460 }
10461 } // end of for(Int_t cti=0;cti<9;cti++) // correction term index
10462 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
10463 } // end of for(Int_t pe=0;pe<2;pe++)
10464 } // end of for(Int_t t=0;t<2;t++)
64e500e3 10465 // other differential correlators:
10466 TString otherDirectDiffCorrelatorsName = "fOtherDirectDiffCorrelators";
10467 otherDirectDiffCorrelatorsName += fAnalysisLabel->Data();
10468 TProfile *otherDirectDiffCorrelators[2][2][2][1] = {{{{NULL}}}};
10469 for(Int_t t=0;t<2;t++)
10470 {
10471 for(Int_t pe=0;pe<2;pe++)
10472 {
10473 // correction terms for NUA:
10474 for(Int_t sc=0;sc<2;sc++) // sin or cos
10475 {
10476 for(Int_t ci=0;ci<1;ci++) // correlator index
10477 {
10478 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)));
10479 if(otherDirectDiffCorrelators[t][pe][sc][ci])
10480 {
10481 this->SetOtherDirectDiffCorrelators(otherDirectDiffCorrelators[t][pe][sc][ci],t,pe,sc,ci);
10482 } else
10483 {
10484 cout<<"WARNING: otherDirectDiffCorrelators[t][pe][sc][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10485 cout<<"t = "<<t<<endl;
10486 cout<<"pe = "<<pe<<endl;
10487 cout<<"sc = "<<sc<<endl;
10488 cout<<"ci = "<<ci<<endl;
10489 }
10490 } // end of for(Int_t ci=0;ci<9;ci++) // correction term index
10491 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
10492 } // end of for(Int_t pe=0;pe<2;pe++)
10493 } // end of for(Int_t t=0;t<2;t++)
489d5531 10494 // number of RPs and POIs in selected pt and eta bins for cross-checkings:
10495 TString noOfParticlesInBinName = "fNoOfParticlesInBin";
10496 TH1D *noOfParticlesInBin = NULL;
10497 noOfParticlesInBin = dynamic_cast<TH1D*>(nestedLoopsList->FindObject(noOfParticlesInBinName.Data()));
10498 if(noOfParticlesInBin)
10499 {
10500 this->SetNoOfParticlesInBin(noOfParticlesInBin);
10501 } else
10502 {
10503 cout<<endl;
10504 cout<<" WARNING (QC): noOfParticlesInBin is NULL in AFAWQC::GPFDFH() !!!!"<<endl;
10505 cout<<endl;
10506 }
10507 } // end of if(bEvaluateDiffFlowNestedLoops)
10508
10509} // end of void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms()
10510
489d5531 10511//================================================================================================================================
10512
489d5531 10513void AliFlowAnalysisWithQCumulants::StoreHarmonic()
10514{
10515 // Store flow harmonic in common control histograms.
10516
10517 (fCommonHists->GetHarmonic())->Fill(0.5,fHarmonic);
dd442cd2 10518 if(fFillMultipleControlHistograms)
10519 {
10520 (fCommonHists2nd->GetHarmonic())->Fill(0.5,fHarmonic);
10521 (fCommonHists4th->GetHarmonic())->Fill(0.5,fHarmonic);
10522 (fCommonHists6th->GetHarmonic())->Fill(0.5,fHarmonic);
10523 (fCommonHists8th->GetHarmonic())->Fill(0.5,fHarmonic);
10524 }
10525
489d5531 10526} // end of void AliFlowAnalysisWithQCumulants::StoreHarmonic()
10527
489d5531 10528//================================================================================================================================
10529
489d5531 10530void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta) // type = RP or POI
10531{
10532 // Calculate all correlations needed for differential flow using particle weights.
10533
2a98ceb8 10534 Int_t t = 0; // type flag
10535 Int_t pe = 0; // ptEta flag
489d5531 10536
10537 if(type == "RP")
10538 {
10539 t = 0;
10540 } else if(type == "POI")
10541 {
10542 t = 1;
10543 }
10544
10545 if(ptOrEta == "Pt")
10546 {
10547 pe = 0;
10548 } else if(ptOrEta == "Eta")
10549 {
10550 pe = 1;
10551 }
10552
10553 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
10554 Double_t minPtEta[2] = {fPtMin,fEtaMin};
10555 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
10556 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
10557
10558 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
10559 Double_t dReQ1n1k = (*fReQ)(0,1);
10560 Double_t dReQ2n2k = (*fReQ)(1,2);
10561 Double_t dReQ1n3k = (*fReQ)(0,3);
10562 //Double_t dReQ4n4k = (*fReQ)(3,4);
10563 Double_t dImQ1n1k = (*fImQ)(0,1);
10564 Double_t dImQ2n2k = (*fImQ)(1,2);
10565 Double_t dImQ1n3k = (*fImQ)(0,3);
10566 //Double_t dImQ4n4k = (*fImQ)(3,4);
10567
1268c371 10568 // S^M_{p,k} (see .h file for the definition of fSpk):
10569 Double_t dSM1p1k = (*fSpk)(0,1);
10570 Double_t dSM1p2k = (*fSpk)(0,2);
10571 Double_t dSM1p3k = (*fSpk)(0,3);
10572 Double_t dSM2p1k = (*fSpk)(1,1);
10573 Double_t dSM3p1k = (*fSpk)(2,1);
489d5531 10574
10575 // looping over all bins and calculating reduced correlations:
10576 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10577 {
10578 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):
10579 Double_t p1n0kRe = 0.;
10580 Double_t p1n0kIm = 0.;
10581
10582 // number of POIs in particular (pt,eta) bin):
10583 Double_t mp = 0.;
10584
10585 // real and imaginary parts of q_{m*n,k}:
10586 // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)
10587 Double_t q1n2kRe = 0.;
10588 Double_t q1n2kIm = 0.;
10589 Double_t q2n1kRe = 0.;
10590 Double_t q2n1kIm = 0.;
10591
10592 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10593 Double_t s1p1k = 0.;
10594 Double_t s1p2k = 0.;
10595 Double_t s1p3k = 0.;
10596
10597 // M0111 from Eq. (118) in QC2c (to be improved (notation))
10598 Double_t dM0111 = 0.;
10599
10600 if(type == "POI")
10601 {
10602 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
10603 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
10604 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
10605 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
10606
10607 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10608
10609 t = 1; // typeFlag = RP or POI
10610
10611 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
10612 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
10613 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
10614 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
10615 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
10616 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
10617 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
10618 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
10619 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
10620
10621 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10622 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
10623 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
10624 s1p3k = pow(fs1dEBE[2][pe][3]->GetBinContent(b)*fs1dEBE[2][pe][3]->GetBinEntries(b),1.);
10625
10626 // M0111 from Eq. (118) in QC2c (to be improved (notation)):
10627 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)
10628 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)
10629 + 2.*(s1p3k-s1p2k*dSM1p1k));
10630 }
10631 else if(type == "RP")
10632 {
10633 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
10634 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
10635 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
10636 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
10637 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
10638 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
10639 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
10640 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
10641 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
10642
10643 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
10644 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
10645 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
10646 s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
10647
10648 // to be improved (cross-checked):
10649 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
10650 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
10651 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
10652 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
10653
10654 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10655
10656 t = 0; // typeFlag = RP or POI
10657
10658 // M0111 from Eq. (118) in QC2c (to be improved (notation)):
10659 dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)
10660 - 3.*(s1p1k*(dSM2p1k-dSM1p2k)
10661 + 2.*(s1p3k-s1p2k*dSM1p1k));
10662 //...............................................................................................
10663 }
10664
10665 // 2'-particle correlation:
10666 Double_t two1n1nW0W1 = 0.;
10667 if(mp*dSM1p1k-s1p1k)
10668 {
10669 two1n1nW0W1 = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)
10670 / (mp*dSM1p1k-s1p1k);
10671
10672 // fill profile to get <<2'>>
b40a910e 10673 fDiffFlowCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1,mp*dSM1p1k-s1p1k);
10674 // fill profile to get <<2'>^2>
10675 fDiffFlowSquaredCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1*two1n1nW0W1,mp*dSM1p1k-s1p1k);
489d5531 10676 // histogram to store <2'> e-b-e (needed in some other methods):
10677 fDiffFlowCorrelationsEBE[t][pe][0]->SetBinContent(b,two1n1nW0W1);
10678 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->SetBinContent(b,mp*dSM1p1k-s1p1k);
10679 } // end of if(mp*dSM1p1k-s1p1k)
10680
10681 // 4'-particle correlation:
10682 Double_t four1n1n1n1nW0W1W1W1 = 0.;
10683 if(dM0111)
10684 {
10685 four1n1n1n1nW0W1W1W1 = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)
10686 - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))
10687 - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k
10688 - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)
10689 + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)
10690 - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)
10691 - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k
10692 + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k)
10693 + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k)
10694 + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k)
10695 + 2.*s1p1k*dSM1p2k
10696 - 6.*s1p3k)
10697 / dM0111; // to be improved (notation of dM0111)
10698
10699 // fill profile to get <<4'>>
b40a910e 10700 fDiffFlowCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1,dM0111);
10701 // fill profile to get <<4'>^2>
10702 fDiffFlowSquaredCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1*four1n1n1n1nW0W1W1W1,dM0111);
489d5531 10703 // histogram to store <4'> e-b-e (needed in some other methods):
10704 fDiffFlowCorrelationsEBE[t][pe][1]->SetBinContent(b,four1n1n1n1nW0W1W1W1);
10705 fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->SetBinContent(b,dM0111);
10706 } // end of if(dM0111)
10707 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10708
10709} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta); // type = RP or POI
10710
489d5531 10711//================================================================================================================================
10712
489d5531 10713void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)
10714{
10715 // Fill common control histograms.
10716
10717 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)
10718 fCommonHists->FillControlHistograms(anEvent);
dd442cd2 10719 if(fFillMultipleControlHistograms)
489d5531 10720 {
dd442cd2 10721 if(nRP>1)
489d5531 10722 {
dd442cd2 10723 fCommonHists2nd->FillControlHistograms(anEvent);
10724 if(nRP>3)
489d5531 10725 {
dd442cd2 10726 fCommonHists4th->FillControlHistograms(anEvent);
10727 if(nRP>5)
489d5531 10728 {
dd442cd2 10729 fCommonHists6th->FillControlHistograms(anEvent);
10730 if(nRP>7)
10731 {
10732 fCommonHists8th->FillControlHistograms(anEvent);
10733 } // end of if(nRP>7)
10734 } // end of if(nRP>5)
10735 } // end of if(nRP>3)
10736 } // end of if(nRP>1)
10737 } // end of if(fFillMultipleControlHistograms)
489d5531 10738
10739} // end of void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)
10740
489d5531 10741//================================================================================================================================
10742
489d5531 10743void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities()
10744{
10745 // Reset all event by event quantities.
10746
1268c371 10747 // Reference flow:
489d5531 10748 fReQ->Zero();
10749 fImQ->Zero();
1268c371 10750 fSpk->Zero();
489d5531 10751 fIntFlowCorrelationsEBE->Reset();
10752 fIntFlowEventWeightsForCorrelationsEBE->Reset();
10753 fIntFlowCorrelationsAllEBE->Reset();
10754
b92ea2b9 10755 for(Int_t sc=0;sc<2;sc++)
489d5531 10756 {
b92ea2b9 10757 fIntFlowCorrectionTermsForNUAEBE[sc]->Reset();
10758 fIntFlowEventWeightForCorrectionTermsForNUAEBE[sc]->Reset();
489d5531 10759 }
10760
1268c371 10761 // Differential flow:
10762 if(fCalculateDiffFlow)
489d5531 10763 {
1268c371 10764 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
489d5531 10765 {
62e36168 10766 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // 1D in pt or eta
489d5531 10767 {
1268c371 10768 for(Int_t m=0;m<4;m++) // multiple of harmonic
489d5531 10769 {
1268c371 10770 for(Int_t k=0;k<9;k++) // power of weight
10771 {
10772 if(fReRPQ1dEBE[t][pe][m][k]) fReRPQ1dEBE[t][pe][m][k]->Reset();
10773 if(fImRPQ1dEBE[t][pe][m][k]) fImRPQ1dEBE[t][pe][m][k]->Reset();
10774 }
10775 }
489d5531 10776 }
1268c371 10777 }
10778 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )
10779 {
62e36168 10780 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // 1D in pt or eta
489d5531 10781 {
1268c371 10782 for(Int_t k=0;k<9;k++)
10783 {
10784 if(fs1dEBE[t][pe][k]) fs1dEBE[t][pe][k]->Reset();
10785 }
489d5531 10786 }
10787 }
1268c371 10788 // e-b-e reduced correlations:
10789 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)
10790 {
62e36168 10791 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 10792 {
1268c371 10793 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
10794 {
10795 if(fDiffFlowCorrelationsEBE[t][pe][rci]) fDiffFlowCorrelationsEBE[t][pe][rci]->Reset();
10796 if(fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]) fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]->Reset();
10797 }
489d5531 10798 }
1268c371 10799 }
10800 // correction terms for NUA:
10801 for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)
10802 {
62e36168 10803 for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
489d5531 10804 {
1268c371 10805 for(Int_t sc=0;sc<2;sc++) // sin or cos
489d5531 10806 {
1268c371 10807 for(Int_t cti=0;cti<9;cti++) // correction term index
10808 {
489d5531 10809 fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti]->Reset();
1268c371 10810 }
489d5531 10811 }
1268c371 10812 }
10813 }
10814 } // end of if(fCalculateDiffFlow)
10815
489d5531 10816 // 2D (pt,eta)
1268c371 10817 if(fCalculate2DDiffFlow)
489d5531 10818 {
10819 for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)
10820 {
10821 for(Int_t m=0;m<4;m++) // multiple of harmonic
10822 {
10823 for(Int_t k=0;k<9;k++) // power of weight
10824 {
b77b6434 10825 if(fReRPQ2dEBE[t][m][k]){fReRPQ2dEBE[t][m][k]->Reset();}
10826 if(fImRPQ2dEBE[t][m][k]){fImRPQ2dEBE[t][m][k]->Reset();}
489d5531 10827 }
10828 }
10829 }
10830 for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )
10831 {
10832 for(Int_t k=0;k<9;k++)
10833 {
b77b6434 10834 if(fs2dEBE[t][k]){fs2dEBE[t][k]->Reset();}
489d5531 10835 }
10836 }
1268c371 10837 } // end of if(fCalculate2DDiffFlow)
489d5531 10838
10839} // end of void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities();
10840
489d5531 10841//================================================================================================================================
10842
489d5531 10843void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)
10844{
10845 // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).
10846
10847 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:
10848 // 0: <<sin n(psi1)>>
10849 // 1: <<sin n(psi1+phi2)>>
10850 // 2: <<sin n(psi1+phi2-phi3)>>
10851 // 3: <<sin n(psi1-phi2-phi3)>>:
10852 // 4:
10853 // 5:
10854 // 6:
10855
10856 // multiplicity:
1268c371 10857 Double_t dMult = (*fSpk)(0,0);
489d5531 10858
10859 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
10860 Double_t dReQ1n = (*fReQ)(0,0);
10861 Double_t dReQ2n = (*fReQ)(1,0);
10862 //Double_t dReQ3n = (*fReQ)(2,0);
10863 //Double_t dReQ4n = (*fReQ)(3,0);
10864 Double_t dImQ1n = (*fImQ)(0,0);
10865 Double_t dImQ2n = (*fImQ)(1,0);
10866 //Double_t dImQ3n = (*fImQ)(2,0);
10867 //Double_t dImQ4n = (*fImQ)(3,0);
10868
2a98ceb8 10869 Int_t t = 0; // type flag
10870 Int_t pe = 0; // ptEta flag
489d5531 10871
10872 if(type == "RP")
10873 {
10874 t = 0;
10875 } else if(type == "POI")
10876 {
10877 t = 1;
10878 }
10879
10880 if(ptOrEta == "Pt")
10881 {
10882 pe = 0;
10883 } else if(ptOrEta == "Eta")
10884 {
10885 pe = 1;
10886 }
10887
10888 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
10889 Double_t minPtEta[2] = {fPtMin,fEtaMin};
10890 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
10891 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
10892
10893 // looping over all bins and calculating correction terms:
10894 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
10895 {
10896 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
10897 Double_t p1n0kRe = 0.;
10898 Double_t p1n0kIm = 0.;
10899
10900 // number of POIs in particular pt or eta bin:
10901 Double_t mp = 0.;
10902
10903 // 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):
10904 Double_t q1n0kRe = 0.;
10905 Double_t q1n0kIm = 0.;
10906 Double_t q2n0kRe = 0.;
10907 Double_t q2n0kIm = 0.;
10908
10909 // number of particles which are both RPs and POIs in particular pt or eta bin:
10910 Double_t mq = 0.;
10911
10912 if(type == "POI")
10913 {
10914 // q_{m*n,0}:
10915 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
10916 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
10917 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
10918 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
10919 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
10920 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
10921 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
10922 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
10923
10924 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10925 }
10926 else if(type == "RP")
10927 {
10928 // q_{m*n,0}:
10929 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
10930 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
10931 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
10932 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
10933 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
10934 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
10935 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
10936 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
10937
10938 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10939 }
10940 if(type == "POI")
10941 {
10942 // p_{m*n,0}:
10943 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
10944 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
10945 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
10946 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
10947
10948 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
10949
10950 t = 1; // typeFlag = RP or POI
10951 }
10952 else if(type == "RP")
10953 {
10954 // p_{m*n,0} = q_{m*n,0}:
10955 p1n0kRe = q1n0kRe;
10956 p1n0kIm = q1n0kIm;
10957
10958 mp = mq;
10959
10960 t = 0; // typeFlag = RP or POI
10961 }
10962
10963 // <<sin n(psi1)>>:
10964 Double_t sinP1nPsi = 0.;
10965 if(mp)
10966 {
10967 sinP1nPsi = p1n0kIm/mp;
10968 // fill profile for <<sin n(psi1)>>:
10969 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);
10970 // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):
10971 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);
10972 } // end of if(mp)
10973
10974 // <<sin n(psi1+phi2)>>:
10975 Double_t sinP1nPsiP1nPhi = 0.;
10976 if(mp*dMult-mq)
10977 {
10978 sinP1nPsiP1nPhi = (p1n0kRe*dImQ1n+p1n0kIm*dReQ1n-q2n0kIm)/(mp*dMult-mq);
10979 // fill profile for <<sin n(psi1+phi2)>>:
10980 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhi,mp*dMult-mq);
10981 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
10982 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhi);
10983 } // end of if(mp*dMult-mq)
10984
10985 // <<sin n(psi1+phi2-phi3)>>:
10986 Double_t sinP1nPsi1P1nPhi2MPhi3 = 0.;
10987 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10988 {
10989 sinP1nPsi1P1nPhi2MPhi3 = (p1n0kIm*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)
10990 - 1.*(q2n0kIm*dReQ1n-q2n0kRe*dImQ1n)
10991 - mq*dImQ1n+2.*q1n0kIm)
10992 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10993 // fill profile for <<sin n(psi1+phi2)>>:
10994 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
10995 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
10996 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3);
10997 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
10998
10999 // <<sin n(psi1-phi2-phi3)>>:
11000 Double_t sinP1nPsi1M1nPhi2MPhi3 = 0.;
11001 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11002 {
11003 sinP1nPsi1M1nPhi2MPhi3 = (p1n0kIm*(pow(dReQ1n,2.)-pow(dImQ1n,2.))-2.*p1n0kRe*dReQ1n*dImQ1n
11004 - 1.*(p1n0kIm*dReQ2n-p1n0kRe*dImQ2n)
11005 + 2.*mq*dImQ1n-2.*q1n0kIm)
11006 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11007 // fill profile for <<sin n(psi1+phi2)>>:
11008 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11009 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11010 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3);
11011 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11012 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11013
11014} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)
11015
11016
11017//================================================================================================================================
11018
11019
11020void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)
11021{
11022 // Calculate correction terms for non-uniform acceptance for differential flow (cos terms).
11023
11024 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:
11025 // 0: <<cos n(psi)>>
11026 // 1: <<cos n(psi1+phi2)>>
11027 // 2: <<cos n(psi1+phi2-phi3)>>
11028 // 3: <<cos n(psi1-phi2-phi3)>>
11029 // 4:
11030 // 5:
11031 // 6:
11032
11033 // multiplicity:
1268c371 11034 Double_t dMult = (*fSpk)(0,0);
489d5531 11035
11036 // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
11037 Double_t dReQ1n = (*fReQ)(0,0);
11038 Double_t dReQ2n = (*fReQ)(1,0);
11039 //Double_t dReQ3n = (*fReQ)(2,0);
11040 //Double_t dReQ4n = (*fReQ)(3,0);
11041 Double_t dImQ1n = (*fImQ)(0,0);
11042 Double_t dImQ2n = (*fImQ)(1,0);
11043 //Double_t dImQ3n = (*fImQ)(2,0);
11044 //Double_t dImQ4n = (*fImQ)(3,0);
11045
2a98ceb8 11046 Int_t t = 0; // type flag
11047 Int_t pe = 0; // ptEta flag
489d5531 11048
11049 if(type == "RP")
11050 {
11051 t = 0;
11052 } else if(type == "POI")
11053 {
11054 t = 1;
11055 }
11056
11057 if(ptOrEta == "Pt")
11058 {
11059 pe = 0;
11060 } else if(ptOrEta == "Eta")
11061 {
11062 pe = 1;
11063 }
11064
11065 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
11066 Double_t minPtEta[2] = {fPtMin,fEtaMin};
11067 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
11068 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
11069
11070 // looping over all bins and calculating correction terms:
11071 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11072 {
11073 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
11074 Double_t p1n0kRe = 0.;
11075 Double_t p1n0kIm = 0.;
11076
11077 // number of POIs in particular pt or eta bin:
11078 Double_t mp = 0.;
11079
11080 // 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):
11081 Double_t q1n0kRe = 0.;
11082 Double_t q1n0kIm = 0.;
11083 Double_t q2n0kRe = 0.;
11084 Double_t q2n0kIm = 0.;
11085
11086 // number of particles which are both RPs and POIs in particular pt or eta bin:
11087 Double_t mq = 0.;
11088
11089 if(type == "POI")
11090 {
11091 // q_{m*n,0}:
11092 q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))
11093 * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));
11094 q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))
11095 * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));
11096 q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))
11097 * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));
11098 q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))
11099 * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));
11100
11101 mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11102 }
11103 else if(type == "RP")
11104 {
11105 // q_{m*n,0}:
11106 q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
11107 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
11108 q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
11109 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
11110 q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))
11111 * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));
11112 q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))
11113 * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));
11114
11115 mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11116 }
11117 if(type == "POI")
11118 {
11119 // p_{m*n,0}:
11120 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
11121 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
11122 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
11123 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
11124
11125 mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
11126
11127 t = 1; // typeFlag = RP or POI
11128 }
11129 else if(type == "RP")
11130 {
11131 // p_{m*n,0} = q_{m*n,0}:
11132 p1n0kRe = q1n0kRe;
11133 p1n0kIm = q1n0kIm;
11134
11135 mp = mq;
11136
11137 t = 0; // typeFlag = RP or POI
11138 }
11139
11140 // <<cos n(psi1)>>:
11141 Double_t cosP1nPsi = 0.;
11142 if(mp)
11143 {
11144 cosP1nPsi = p1n0kRe/mp;
11145
11146 // fill profile for <<cos n(psi1)>>:
11147 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);
11148 // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):
11149 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);
11150 } // end of if(mp)
11151
11152 // <<cos n(psi1+phi2)>>:
11153 Double_t cosP1nPsiP1nPhi = 0.;
11154 if(mp*dMult-mq)
11155 {
11156 cosP1nPsiP1nPhi = (p1n0kRe*dReQ1n-p1n0kIm*dImQ1n-q2n0kRe)/(mp*dMult-mq);
11157 // fill profile for <<sin n(psi1+phi2)>>:
11158 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhi,mp*dMult-mq);
11159 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11160 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhi);
11161 } // end of if(mp*dMult-mq)
11162
11163 // <<cos n(psi1+phi2-phi3)>>:
11164 Double_t cosP1nPsi1P1nPhi2MPhi3 = 0.;
11165 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11166 {
11167 cosP1nPsi1P1nPhi2MPhi3 = (p1n0kRe*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)
11168 - 1.*(q2n0kRe*dReQ1n+q2n0kIm*dImQ1n)
11169 - mq*dReQ1n+2.*q1n0kRe)
11170 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11171 // fill profile for <<sin n(psi1+phi2)>>:
11172 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11173 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11174 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3);
11175 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11176
11177 // <<cos n(psi1-phi2-phi3)>>:
11178 Double_t cosP1nPsi1M1nPhi2MPhi3 = 0.;
11179 if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11180 {
11181 cosP1nPsi1M1nPhi2MPhi3 = (p1n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))+2.*p1n0kIm*dReQ1n*dImQ1n
11182 - 1.*(p1n0kRe*dReQ2n+p1n0kIm*dImQ2n)
11183 - 2.*mq*dReQ1n+2.*q1n0kRe)
11184 / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11185 // fill profile for <<sin n(psi1+phi2)>>:
11186 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));
11187 // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):
11188 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3);
11189 } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))
11190 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11191
11192} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)
11193
489d5531 11194//==================================================================================================================================
11195
489d5531 11196void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)
11197{
1268c371 11198 // Transfer profiles into histogams and correctly propagate the error.
489d5531 11199
2a98ceb8 11200 Int_t t = 0; // type flag
11201 Int_t pe = 0; // ptEta flag
489d5531 11202
11203 if(type == "RP")
11204 {
11205 t = 0;
11206 } else if(type == "POI")
11207 {
11208 t = 1;
11209 }
11210
11211 if(ptOrEta == "Pt")
11212 {
11213 pe = 0;
11214 } else if(ptOrEta == "Eta")
11215 {
11216 pe = 1;
11217 }
11218
11219 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
11220 //Double_t minPtEta[2] = {fPtMin,fEtaMin};
11221 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
11222 //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
11223
11224 for(Int_t sc=0;sc<2;sc++) // sin or cos
11225 {
11226 for(Int_t cti=0;cti<9;cti++) // correction term index
11227 {
11228 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11229 {
11230 Double_t correctionTerm = fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(b);
11231 fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]->SetBinContent(b,correctionTerm);
11232 // to be improved (propagate error correctly)
11233 // ...
11234 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11235 } // correction term index
11236 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos
11237
11238}// end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)
11239
489d5531 11240//==================================================================================================================================
11241
489d5531 11242void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
11243{
1268c371 11244 // Calculate generalized differential flow cumulants (corrected for non-uniform acceptance).
11245
11246 // to be improved - propagate error also from non-isotropic terms
489d5531 11247
1268c371 11248 Int_t t = 0; // RP = 0, POI = 1
11249 Int_t pe = 0; // pt = 0, eta = 1
489d5531 11250
11251 if(type == "RP")
11252 {
1268c371 11253 t = 0;
489d5531 11254 } else if(type == "POI")
11255 {
1268c371 11256 t = 1;
489d5531 11257 }
11258
11259 if(ptOrEta == "Pt")
11260 {
1268c371 11261 pe = 0;
489d5531 11262 } else if(ptOrEta == "Eta")
11263 {
1268c371 11264 pe = 1;
489d5531 11265 }
1268c371 11266
11267 // Common:
489d5531 11268 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
489d5531 11269 // 2-particle correlation:
11270 Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>
1268c371 11271 // sinus terms coming from reference flow:
489d5531 11272 Double_t sinP1nPhi = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>
11273 Double_t sinP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>
11274 Double_t sinP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>
1268c371 11275 // cosinus terms coming from reference flow:
489d5531 11276 Double_t cosP1nPhi = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>
11277 Double_t cosP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>
11278 Double_t cosP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>
11279
11280 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11281 {
11282 Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>
11283 Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>
11284 Double_t sinP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][0]->GetBinContent(b); // <<sin n(Psi)>>
11285 Double_t cosP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][0]->GetBinContent(b); // <<cos n(Psi)>>
11286 Double_t sinP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][1]->GetBinContent(b); // <<sin n(psi1+phi2)>>
11287 Double_t cosP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][1]->GetBinContent(b); // <<cos n(psi1+phi2)>>
11288 Double_t sinP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][2]->GetBinContent(b); // <<sin n(psi1+phi2-phi3)>>
11289 Double_t cosP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][2]->GetBinContent(b); // <<cos n(psi1+phi2-phi3)>>
11290 Double_t sinP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][3]->GetBinContent(b); // <<sin n(psi1-phi2-phi3)>>
11291 Double_t cosP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][3]->GetBinContent(b); // <<cos n(psi1-phi2-phi3)>>
1268c371 11292 // Generalized QC{2'}:
489d5531 11293 Double_t qc2Prime = twoPrime - sinP1nPsi*sinP1nPhi - cosP1nPsi*cosP1nPhi;
1268c371 11294 if(fApplyCorrectionForNUA)
11295 {
11296 fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);
11297 }
11298 if(TMath::Abs(twoPrime)>0.)
11299 {
11300 fDiffFlowDetectorBias[t][pe][0]->SetBinContent(b,qc2Prime/twoPrime); // detector bias = generalized/isotropic cumulant.
11301 }
11302 // Generalized QC{4'}:
489d5531 11303 Double_t qc4Prime = fourPrime-2.*twoPrime*two
11304 - cosP1nPsi*cosP1nPhi1M1nPhi2M1nPhi3
11305 + sinP1nPsi*sinP1nPhi1M1nPhi2M1nPhi3
11306 - cosP1nPhi*cosP1nPsi1M1nPhi2M1nPhi3
11307 + sinP1nPhi*sinP1nPsi1M1nPhi2M1nPhi3
11308 - 2.*cosP1nPhi*cosP1nPsi1P1nPhi2M1nPhi3
11309 - 2.*sinP1nPhi*sinP1nPsi1P1nPhi2M1nPhi3
11310 - cosP1nPsi1P1nPhi2*cosP1nPhi1P1nPhi2
11311 - sinP1nPsi1P1nPhi2*sinP1nPhi1P1nPhi2
11312 + 2.*cosP1nPhi1P1nPhi2*(cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)
11313 + 2.*sinP1nPhi1P1nPhi2*(cosP1nPsi*sinP1nPhi+sinP1nPsi*cosP1nPhi)
11314 + 4.*two*(cosP1nPsi*cosP1nPhi+sinP1nPsi*sinP1nPhi)
11315 + 2.*cosP1nPsi1P1nPhi2*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))
11316 + 4.*sinP1nPsi1P1nPhi2*cosP1nPhi*sinP1nPhi
11317 + 4.*twoPrime*(pow(cosP1nPhi,2.)+pow(sinP1nPhi,2.))
11318 - 6.*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))
11319 * (cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)
11320 - 12.*cosP1nPhi*sinP1nPhi
11321 * (sinP1nPsi*cosP1nPhi+cosP1nPsi*sinP1nPhi);
1268c371 11322 if(fApplyCorrectionForNUA)
11323 {
11324 fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime);
11325 }
11326 if(TMath::Abs(fourPrime-2.*twoPrime*two)>0.)
11327 {
11328 fDiffFlowDetectorBias[t][pe][1]->SetBinContent(b,qc4Prime/(fourPrime-2.*twoPrime*two)); // detector bias = generalized/isotropic cumulant.
11329 }
489d5531 11330 } // end of for(Int_t p=1;p<=fnBinsPt;p++)
11331
11332} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)
11333
1268c371 11334//==================================================================================================================================
489d5531 11335
11336void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)
11337{
11338 // Calculate differential flow corrected for non-uniform acceptance.
11339
1268c371 11340 // to be improved: eventually I will have to access here masured correlations and NUA terms
11341 // instead of cumulants in order to propagate statistical error correctly also
11342 // to NUA terms (propagating errors directly from cumulants is WRONG for
11343 // differential flow becuase that doesn't account at all cross-covariance terms)
489d5531 11344
1268c371 11345 // REMARK: When NUA correction is apllied error for differential flow DOES NOT get corrected,
11346 // i.e. only value is being corrected, error is still the one relevant for isotropic
11347 // case. This eventually will be resolved.
11348
11349
11350 Int_t t = 0; // RP or POI
11351 Int_t pe = 0; // pt or eta
489d5531 11352
11353 if(type == "RP")
11354 {
1268c371 11355 t = 0;
489d5531 11356 } else if(type == "POI")
11357 {
1268c371 11358 t = 1;
11359 }
489d5531 11360 if(ptOrEta == "Pt")
11361 {
1268c371 11362 pe = 0;
489d5531 11363 } else if(ptOrEta == "Eta")
11364 {
1268c371 11365 pe = 1;
489d5531 11366 }
11367
1268c371 11368 // Common:
489d5531 11369 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
1268c371 11370 // Reference Q-cumulants
11371 Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}
11372 Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}
11373 // Loop over pt or eta bins:
489d5531 11374 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
11375 {
1268c371 11376 // Differential Q-cumulants:
11377 Double_t qc2Prime = fDiffFlowCumulants[t][pe][0]->GetBinContent(b); // QC{2'}
11378 Double_t qc4Prime = fDiffFlowCumulants[t][pe][1]->GetBinContent(b); // QC{4'}
489d5531 11379 // v'{2}:
1268c371 11380 if(qc2>0.)
489d5531 11381 {
1268c371 11382 Double_t v2Prime = qc2Prime/pow(qc2,0.5);
11383 if(TMath::Abs(v2Prime)>0.){fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime);}
489d5531 11384 }
489d5531 11385 // v'{4}:
1268c371 11386 if(qc4<0.)
489d5531 11387 {
1268c371 11388 Double_t v4Prime = -qc4Prime/pow(-qc4,3./4.);
11389 if(TMath::Abs(v4Prime)>0.){fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);}
489d5531 11390 }
11391 } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)
11392
11393} // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta);
11394
489d5531 11395//==================================================================================================================================
11396
0328db2d 11397void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple * const anEvent)
489d5531 11398{
11399 // Evaluate with nested loops multiparticle correlations for integrated flow (without using the particle weights).
11400
11401 // Remark: Results are stored in profile fIntFlowDirectCorrelations whose binning is organized as follows:
11402 //
11403 // 1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>
11404 // 2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>
11405 // 3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))>
11406 // 4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>
11407 // 5th bin: ---- EMPTY ----
11408 // 6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>
11409 // 7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>
11410 // 8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>
11411 // 9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>
11412 // 10th bin: ---- EMPTY ----
11413 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>
11414 // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>
11415 // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>
11416 // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))>
11417 // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>
11418 // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>
11419 // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))>
11420 // 18th bin: ---- EMPTY ----
11421 // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>
11422 // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>
11423 // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>
11424 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>
11425 // 23rd bin: ---- EMPTY ----
11426 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>
11427 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>
11428 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>
11429 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>
11430 // 28th bin: ---- EMPTY ----
11431 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>
11432 // 30th bin: ---- EMPTY ----
11433 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>
8ed4edc7 11434 // 32nd bin: ---- EMPTY ----
b84464d3 11435 // Extra correlations for 3p TY study:
8ed4edc7 11436 // 33rd bin: <4>_{4n,2n|3n,3n}= four4n2n3n3n = <cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4))>
b84464d3 11437 // 34th bin: <5>_{3n,3n|2n,2n,2n} = five3n3n2n2n2n = <cos(n(3*phi1+3*phi2-2*phi3-2*phi4-2*phi5))>
11438 // Extra correlations for 6p TY study:
11439 // 35th bin: <2>_{5n|5n} = two5n5n = <cos(5n*(phi1-phi2)> T
11440 // 36th bin: <2>_{6n|6n} = two6n6n = <cos(6n*(phi1-phi2)> T
11441 // 37th bin: <3>_{5n|3n,2n} = three5n3n2n = <cos(n*(5*phi1-3*phi2-2*phi3)>
11442 // 38th bin: <3>_{5n|4n,1n} = three5n4n1n = <cos(n*(5*phi1-4*phi2-1*phi3)>
11443 // 39th bin: <3>_{6n|3n,3n} = three6n3n3n = <cos(n*(6*phi1-3*phi2-3*phi3)> T
11444 // 40th bin: <3>_{6n|4n,2n} = three6n4n2n = <cos(n*(6*phi1-4*phi2-2*phi3)> T
11445 // 41st bin: <3>_{6n|5n,1n} = three6n5n1n = <cos(n*(6*phi1-5*phi2-1*phi3)>
11446 // 42nd bin: <4>_{6n|3n,2n,1n} = four6n3n2n1n = <cos(n*(6*phi1-3*phi2-2*phi3-1*phi4)>
11447 // 43rd bin: <4>_{3n,2n|3n,2n} = four3n2n3n2n = <cos(n*(3*phi1+2*phi2-3*phi3-2*phi4)>
11448 // 44th bin: <4>_{4n,1n|3n,2n} = four4n1n3n2n = <cos(n*(4*phi1+1*phi2-3*phi3-2*phi4)>
11449 // 45th bin: <4>_{3n,3n|3n,3n} = four3n3n3n3n = <cos(3.*n*(phi1+phi2-phi3-phi4))> T
11450 // 46th bin: <4>_{4n,2n|3n,3n} = four4n2n3n3n = <cos(n*(4*phi1+2*phi2-3*phi3-3*phi4)>
11451 // 47th bin: <4>_{5n,1n|3n,3n} = four5n1n3n3n = <cos(n*(5*phi1+1*phi2-3*phi3-3*phi4)>
11452 // 48th bin: <4>_{4n,2n|4n,2n} = four4n2n4n2n = <cos(n*(4*phi1+2*phi2-4*phi3-2*phi4)> T
11453 // 49th bin: <4>_{5n,1n|4n,2n} = four5n1n4n2n = <cos(n*(5*phi1+1*phi2-4*phi3-2*phi4)>
11454 // 50th bin: <4>_{5n|3n,1n,1n} = four5n3n1n1n = <cos(n*(5*phi1-3*phi2-1*phi3-1*phi4)>
11455 // 51st bin: <4>_{5n|2n,2n,1n} = four5n2n2n1n = <cos(n*(5*phi1-2*phi2-2*phi3-1*phi4)>
11456 // 52nd bin: <4>_{5n,1n|5n,1n} = four5n1n5n1n = <cos(n*(5*phi1+1*phi2-5*phi3-1*phi4)>
11457 // 53rd bin: <5>_{3n,3n|3n,2n,1n} = four3n3n3n2n1n = <cos(n*(3*phi1+3*phi2-3*phi3-2*phi4-1*phi5)>
11458 // 54th bin: <5>_{4n,2n|3n,2n,1n} = four4n2n3n2n1n = <cos(n*(4*phi1+2*phi2-3*phi3-2*phi4-1*phi5)>
11459 // 55th bin: <5>_{3n,2n|3n,1n,1n} = four3n2n3n1n1n = <cos(n*(3*phi1+2*phi2-3*phi3-1*phi4-1*phi5)>
11460 // 56th bin: <5>_{3n,2n|2n,2n,1n} = four3n2n2n2n1n = <cos(n*(3*phi1+2*phi2-2*phi3-2*phi4-1*phi5)>
11461 // 57th bin: <5>_{5n,1n|3n,2n,1n} = four5n1n3n2n1n = <cos(n*(5*phi1+1*phi2-3*phi3-2*phi4-1*phi5)>
11462 // 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 11463
489d5531 11464 Int_t nPrim = anEvent->NumberOfTracks();
11465 AliFlowTrackSimple *aftsTrack = NULL;
11466 Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
11467 Int_t n = fHarmonic;
11468 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 11469 Double_t dMult = (*fSpk)(0,0);
489d5531 11470 cout<<endl;
11471 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
11472 if(dMult<2)
11473 {
11474 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
11475 } else if (dMult>fMaxAllowedMultiplicity)
11476 {
11477 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
11478 } else
11479 {
11480 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;
11481 }
11482
11483 // 2-particle correlations:
11484 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
11485 {
11486 for(Int_t i1=0;i1<nPrim;i1++)
11487 {
11488 aftsTrack=anEvent->GetTrack(i1);
11489 if(!(aftsTrack->InRPSelection())) continue;
11490 phi1=aftsTrack->Phi();
11491 for(Int_t i2=0;i2<nPrim;i2++)
11492 {
11493 if(i2==i1)continue;
11494 aftsTrack=anEvent->GetTrack(i2);
11495 if(!(aftsTrack->InRPSelection())) continue;
11496 phi2=aftsTrack->Phi();
11497 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
11498 // fill the profile with 2-p correlations:
b84464d3 11499 fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),1.); // <cos(n*(phi1-phi2))>
11500 fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),1.); // <cos(2n*(phi1-phi2))>
11501 fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),1.); // <cos(3n*(phi1-phi2))>
11502 fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),1.); // <cos(4n*(phi1-phi2))>
11503 fIntFlowDirectCorrelations->Fill(34.5,cos(5.*n*(phi1-phi2)),1.); // <cos(5n*(phi1-phi2))>
11504 fIntFlowDirectCorrelations->Fill(35.5,cos(6.*n*(phi1-phi2)),1.); // <cos(6n*(phi1-phi2))>
489d5531 11505 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11506 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11507 } // end of if(nPrim>=2)
11508
11509 // 3-particle correlations:
11510 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
11511 {
11512 for(Int_t i1=0;i1<nPrim;i1++)
11513 {
11514 aftsTrack=anEvent->GetTrack(i1);
11515 if(!(aftsTrack->InRPSelection())) continue;
11516 phi1=aftsTrack->Phi();
11517 for(Int_t i2=0;i2<nPrim;i2++)
11518 {
11519 if(i2==i1)continue;
11520 aftsTrack=anEvent->GetTrack(i2);
11521 if(!(aftsTrack->InRPSelection())) continue;
11522 phi2=aftsTrack->Phi();
11523 for(Int_t i3=0;i3<nPrim;i3++)
11524 {
11525 if(i3==i1||i3==i2)continue;
11526 aftsTrack=anEvent->GetTrack(i3);
11527 if(!(aftsTrack->InRPSelection())) continue;
11528 phi3=aftsTrack->Phi();
11529 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
11530 // fill the profile with 3-p correlations:
b84464d3 11531 fIntFlowDirectCorrelations->Fill(5.,cos(2.*n*phi1-n*(phi2+phi3)),1.); //<3>_{2n|nn,n}
11532 fIntFlowDirectCorrelations->Fill(6.,cos(3.*n*phi1-2.*n*phi2-n*phi3),1.); //<3>_{3n|2n,n}
11533 fIntFlowDirectCorrelations->Fill(7.,cos(4.*n*phi1-2.*n*phi2-2.*n*phi3),1.); //<3>_{4n|2n,2n}
11534 fIntFlowDirectCorrelations->Fill(8.,cos(4.*n*phi1-3.*n*phi2-n*phi3),1.); //<3>_{4n|3n,n}
11535 fIntFlowDirectCorrelations->Fill(36.5,cos(5.*n*phi1-3.*n*phi2-2.*n*phi3),1.); //<3>_{5n|3n,2n}
11536 fIntFlowDirectCorrelations->Fill(37.5,cos(5.*n*phi1-4.*n*phi2-1.*n*phi3),1.); //<3>_{5n|4n,1n}
11537 fIntFlowDirectCorrelations->Fill(38.5,cos(6.*n*phi1-3.*n*phi2-3.*n*phi3),1.); //<3>_{6n|3n,3n}
11538 fIntFlowDirectCorrelations->Fill(39.5,cos(6.*n*phi1-4.*n*phi2-2.*n*phi3),1.); //<3>_{6n|4n,2n}
11539 fIntFlowDirectCorrelations->Fill(40.5,cos(6.*n*phi1-5.*n*phi2-1.*n*phi3),1.); //<3>_{6n|5n,1n}
489d5531 11540 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11541 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11542 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11543 } // end of if(nPrim>=3)
11544
11545 // 4-particle correlations:
11546 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
11547 {
11548 for(Int_t i1=0;i1<nPrim;i1++)
11549 {
11550 aftsTrack=anEvent->GetTrack(i1);
11551 if(!(aftsTrack->InRPSelection())) continue;
11552 phi1=aftsTrack->Phi();
11553 for(Int_t i2=0;i2<nPrim;i2++)
11554 {
11555 if(i2==i1)continue;
11556 aftsTrack=anEvent->GetTrack(i2);
11557 if(!(aftsTrack->InRPSelection())) continue;
11558 phi2=aftsTrack->Phi();
11559 for(Int_t i3=0;i3<nPrim;i3++)
11560 {
11561 if(i3==i1||i3==i2)continue;
11562 aftsTrack=anEvent->GetTrack(i3);
11563 if(!(aftsTrack->InRPSelection())) continue;
11564 phi3=aftsTrack->Phi();
11565 for(Int_t i4=0;i4<nPrim;i4++)
11566 {
11567 if(i4==i1||i4==i2||i4==i3)continue;
11568 aftsTrack=anEvent->GetTrack(i4);
11569 if(!(aftsTrack->InRPSelection())) continue;
11570 phi4=aftsTrack->Phi();
11571 if(nPrim==4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush;
11572 // fill the profile with 4-p correlations:
11573 fIntFlowDirectCorrelations->Fill(10.,cos(n*phi1+n*phi2-n*phi3-n*phi4),1.); // <4>_{n,n|n,n}
11574 fIntFlowDirectCorrelations->Fill(11.,cos(2.*n*phi1+n*phi2-2.*n*phi3-n*phi4),1.); // <4>_{2n,n|2n,n}
11575 fIntFlowDirectCorrelations->Fill(12.,cos(2.*n*phi1+2*n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{2n,2n|2n,2n}
11576 fIntFlowDirectCorrelations->Fill(13.,cos(3.*n*phi1-n*phi2-n*phi3-n*phi4),1.); // <4>_{3n|n,n,n}
11577 fIntFlowDirectCorrelations->Fill(14.,cos(3.*n*phi1+n*phi2-3.*n*phi3-n*phi4),1.); // <4>_{3n,n|3n,n}
11578 fIntFlowDirectCorrelations->Fill(15.,cos(3.*n*phi1+n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{3n,n|2n,2n}
11579 fIntFlowDirectCorrelations->Fill(16.,cos(4.*n*phi1-2.*n*phi2-n*phi3-n*phi4),1.); // <4>_{4n|2n,n,n}
b84464d3 11580 fIntFlowDirectCorrelations->Fill(32.,cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{4n,2n|3n,3n}
11581 fIntFlowDirectCorrelations->Fill(41.5,cos(n*(6.*phi1-3.*phi2-2.*phi3-1.*phi4)),1.); // <4>_{6n|3n,2n,1n}
11582 fIntFlowDirectCorrelations->Fill(42.5,cos(n*(3.*phi1+2.*phi2-3.*phi3-2.*phi4)),1.); // <4>_{3n,2n|3n,2n}
11583 fIntFlowDirectCorrelations->Fill(43.5,cos(n*(4.*phi1+1.*phi2-3.*phi3-2.*phi4)),1.); // <4>_{4n,1n|3n,2n}
11584 fIntFlowDirectCorrelations->Fill(44.5,cos(n*(3.*phi1+3.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{3n,3n|3n,3n}
11585 fIntFlowDirectCorrelations->Fill(45.5,cos(n*(4.*phi1+2.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{4n,2n|3n,3n}
11586 fIntFlowDirectCorrelations->Fill(46.5,cos(n*(5.*phi1+1.*phi2-3.*phi3-3.*phi4)),1.); // <4>_{5n,1n|3n,3n}
11587 fIntFlowDirectCorrelations->Fill(47.5,cos(n*(4.*phi1+2.*phi2-4.*phi3-2.*phi4)),1.); // <4>_{4n,2n|4n,2n}
11588 fIntFlowDirectCorrelations->Fill(48.5,cos(n*(5.*phi1+1.*phi2-4.*phi3-2.*phi4)),1.); // <4>_{5n,1n|4n,2n}
11589 fIntFlowDirectCorrelations->Fill(49.5,cos(n*(5.*phi1-3.*phi2-1.*phi3-1.*phi4)),1.); // <4>_{5n|3n,1n,1n}
11590 fIntFlowDirectCorrelations->Fill(50.5,cos(n*(5.*phi1-2.*phi2-2.*phi3-1.*phi4)),1.); // <4>_{5n|2n,2n,1n}
403e3389 11591 fIntFlowDirectCorrelations->Fill(51.5,cos(n*(5.*phi1+1.*phi2-5.*phi3-1.*phi4)),1.); // <4>_{5n,1n|5n,1n}
11592 fIntFlowDirectCorrelations->Fill(58.5,cos(n*(6.*phi1-4.*phi2-1.*phi3-1.*phi4)),1.); // <4>_{6n|4n,1n,1n}
11593 fIntFlowDirectCorrelations->Fill(59.5,cos(n*(6.*phi1-2.*phi2-2.*phi3-2.*phi4)),1.); // <4>_{6n|2n,2n,2n}
489d5531 11594 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11595 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11596 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11597 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11598 } // end of if(nPrim>=)
11599
11600 // 5-particle correlations:
11601 if(nPrim>=5 && nPrim<=fMaxAllowedMultiplicity)
11602 {
11603 for(Int_t i1=0;i1<nPrim;i1++)
11604 {
11605 aftsTrack=anEvent->GetTrack(i1);
11606 if(!(aftsTrack->InRPSelection())) continue;
11607 phi1=aftsTrack->Phi();
11608 for(Int_t i2=0;i2<nPrim;i2++)
11609 {
11610 if(i2==i1)continue;
11611 aftsTrack=anEvent->GetTrack(i2);
11612 if(!(aftsTrack->InRPSelection())) continue;
11613 phi2=aftsTrack->Phi();
11614 for(Int_t i3=0;i3<nPrim;i3++)
11615 {
11616 if(i3==i1||i3==i2)continue;
11617 aftsTrack=anEvent->GetTrack(i3);
11618 if(!(aftsTrack->InRPSelection())) continue;
11619 phi3=aftsTrack->Phi();
11620 for(Int_t i4=0;i4<nPrim;i4++)
11621 {
11622 if(i4==i1||i4==i2||i4==i3)continue;
11623 aftsTrack=anEvent->GetTrack(i4);
11624 if(!(aftsTrack->InRPSelection())) continue;
11625 phi4=aftsTrack->Phi();
11626 for(Int_t i5=0;i5<nPrim;i5++)
11627 {
11628 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11629 aftsTrack=anEvent->GetTrack(i5);
11630 if(!(aftsTrack->InRPSelection())) continue;
11631 phi5=aftsTrack->Phi();
11632 if(nPrim==5) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<"\r"<<flush;
11633 // fill the profile with 5-p correlations:
b84464d3 11634 fIntFlowDirectCorrelations->Fill(18.,cos(2.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5),1.); // <5>_{2n,n|n,n,n}
11635 fIntFlowDirectCorrelations->Fill(19.,cos(2.*n*phi1+2.*n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); // <5>_{2n,2n|2n,n,n}
11636 fIntFlowDirectCorrelations->Fill(20.,cos(3.*n*phi1+n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); // <5>_{3n,n|2n,n,n}
11637 fIntFlowDirectCorrelations->Fill(21.,cos(4.*n*phi1-n*phi2-n*phi3-n*phi4-n*phi5),1.); // <5>_{4n|n,n,n,n}
11638 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}
11639 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}
11640 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}
11641 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}
11642 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}
11643 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 11644 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}
11645 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 11646 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11647 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11648 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11649 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11650 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11651 } // end of if(nPrim>=5)
11652
11653 // 6-particle correlations:
11654 if(nPrim>=6 && nPrim<=fMaxAllowedMultiplicity)
11655 {
11656 for(Int_t i1=0;i1<nPrim;i1++)
11657 {
11658 aftsTrack=anEvent->GetTrack(i1);
11659 if(!(aftsTrack->InRPSelection())) continue;
11660 phi1=aftsTrack->Phi();
11661 for(Int_t i2=0;i2<nPrim;i2++)
11662 {
11663 if(i2==i1)continue;
11664 aftsTrack=anEvent->GetTrack(i2);
11665 if(!(aftsTrack->InRPSelection())) continue;
11666 phi2=aftsTrack->Phi();
11667 for(Int_t i3=0;i3<nPrim;i3++)
11668 {
11669 if(i3==i1||i3==i2)continue;
11670 aftsTrack=anEvent->GetTrack(i3);
11671 if(!(aftsTrack->InRPSelection())) continue;
11672 phi3=aftsTrack->Phi();
11673 for(Int_t i4=0;i4<nPrim;i4++)
11674 {
11675 if(i4==i1||i4==i2||i4==i3)continue;
11676 aftsTrack=anEvent->GetTrack(i4);
11677 if(!(aftsTrack->InRPSelection())) continue;
11678 phi4=aftsTrack->Phi();
11679 for(Int_t i5=0;i5<nPrim;i5++)
11680 {
11681 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11682 aftsTrack=anEvent->GetTrack(i5);
11683 if(!(aftsTrack->InRPSelection())) continue;
11684 phi5=aftsTrack->Phi();
11685 for(Int_t i6=0;i6<nPrim;i6++)
11686 {
11687 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11688 aftsTrack=anEvent->GetTrack(i6);
11689 if(!(aftsTrack->InRPSelection())) continue;
11690 phi6=aftsTrack->Phi();
11691 if(nPrim==6) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<"\r"<<flush;
11692 // fill the profile with 6-p correlations:
403e3389 11693 fIntFlowDirectCorrelations->Fill(23.,cos(n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6),1.); // <6>_{1n,1n,1n|1n,1n,1n}
11694 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}
11695 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}
11696 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 11697 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 11698 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 11699 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11700 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11701 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11702 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11703 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11704 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11705 } // end of if(nPrim>=6)
11706
11707 // 7-particle correlations:
11708 if(nPrim>=7 && nPrim<=fMaxAllowedMultiplicity)
11709 {
11710 for(Int_t i1=0;i1<nPrim;i1++)
11711 {
11712 aftsTrack=anEvent->GetTrack(i1);
11713 if(!(aftsTrack->InRPSelection())) continue;
11714 phi1=aftsTrack->Phi();
11715 for(Int_t i2=0;i2<nPrim;i2++)
11716 {
11717 if(i2==i1)continue;
11718 aftsTrack=anEvent->GetTrack(i2);
11719 if(!(aftsTrack->InRPSelection())) continue;
11720 phi2=aftsTrack->Phi();
11721 for(Int_t i3=0;i3<nPrim;i3++)
11722 {
11723 if(i3==i1||i3==i2)continue;
11724 aftsTrack=anEvent->GetTrack(i3);
11725 if(!(aftsTrack->InRPSelection())) continue;
11726 phi3=aftsTrack->Phi();
11727 for(Int_t i4=0;i4<nPrim;i4++)
11728 {
11729 if(i4==i1||i4==i2||i4==i3)continue;
11730 aftsTrack=anEvent->GetTrack(i4);
11731 if(!(aftsTrack->InRPSelection())) continue;
11732 phi4=aftsTrack->Phi();
11733 for(Int_t i5=0;i5<nPrim;i5++)
11734 {
11735 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11736 aftsTrack=anEvent->GetTrack(i5);
11737 if(!(aftsTrack->InRPSelection())) continue;
11738 phi5=aftsTrack->Phi();
11739 for(Int_t i6=0;i6<nPrim;i6++)
11740 {
11741 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11742 aftsTrack=anEvent->GetTrack(i6);
11743 if(!(aftsTrack->InRPSelection())) continue;
11744 phi6=aftsTrack->Phi();
11745 for(Int_t i7=0;i7<nPrim;i7++)
11746 {
11747 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;
11748 aftsTrack=anEvent->GetTrack(i7);
11749 if(!(aftsTrack->InRPSelection())) continue;
11750 phi7=aftsTrack->Phi();
11751 if(nPrim==7) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<"\r"<<flush;
11752 // fill the profile with 7-p correlation:
11753 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}
11754 } // end of for(Int_t i7=0;i7<nPrim;i7++)
11755 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11756 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11757 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11758 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11759 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11760 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11761 } // end of if(nPrim>=7)
11762
11763 // 8-particle correlations:
11764 if(nPrim>=8 && nPrim<=fMaxAllowedMultiplicity)
11765 {
11766 for(Int_t i1=0;i1<nPrim;i1++)
11767 {
11768 aftsTrack=anEvent->GetTrack(i1);
11769 if(!(aftsTrack->InRPSelection())) continue;
11770 phi1=aftsTrack->Phi();
11771 for(Int_t i2=0;i2<nPrim;i2++)
11772 {
11773 if(i2==i1)continue;
11774 aftsTrack=anEvent->GetTrack(i2);
11775 if(!(aftsTrack->InRPSelection())) continue;
11776 phi2=aftsTrack->Phi();
11777 for(Int_t i3=0;i3<nPrim;i3++)
11778 {
11779 if(i3==i1||i3==i2)continue;
11780 aftsTrack=anEvent->GetTrack(i3);
11781 if(!(aftsTrack->InRPSelection())) continue;
11782 phi3=aftsTrack->Phi();
11783 for(Int_t i4=0;i4<nPrim;i4++)
11784 {
11785 if(i4==i1||i4==i2||i4==i3)continue;
11786 aftsTrack=anEvent->GetTrack(i4);
11787 if(!(aftsTrack->InRPSelection())) continue;
11788 phi4=aftsTrack->Phi();
11789 for(Int_t i5=0;i5<nPrim;i5++)
11790 {
11791 if(i5==i1||i5==i2||i5==i3||i5==i4)continue;
11792 aftsTrack=anEvent->GetTrack(i5);
11793 if(!(aftsTrack->InRPSelection())) continue;
11794 phi5=aftsTrack->Phi();
11795 for(Int_t i6=0;i6<nPrim;i6++)
11796 {
11797 if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;
11798 aftsTrack=anEvent->GetTrack(i6);
11799 if(!(aftsTrack->InRPSelection())) continue;
11800 phi6=aftsTrack->Phi();
11801 for(Int_t i7=0;i7<nPrim;i7++)
11802 {
11803 if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;
11804 aftsTrack=anEvent->GetTrack(i7);
11805 if(!(aftsTrack->InRPSelection())) continue;
11806 phi7=aftsTrack->Phi();
11807 for(Int_t i8=0;i8<nPrim;i8++)
11808 {
11809 if(i8==i1||i8==i2||i8==i3||i8==i4||i8==i5||i8==i6||i8==i7)continue;
11810 aftsTrack=anEvent->GetTrack(i8);
11811 if(!(aftsTrack->InRPSelection())) continue;
11812 phi8=aftsTrack->Phi();
11813 cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<" "<<i8<<"\r"<<flush;
11814 // fill the profile with 8-p correlation:
11815 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}
11816 } // end of for(Int_t i8=0;i8<nPrim;i8++)
11817 } // end of for(Int_t i7=0;i7<nPrim;i7++)
11818 } // end of for(Int_t i6=0;i6<nPrim;i6++)
11819 } // end of for(Int_t i5=0;i5<nPrim;i5++)
11820 } // end of for(Int_t i4=0;i4<nPrim;i4++)
11821 } // end of for(Int_t i3=0;i3<nPrim;i3++)
11822 } // end of for(Int_t i2=0;i2<nPrim;i2++)
11823 } // end of for(Int_t i1=0;i1<nPrim;i1++)
11824 } // end of if(nPrim>=8)
11825
11826 cout<<endl;
11827
11828} // end of AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)
11829
11830
11831//==================================================================================================================================
11832
11833
11834void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()
11835{
11836 // Cross-check results for multiparticle correlations needed for int. flow: results from Q-vectors vs results from nested loops.
11837
11838 cout<<endl;
11839 cout<<endl;
11840 cout<<" *****************************************"<<endl;
11841 cout<<" **** cross-checking the correlations ****"<<endl;
11842 cout<<" **** for integrated flow ****"<<endl;
403e3389 11843 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 11844 {
11845 cout<<" **** (particle weights not used) ****"<<endl;
11846 } else
11847 {
11848 cout<<" **** (particle weights used) ****"<<endl;
11849 }
11850 cout<<" *****************************************"<<endl;
11851 cout<<endl;
11852 cout<<endl;
11853
403e3389 11854 Int_t ciMax = 64; // to be improved (removed eventually when I calculate 6th and 8th order with particle weights)
489d5531 11855
403e3389 11856 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
489d5531 11857 {
11858 ciMax = 11;
11859 }
11860
11861 for(Int_t ci=1;ci<=ciMax;ci++)
11862 {
11863 if(strcmp((fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)
11864 cout<<(fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)
11865 cout<<"from Q-vectors = "<<fIntFlowCorrelationsAllPro->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)
11866 cout<<"from nested loops = "<<fIntFlowDirectCorrelations->GetBinContent(ci)<<endl;
11867 cout<<endl;
11868 }
11869
11870} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()
11871
489d5531 11872//================================================================================================================================
11873
489d5531 11874void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()
11875{
11876 // Cross-check results for corrections terms for non-uniform acceptance needed for int. flow: results from Q-vectors vs results from nested loops.
11877
11878 cout<<endl;
11879 cout<<endl;
11880 cout<<" *********************************************"<<endl;
11881 cout<<" **** cross-checking the correction terms ****"<<endl;
11882 cout<<" **** for non-uniform acceptance relevant ****"<<endl;
11883 cout<<" **** for integrated flow ****"<<endl;
403e3389 11884 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 11885 {
11886 cout<<" **** (particle weights not used) ****"<<endl;
11887 } else
11888 {
11889 cout<<" **** (particle weights used) ****"<<endl;
11890 }
11891 cout<<" *********************************************"<<endl;
11892 cout<<endl;
11893 cout<<endl;
11894
b92ea2b9 11895 for(Int_t ci=1;ci<=4;ci++) // correction term index (to be improved - hardwired 4)
489d5531 11896 {
11897 for(Int_t sc=0;sc<2;sc++) // sin or cos term
11898 {
11899 if(strcmp((fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)
11900 cout<<(fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)
11901 cout<<"from Q-vectors = "<<fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)
11902 cout<<"from nested loops = "<<fIntFlowDirectCorrectionTermsForNUA[sc]->GetBinContent(ci)<<endl;
11903 cout<<endl;
11904 } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos term
11905 } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index
11906
11907} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()
11908
489d5531 11909//================================================================================================================================
11910
0328db2d 11911void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent)
489d5531 11912{
11913 // Evaluate with nested loops multiparticle correlations for integrated flow (using the particle weights).
11914
11915 // Results are stored in profile fIntFlowDirectCorrelations.
11916 // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrelations is organized as follows:
11917 //
11918 // 1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>
11919 // 2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>
11920 // 3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))>
11921 // 4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>
11922 // 5th bin: ---- EMPTY ----
11923 // 6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>
11924 // 7th bin: <3>_{3n|2n,1n} = ...
11925 // 8th bin: <3>_{4n|2n,2n} = ...
11926 // 9th bin: <3>_{4n|3n,1n} = ...
11927 // 10th bin: ---- EMPTY ----
11928 // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>
11929 // 12th bin: <4>_{2n,1n|2n,1n} = ...
11930 // 13th bin: <4>_{2n,2n|2n,2n} = ...
11931 // 14th bin: <4>_{3n|1n,1n,1n} = ...
11932 // 15th bin: <4>_{3n,1n|3n,1n} = ...
11933 // 16th bin: <4>_{3n,1n|2n,2n} = ...
11934 // 17th bin: <4>_{4n|2n,1n,1n} = ...
11935 // 18th bin: ---- EMPTY ----
11936 // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...
11937 // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...
11938 // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...
11939 // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...
11940 // 23rd bin: ---- EMPTY ----
11941 // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...
11942 // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...
11943 // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...
11944 // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...
11945 // 28th bin: ---- EMPTY ----
11946 // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...
11947 // 30th bin: ---- EMPTY ----
11948 // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...
57340a27 11949
489d5531 11950 // Remark 2: When particle weights are used there are some extra correlations. They are stored in
11951 // fIntFlowExtraDirectCorrelations binning of which is organized as follows:
57340a27 11952
489d5531 11953 // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>
11954 // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>
11955 // ...
57340a27 11956
489d5531 11957 Int_t nPrim = anEvent->NumberOfTracks();
11958 AliFlowTrackSimple *aftsTrack = NULL;
11959 //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
11960 //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
11961 Double_t phi1=0., phi2=0., phi3=0., phi4=0.;
11962 Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1.;
11963 Int_t n = fHarmonic;
11964 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 11965 Double_t dMult = (*fSpk)(0,0);
489d5531 11966 cout<<endl;
11967 cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
11968 if(dMult<2)
11969 {
11970 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
11971 } else if (dMult>fMaxAllowedMultiplicity)
11972 {
11973 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
11974 } else
11975 {
11976 cout<<"... evaluating nested loops (using particle weights) ..."<<endl;
11977 }
11978
11979 // 2-particle correlations:
11980 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
11981 {
11982 // 2 nested loops multiparticle correlations using particle weights:
11983 for(Int_t i1=0;i1<nPrim;i1++)
11984 {
11985 aftsTrack=anEvent->GetTrack(i1);
11986 if(!(aftsTrack->InRPSelection())) continue;
11987 phi1=aftsTrack->Phi();
11988 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
11989 for(Int_t i2=0;i2<nPrim;i2++)
11990 {
11991 if(i2==i1)continue;
11992 aftsTrack=anEvent->GetTrack(i2);
11993 if(!(aftsTrack->InRPSelection())) continue;
11994 phi2=aftsTrack->Phi();
11995 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
11996 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
11997 // 2-p correlations using particle weights:
11998 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),wPhi1*wPhi2); // <w1 w2 cos( n*(phi1-phi2))>
11999 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))>
12000 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))>
12001 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))>
12002 // extra correlations:
12003 // 2-p extra correlations (do not appear if particle weights are not used):
12004 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),pow(wPhi1,3)*wPhi2); // <w1^3 w2 cos(n*(phi1-phi2))>
12005 // ...
12006 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12007 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12008 } // end of if(nPrim>=2)
12009
12010 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
57340a27 12011 {
489d5531 12012 // 3 nested loops multiparticle correlations using particle weights:
12013 for(Int_t i1=0;i1<nPrim;i1++)
57340a27 12014 {
489d5531 12015 aftsTrack=anEvent->GetTrack(i1);
12016 if(!(aftsTrack->InRPSelection())) continue;
12017 phi1=aftsTrack->Phi();
12018 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
12019 for(Int_t i2=0;i2<nPrim;i2++)
12020 {
12021 if(i2==i1)continue;
12022 aftsTrack=anEvent->GetTrack(i2);
12023 if(!(aftsTrack->InRPSelection())) continue;
12024 phi2=aftsTrack->Phi();
12025 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12026 for(Int_t i3=0;i3<nPrim;i3++)
12027 {
12028 if(i3==i1||i3==i2)continue;
12029 aftsTrack=anEvent->GetTrack(i3);
12030 if(!(aftsTrack->InRPSelection())) continue;
12031 phi3=aftsTrack->Phi();
12032 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
12033 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
12034 // 3-p correlations using particle weights:
12035 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))>
12036 // ...
12037 // extra correlations:
12038 // 2-p extra correlations (do not appear if particle weights are not used):
12039 if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(1.5,cos(n*(phi1-phi2)),wPhi1*wPhi2*pow(wPhi3,2)); // <w1 w2 w3^2 cos(n*(phi1-phi2))>
12040 // ...
12041 // 3-p extra correlations (do not appear if particle weights are not used):
12042 // ...
12043 } // end of for(Int_t i3=0;i3<nPrim;i3++)
12044 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12045 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12046 } // end of if(nPrim>=3)
57340a27 12047
489d5531 12048 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
12049 {
12050 // 4 nested loops multiparticle correlations using particle weights:
12051 for(Int_t i1=0;i1<nPrim;i1++)
12052 {
12053 aftsTrack=anEvent->GetTrack(i1);
12054 if(!(aftsTrack->InRPSelection())) continue;
12055 phi1=aftsTrack->Phi();
12056 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
12057 for(Int_t i2=0;i2<nPrim;i2++)
12058 {
12059 if(i2==i1)continue;
12060 aftsTrack=anEvent->GetTrack(i2);
12061 if(!(aftsTrack->InRPSelection())) continue;
12062 phi2=aftsTrack->Phi();
12063 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12064 for(Int_t i3=0;i3<nPrim;i3++)
12065 {
12066 if(i3==i1||i3==i2)continue;
12067 aftsTrack=anEvent->GetTrack(i3);
12068 if(!(aftsTrack->InRPSelection())) continue;
12069 phi3=aftsTrack->Phi();
12070 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
12071 for(Int_t i4=0;i4<nPrim;i4++)
12072 {
12073 if(i4==i1||i4==i2||i4==i3)continue;
12074 aftsTrack=anEvent->GetTrack(i4);
12075 if(!(aftsTrack->InRPSelection())) continue;
12076 phi4=aftsTrack->Phi();
12077 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
12078 if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))
12079 // 4-p correlations using particle weights:
12080 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4);
12081 // extra correlations:
12082 // 2-p extra correlations (do not appear if particle weights are not used):
12083 // ...
12084 // 3-p extra correlations (do not appear if particle weights are not used):
12085 // ...
12086 // 4-p extra correlations (do not appear if particle weights are not used):
12087 // ...
12088 } // end of for(Int_t i4=0;i4<nPrim;i4++)
12089 } // end of for(Int_t i3=0;i3<nPrim;i3++)
12090 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12091 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12092 } // end of if(nPrim>=4)
57340a27 12093
489d5531 12094 cout<<endl;
57340a27 12095
489d5531 12096} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)
57340a27 12097
489d5531 12098//================================================================================================================================
12099
489d5531 12100void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()
57340a27 12101{
489d5531 12102 // Cross-check results for extra multiparticle correlations needed for int. flow
12103 // which appear only when particle weights are used: results from Q-vectors vs results from nested loops.
57340a27 12104
489d5531 12105 cout<<endl;
12106 cout<<endl;
12107 cout<<" ***********************************************"<<endl;
12108 cout<<" **** cross-checking the extra correlations ****"<<endl;
12109 cout<<" **** for integrated flow ****"<<endl;
12110 cout<<" ***********************************************"<<endl;
12111 cout<<endl;
12112 cout<<endl;
12113
12114 for(Int_t eci=1;eci<=2;eci++) // to be improved (increased eciMax eventually when I calculate 6th and 8th)
57340a27 12115 {
489d5531 12116 if(strcmp((fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci), "") == 0) continue;
12117 cout<<(fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci)<<":"<<endl;
12118 cout<<"from Q-vectors = "<<fIntFlowExtraCorrelationsPro->GetBinContent(eci)<<endl;
12119 cout<<"from nested loops = "<<fIntFlowExtraDirectCorrelations->GetBinContent(eci)<<endl;
12120 cout<<endl;
12121 }
57340a27 12122
489d5531 12123} // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()
57340a27 12124
489d5531 12125//================================================================================================================================
3b552efe 12126
0328db2d 12127void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoops(AliFlowEventSimple * const anEvent)
489d5531 12128{
12129 // Evaluate with nested loops correction terms for non-uniform acceptance relevant for NONAME integrated flow (to be improved (name)).
12130 //
12131 // Remark: Both sin and cos correction terms are calculated in this method. Sin terms are stored in fIntFlowDirectCorrectionTermsForNUA[0],
12132 // and cos terms in fIntFlowDirectCorrectionTermsForNUA[1]. Binning of fIntFlowDirectCorrectionTermsForNUA[sc] is organized as follows
12133 // (sc stands for either sin or cos):
12134
12135 // 1st bin: <<sc(n*(phi1))>>
12136 // 2nd bin: <<sc(n*(phi1+phi2))>>
12137 // 3rd bin: <<sc(n*(phi1-phi2-phi3))>>
12138 // 4th bin: <<sc(n*(2phi1-phi2))>>
12139
12140 Int_t nPrim = anEvent->NumberOfTracks();
12141 AliFlowTrackSimple *aftsTrack = NULL;
12142 Double_t phi1=0., phi2=0., phi3=0.;
12143 Int_t n = fHarmonic;
12144 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 12145 Double_t dMult = (*fSpk)(0,0);
489d5531 12146 cout<<endl;
12147 cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
12148 if(dMult<1)
3b552efe 12149 {
489d5531 12150 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
12151 } else if (dMult>fMaxAllowedMultiplicity)
3b552efe 12152 {
489d5531 12153 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
12154 } else
12155 {
12156 cout<<"... evaluating nested loops (without using particle weights)..."<<endl;
12157 }
12158
12159 if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
12160 {
12161 // 1-particle correction terms for non-uniform acceptance:
12162 for(Int_t i1=0;i1<nPrim;i1++)
12163 {
12164 aftsTrack=anEvent->GetTrack(i1);
12165 if(!(aftsTrack->InRPSelection())) continue;
12166 phi1=aftsTrack->Phi();
12167 if(nPrim==1) cout<<i1<<"\r"<<flush;
12168 // sin terms:
12169 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),1.); // <sin(n*phi1)>
12170 // cos terms:
12171 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),1.); // <cos(n*phi1)>
12172 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12173 } // end of if(nPrim>=1)
12174
12175 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
12176 {
12177 // 2-particle correction terms for non-uniform acceptance:
12178 for(Int_t i1=0;i1<nPrim;i1++)
12179 {
12180 aftsTrack=anEvent->GetTrack(i1);
12181 if(!(aftsTrack->InRPSelection())) continue;
12182 phi1=aftsTrack->Phi();
12183 for(Int_t i2=0;i2<nPrim;i2++)
3b552efe 12184 {
489d5531 12185 if(i2==i1)continue;
12186 aftsTrack=anEvent->GetTrack(i2);
12187 if(!(aftsTrack->InRPSelection())) continue;
12188 phi2=aftsTrack->Phi();
12189 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
12190 // sin terms:
3b552efe 12191 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),1.); // <<sin(n*(phi1+phi2))>>
489d5531 12192 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(3.5,sin(n*(2*phi1-phi2)),1.); // <<sin(n*(2*phi1-phi2))>>
12193 // cos terms:
3b552efe 12194 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),1.); // <<cos(n*(phi1+phi2))>>
489d5531 12195 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(3.5,cos(n*(2*phi1-phi2)),1.); // <<cos(n*(2*phi1-phi2))>>
12196 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12197 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12198 } // end of if(nPrim>=2)
12199
12200 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
12201 {
12202 // 3-particle correction terms for non-uniform acceptance:
12203 for(Int_t i1=0;i1<nPrim;i1++)
12204 {
12205 aftsTrack=anEvent->GetTrack(i1);
12206 if(!(aftsTrack->InRPSelection())) continue;
12207 phi1=aftsTrack->Phi();
12208 for(Int_t i2=0;i2<nPrim;i2++)
12209 {
12210 if(i2==i1)continue;
12211 aftsTrack=anEvent->GetTrack(i2);
12212 if(!(aftsTrack->InRPSelection())) continue;
12213 phi2=aftsTrack->Phi();
12214 for(Int_t i3=0;i3<nPrim;i3++)
12215 {
12216 if(i3==i1||i3==i2)continue;
12217 aftsTrack=anEvent->GetTrack(i3);
12218 if(!(aftsTrack->InRPSelection())) continue;
12219 phi3=aftsTrack->Phi();
12220 if(nPrim>=3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush; // to be improved (eventually I will change this if statement)
12221 // sin terms:
12222 fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),1.); // <<sin(n*(phi1-phi2-phi3))>>
12223 // cos terms:
12224 fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),1.); // <<cos(n*(phi1-phi2-phi3))>>
12225 } // end of for(Int_t i3=0;i3<nPrim;i3++)
12226 } // end of for(Int_t i2=0;i2<nPrim;i2++)
12227 } // end of for(Int_t i1=0;i1<nPrim;i1++)
12228 } // end of if(nPrim>=3)
12229
12230 cout<<endl;
12231}
64e500e3 12232
489d5531 12233//================================================================================================================================
64e500e3 12234
0328db2d 12235void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12236{
12237 // Evaluate reduced correlations with nested loops without using the particle weights.
12238
12239 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12240 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:
12241 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>]
12242 // Remark 3: <2'> = <cos(n*(psi1-phi2))>
12243 // <4'> = <cos(n*(psi1+phi2-phi3-phi4))>
12244 // ...
12245
2a98ceb8 12246 Int_t typeFlag = 0;
12247 Int_t ptEtaFlag = 0;
489d5531 12248 if(type == "RP")
12249 {
12250 typeFlag = 0;
12251 } else if(type == "POI")
12252 {
12253 typeFlag = 1;
12254 }
12255 if(ptOrEta == "Pt")
12256 {
12257 ptEtaFlag = 0;
12258 } else if(ptOrEta == "Eta")
12259 {
12260 ptEtaFlag = 1;
12261 }
12262 // shortcuts:
12263 Int_t t = typeFlag;
12264 Int_t pe = ptEtaFlag;
12265
12266 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12267 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12268 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12269
12270 Int_t nPrim = anEvent->NumberOfTracks();
12271 AliFlowTrackSimple *aftsTrack = NULL;
12272
12273 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12274
3b552efe 12275 Int_t n = fHarmonic;
489d5531 12276
12277 // 2'-particle correlations:
12278 for(Int_t i1=0;i1<nPrim;i1++)
12279 {
12280 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12281 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12282 if(typeFlag==1) // this is diff flow of POIs
489d5531 12283 {
12284 if(ptOrEta == "Pt")
12285 {
12286 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12287 } else if (ptOrEta == "Eta")
12288 {
12289 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12290 }
12291 } else // this is diff flow of RPs
12292 {
489d5531 12293 if(ptOrEta == "Pt")
12294 {
12295 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12296 } else if (ptOrEta == "Eta")
12297 {
12298 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12299 }
12300 }
489d5531 12301
12302 psi1=aftsTrack->Phi();
12303 for(Int_t i2=0;i2<nPrim;i2++)
12304 {
12305 if(i2==i1)continue;
12306 aftsTrack=anEvent->GetTrack(i2);
12307 // RP condition (!(first) particle in the correlator must be RP):
12308 if(!(aftsTrack->InRPSelection()))continue;
12309 phi2=aftsTrack->Phi();
12310 // 2'-particle correlations:
12311 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),1.); // <cos(n*(psi1-phi2))
12312 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12313 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12314
12315 /*
12316
12317 // 3'-particle correlations:
12318 for(Int_t i1=0;i1<nPrim;i1++)
12319 {
12320 aftsTrack=anEvent->GetTrack(i1);
12321 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
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;
12328 }
12329 psi1=aftsTrack->Phi();
12330 for(Int_t i2=0;i2<nPrim;i2++)
12331 {
12332 if(i2==i1)continue;
12333 aftsTrack=anEvent->GetTrack(i2);
12334 // RP condition (!(first) particle in the correlator must be RP):
12335 if(!(aftsTrack->InRPSelection())) continue;
12336 phi2=aftsTrack->Phi();
12337 for(Int_t i3=0;i3<nPrim;i3++)
12338 {
12339 if(i3==i1||i3==i2)continue;
12340 aftsTrack=anEvent->GetTrack(i3);
12341 // RP condition (!(first) particle in the correlator must be RP):
12342 if(!(aftsTrack->InRPSelection())) continue;
12343 phi3=aftsTrack->Phi();
12344 // 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))>
12345 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12346 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12347 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12348
12349 */
12350
12351 // 4'-particle correlations:
12352 for(Int_t i1=0;i1<nPrim;i1++)
12353 {
12354 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12355 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12356 if(typeFlag==1) // this is diff flow of POIs
489d5531 12357 {
12358 if(ptOrEta == "Pt")
12359 {
12360 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12361 } else if (ptOrEta == "Eta")
12362 {
12363 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12364 }
12365 } else // this is diff flow of RPs
12366 {
489d5531 12367 if(ptOrEta == "Pt")
12368 {
12369 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12370 } else if (ptOrEta == "Eta")
12371 {
12372 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12373 }
12374 }
489d5531 12375
12376 psi1=aftsTrack->Phi();
12377 for(Int_t i2=0;i2<nPrim;i2++)
12378 {
12379 if(i2==i1) continue;
12380 aftsTrack=anEvent->GetTrack(i2);
12381 // RP condition (!(first) particle in the correlator must be RP):
12382 if(!(aftsTrack->InRPSelection())) continue;
12383 phi2=aftsTrack->Phi();
12384 for(Int_t i3=0;i3<nPrim;i3++)
12385 {
12386 if(i3==i1||i3==i2) continue;
12387 aftsTrack=anEvent->GetTrack(i3);
12388 // RP condition (!(first) particle in the correlator must be RP):
12389 if(!(aftsTrack->InRPSelection())) continue;
12390 phi3=aftsTrack->Phi();
12391 for(Int_t i4=0;i4<nPrim;i4++)
12392 {
12393 if(i4==i1||i4==i2||i4==i3) continue;
12394 aftsTrack=anEvent->GetTrack(i4);
12395 // RP condition (!(first) particle in the correlator must be RP):
12396 if(!(aftsTrack->InRPSelection())) continue;
12397 phi4=aftsTrack->Phi();
12398 // 4'-particle correlations:
12399 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),1.); // <cos(n(psi1+phi2-phi3-phi4))>
12400 }//end of for(Int_t i4=0;i4<nPrim;i4++)
12401 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12402 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12403 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12404
12405 // count # of RPs and POIs in selected pt and eta bins for cross-checkings:
3b552efe 12406 for(Int_t i=0;i<nPrim;i++)
12407 {
12408 aftsTrack=anEvent->GetTrack(i);
12409 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12410 if(typeFlag==1) // this is diff flow of POIs
489d5531 12411 {
12412 if(ptOrEta == "Pt")
12413 {
12414 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12415 } else if (ptOrEta == "Eta")
12416 {
12417 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12418 }
12419 } else // this is diff flow of RPs
12420 {
489d5531 12421 if(ptOrEta == "Pt")
12422 {
12423 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12424 } else if (ptOrEta == "Eta")
12425 {
12426 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12427 }
12428 }
12429 if(t==1)t++;
12430 fNoOfParticlesInBin->Fill(t+pe+0.5);
489d5531 12431 }
12432
12433} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12434
489d5531 12435//================================================================================================================================
12436
64e500e3 12437void AliFlowAnalysisWithQCumulants::EvaluateOtherDiffCorrelatorsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
12438{
12439 // Evaluate other differential correlators with nested loops without using the particle weights.
12440
12441 // Remark 1: Other differential correlators are evaluated in pt bin number fCrossCheckInPtBinNo
12442 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12443 // Remark 2: Results are stored in 1 bin profiles fOtherDirectDiffCorrelators[t][pe][sc][ci], where indices runs as follows:
12444 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms][ci = correlator index]
12445 // Remark 3: Correlator index 'ci' runs as follows:
12446 // 0: <exp(n*(psi1-3phi2+2phi3))> (Teaney-Yan correlator)
12447
12448 Int_t typeFlag = 0;
12449 Int_t ptEtaFlag = 0;
12450 if(type == "RP")
12451 {
12452 typeFlag = 0;
12453 } else if(type == "POI")
12454 {
12455 typeFlag = 1;
12456 }
12457 if(ptOrEta == "Pt")
12458 {
12459 ptEtaFlag = 0;
12460 } else if(ptOrEta == "Eta")
12461 {
12462 ptEtaFlag = 1;
12463 }
12464 // shortcuts:
12465 Int_t t = typeFlag;
12466 Int_t pe = ptEtaFlag;
12467
12468 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12469 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12470 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12471
12472 Int_t nPrim = anEvent->NumberOfTracks();
12473 AliFlowTrackSimple *aftsTrack = NULL;
12474
12475 Double_t psi1=0., phi2=0., phi3=0.;
12476
12477 Int_t n = fHarmonic;
12478
12479 // 3-p correlators:
12480 for(Int_t i1=0;i1<nPrim;i1++)
12481 {
12482 aftsTrack=anEvent->GetTrack(i1);
12483 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12484 if(typeFlag==1) // this is diff flow of POIs
12485 {
12486 if(ptOrEta == "Pt")
12487 {
12488 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12489 } else if (ptOrEta == "Eta")
12490 {
12491 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12492 }
12493 } else // this is diff flow of RPs
12494 {
12495 if(ptOrEta == "Pt")
12496 {
12497 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12498 } else if (ptOrEta == "Eta")
12499 {
12500 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12501 }
12502 }
12503 psi1=aftsTrack->Phi();
12504 for(Int_t i2=0;i2<nPrim;i2++)
12505 {
12506 if(i2==i1) continue;
12507 aftsTrack=anEvent->GetTrack(i2);
12508 // RP condition (!(first) particle in the correlator must be RP):
12509 if(!(aftsTrack->InRPSelection())) continue;
12510 phi2=aftsTrack->Phi();
12511 for(Int_t i3=0;i3<nPrim;i3++)
12512 {
12513 if(i3==i1||i3==i2) continue;
12514 aftsTrack=anEvent->GetTrack(i3);
12515 // RP condition (!(first) particle in the correlator must be RP):
12516 if(!(aftsTrack->InRPSelection())) continue;
12517 phi3=aftsTrack->Phi();
12518 // Fill 3-p correlators:
12519 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))>
12520 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12521 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12522 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12523} // end of void AliFlowAnalysisWithQCumulants::EvaluateOtherDiffCorrelatorsWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
12524
12525//================================================================================================================================
489d5531 12526
12527void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)
12528{
12529 // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors
12530
2a98ceb8 12531 Int_t typeFlag = 0;
12532 Int_t ptEtaFlag = 0;
489d5531 12533 if(type == "RP")
12534 {
12535 typeFlag = 0;
12536 } else if(type == "POI")
12537 {
12538 typeFlag = 1;
12539 }
12540 if(ptOrEta == "Pt")
12541 {
12542 ptEtaFlag = 0;
12543 } else if(ptOrEta == "Eta")
12544 {
12545 ptEtaFlag = 1;
12546 }
12547 // shortcuts:
12548 Int_t t = typeFlag;
12549 Int_t pe = ptEtaFlag;
12550
12551 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12552 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12553 TString reducedCorrelations[4] = {"<<cos(n(psi1-phi2))>>","<<cos(n(psi1+phi2-phi3-phi4))>>","",""}; // to be improved (access this from pro or hist)
12554 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12555 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12556
12557 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
12558
12559
12560 cout<<endl;
12561 cout<<" *****************************************"<<endl;
12562 cout<<" **** cross-checking the correlations ****"<<endl;
12563 cout<<" **** for differential flow ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 12564 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 12565 {
12566 cout<<" **** (particle weights not used) ****"<<endl;
12567 } else
12568 {
12569 cout<<" **** (particle weights used) ****"<<endl;
12570 }
12571 cout<<" *****************************************"<<endl;
12572 cout<<endl;
12573 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
12574 cout<<endl;
12575
12576 for(Int_t rci=0;rci<2;rci++) // to be improved (calculate 6th and 8th order)
12577 {
12578 cout<<" "<<reducedCorrelations[rci].Data()<<":"<<endl;
12579 cout<<" from Q-vectors = "<<fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
12580 cout<<" from nested loops = "<<fDiffFlowDirectCorrelations[t][pe][rci]->GetBinContent(1)<<endl;
12581 cout<<endl;
12582 } // end of for(Int_t rci=0;rci<4;rci++)
12583
12584} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)
12585
3b552efe 12586//================================================================================================================================
12587
64e500e3 12588void AliFlowAnalysisWithQCumulants::CrossCheckOtherDiffCorrelators(TString type, TString ptOrEta)
12589{
12590 // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors
12591
12592 Int_t typeFlag = 0;
12593 Int_t ptEtaFlag = 0;
12594 if(type == "RP")
12595 {
12596 typeFlag = 0;
12597 } else if(type == "POI")
12598 {
12599 typeFlag = 1;
12600 }
12601 if(ptOrEta == "Pt")
12602 {
12603 ptEtaFlag = 0;
12604 } else if(ptOrEta == "Eta")
12605 {
12606 ptEtaFlag = 1;
12607 }
12608 // shortcuts:
12609 Int_t t = typeFlag;
12610 Int_t pe = ptEtaFlag;
12611
12612 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12613 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
12614 TString otherCorrelators[1] = {"<<cos(n(psi1-3phi2+2phi3))>>"}; // to be improved (access this from pro or hist)
12615 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12616 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12617
12618 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
12619
12620 cout<<endl;
12621 cout<<" *****************************************"<<endl;
12622 cout<<" **** cross-checking the other ****"<<endl;
12623 cout<<" **** diff. correlators ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 12624 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
64e500e3 12625 {
12626 cout<<" **** (particle weights not used) ****"<<endl;
12627 } else
12628 {
12629 cout<<" **** (particle weights used) ****"<<endl;
12630 }
12631 cout<<" *****************************************"<<endl;
12632 cout<<endl;
12633 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
12634 cout<<endl;
12635
12636 for(Int_t ci=0;ci<1;ci++)
12637 {
12638 cout<<" "<<otherCorrelators[ci].Data()<<":"<<endl;
12639 cout<<" from Q-vectors = "<<fOtherDiffCorrelators[t][pe][1][ci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
12640 cout<<" from nested loops = "<<fOtherDirectDiffCorrelators[t][pe][1][ci]->GetBinContent(1)<<endl;
12641 cout<<endl;
12642 } // end of for(Int_t ci=0;ci<1;ci++)
12643
12644} // end of void AliFlowAnalysisWithQCumulants::CrossCheckOtherDiffCorrelators(TString type, TString ptOrEta)
12645
12646//================================================================================================================================
12647
489d5531 12648void AliFlowAnalysisWithQCumulants::PrintNumberOfParticlesInSelectedBin()
3b552efe 12649{
12650 // Print on the screen number of RPs and POIs in selected pt and eta bin for cross checkings.
12651
12652 cout<<endl;
12653 cout<<"Number of RPs in selected pt bin = "<<fNoOfParticlesInBin->GetBinContent(1)<<endl;
12654 cout<<"Number of RPs in selected eta bin = "<<fNoOfParticlesInBin->GetBinContent(2)<<endl;
12655 cout<<"Number of POIs in selected pt bin = "<<fNoOfParticlesInBin->GetBinContent(3)<<endl;
12656 cout<<"Number of POIs in selected eta bin = "<<fNoOfParticlesInBin->GetBinContent(4)<<endl;
12657
489d5531 12658} // end of void AliFlowAnalysisWithQCumulants::PrintNumberOfParticlesInSelectedBin()
12659
3b552efe 12660//================================================================================================================================
12661
0328db2d 12662void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12663{
12664 // Evaluate reduced correlations with nested loops without using the particle weights.
12665
12666 // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12667 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:
12668 // [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>]
12669 // Remark 3: <2'> = <w2 cos(n*(psi1-phi2))>
12670 // <4'> = <w2 w3 w4 cos(n*(psi1+phi2-phi3-phi4))>
12671 // ...
12672
2a98ceb8 12673 Int_t typeFlag = 0;
12674 Int_t ptEtaFlag = 0;
489d5531 12675 if(type == "RP")
12676 {
12677 typeFlag = 0;
12678 } else if(type == "POI")
12679 {
12680 typeFlag = 1;
12681 }
12682 if(ptOrEta == "Pt")
12683 {
12684 ptEtaFlag = 0;
12685 } else if(ptOrEta == "Eta")
12686 {
12687 ptEtaFlag = 1;
12688 }
12689 // shortcuts:
12690 Int_t t = typeFlag;
12691 Int_t pe = ptEtaFlag;
12692
12693 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12694 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12695 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12696
12697 Int_t nPrim = anEvent->NumberOfTracks();
12698 AliFlowTrackSimple *aftsTrack = NULL;
12699
12700 Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12701 Double_t wPhi2=1., wPhi3=1., wPhi4=1.;// wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
12702
12703 Int_t n = fHarmonic;
12704
12705 // 2'-particle correlations:
12706 for(Int_t i1=0;i1<nPrim;i1++)
12707 {
12708 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12709 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12710 if(typeFlag==1) // this is diff flow of POIs
489d5531 12711 {
12712 if(ptOrEta == "Pt")
12713 {
12714 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12715 } else if (ptOrEta == "Eta")
12716 {
12717 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12718 }
12719 } else // this is diff flow of RPs
12720 {
489d5531 12721 if(ptOrEta == "Pt")
12722 {
12723 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12724 } else if (ptOrEta == "Eta")
12725 {
12726 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12727 }
489d5531 12728 }
12729 psi1=aftsTrack->Phi();
12730 for(Int_t i2=0;i2<nPrim;i2++)
12731 {
12732 if(i2==i1) continue;
12733 aftsTrack=anEvent->GetTrack(i2);
12734 // RP condition (!(first) particle in the correlator must be RP):
12735 if(!(aftsTrack->InRPSelection())) continue;
12736 phi2=aftsTrack->Phi();
12737 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12738 // 2'-particle correlations:
12739 fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),wPhi2); // <w2 cos(n*(psi1-phi2))
12740 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12741 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12742
12743 // 4'-particle correlations:
12744 for(Int_t i1=0;i1<nPrim;i1++)
12745 {
12746 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12747 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12748 if(typeFlag==1) // this is diff flow of POIs
489d5531 12749 {
12750 if(ptOrEta == "Pt")
12751 {
12752 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12753 } else if (ptOrEta == "Eta")
12754 {
12755 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12756 }
12757 } else // this is diff flow of RPs
12758 {
489d5531 12759 if(ptOrEta == "Pt")
12760 {
12761 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12762 } else if (ptOrEta == "Eta")
12763 {
12764 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12765 }
489d5531 12766 }
12767 psi1=aftsTrack->Phi();
12768 for(Int_t i2=0;i2<nPrim;i2++)
12769 {
12770 if(i2==i1) continue;
12771 aftsTrack=anEvent->GetTrack(i2);
12772 // RP condition (!(first) particle in the correlator must be RP):
12773 if(!(aftsTrack->InRPSelection())) continue;
12774 phi2=aftsTrack->Phi();
12775 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
12776 for(Int_t i3=0;i3<nPrim;i3++)
12777 {
12778 if(i3==i1||i3==i2) continue;
12779 aftsTrack=anEvent->GetTrack(i3);
12780 // RP condition (!(first) particle in the correlator must be RP):
12781 if(!(aftsTrack->InRPSelection())) continue;
12782 phi3=aftsTrack->Phi();
12783 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
12784 for(Int_t i4=0;i4<nPrim;i4++)
12785 {
12786 if(i4==i1||i4==i2||i4==i3) continue;
12787 aftsTrack=anEvent->GetTrack(i4);
12788 // RP condition (!(first) particle in the correlator must be RP):
12789 if(!(aftsTrack->InRPSelection())) continue;
12790 phi4=aftsTrack->Phi();
12791 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
12792 // 4'-particle correlations <w2 w3 w4 cos(n(psi1+phi2-phi3-phi4))>:
12793 fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),wPhi2*wPhi3*wPhi4);
12794 }//end of for(Int_t i4=0;i4<nPrim;i4++)
12795 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12796 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12797 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12798
12799 // count # of RPs and POIs in selected pt and eta bins for cross-checkings: (to be improved - moved to dedicated method)
3b552efe 12800 for(Int_t i=0;i<nPrim;i++)
12801 {
489d5531 12802 aftsTrack=anEvent->GetTrack(i);
12803 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12804 if(typeFlag==1) // this is diff flow of POIs
12805 {
12806 if(ptOrEta == "Pt")
12807 {
12808 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12809 } else if (ptOrEta == "Eta")
12810 {
12811 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12812 }
12813 } else // this is diff flow of RPs
12814 {
12815 if(ptOrEta == "Pt")
12816 {
12817 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12818 } else if (ptOrEta == "Eta")
12819 {
12820 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12821 }
12822 }
12823 if(t==1)t++;
12824 fNoOfParticlesInBin->Fill(t+pe+0.5);
12825 }
12826
12827} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12828
489d5531 12829//================================================================================================================================
12830
0328db2d 12831void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 12832{
12833 // Evaluate with nested loops correction terms for non-uniform acceptance (both sin and cos terms) relevant for differential flow.
12834
12835 // Remark 1: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo
12836 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
12837 // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as:
12838 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows:
12839 // cti:
12840 // 0: <<sc n(psi1)>>
12841 // 1: <<sc n(psi1+phi2)>>
12842 // 2: <<sc n(psi1+phi2-phi3)>>
12843 // 3: <<sc n(psi1-phi2-phi3)>>
12844 // 4:
12845 // 5:
12846 // 6:
12847
2a98ceb8 12848 Int_t typeFlag = 0;
12849 Int_t ptEtaFlag = 0;
489d5531 12850 if(type == "RP")
12851 {
12852 typeFlag = 0;
12853 } else if(type == "POI")
12854 {
12855 typeFlag = 1;
12856 }
12857 if(ptOrEta == "Pt")
12858 {
12859 ptEtaFlag = 0;
12860 } else if(ptOrEta == "Eta")
12861 {
12862 ptEtaFlag = 1;
12863 }
12864 // shortcuts:
12865 Int_t t = typeFlag;
12866 Int_t pe = ptEtaFlag;
12867
12868 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
12869 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
12870 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
12871
12872 Int_t nPrim = anEvent->NumberOfTracks();
12873 AliFlowTrackSimple *aftsTrack = NULL;
12874
12875 Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
12876
12877 Int_t n = fHarmonic;
12878
12879 // 1-particle correction terms:
12880 for(Int_t i1=0;i1<nPrim;i1++)
12881 {
12882 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12883 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12884 if(typeFlag==1) // this is diff flow of POIs
489d5531 12885 {
12886 if(ptOrEta == "Pt")
12887 {
12888 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12889 } else if (ptOrEta == "Eta")
12890 {
12891 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12892 }
12893 } else // this is diff flow of RPs
12894 {
489d5531 12895 if(ptOrEta == "Pt")
12896 {
12897 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12898 } else if (ptOrEta == "Eta")
12899 {
12900 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12901 }
12902 }
489d5531 12903 psi1=aftsTrack->Phi();
12904 // sin terms:
12905 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>
12906 // cos terms:
12907 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>
12908 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12909
12910 // 2-particle correction terms:
12911 for(Int_t i1=0;i1<nPrim;i1++)
12912 {
12913 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12914 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12915 if(typeFlag==1) // this is diff flow of POIs
489d5531 12916 {
12917 if(ptOrEta == "Pt")
12918 {
12919 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12920 } else if (ptOrEta == "Eta")
12921 {
12922 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12923 }
12924 } else // this is diff flow of RPs
12925 {
489d5531 12926 if(ptOrEta == "Pt")
12927 {
12928 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12929 } else if (ptOrEta == "Eta")
12930 {
12931 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12932 }
489d5531 12933 }
12934 psi1=aftsTrack->Phi();
12935 for(Int_t i2=0;i2<nPrim;i2++)
12936 {
12937 if(i2==i1) continue;
12938 aftsTrack=anEvent->GetTrack(i2);
12939 // RP condition (!(first) particle in the correlator must be RP):
12940 if(!(aftsTrack->InRPSelection())) continue;
12941 phi2=aftsTrack->Phi();
12942 // sin terms:
12943 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),1.); // <<sin(n*(psi1+phi2))>>
12944 // cos terms:
12945 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),1.); // <<cos(n*(psi1+phi2))>>
12946 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12947 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12948
12949 // 3-particle correction terms:
12950 for(Int_t i1=0;i1<nPrim;i1++)
12951 {
12952 aftsTrack=anEvent->GetTrack(i1);
3b552efe 12953 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
12954 if(typeFlag==1) // this is diff flow of POIs
489d5531 12955 {
12956 if(ptOrEta == "Pt")
12957 {
12958 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
12959 } else if (ptOrEta == "Eta")
12960 {
12961 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 12962 }
12963 } else // this is diff flow of RPs
12964 {
489d5531 12965 if(ptOrEta == "Pt")
12966 {
12967 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
12968 } else if (ptOrEta == "Eta")
12969 {
12970 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 12971 }
489d5531 12972 }
12973 psi1=aftsTrack->Phi();
12974 for(Int_t i2=0;i2<nPrim;i2++)
12975 {
12976 if(i2==i1) continue;
12977 aftsTrack=anEvent->GetTrack(i2);
12978 // RP condition (!(first) particle in the correlator must be RP):
12979 if(!(aftsTrack->InRPSelection())) continue;
12980 phi2=aftsTrack->Phi();
12981 for(Int_t i3=0;i3<nPrim;i3++)
12982 {
12983 if(i3==i1||i3==i2) continue;
12984 aftsTrack=anEvent->GetTrack(i3);
12985 // RP condition (!(first) particle in the correlator must be RP):
12986 if(!(aftsTrack->InRPSelection())) continue;
12987 phi3=aftsTrack->Phi();
12988 // sin terms:
12989 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),1.); // <<sin(n*(psi1+phi2-phi3))>>
12990 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),1.); // <<sin(n*(psi1-phi2-phi3))>>
12991 // cos terms:
12992 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),1.); // <<cos(n*(psi1+phi2-phi3))>>
12993 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),1.); // <<cos(n*(psi1-phi2-phi3))>>
12994 }//end of for(Int_t i3=0;i3<nPrim;i3++)
12995 }//end of for(Int_t i2=0;i2<nPrim;i2++)
12996 }//end of for(Int_t i1=0;i1<nPrim;i1++)
12997
12998} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
12999
13000
13001//================================================================================================================================
13002
13003
13004void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)
13005{
13006 // Compare corrections temrs for non-uniform acceptance needed for diff. flow calculated with nested loops and those calculated from Q-vectors
13007
2a98ceb8 13008 Int_t typeFlag = 0;
13009 Int_t ptEtaFlag = 0;
489d5531 13010 if(type == "RP")
13011 {
13012 typeFlag = 0;
13013 } else if(type == "POI")
13014 {
13015 typeFlag = 1;
13016 }
13017 if(ptOrEta == "Pt")
13018 {
13019 ptEtaFlag = 0;
13020 } else if(ptOrEta == "Eta")
13021 {
13022 ptEtaFlag = 1;
13023 }
13024 // shortcuts:
13025 Int_t t = typeFlag;
13026 Int_t pe = ptEtaFlag;
13027
13028 TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
13029 TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member)
13030 //TString sinCosFlag[2] = {"sin","cos"}; // to be improved (eventually promote to data member)
13031 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)
13032 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)
13033 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
13034 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
13035
13036 Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};
13037
13038 cout<<endl;
13039 cout<<" ******************************************"<<endl;
13040 cout<<" **** cross-checking the correction ****"<<endl;
46b94261 13041 cout<<" **** terms for non-uniform acceptance ****"<<endl;
489d5531 13042 cout<<" **** for differential flow ("<<rpORpoiString[t]<<") ****"<<endl;
403e3389 13043 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
489d5531 13044 {
13045 cout<<" **** (particle weights not used) ****"<<endl;
13046 } else
13047 {
13048 cout<<" **** (particle weights used) ****"<<endl;
13049 }
13050 cout<<" ******************************************"<<endl;
13051 cout<<endl;
13052 cout<<" "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;
13053 cout<<endl;
13054
13055 for(Int_t cti=0;cti<4;cti++) // correction term index
13056 {
13057 for(Int_t sc=0;sc<2;sc++) // sin or cos terms
13058 {
13059 if(sc==0) // to be improved (this can be implemented better)
13060 {
13061 cout<<" "<<reducedCorrectionSinTerms[cti].Data()<<":"<<endl;
13062 } else
13063 {
13064 cout<<" "<<reducedCorrectionCosTerms[cti].Data()<<":"<<endl;
13065 }
13066 cout<<" from Q-vectors = "<<fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;
13067 cout<<" from nested loops = "<<fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]->GetBinContent(1)<<endl;
13068 cout<<endl;
13069 }
13070 } // end of for(Int_t rci=0;rci<4;rci++)
13071
13072} // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)
13073
57340a27 13074//================================================================================================================================
13075
489d5531 13076void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()
13077{
13078 // Calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (cos terms).
13079
13080 // **********************************************************************
13081 // **** weighted corrections for non-uniform acceptance (cos terms): ****
13082 // **********************************************************************
57340a27 13083
489d5531 13084 // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
57340a27 13085 //
489d5531 13086 // 1st bin: <<w1 cos(n*(phi1))>> = cosP1nW1
13087 // 2nd bin: <<w1 w2 cos(n*(phi1+phi2))>> = cosP1nP1nW1W1
13088 // 3rd bin: <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1nW1W1W1
13089 // ...
13090
13091 // multiplicity (number of particles used to determine the reaction plane)
1268c371 13092 Double_t dMult = (*fSpk)(0,0);
489d5531 13093
13094 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13095 Double_t dReQ1n1k = (*fReQ)(0,1);
13096 Double_t dReQ2n2k = (*fReQ)(1,2);
13097 //Double_t dReQ3n3k = (*fReQ)(2,3);
13098 //Double_t dReQ4n4k = (*fReQ)(3,4);
13099 Double_t dReQ1n3k = (*fReQ)(0,3);
13100 Double_t dImQ1n1k = (*fImQ)(0,1);
13101 Double_t dImQ2n2k = (*fImQ)(1,2);
13102 //Double_t dImQ3n3k = (*fImQ)(2,3);
13103 //Double_t dImQ4n4k = (*fImQ)(3,4);
13104 //Double_t dImQ1n3k = (*fImQ)(0,3);
13105
13106 // dMs are variables introduced in order to simplify some Eqs. bellow:
13107 //..............................................................................................
1268c371 13108 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
13109 Double_t dM111 = (*fSpk)(2,1)-3.*(*fSpk)(0,2)*(*fSpk)(0,1)
13110 + 2.*(*fSpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k
489d5531 13111 //..............................................................................................
ecac11c2 13112 // 1-particle:
489d5531 13113 Double_t cosP1nW1 = 0.; // <<w1 cos(n*(phi1))>>
13114
1268c371 13115 if(dMult>0 && TMath::Abs((*fSpk)(0,1))>1.e-6)
489d5531 13116 {
1268c371 13117 cosP1nW1 = dReQ1n1k/(*fSpk)(0,1);
489d5531 13118
13119 // average weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
13120 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1nW1);
13121
13122 // final average weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
1268c371 13123 fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1nW1,(*fSpk)(0,1));
489d5531 13124 }
13125
13126 // 2-particle:
13127 Double_t cosP1nP1nW1W1 = 0.; // <<w1 w2 cos(n*(phi1+phi2))>>
13128
1268c371 13129 if(dMult>1 && TMath::Abs(dM11)>1.e-6)
489d5531 13130 {
13131 cosP1nP1nW1W1 = (pow(dReQ1n1k,2)-pow(dImQ1n1k,2)-dReQ2n2k)/dM11;
13132
13133 // average weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
13134 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1nW1W1);
13135
13136 // final average weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
13137 fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1nW1W1,dM11);
13138 }
13139
13140 // 3-particle:
13141 Double_t cosP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>>
13142
1268c371 13143 if(dMult>2 && TMath::Abs(dM111)>1.e-6)
489d5531 13144 {
57340a27 13145 cosP1nM1nM1nW1W1W1 = (dReQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
13146 - dReQ1n1k*dReQ2n2k-dImQ1n1k*dImQ2n2k
1268c371 13147 - 2.*((*fSpk)(0,2))*dReQ1n1k
489d5531 13148 + 2.*dReQ1n3k)
13149 / dM111;
13150
13151 // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
13152 fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1nW1W1W1);
13153
13154 // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
13155 fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1nW1W1W1,dM111);
13156 }
13157
13158} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()
13159
13160
13161//================================================================================================================================
13162
13163
13164void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()
13165{
13166 // calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
13167
13168 // **********************************************************************
13169 // **** weighted corrections for non-uniform acceptance (sin terms): ****
13170 // **********************************************************************
13171
13172 // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
57340a27 13173 //
489d5531 13174 // 1st bin: <<w1 sin(n*(phi1))>> = sinP1nW1
13175 // 2nd bin: <<w1 w2 sin(n*(phi1+phi2))>> = sinP1nP1nW1W1
13176 // 3rd bin: <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1nW1W1W1
13177 // ...
13178
13179 // multiplicity (number of particles used to determine the reaction plane)
1268c371 13180 Double_t dMult = (*fSpk)(0,0);
489d5531 13181
13182 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13183 Double_t dReQ1n1k = (*fReQ)(0,1);
13184 Double_t dReQ2n2k = (*fReQ)(1,2);
13185 //Double_t dReQ3n3k = (*fReQ)(2,3);
13186 //Double_t dReQ4n4k = (*fReQ)(3,4);
13187 //Double_t dReQ1n3k = (*fReQ)(0,3);
13188 Double_t dImQ1n1k = (*fImQ)(0,1);
13189 Double_t dImQ2n2k = (*fImQ)(1,2);
13190 //Double_t dImQ3n3k = (*fImQ)(2,3);
13191 //Double_t dImQ4n4k = (*fImQ)(3,4);
13192 Double_t dImQ1n3k = (*fImQ)(0,3);
13193
13194 // dMs are variables introduced in order to simplify some Eqs. bellow:
13195 //..............................................................................................
1268c371 13196 Double_t dM11 = (*fSpk)(1,1)-(*fSpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j
13197 Double_t dM111 = (*fSpk)(2,1)-3.*(*fSpk)(0,2)*(*fSpk)(0,1)
13198 + 2.*(*fSpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k
489d5531 13199 //..............................................................................................
13200
13201 // 1-particle:
13202 Double_t sinP1nW1 = 0.; // <<w1 sin(n*(phi1))>>
13203
1268c371 13204 if(dMult>0 && TMath::Abs((*fSpk)(0,1))>1.e-6)
489d5531 13205 {
1268c371 13206 sinP1nW1 = dImQ1n1k/((*fSpk)(0,1));
489d5531 13207
13208 // average weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
13209 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1nW1);
13210
13211 // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1268c371 13212 fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1nW1,(*fSpk)(0,1));
489d5531 13213 }
13214
13215 // 2-particle:
13216 Double_t sinP1nP1nW1W1 = 0.; // <<w1 w2 sin(n*(phi1+phi2))>>
13217
1268c371 13218 if(dMult>1 && TMath::Abs(dM11)>1.e-6)
489d5531 13219 {
13220 sinP1nP1nW1W1 = (2.*dReQ1n1k*dImQ1n1k-dImQ2n2k)/dM11;
13221
13222 // average weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
13223 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1nW1W1);
13224
13225 // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
13226 fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1nW1W1,dM11);
13227 }
13228
13229 // 3-particle:
13230 Double_t sinP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>>
13231
1268c371 13232 if(dMult>2 && TMath::Abs(dM111)>1.e-6)
489d5531 13233 {
57340a27 13234 sinP1nM1nM1nW1W1W1 = (-dImQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
13235 + dReQ1n1k*dImQ2n2k-dImQ1n1k*dReQ2n2k
1268c371 13236 + 2.*((*fSpk)(0,2))*dImQ1n1k
489d5531 13237 - 2.*dImQ1n3k)
13238 / dM111;
13239
13240 // average weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
13241 fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1nW1W1W1);
13242
13243 // final average weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
13244 fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1nW1W1W1,dM111);
13245 }
13246
13247} // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()
13248
57340a27 13249//================================================================================================================================
489d5531 13250
0328db2d 13251void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent)
489d5531 13252{
13253 // Evaluate with nested loops correction terms for non-uniform acceptance for integrated flow (using the particle weights).
13254
57340a27 13255 // Results are stored in profiles fIntFlowDirectCorrectionTermsForNUA[0] (sin terms) and
13256 // fIntFlowDirectCorrectionTermsForNUA[1] (cos terms).
489d5531 13257
57340a27 13258 // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrectionTermsForNUA[sc] is
489d5531 13259 // organized as follows (sc stands for either sin or cos):
13260 //
13261 // 1st bin: <<w1 sc(n*(phi1))>> = scP1nW1
13262 // 2nd bin: <<w1 w2 sc(n*(phi1+phi2))>> = scP1nP1nW1W1
13263 // 3rd bin: <<w1 w2 w3 sc(n*(phi1-phi2-phi3))>> = scP1nM1nM1nW1W1W1
3b552efe 13264 // ...
489d5531 13265
13266 Int_t nPrim = anEvent->NumberOfTracks();
13267 AliFlowTrackSimple *aftsTrack = NULL;
13268 //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;
13269 //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;
13270 Double_t phi1=0., phi2=0., phi3=0.;
13271 Double_t wPhi1=1., wPhi2=1., wPhi3=1.;
13272 Int_t n = fHarmonic;
13273 Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)
1268c371 13274 Double_t dMult = (*fSpk)(0,0);
489d5531 13275 cout<<endl;
13276 cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;
13277 if(dMult<1)
13278 {
13279 cout<<"... skipping this event (multiplicity too low) ..."<<endl;
13280 } else if (dMult>fMaxAllowedMultiplicity)
13281 {
13282 cout<<"... skipping this event (multiplicity too high) ..."<<endl;
13283 } else
13284 {
13285 cout<<"... evaluating nested loops (using particle weights) ..."<<endl;
13286 }
13287
13288 // 1-particle correction terms using particle weights:
13289 if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
13290 {
13291 for(Int_t i1=0;i1<nPrim;i1++)
13292 {
13293 aftsTrack=anEvent->GetTrack(i1);
13294 if(!(aftsTrack->InRPSelection())) continue;
13295 phi1=aftsTrack->Phi();
13296 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
57340a27 13297 // 1-particle correction terms using particle weights:
489d5531 13298 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),wPhi1); // <w1 sin(n*phi1)>
13299 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),wPhi1); // <w1 cos(n*phi1)>
57340a27 13300 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13301 } // end of if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
13302
489d5531 13303 // 2-particle correction terms using particle weights:
13304 if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)
13305 {
13306 for(Int_t i1=0;i1<nPrim;i1++)
13307 {
13308 aftsTrack=anEvent->GetTrack(i1);
13309 if(!(aftsTrack->InRPSelection())) continue;
13310 phi1=aftsTrack->Phi();
13311 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13312 for(Int_t i2=0;i2<nPrim;i2++)
13313 {
13314 if(i2==i1)continue;
13315 aftsTrack=anEvent->GetTrack(i2);
13316 if(!(aftsTrack->InRPSelection())) continue;
13317 phi2=aftsTrack->Phi();
13318 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13319 if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;
57340a27 13320 // 2-p correction terms using particle weights:
489d5531 13321 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 sin(n*(phi1+phi2))>
13322 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 cos(n*(phi1+phi2))>
13323 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13324 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13325 } // end of if(nPrim>=2)
13326
13327 // 3-particle correction terms using particle weights:
13328 if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)
13329 {
13330 for(Int_t i1=0;i1<nPrim;i1++)
13331 {
13332 aftsTrack=anEvent->GetTrack(i1);
13333 if(!(aftsTrack->InRPSelection())) continue;
13334 phi1=aftsTrack->Phi();
13335 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13336 for(Int_t i2=0;i2<nPrim;i2++)
13337 {
13338 if(i2==i1)continue;
13339 aftsTrack=anEvent->GetTrack(i2);
13340 if(!(aftsTrack->InRPSelection())) continue;
13341 phi2=aftsTrack->Phi();
13342 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13343 for(Int_t i3=0;i3<nPrim;i3++)
13344 {
13345 if(i3==i1||i3==i2)continue;
13346 aftsTrack=anEvent->GetTrack(i3);
13347 if(!(aftsTrack->InRPSelection())) continue;
13348 phi3=aftsTrack->Phi();
13349 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13350 if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;
57340a27 13351 // 3-p correction terms using particle weights:
489d5531 13352 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 sin(n*(phi1-phi2-phi3))>
13353 if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 cos(n*(phi1-phi2-phi3))>
13354 } // end of for(Int_t i3=0;i3<nPrim;i3++)
13355 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13356 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13357 } // end of if(nPrim>=3)
13358
57340a27 13359 /*
13360
489d5531 13361 if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)
13362 {
13363 // 4 nested loops multiparticle correlations using particle weights:
13364 for(Int_t i1=0;i1<nPrim;i1++)
13365 {
13366 aftsTrack=anEvent->GetTrack(i1);
13367 if(!(aftsTrack->InRPSelection())) continue;
13368 phi1=aftsTrack->Phi();
13369 if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));
13370 for(Int_t i2=0;i2<nPrim;i2++)
13371 {
13372 if(i2==i1)continue;
13373 aftsTrack=anEvent->GetTrack(i2);
13374 if(!(aftsTrack->InRPSelection())) continue;
13375 phi2=aftsTrack->Phi();
13376 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13377 for(Int_t i3=0;i3<nPrim;i3++)
13378 {
13379 if(i3==i1||i3==i2)continue;
13380 aftsTrack=anEvent->GetTrack(i3);
13381 if(!(aftsTrack->InRPSelection())) continue;
13382 phi3=aftsTrack->Phi();
13383 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13384 for(Int_t i4=0;i4<nPrim;i4++)
13385 {
13386 if(i4==i1||i4==i2||i4==i3)continue;
13387 aftsTrack=anEvent->GetTrack(i4);
13388 if(!(aftsTrack->InRPSelection())) continue;
13389 phi4=aftsTrack->Phi();
13390 if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));
13391 if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))
13392 // 4-p correlations using particle weights:
13393 if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4);
13394 // extra correlations:
13395 // 2-p extra correlations (do not appear if particle weights are not used):
13396 // ...
13397 // 3-p extra correlations (do not appear if particle weights are not used):
13398 // ...
13399 // 4-p extra correlations (do not appear if particle weights are not used):
13400 // ...
13401 } // end of for(Int_t i4=0;i4<nPrim;i4++)
13402 } // end of for(Int_t i3=0;i3<nPrim;i3++)
13403 } // end of for(Int_t i2=0;i2<nPrim;i2++)
13404 } // end of for(Int_t i1=0;i1<nPrim;i1++)
13405 } // end of if(nPrim>=4)
13406
13407 */
13408
13409 cout<<endl;
13410
13411} // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)
13412
57340a27 13413//================================================================================================================================
489d5531 13414
489d5531 13415void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)
13416{
13417 // Calculate correction terms for non-uniform acceptance for differential flow (cos terms) using particle weights.
57340a27 13418
489d5531 13419 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:
57340a27 13420 //
489d5531 13421 // 0: <<cos n(psi)>>
13422 // 1: <<w2 cos n(psi1+phi2)>>
13423 // 2: <<w2 w3 cos n(psi1+phi2-phi3)>>
13424 // 3: <<w2 w3 cos n(psi1-phi2-phi3)>>
13425 // 4:
13426 // 5:
13427 // 6:
13428
13429 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13430 Double_t dReQ1n1k = (*fReQ)(0,1);
13431 Double_t dReQ2n2k = (*fReQ)(1,2);
13432 //Double_t dReQ1n3k = (*fReQ)(0,3);
13433 //Double_t dReQ4n4k = (*fReQ)(3,4);
13434 Double_t dImQ1n1k = (*fImQ)(0,1);
13435 Double_t dImQ2n2k = (*fImQ)(1,2);
13436 //Double_t dImQ1n3k = (*fImQ)(0,3);
13437 //Double_t dImQ4n4k = (*fImQ)(3,4);
13438
1268c371 13439 // S^M_{p,k} (see .h file for the definition of fSpk):
13440 Double_t dSM1p1k = (*fSpk)(0,1);
13441 Double_t dSM1p2k = (*fSpk)(0,2);
13442 Double_t dSM2p1k = (*fSpk)(1,1);
489d5531 13443
2a98ceb8 13444 Int_t t = 0; // type flag
13445 Int_t pe = 0; // ptEta flag
489d5531 13446
13447 if(type == "RP")
13448 {
13449 t = 0;
13450 } else if(type == "POI")
13451 {
13452 t = 1;
13453 }
13454
13455 if(ptOrEta == "Pt")
13456 {
13457 pe = 0;
13458 } else if(ptOrEta == "Eta")
13459 {
13460 pe = 1;
13461 }
13462
13463 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
13464 Double_t minPtEta[2] = {fPtMin,fEtaMin};
13465 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
13466 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13467
13468 // looping over all bins and calculating correction terms:
13469 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13470 {
13471 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
13472 Double_t p1n0kRe = 0.;
13473 Double_t p1n0kIm = 0.;
13474
13475 // number of POIs in particular pt or eta bin:
13476 Double_t mp = 0.;
13477
13478 // 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):
13479 Double_t q1n2kRe = 0.;
ea239361 13480 //Double_t q1n2kIm = 0.;
489d5531 13481 Double_t q2n1kRe = 0.;
13482 Double_t q2n1kIm = 0.;
46b94261 13483
489d5531 13484 // s_{1,1}, s_{1,2} // to be improved (add explanation)
13485 Double_t s1p1k = 0.;
13486 Double_t s1p2k = 0.;
46b94261 13487
489d5531 13488 // number of particles which are both RPs and POIs in particular pt or eta bin:
ea239361 13489 //Double_t mq = 0.;
489d5531 13490
13491 // M0111 from Eq. (118) in QC2c (to be improved (notation))
13492 Double_t dM01 = 0.;
13493 Double_t dM011 = 0.;
13494
13495 if(type == "POI")
13496 {
13497 // q_{m*n,k}:
13498 q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
13499 * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
ea239361 13500 //q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
13501 // * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
489d5531 13502 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
13503 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
13504 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
13505 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
ea239361 13506 //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 13507
489d5531 13508 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
13509 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
13510 }else if(type == "RP")
13511 {
13512 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
13513 q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
13514 * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
ea239361 13515 //q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
13516 // * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
489d5531 13517 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
13518 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
13519 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
13520 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
13521 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13522 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
13523 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
3b552efe 13524 //s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
13525
ea239361 13526 //mq = fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
489d5531 13527 }
3b552efe 13528
489d5531 13529 if(type == "POI")
3b552efe 13530 {
13531 // p_{m*n,k}:
489d5531 13532 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
13533 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
13534 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
3b552efe 13535 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
13536 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 13537 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13538 dM01 = mp*dSM1p1k-s1p1k;
13539 dM011 = mp*(dSM2p1k-dSM1p2k)
13540 - 2.*(s1p1k*dSM1p1k-s1p2k);
13541
13542 // typeFlag = RP (0) or POI (1):
13543 t = 1;
13544 } else if(type == "RP")
489d5531 13545 {
13546 // to be improved (cross-checked):
13547 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
13548 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
13549 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
13550 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
13551 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
13552 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13553 dM01 = mp*dSM1p1k-s1p1k;
13554 dM011 = mp*(dSM2p1k-dSM1p2k)
13555 - 2.*(s1p1k*dSM1p1k-s1p2k);
489d5531 13556 // typeFlag = RP (0) or POI (1):
3b552efe 13557 t = 0;
13558 }
489d5531 13559
13560 // <<cos n(psi1)>>:
13561 Double_t cosP1nPsi = 0.;
13562 if(mp)
13563 {
13564 cosP1nPsi = p1n0kRe/mp;
13565
13566 // fill profile for <<cos n(psi1)>>:
13567 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);
13568 // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):
13569 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);
46b94261 13570 } // end of if(mp)
57340a27 13571
489d5531 13572 // <<w2 cos n(psi1+phi2)>>:
13573 Double_t cosP1nPsiP1nPhiW2 = 0.;
13574 if(dM01)
13575 {
13576 cosP1nPsiP1nPhiW2 = (p1n0kRe*dReQ1n1k-p1n0kIm*dImQ1n1k-q2n1kRe)/(dM01);
13577 // fill profile for <<w2 cos n(psi1+phi2)>>:
13578 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhiW2,dM01);
13579 // histogram to store <w2 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13580 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhiW2);
13581 } // end of if(dM01)
13582
13583 // <<w2 w3 cos n(psi1+phi2-phi3)>>:
13584 Double_t cosP1nPsi1P1nPhi2MPhi3W2W3 = 0.;
13585 if(dM011)
13586 {
46b94261 13587 cosP1nPsi1P1nPhi2MPhi3W2W3 = (p1n0kRe*(pow(dImQ1n1k,2.)+pow(dReQ1n1k,2.))
13588 - p1n0kRe*dSM1p2k
13589 - q2n1kRe*dReQ1n1k-q2n1kIm*dImQ1n1k
13590 - s1p1k*dReQ1n1k
13591 + 2.*q1n2kRe)
13592 / dM011;
489d5531 13593 // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:
13594 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3W2W3,dM011);
13595 // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13596 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3W2W3);
13597 } // end of if(dM011)
13598
13599 // <<w2 w3 cos n(psi1-phi2-phi3)>>:
13600 Double_t cosP1nPsi1M1nPhi2MPhi3W2W3 = 0.;
13601 if(dM011)
13602 {
13603 cosP1nPsi1M1nPhi2MPhi3W2W3 = (p1n0kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))+2.*p1n0kIm*dReQ1n1k*dImQ1n1k
13604 - 1.*(p1n0kRe*dReQ2n2k+p1n0kIm*dImQ2n2k)
46b94261 13605 - 2.*s1p1k*dReQ1n1k
489d5531 13606 + 2.*q1n2kRe)
13607 / dM011;
13608 // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:
13609 fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3W2W3,dM011);
13610 // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):
13611 fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3W2W3);
13612 } // end of if(dM011)
13613
13614 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
46b94261 13615
57340a27 13616} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)
13617
489d5531 13618
13619//================================================================================================================================
13620
13621
13622void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)
13623{
13624 // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).
13625
13626 // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:
13627 // 0: <<sin n(psi1)>>
13628 // 1: <<w2 sin n(psi1+phi2)>>
13629 // 2: <<w2 w3 sin n(psi1+phi2-phi3)>>
13630 // 3: <<w2 w3 sin n(psi1-phi2-phi3)>>:
13631 // 4:
13632 // 5:
13633 // 6:
13634
13635 // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
13636 Double_t dReQ1n1k = (*fReQ)(0,1);
13637 Double_t dReQ2n2k = (*fReQ)(1,2);
13638 //Double_t dReQ1n3k = (*fReQ)(0,3);
13639 //Double_t dReQ4n4k = (*fReQ)(3,4);
13640 Double_t dImQ1n1k = (*fImQ)(0,1);
13641 Double_t dImQ2n2k = (*fImQ)(1,2);
13642 //Double_t dImQ1n3k = (*fImQ)(0,3);
13643 //Double_t dImQ4n4k = (*fImQ)(3,4);
13644
1268c371 13645 // S^M_{p,k} (see .h file for the definition of fSpk):
13646 Double_t dSM1p1k = (*fSpk)(0,1);
13647 Double_t dSM1p2k = (*fSpk)(0,2);
13648 Double_t dSM2p1k = (*fSpk)(1,1);
489d5531 13649
2a98ceb8 13650 Int_t t = 0; // type flag
13651 Int_t pe = 0; // ptEta flag
489d5531 13652
13653 if(type == "RP")
13654 {
13655 t = 0;
13656 } else if(type == "POI")
13657 {
13658 t = 1;
13659 }
13660
13661 if(ptOrEta == "Pt")
13662 {
13663 pe = 0;
13664 } else if(ptOrEta == "Eta")
13665 {
13666 pe = 1;
13667 }
13668
13669 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
13670 Double_t minPtEta[2] = {fPtMin,fEtaMin};
13671 //Double_t maxPtEta[2] = {fPtMax,fEtaMax};
13672 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13673
13674 // looping over all bins and calculating correction terms:
13675 for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13676 {
13677 // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin):
13678 Double_t p1n0kRe = 0.;
13679 Double_t p1n0kIm = 0.;
13680
13681 // number of POIs in particular pt or eta bin:
13682 Double_t mp = 0.;
13683
13684 // 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):
ea239361 13685 //Double_t q1n2kRe = 0.;
489d5531 13686 Double_t q1n2kIm = 0.;
13687 Double_t q2n1kRe = 0.;
13688 Double_t q2n1kIm = 0.;
46b94261 13689
489d5531 13690 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13691 Double_t s1p1k = 0.;
13692 Double_t s1p2k = 0.;
46b94261 13693
489d5531 13694 // number of particles which are both RPs and POIs in particular pt or eta bin:
ea239361 13695 //Double_t mq = 0.;
489d5531 13696
13697 // M0111 from Eq. (118) in QC2c (to be improved (notation))
13698 Double_t dM01 = 0.;
13699 Double_t dM011 = 0.;
13700
13701 if(type == "POI")
13702 {
13703 // q_{m*n,k}:
ea239361 13704 //q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))
13705 // * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));
489d5531 13706 q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))
13707 * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));
13708 q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))
13709 * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));
13710 q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))
13711 * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));
ea239361 13712 //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 13713
489d5531 13714 s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.);
13715 s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.);
13716 }else if(type == "RP")
13717 {
13718 // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!))
ea239361 13719 //q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))
13720 // * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));
489d5531 13721 q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))
13722 * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));
13723 q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))
13724 * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));
13725 q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))
13726 * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));
13727 // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)
13728 s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.);
13729 s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.);
13730 //s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.);
3b552efe 13731 }
13732
13733 if(type == "POI")
13734 {
13735 // p_{m*n,k}:
489d5531 13736 p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))
13737 * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));
13738 p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))
3b552efe 13739 * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
13740 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 13741 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13742 dM01 = mp*dSM1p1k-s1p1k;
13743 dM011 = mp*(dSM2p1k-dSM1p2k)
13744 - 2.*(s1p1k*dSM1p1k-s1p2k);
13745 // typeFlag = RP (0) or POI (1):
13746 t = 1;
489d5531 13747 } else if(type == "RP")
3b552efe 13748 {
489d5531 13749 // to be improved (cross-checked):
13750 p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))
13751 * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));
13752 p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))
13753 * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));
13754 mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)
13755 // M01 from Eq. (118) in QC2c (to be improved (notation)):
3b552efe 13756 dM01 = mp*dSM1p1k-s1p1k;
13757 dM011 = mp*(dSM2p1k-dSM1p2k)
489d5531 13758 - 2.*(s1p1k*dSM1p1k-s1p2k);
13759 // typeFlag = RP (0) or POI (1):
3b552efe 13760 t = 0;
13761 }
13762
489d5531 13763 // <<sin n(psi1)>>:
13764 Double_t sinP1nPsi = 0.;
13765 if(mp)
13766 {
13767 sinP1nPsi = p1n0kIm/mp;
13768
13769 // fill profile for <<sin n(psi1)>>:
13770 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);
13771 // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):
13772 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);
46b94261 13773 } // end of if(mp)
13774
489d5531 13775 // <<w2 sin n(psi1+phi2)>>:
13776 Double_t sinP1nPsiP1nPhiW2 = 0.;
13777 if(dM01)
13778 {
13779 sinP1nPsiP1nPhiW2 = (p1n0kRe*dImQ1n1k+p1n0kIm*dReQ1n1k-q2n1kIm)/(dM01);
13780 // fill profile for <<w2 sin n(psi1+phi2)>>:
13781 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhiW2,dM01);
13782 // histogram to store <w2 sin n(psi1+phi2)> e-b-e (needed in some other methods):
13783 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhiW2);
13784 } // end of if(mp*dMult-mq)
13785
13786 // <<w2 w3 sin n(psi1+phi2-phi3)>>:
13787 Double_t sinP1nPsi1P1nPhi2MPhi3W2W3 = 0.;
13788 if(dM011)
13789 {
46b94261 13790 sinP1nPsi1P1nPhi2MPhi3W2W3 = (p1n0kIm*(pow(dImQ1n1k,2.)+pow(dReQ1n1k,2.))
13791 - p1n0kIm*dSM1p2k
13792 + q2n1kRe*dImQ1n1k-q2n1kIm*dReQ1n1k
13793 - s1p1k*dImQ1n1k
13794 + 2.*q1n2kIm)
13795 / dM011;
489d5531 13796 // fill profile for <<w2 w3 sin n(psi1+phi2-phi3)>>:
13797 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3W2W3,dM011);
13798 // histogram to store <w2 w3 sin n(psi1+phi2-phi3)> e-b-e (needed in some other methods):
13799 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3W2W3);
13800 } // end of if(dM011)
13801
13802 // <<w2 w3 sin n(psi1-phi2-phi3)>>:
13803 Double_t sinP1nPsi1M1nPhi2MPhi3W2W3 = 0.;
13804 if(dM011)
13805 {
13806 sinP1nPsi1M1nPhi2MPhi3W2W3 = (p1n0kIm*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))-2.*p1n0kRe*dReQ1n1k*dImQ1n1k
13807 + 1.*(p1n0kRe*dImQ2n2k-p1n0kIm*dReQ2n2k)
46b94261 13808 + 2.*s1p1k*dImQ1n1k
489d5531 13809 - 2.*q1n2kIm)
13810 / dM011;
13811 // fill profile for <<w2 w3 sin n(psi1-phi2-phi3)>>:
13812 fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3W2W3,dM011);
13813 // histogram to store <w2 w3 sin n(psi1-phi2-phi3)> e-b-e (needed in some other methods):
13814 fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3W2W3);
13815 } // end of if(dM011)
13816
13817 } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)
13818
13819} // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)
13820
489d5531 13821//================================================================================================================================
489d5531 13822
0328db2d 13823void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple * const anEvent, TString type, TString ptOrEta)
489d5531 13824{
57340a27 13825 // Evaluate with nested loops correction terms for non-uniform acceptance
489d5531 13826 // with using particle weights (both sin and cos terms) relevant for differential flow.
13827
57340a27 13828 // Remark 1: "w1" in expressions bellow is a particle weight used only for particles which were
13829 // flagged both as POI and RP.
489d5531 13830 // Remark 2: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo
13831 // and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.
13832 // Remark 3: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as:
13833 // [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows:
13834 // cti:
13835 // 0: <<sc n(psi1)>>
13836 // 1: <<w2 sc n(psi1+phi2)>>
13837 // 2: <<w2 w3 sc n(psi1+phi2-phi3)>>
13838 // 3: <<w2 w3 sc n(psi1-phi2-phi3)>>
13839 // 4:
13840 // 5:
13841 // 6:
46b94261 13842
2a98ceb8 13843 Int_t typeFlag = 0;
13844 Int_t ptEtaFlag = 0;
489d5531 13845 if(type == "RP")
13846 {
13847 typeFlag = 0;
13848 } else if(type == "POI")
13849 {
13850 typeFlag = 1;
13851 }
13852 if(ptOrEta == "Pt")
13853 {
13854 ptEtaFlag = 0;
13855 } else if(ptOrEta == "Eta")
13856 {
13857 ptEtaFlag = 1;
13858 }
13859 // shortcuts:
13860 Int_t t = typeFlag;
13861 Int_t pe = ptEtaFlag;
13862
13863 Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};
13864 Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};
13865 Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};
13866
13867 Int_t nPrim = anEvent->NumberOfTracks();
13868 AliFlowTrackSimple *aftsTrack = NULL;
13869
13870 Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;
13871 Double_t wPhi2=1., wPhi3=1.;
13872
13873 Int_t n = fHarmonic;
13874
13875 // 1'-particle correction terms:
13876 for(Int_t i1=0;i1<nPrim;i1++)
13877 {
13878 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13879 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13880 if(typeFlag==1) // this is diff flow of POIs
489d5531 13881 {
13882 if(ptOrEta == "Pt")
13883 {
13884 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13885 } else if (ptOrEta == "Eta")
13886 {
13887 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13888 }
13889 } else // this is diff flow of RPs
13890 {
489d5531 13891 if(ptOrEta == "Pt")
13892 {
13893 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13894 } else if (ptOrEta == "Eta")
13895 {
13896 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13897 }
489d5531 13898 }
13899 psi1=aftsTrack->Phi();
13900 // sin terms:
13901 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>
13902 // cos terms:
13903 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>
13904 }//end of for(Int_t i1=0;i1<nPrim;i1++)
13905
13906 // 2'-particle correction terms:
13907 for(Int_t i1=0;i1<nPrim;i1++)
13908 {
13909 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13910 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13911 if(typeFlag==1) // this is diff flow of POIs
489d5531 13912 {
13913 if(ptOrEta == "Pt")
13914 {
13915 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13916 } else if (ptOrEta == "Eta")
13917 {
13918 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13919 }
13920 } else // this is diff flow of RPs
13921 {
489d5531 13922 if(ptOrEta == "Pt")
13923 {
13924 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13925 } else if (ptOrEta == "Eta")
13926 {
13927 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13928 }
489d5531 13929 }
13930 psi1=aftsTrack->Phi();
13931 for(Int_t i2=0;i2<nPrim;i2++)
13932 {
13933 if(i2==i1) continue;
13934 aftsTrack=anEvent->GetTrack(i2);
13935 // RP condition (!(first) particle in the correlator must be RP):
13936 if(!(aftsTrack->InRPSelection())) continue;
46b94261 13937 phi2=aftsTrack->Phi();
489d5531 13938 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13939 // sin terms:
13940 fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),wPhi2); // <<w2 sin(n*(psi1+phi2))>>
13941 // cos terms:
13942 fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),wPhi2); // <<w2 cos(n*(psi1+phi2))>>
13943 }//end of for(Int_t i2=0;i2<nPrim;i2++)
13944 }//end of for(Int_t i1=0;i1<nPrim;i1++)
13945
13946 // 3'-particle correction terms:
13947 for(Int_t i1=0;i1<nPrim;i1++)
13948 {
13949 aftsTrack=anEvent->GetTrack(i1);
3b552efe 13950 // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)
13951 if(typeFlag==1) // this is diff flow of POIs
489d5531 13952 {
13953 if(ptOrEta == "Pt")
13954 {
13955 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
13956 } else if (ptOrEta == "Eta")
13957 {
13958 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;
3b552efe 13959 }
13960 } else // this is diff flow of RPs
13961 {
489d5531 13962 if(ptOrEta == "Pt")
13963 {
13964 if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
13965 } else if (ptOrEta == "Eta")
13966 {
13967 if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InRPSelection())))continue;
3b552efe 13968 }
489d5531 13969 }
13970 psi1=aftsTrack->Phi();
13971 for(Int_t i2=0;i2<nPrim;i2++)
13972 {
13973 if(i2==i1) continue;
13974 aftsTrack=anEvent->GetTrack(i2);
13975 // RP condition (!(first) particle in the correlator must be RP):
13976 if(!(aftsTrack->InRPSelection())) continue;
13977 phi2=aftsTrack->Phi();
13978 if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));
13979 for(Int_t i3=0;i3<nPrim;i3++)
13980 {
13981 if(i3==i1||i3==i2) continue;
13982 aftsTrack=anEvent->GetTrack(i3);
13983 // RP condition (!(first) particle in the correlator must be RP):
13984 if(!(aftsTrack->InRPSelection())) continue;
13985 phi3=aftsTrack->Phi();
13986 if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));
13987 // sin terms:
13988 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))>>
13989 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))>>
13990 // cos terms:
13991 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))>>
13992 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))>>
13993 }//end of for(Int_t i3=0;i3<nPrim;i3++)
13994 }//end of for(Int_t i2=0;i2<nPrim;i2++)
46b94261 13995 }//end of for(Int_t i1=0;i1<nPrim;i1++)
489d5531 13996
13997} // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)
13998
2001bc3a 13999//================================================================================================================================
14000
b3dacf6b 14001void AliFlowAnalysisWithQCumulants::CheckPointersUsedInFinish()
14002{
14003 // Check all pointers used in method Finish().
14004
b77b6434 14005 if(!fAvMultiplicity)
14006 {
14007 cout<<endl;
14008 cout<<" WARNING (QC): fAvMultiplicity is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14009 cout<<endl;
14010 exit(0);
14011 }
b3dacf6b 14012 if(!fIntFlowCorrelationsPro)
14013 {
14014 cout<<endl;
14015 cout<<" WARNING (QC): fIntFlowCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14016 cout<<endl;
14017 exit(0);
14018 }
b40a910e 14019 if(!fIntFlowSquaredCorrelationsPro)
14020 {
14021 cout<<endl;
14022 cout<<" WARNING (QC): fIntFlowSquaredCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14023 cout<<endl;
14024 exit(0);
14025 }
b3dacf6b 14026 if(!fIntFlowCorrelationsHist)
14027 {
14028 cout<<endl;
14029 cout<<" WARNING (QC): fIntFlowCorrelationsHist is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14030 cout<<endl;
14031 exit(0);
14032 }
403e3389 14033 if((fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights) && !fIntFlowExtraCorrelationsPro)
b77b6434 14034 {
14035 cout<<endl;
14036 cout<<" WARNING (QC): fIntFlowExtraCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14037 cout<<endl;
14038 exit(0);
14039 }
b3dacf6b 14040 for(Int_t power=0;power<2;power++)
14041 {
14042 if(!fIntFlowSumOfEventWeights[power])
14043 {
14044 cout<<endl;
14045 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeights[%d] is NULL in CheckPointersUsedInFinish() !!!!",power)<<endl;
14046 cout<<endl;
14047 exit(0);
14048 }
14049 } // end of for(Int_t power=0;power<2;power++)
14050 if(!fIntFlowProductOfCorrelationsPro)
14051 {
14052 cout<<endl;
14053 cout<<" WARNING (QC): fIntFlowProductOfCorrelationsPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14054 cout<<endl;
14055 exit(0);
14056 }
14057 if(!fIntFlowSumOfProductOfEventWeights)
14058 {
14059 cout<<endl;
14060 cout<<" WARNING (QC): fIntFlowSumOfProductOfEventWeights is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14061 cout<<endl;
14062 exit(0);
14063 }
14064 if(!fIntFlowCovariances)
14065 {
14066 cout<<endl;
14067 cout<<" WARNING (QC): fIntFlowCovariances is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14068 cout<<endl;
14069 exit(0);
14070 }
14071 if(!fIntFlowQcumulants)
14072 {
14073 cout<<endl;
14074 cout<<" WARNING (QC): fIntFlowQcumulants is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14075 cout<<endl;
14076 exit(0);
14077 }
0dd3b008 14078 if(!fIntFlow)
14079 {
14080 cout<<endl;
14081 cout<<" WARNING (QC): fIntFlow is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14082 cout<<endl;
14083 exit(0);
14084 }
14085 if(!fCommonHists)
14086 {
14087 cout<<endl;
14088 cout<<" WARNING (QC): fCommonHists is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14089 cout<<endl;
14090 exit(0);
14091 }
14092 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))
14093 {
14094 cout<<endl;
14095 cout<<" WARNING (QC): fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th"<<endl;
14096 cout<<" && fCommonHistsResults8th is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14097 cout<<endl;
14098 exit(0);
14099 }
b3dacf6b 14100
b92ea2b9 14101 // NUA stuff:
14102 for(Int_t sc=0;sc<2;sc++) // sin/cos
14103 {
14104 if(!fIntFlowCorrectionTermsForNUAPro[sc])
14105 {
14106 cout<<endl;
14107 cout<<Form(" WARNING (QC): fIntFlowCorrectionTermsForNUAPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",sc)<<endl;
14108 cout<<endl;
14109 exit(0);
14110 }
14111 if(!fIntFlowCorrectionTermsForNUAHist[sc])
14112 {
14113 cout<<endl;
14114 cout<<Form(" WARNING (QC): fIntFlowCorrectionTermsForNUAHist[%d] is NULL in CheckPointersUsedInFinish() !!!!",sc)<<endl;
14115 cout<<endl;
14116 exit(0);
14117 }
14118 for(Int_t lq=0;lq<2;lq++) // linear/quadratic
14119 {
14120 if(!fIntFlowSumOfEventWeightsNUA[sc][lq])
14121 {
14122 cout<<endl;
14123 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeightsNUA[%d][%d] is NULL in CheckPointersUsedInFinish() !!!!",sc,lq)<<endl;
14124 cout<<endl;
14125 exit(0);
14126 }
14127 } // end of for(Int_t lq=0;lq<2;lq++) // linear/quadratic
14128 } // end of for(Int_t power=0;power<2;power++)
14129 if(!fIntFlowProductOfCorrectionTermsForNUAPro)
14130 {
14131 cout<<endl;
14132 cout<<" WARNING (QC): fIntFlowProductOfCorrectionTermsForNUAPro is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14133 cout<<endl;
14134 exit(0);
14135 }
14136 if(!fIntFlowSumOfProductOfEventWeightsNUA)
14137 {
14138 cout<<endl;
14139 cout<<" WARNING (QC): fIntFlowSumOfProductOfEventWeightsNUA is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14140 cout<<endl;
14141 exit(0);
14142 }
14143 if(!fIntFlowCovariancesNUA)
14144 {
14145 cout<<endl;
14146 cout<<" WARNING (QC): fIntFlowCovariancesNUA is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14147 cout<<endl;
14148 exit(0);
14149 }
14150 if(!fIntFlowQcumulantsErrorSquaredRatio)
14151 {
14152 cout<<endl;
14153 cout<<" WARNING (QC): fIntFlowQcumulantsErrorSquaredRatio is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14154 cout<<endl;
14155 exit(0);
14156 }
14157 if(!fIntFlowDetectorBias)
14158 {
14159 cout<<endl;
14160 cout<<" WARNING (QC): fIntFlowDetectorBias is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14161 cout<<endl;
14162 exit(0);
14163 }
14164
b3dacf6b 14165 // Versus multiplicity:
14166 if(!fCalculateCumulantsVsM){return;}
b77b6434 14167 for(Int_t co=0;co<=3;co++) // cumulant order
b3dacf6b 14168 {
b77b6434 14169 if(!fIntFlowQcumulantsVsM[co])
b3dacf6b 14170 {
14171 cout<<endl;
b77b6434 14172 cout<<Form(" WARNING (QC): fIntFlowQcumulantsVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
b3dacf6b 14173 cout<<endl;
14174 exit(0);
14175 }
b77b6434 14176 if(!fIntFlowVsM[co])
b3dacf6b 14177 {
14178 cout<<endl;
b77b6434 14179 cout<<Form(" WARNING (QC): fIntFlowVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
14180 cout<<endl;
14181 exit(0);
14182 }
14183 if(!fIntFlowDetectorBiasVsM[co])
14184 {
14185 cout<<endl;
14186 cout<<Form(" WARNING (QC): fIntFlowDetectorBiasVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",co)<<endl;
14187 cout<<endl;
14188 exit(0);
14189 }
14190 } // end of for(Int_t c0=0;c0<=3;c0++) // cumulant order
14191 for(Int_t ci=0;ci<=3;ci++) // correlation index
14192 {
14193 if(!fIntFlowCorrelationsVsMPro[ci])
14194 {
14195 cout<<endl;
14196 cout<<Form(" WARNING (QC): fIntFlowCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
b3dacf6b 14197 cout<<endl;
14198 exit(0);
14199 }
b40a910e 14200 if(!fIntFlowSquaredCorrelationsVsMPro[ci])
14201 {
14202 cout<<endl;
14203 cout<<Form(" WARNING (QC): fIntFlowSquaredCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
14204 cout<<endl;
14205 exit(0);
14206 }
b77b6434 14207 if(!fIntFlowCorrelationsVsMHist[ci])
b92ea2b9 14208 {
14209 cout<<endl;
b77b6434 14210 cout<<Form(" WARNING (QC): fIntFlowCorrelationsVsMHist[%d] is NULL in CheckPointersUsedInFinish() !!!!",ci)<<endl;
b92ea2b9 14211 cout<<endl;
14212 exit(0);
14213 }
b3dacf6b 14214 for(Int_t power=0;power<2;power++)
14215 {
14216 if(!fIntFlowSumOfEventWeightsVsM[ci][power])
14217 {
14218 cout<<endl;
14219 cout<<Form(" WARNING (QC): fIntFlowSumOfEventWeightsVsM[%d][%d] is NULL in CheckPointersUsedInFinish() !!!!",ci,power)<<endl;
14220 cout<<endl;
14221 exit(0);
14222 }
14223 } // end of for(Int_t power=0;power<2;power++)
14224 } // end of for(Int_t ci=0;ci<=3;ci++) // correlation index
14225 for(Int_t i=0;i<6;i++)
14226 {
14227 if(!fIntFlowProductOfCorrelationsVsMPro[i])
14228 {
14229 cout<<endl;
14230 cout<<Form(" WARNING (QC): fIntFlowProductOfCorrelationsVsMPro[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14231 cout<<endl;
14232 exit(0);
14233 }
14234 if(!fIntFlowSumOfProductOfEventWeightsVsM[i])
14235 {
14236 cout<<endl;
14237 cout<<Form(" WARNING (QC): fIntFlowSumOfProductOfEventWeightsVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14238 cout<<endl;
14239 exit(0);
14240 }
14241 if(!fIntFlowCovariancesVsM[i])
14242 {
14243 cout<<endl;
14244 cout<<Form(" WARNING (QC): fIntFlowCovariancesVsM[%d] is NULL in CheckPointersUsedInFinish() !!!!",i)<<endl;
14245 cout<<endl;
14246 exit(0);
14247 }
14248 } // end of for(Int_t i=0;i<6;i++)
14249 if(!fIntFlowRebinnedInM)
14250 {
14251 cout<<endl;
14252 cout<<" WARNING (QC): fIntFlowRebinnedInM is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14253 cout<<endl;
14254 exit(0);
14255 }
14256 if(!fIntFlowQcumulantsRebinnedInM)
14257 {
14258 cout<<endl;
14259 cout<<" WARNING (QC): fIntFlowQcumulantsRebinnedInM is NULL in CheckPointersUsedInFinish() !!!!"<<endl;
14260 cout<<endl;
14261 exit(0);
14262 }
14263
14264} // end of void AliFlowAnalysisWithQCumulants::CheckPointersUsedInFinish()
14265
14266//================================================================================================================================
14267
14268void AliFlowAnalysisWithQCumulants::CheckPointersUsedInMake()
14269{
1268c371 14270 // Check all pointers used in method Make(). // to be improved - check other pointers as well
b3dacf6b 14271
b77b6434 14272 if(!fAvMultiplicity)
14273 {
1268c371 14274 printf("\n WARNING (QC): fAvMultiplicity is NULL in CheckPointersUsedInMake() !!!!\n\n");
b77b6434 14275 exit(0);
14276 }
403e3389 14277 if((fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights) && !fIntFlowExtraCorrelationsPro)
b77b6434 14278 {
1268c371 14279 printf("\n WARNING (QC): fIntFlowExtraCorrelationsPro is NULL in CheckPointersUsedInMake() !!!!\n\n");
b77b6434 14280 exit(0);
14281 }
1268c371 14282 // 2D:
14283 if(fCalculate2DDiffFlow)
14284 {
14285 for(Int_t t=0;t<2;t++) // type = RP or POI
14286 {
14287 for(Int_t rci=0;rci<4;rci++) // reduced correlation index
14288 {
14289 if(!f2DDiffFlowCorrelationsPro[t][rci])
14290 {
14291 printf("\n WARNING (QC): f2DDiffFlowCorrelationsPro[%i][%i] is NULL in CheckPointersUsedInMake() !!!!\n\n",t,rci);
14292 exit(0);
14293 } // end of if(!f2DDiffFlowCorrelationsPro[t][rci])
14294 } // end of for(Int_t rci=0;rci<4;rci++) // reduced correlation index
14295 } // end of for(Int_t t=0;t<2;t++)
14296 } // end of if(fCalculate2DDiffFlow)
b3dacf6b 14297
14298} // end of void AliFlowAnalysisWithQCumulants::CheckPointersUsedInMake()
14299
57340a27 14300