AliPhysics  c923f52 (c923f52)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
AliFlowAnalysisCRC.cxx
Go to the documentation of this file.
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  * Charge-rapidity correlations with Q-cumulants *
18  * *
19  * author: Jacopo Margutti *
20  * (margutti@nikhef.nl) *
21  *************************************************/
22 
23 #define AliFlowAnalysisCRC_cxx
24 
25 #include "Riostream.h"
26 #include "AliFlowCommonConstants.h"
27 #include "AliFlowCommonHist.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"
39 #include "TProfile3D.h"
40 #include "TMath.h"
41 #include "TArrow.h"
42 #include "TPaveLabel.h"
43 #include "TCanvas.h"
44 #include "AliFlowEventSimple.h"
45 #include "AliFlowVector.h"
46 #include "AliFlowTrackSimple.h"
47 #include "AliFlowAnalysisCRC.h"
48 #include "TRandom.h"
49 #include "TF1.h"
50 #include "TNtuple.h"
51 #include "THnSparse.h"
52 #include <cmath>
53 
54 //using std::isfinite;
55 
56 class TH1;
57 class TH2;
58 class TGraph;
59 class TPave;
60 class TLatex;
61 class TMarker;
62 class TRandom3;
63 class TObjArray;
64 class TList;
65 class TCanvas;
66 class TSystem;
67 class TROOT;
68 class AliFlowVector;
69 class TVector;
70 
71 //==============================================================================================================
72 
73 using std::endl;
74 using std::cout;
75 using std::flush;
77 
78 AliFlowAnalysisCRC::AliFlowAnalysisCRC(const char* name,
79  Int_t nCen,
80  Double_t CenWidth):
81 TNamed(name,name),
82 // 0.) base:
83 fHistList(NULL),
84 // 1.) common:
85 fBookOnlyBasicCCH(kTRUE),
86 fCommonHists(NULL),
87 fCommonHists2nd(NULL),
88 fCommonHists4th(NULL),
89 fCommonHists6th(NULL),
90 fCommonHists8th(NULL),
91 fCommonHistsResults2nd(NULL),
92 fCommonHistsResults4th(NULL),
93 fCommonHistsResults6th(NULL),
94 fCommonHistsResults8th(NULL),
95 fnBinsPhi(0),
96 fPhiMin(0),
97 fPhiMax(0),
98 fPhiBinWidth(0),
99 fnBinsPt(0),
100 fPtMin(0),
101 fPtMax(0),
102 fPtBinWidth(0),
103 fnBinsEta(0),
104 fEtaMin(0),
105 fEtaMax(0),
106 fEtaBinWidth(0),
107 fCommonConstants(NULL),
108 fFillMultipleControlHistograms(kFALSE),
109 fHarmonic(1),
110 fAnalysisLabel(NULL),
111 // 2a.) particle weights:
112 fUsePhiWeights(kFALSE),
113 fUsePtWeights(kFALSE),
114 fUseEtaWeights(kFALSE),
115 fUseTrackWeights(kFALSE),
116 fUsePhiEtaWeights(kFALSE),
117 fUseZDCESEMulWeights(kFALSE),
118 fUseZDCESESpecWeights(kFALSE),
119 fUseParticleWeights(NULL),
120 // 2b.) event weights:
121 fMultiplicityWeight(NULL),
122 fMultiplicityIs(AliFlowCommonConstants::kRP),
123 // 3.) integrated flow:
124 fIntFlowList(NULL),
125 fIntFlowProfiles(NULL),
126 fIntFlowResults(NULL),
127 fIntFlowAllCorrelationsVsM(NULL),
128 fIntFlowFlags(NULL),
129 fApplyCorrectionForNUA(kFALSE),
130 fApplyCorrectionForNUAVsM(kFALSE),
131 fnBinsMult(10000),
132 fMinMult(0.),
133 fMaxMult(10000.),
134 fPropagateErrorAlsoFromNIT(kFALSE),
135 fCalculateCumulantsVsM(kFALSE),
136 fCalculateAllCorrelationsVsM(kFALSE),
137 fMinimumBiasReferenceFlow(kTRUE),
138 fForgetAboutCovariances(kFALSE),
139 fStoreVarious(kFALSE),
140 fExactNoRPs(0),
141 fUse2DHistograms(kFALSE),
142 fFillProfilesVsMUsingWeights(kTRUE),
143 fUseQvectorTerms(kFALSE),
144 fReQ(NULL),
145 fImQ(NULL),
146 fSpk(NULL),
147 fIntFlowCorrelationsEBE(NULL),
148 fIntFlowEventWeightsForCorrelationsEBE(NULL),
149 fIntFlowCorrelationsAllEBE(NULL),
150 fNumberOfRPsEBE(0.),
151 fNumberOfPOIsEBE(0.),
152 fReferenceMultiplicityEBE(0.),
153 fCentralityEBE(0.),
154 fNewCentralityEBE(0.),
155 fZDCESEclEbE(0),
156 fNewMetricLEBE(0.),
157 fNewMetricDEBE(0.),
158 fNewMetricL2EBE(0.),
159 fNewMetricD2EBE(0.),
160 fCentralityCL1EBE(0.),
161 fNITSCL1EBE(0.),
162 fCentralityTRKEBE(0.),
163 fZNCen(0.),
164 fZNAen(0.),
165 fEnNucl(1.),
166 fAvMultiplicity(NULL),
167 fIntFlowCorrelationsPro(NULL),
168 fIntFlowSquaredCorrelationsPro(NULL),
169 fIntFlowCorrelationsAllPro(NULL),
170 fIntFlowExtraCorrelationsPro(NULL),
171 fIntFlowProductOfCorrelationsPro(NULL),
172 fIntFlowProductOfCorrectionTermsForNUAPro(NULL),
173 fIntFlowCorrelationsHist(NULL),
174 fIntFlowCorrelationsAllHist(NULL),
175 fIntFlowCovariances(NULL),
176 fIntFlowSumOfProductOfEventWeights(NULL),
177 fIntFlowCovariancesNUA(NULL),
178 fIntFlowSumOfProductOfEventWeightsNUA(NULL),
179 fIntFlowQcumulants(NULL),
180 fIntFlowQcumulantsRebinnedInM(NULL),
181 fIntFlowQcumulantsErrorSquaredRatio(NULL),
182 fIntFlow(NULL),
183 fIntFlowRebinnedInM(NULL),
184 fIntFlowDetectorBias(NULL),
185 // 4.) differential flow:
186 fDiffFlowList(NULL),
187 fDiffFlowProfiles(NULL),
188 fDiffFlowResults(NULL),
189 fDiffFlow2D(NULL),
190 fDiffFlowFlags(NULL),
191 fCalculateDiffFlow(kTRUE),
192 fCalculate2DDiffFlow(kFALSE),
193 fCalculateDiffFlowVsEta(kTRUE),
194 // 5.) other differential correlators:
195 fOtherDiffCorrelatorsList(NULL),
196 // 6.) distributions:
197 fDistributionsList(NULL),
198 fDistributionsFlags(NULL),
199 fStoreDistributions(kFALSE),
200 fnBinsForCorrelations(10000),
201 // 8.) debugging and cross-checking:
202 fNestedLoopsList(NULL),
203 fEvaluateIntFlowNestedLoops(kFALSE),
204 fEvaluateDiffFlowNestedLoops(kFALSE),
205 fMaxAllowedMultiplicity(10),
206 fEvaluateNestedLoops(NULL),
207 fIntFlowDirectCorrelations(NULL),
208 fIntFlowExtraDirectCorrelations(NULL),
209 fCrossCheckInPtBinNo(10),
210 fCrossCheckInEtaBinNo(20),
211 fNoOfParticlesInBin(NULL),
212 fMixedHarmonicsNestedLoops(NULL),
213 // 9.) mixed harmonics:
214 fMixedHarmonicsList(NULL),
215 fMixedHarmonicsProfiles(NULL),
216 fMixedHarmonicsResults(NULL),
217 fMixedHarmonicsErrorPropagation(NULL),
218 fMixedHarmonicsFlags(NULL),
219 fCalculateMixedHarmonics(kFALSE),
220 fCalculateMixedHarmonicsVsM(kFALSE),
221 f2pCorrelations(NULL),
222 f3pCorrelations(NULL),
223 f4pCorrelations(NULL),
224 f5pCorrelations(NULL),
225 f6pCorrelations(NULL),
226 f7pCorrelations(NULL),
227 f8pCorrelations(NULL),
228 f2pCumulants(NULL),
229 f3pCumulants(NULL),
230 f4pCumulants(NULL),
231 f5pCumulants(NULL),
232 f6pCumulants(NULL),
233 f7pCumulants(NULL),
234 f8pCumulants(NULL),
235 fMixedHarmonicProductOfEventWeights(NULL),
236 fMixedHarmonicProductOfCorrelations(NULL),
237 // 10.) Control histograms:
238 fControlHistogramsList(NULL),
239 fControlHistogramsFlags(NULL),
240 fStoreControlHistograms(kFALSE),
241 fCorrelationNoRPsVsRefMult(NULL),
242 fCorrelationNoPOIsVsRefMult(NULL),
243 fCorrelationNoRPsVsNoPOIs(NULL),
244 // 11.) Bootstrap:
245 fBootstrapList(NULL),
246 fBootstrapProfilesList(NULL),
247 fBootstrapResultsList(NULL),
248 fBootstrapFlags(NULL),
249 fUseBootstrap(kFALSE),
250 fUseBootstrapVsM(kFALSE),
251 fnSubsamples(10),
252 fRandom(NULL),
253 fBootstrapCorrelations(NULL),
254 fBootstrapCumulants(NULL),
255 // 12.) Charge-Eta Asymmetry:
256 fCRCList(NULL),
257 fTempList(NULL),
258 fCRCFlags(NULL),
259 fCalculateCRC(kTRUE),
260 fCalculateCRCPt(kFALSE),
261 fCalculateCME(kFALSE),
262 fCalculateCRC2(kFALSE),
263 fCalculateCRCVZ(kFALSE),
264 fCalculateCRCZDC(kFALSE),
265 fCalculateFlowQC(kFALSE),
266 fCalculateFlowZDC(kFALSE),
267 fCalculateFlowVZ(kFALSE),
268 fCalculateEbEFlow(kFALSE),
269 fUseVZERO(kFALSE),
270 fUseZDC(kFALSE),
271 fRecenterZDC(kFALSE),
272 fNUAforCRC(kFALSE),
273 fUseCRCRecenter(kFALSE),
274 fDivSigma(kTRUE),
275 fInvertZDC(kFALSE),
276 fCRCTestSin(kFALSE),
277 fCRCEtaMin(0.),
278 fCRCEtaMax(0.),
279 fRunNum(0),
280 fCachedRunNum(0),
281 fRunBin(0),
282 fCenBin(0),
283 fCorrWeightTPC(kUnit),
284 fCorrWeightVZ(kUnit),
285 fCorrWeightZDC(kUnit),
286 fCRCIntList(NULL),
287 fCRCnCen(nCen),
288 fCRCCenBinWidth(CenWidth),
289 fCRCIntRbRList(NULL),
290 fCRCnRun(211),
291 fDataSet(kAny),
292 fMPolSelec(kMAll),
293 fCRCQVecList(NULL),
294 fCRCQVecWeightsList(NULL),
295 fCRCZDCCalibList(NULL),
296 fZDCESEList(NULL),
297 fCRCVZList(NULL),
298 fCRCVZRbRList(NULL),
299 fCRCZDCList(NULL),
300 fCRCZDCRbRList(NULL),
301 fCRCPtList(NULL),
302 fCMEList(NULL),
303 fCMETPCList(NULL),
304 fCMEZDCList(NULL),
305 fCRC2List(NULL),
306 fCRC2nEtaBins(6),
307 fCRC2RbRList(NULL),
308 fFlowSPZDCList(NULL),
309 fFlowSPZDCRbRList(NULL),
310 fFlowQCList(NULL),
311 fFlowQCCenBin(100),
312 fFlowQCDeltaEta(0.4),
313 fFlowSPVZList(NULL),
314 fVariousList(NULL),
315 fEbEFlowList(NULL),
316 fCenWeightEbE(0.),
317 fQAZDCCuts(kFALSE),
318 fQAZDCCutsFlag(kTRUE),
319 fMinMulZN(0),
320 fMaxDevZN(5.)
321 {
322  // constructor
323 
324  // base list to hold all output objects:
325  fHistList = new TList();
326  fHistList->SetName("cobjQC");
327  fHistList->SetOwner(kTRUE);
328 
329  // base list to hold all temp objects:
330  fTempList = new TList();
331  fTempList->SetName("temp");
332  fTempList->SetOwner(kTRUE);
333 
334  // multiplicity weight:
335  fMultiplicityWeight = new TString("combinations");
336 
337  // analysis label;
338  fAnalysisLabel = new TString();
339 
340  // initialize all arrays:
341  this->InitializeArraysForIntFlow();
342  this->InitializeArraysForDiffFlow();
343  this->InitializeArraysForDistributions();
344  this->InitializeArraysForVarious();
345  this->InitializeArraysForParticleWeights();
346  this->InitializeArraysForNestedLoops();
347  this->InitializeArraysForMixedHarmonics();
348  this->InitializeArraysForControlHistograms();
349  this->InitializeArraysForBootstrap();
350 
351  fRunList = TArrayI();
352 
353  // CRC
354  this->InitializeCostantsForCRC();
355  this->InitializeArraysForCRC();
356  this->InitializeArraysForCRCVZ();
357  this->InitializeArraysForCRCZDC();
358  this->InitializeArraysForCRC2();
359  this->InitializeArraysForQVec();
360  this->InitializeArraysForCRCPt();
361  this->InitializeArraysForCME();
362  this->InitializeArraysForFlowEbE();
363  this->InitializeArraysForFlowQC();
364  this->InitializeArraysForFlowSPZDC();
365  this->InitializeArraysForFlowSPVZ();
366  this->InitializeArraysForEbEFlow();
367 
368  // printf("Arrays initialized \n");
369 
370 } // end of constructor
371 
372 //================================================================================================================
373 
375 {
376  // destructor
377  delete fHistList;
378  delete fTempList;
379  delete[] fCRCPtvarPtBins;
380  delete[] fCRCPtBins;
381  delete[] fCorrMap;
382  delete[] fchisqVA;
383  delete[] fchisqVC;
384 } // end of AliFlowAnalysisCRC::~AliFlowAnalysisCRC()
385 
386 //================================================================================================================
387 
389 {
390  // a) Cross check if the settings make sense before starting the QC adventure;
391  // b) Access all common constants;
392  // c) Book all objects;
393  // d) Store flags for integrated and differential flow;
394  // e) Store flags for distributions of corelations;
395  // f) Store harmonic which will be estimated;
396  // g) Store flags for mixed harmonics;
397  // h) Store flags for control histograms;
398  // i) Store bootstrap flags.
399 
400  //save old value and prevent histograms from being added to directory
401  //to avoid name clashes in case multiple analaysis objects are used
402  //in an analysis
403  Bool_t oldHistAddStatus = TH1::AddDirectoryStatus();
404  TH1::AddDirectory(kFALSE);
405 
406  // a) Cross check if the settings make sense before starting the QC adventure;
407  this->CrossCheckSettings();
408  // b) Access all common constants and book a profile to hold them:
409  this->CommonConstants("Init");
410  // c) Book all objects:
412  this->BookAndNestAllLists();
413  this->BookCommonHistograms();
422  this->SetRunList();
423  this->BookEverythingForCRC();
424  this->BookEverythingForCRCVZ();
425  this->BookEverythingForCRCZDC();
426  this->BookEverythingForCRCPt();
427  this->BookEverythingForCRC2();
428  this->BookEverythingForQVec();
429  this->BookEverythingForCME();
430  this->BookEverythingForFlowEbE();
431  this->BookEverythingForFlowQC();
434  this->BookEverythingForEbEFlow();
435  this->BookEverythingForVarious();
436 
437  this->SetCentralityWeights();
438 
439  // d) Store flags for integrated and differential flow:
440  this->StoreIntFlowFlags();
441  this->StoreDiffFlowFlags();
442  // e) Store flags for distributions of corelations:
444  // f) Store harmonic which will be estimated:
445  this->StoreHarmonic();
446  // g) Store flags for mixed harmonics:
447  this->StoreMixedHarmonicsFlags();
448  // h) Store flags for control histograms:
450  // i) Store bootstrap flags:
451  this->StoreBootstrapFlags();
452  // j) Store CRC flags:
453  this->StoreCRCFlags();
454 
455  TH1::AddDirectory(oldHistAddStatus);
456 
457  // printf("Stuff booked \n");
458 
459 } // end of void AliFlowAnalysisCRC::Init()
460 
461 //================================================================================================================
462 
464 {
465  // Running over data only in this method.
466  // a) Check all pointers used in this method;
467  // b) Define local variables;
468  // c) Fill the common control histograms and call the method to fill fAvMultiplicity;
469  // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k};
470  // d.1) initialize particle weights
471  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!);
472  // f) Call the methods which calculate correlations for reference flow;
473  // g) Call the methods which calculate correlations for differential flow;
474  // h) Call the methods which calculate correlations for 2D differential flow;
475  // i) Call the methods which calculate other differential correlators;
476  // j) Distributions of correlations;
477  // k) Store various;
478  // l) Cross-check with nested loops correlators for reference flow;
479  // m) Cross-check with nested loops correlators for differential flow;
480  // n) Reset all event-by-event quantities (very important !!!!).
481 
482  // a) Check all pointers used in this method:
483  this->CheckPointersUsedInMake();
484 
485  // b) Define local variables:
486  Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
487  Double_t dPt = 0.; // transverse momentum
488  Double_t dEta = 0.; // pseudorapidity
489  Double_t wPhi = 1.; // phi weight
490  Double_t wPt = 1.; // pt weight
491  Double_t wEta = 1.; // eta weight
492  Double_t wTrack = 1.; // track weight
493  Double_t wPhiEta = 1.;
494  Int_t nCounterNoRPs = 0; // needed only for shuffling
495  fNumberOfRPsEBE = anEvent->GetNumberOfRPs(); // number of RPs (i.e. number of reference particles)
496  fNumberOfPOIsEBE = anEvent->GetNumberOfPOIs(); // number of POIs (i.e. number of particles of interest)
497  fReferenceMultiplicityEBE = anEvent->GetReferenceMultiplicity(); // reference multiplicity for current event
498  fCentralityEBE = anEvent->GetCentrality(); // centrality percentile for current event
499  fCentralityCL1EBE = anEvent->GetCentralityCL1(); // centrality percentile for current event (alternative estimation)
500  fCentralityTRKEBE = anEvent->GetCentralityTRK(); // centrality percentile for current event (alternative estimation)
501  fNITSCL1EBE = anEvent->GetNITSCL1();
502 
503 // printf("debug: NoRPs %e, NoPOIs %e, RunNum %d, Cen %e \n",fNumberOfRPsEBE,fNumberOfPOIsEBE,fRunNum,fCentralityEBE);
504 
505  if(fExactNoRPs > 0 && fNumberOfRPsEBE<fExactNoRPs){return;}
506  if(!fCentralityEBE){return;}
507  if(!fNumberOfRPsEBE || !fNumberOfPOIsEBE){return;}
508 
509  // centrality flattening with weights
510  fCenWeightEbE = 1.;
512 
513  // primary vertex position (x,y,z)
514  anEvent->GetVertexPosition(fVtxPos);
515 
516  Double_t ptEta[2] = {0.,0.}; // 0 = dPt, 1 = dEta
517  Int_t dCharge = 0; // charge
518 
519  // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k}:
520  Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks
521  AliFlowTrackSimple *aftsTrack = NULL;
522  Int_t n = fHarmonic; // shortcut for the harmonic
523 
524  // d.1) Initialize particle weights
525  Int_t cw = 0;
526 
527  if (fDataSet==kAny) {fRunBin = 0;}
528  else {fRunBin = GetCRCRunBin(fRunNum);}
529  if(fRunBin<0 || fRunBin>=fCRCnRun) {return;}
531  if(fCenBin<0 || fCenBin>=fCRCnCen) {return;}
532 
533  // determine phi,eta weight for POI && RP particle:
535 
536  if(fRunNum!=fCachedRunNum) {
537  for(Int_t h=0;h<fCRCnCen;h++) {
538  for(Int_t k=0; k<2; k++) {
539  fRunPhiEtaHist[h][k] = (TH2D*)(fWeightsList->FindObject(Form("Run %d",fRunNum))->FindObject(Form("fCRCPhiHist[%d][%d][%d]",fRunNum,h,k)));
540  }
541  }
542  }
543 
544  Int_t nBinsEta = fRunPhiEtaHist[0][0]->GetNbinsY();
545  Int_t nBinsPhi = fRunPhiEtaHist[0][0]->GetNbinsX();
546 
547  Double_t PhiEtaAv = 0.;
548  for(Int_t k=0; k<2; k++) {
549  PhiEtaAv = 0.;
550  if(fRunPhiEtaHist[fCenBin][k]) {
551  for(Int_t i=1; i<=nBinsEta; i++) {
552  for (Int_t j=1; j<=nBinsPhi; j++) {
553  PhiEtaAv += fRunPhiEtaHist[fCenBin][k]->GetBinContent(j,i);
554  }
555  }
556  PhiEtaAv /= 1.*nBinsPhi*nBinsEta;
557  for(Int_t i=1; i<=nBinsEta; i++) {
558  for (Int_t j=1; j<=nBinsPhi; j++) {
559  Double_t Val = fRunPhiEtaHist[fCenBin][k]->GetBinContent(j,i);
560  fPhiEtaWeights[k]->SetBinContent(j,i,PhiEtaAv/Val);
561  }
562  }
563  } else cout << " WARNING: fPhiEtaWeights not found !!! " << endl;
564  } // end of for(Int_t k=0; k<2; k++)
565 
566  } // end of if(fUsePhiEtaWeights && fWeightsList)
567 
568  // VZERO *********************************************************************************************************
569 
570  if(fUseVZERO) {
571  for(Int_t h=0; h<fCRCnHar; h++) {
572  // Get Q vectors for the subevents
573  AliFlowVector vQarray[2];
574  anEvent->Get2Qsub(vQarray,h+1);
575  fVZFlowVect[0][h] = vQarray[0];
576  fVZFlowVect[1][h] = vQarray[1];
577  } // end of for(Int_t h=0; h<fCRCnHar; h++)
578  } // end of if(fUseVZERO)
579 
580  // ZDC *********************************************************************************************************
581 
582  if(fUseZDC) {
583  // Get Q vectors for the subevents
584  AliFlowVector vQarray[2];
585  anEvent->GetZDC2Qsub(vQarray);
586  fZDCFlowVect[0] = vQarray[0];
587  fZDCFlowVect[1] = vQarray[1];
588  fZNCen = anEvent->GetZNCEnergy()/fEnNucl;
589  fZNAen = anEvent->GetZNAEnergy()/fEnNucl;
590  } // end of if(fUseZDC)
591 
592  this->CalculateCRCQVec();
593  if(fRecenterZDC) {
594  this->RecenterCRCQVecZDC();
595  }
596  // ZDC-C (eta < -8.8)
597  Double_t ZCRe = fZDCFlowVect[0].X();
598  Double_t ZCIm = fZDCFlowVect[0].Y();
599  Double_t ZCM = fZDCFlowVect[0].GetMult();
600  // ZDC-A (eta > 8.8)
601  Double_t ZARe = fZDCFlowVect[1].X();
602  Double_t ZAIm = fZDCFlowVect[1].Y();
603  Double_t ZAM = fZDCFlowVect[1].GetMult();
604  if( fInvertZDC ) ZARe = -ZARe;
605 
606  if(fCalculateCRC) {
608  }
609 
610  // EbE flow *********************************************************************************************************
611 
612  if(fCalculateEbEFlow) {
613  if(fNumberOfPOIsEBE>0 && fNumberOfPOIsEBE<=2500) {
615  } else {
616  fEBEFlowMulBin = -1;
617  }
618  }
619 
620  // loop over particles **********************************************************************************************
621 
622  for(Int_t i=0;i<nPrim;i++) {
623  if(fExactNoRPs > 0 && nCounterNoRPs>fExactNoRPs){continue;}
624  aftsTrack=anEvent->GetTrack(i);
625  if(aftsTrack) {
626  if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())){continue;} // safety measure: consider only tracks which are RPs or POIs
627 
628  // RPs *********************************************************************************************************
629 
630  if(aftsTrack->InRPSelection()) {
631  nCounterNoRPs++;
632  dPhi = aftsTrack->Phi();
633  dPt = aftsTrack->Pt();
634  dEta = aftsTrack->Eta();
635  wPhi = 1.;
636  wPt = 1.;
637  wEta = 1.;
638  wPhiEta = 1.;
639  wTrack = 1.;
640  // if(fUsePhiWeights && fPhiWeightsRPs && fnBinsPhi) // determine phi weight for POI:
641  // {
642  // wPhi = fPhiWeightsRPs->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
643  // }
644  // if(fUsePtWeights) // determine pt weight for POI:
645  // {
646  // wPt = 1.;
647  // }
648  // if(fUseEtaWeights && fEtaWeightsRPs && fEtaBinWidth) // determine eta weight for POI:
649  // {
650  // wEta = fEtaWeightsRPs->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
651  // }
652  // if(fUsePhiEtaWeights && fPhiEtaWeightsPOIs[cw] && fnBinsPhi && fEtaBinWidth) // determine eta weight for POI:
653  // {
654  // wPhiEta = fPhiEtaWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())),1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
655  // }
656  // if(aftsTrack->InPOISelection() && fUseTrackWeights) // Access track weight for POI && RP particle:
657  // {
658  // wTrack = aftsTrack->Weight();
659  // }
660  // Calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}] for this event (m = 1,2,...,12, k = 0,1,...,8):
661  for(Int_t m=0;m<12;m++) // to be improved - hardwired 6
662  {
663  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
664  {
665  (*fReQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1)*n*dPhi);
666  (*fImQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1)*n*dPhi);
667  }
668  }
669  // Calculate S_{p,k} for this event (Remark: final calculation of S_{p,k} follows after the loop over data bellow):
670  for(Int_t p=0;p<8;p++)
671  {
672  for(Int_t k=0;k<9;k++)
673  {
674  (*fSpk)(p,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k);
675  }
676  }
677  // Differential flow:
679  {
680  ptEta[0] = dPt;
681  ptEta[1] = dEta;
682  // Calculate r_{m*n,k} and s_{p,k} (r_{m,k} is 'p-vector' for RPs):
683  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
684  {
685  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
686  {
688  {
689  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
690  {
691  fReRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
692  fImRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
693  if(m==0) // s_{p,k} does not depend on index m
694  {
695  fs1dEBE[0][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
696  } // end of if(m==0) // s_{p,k} does not depend on index m
697  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
698  } // end of if(fCalculateDiffFlow)
700  {
701  fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
702  fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
703  if(m==0) // s_{p,k} does not depend on index m
704  {
705  fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
706  } // end of if(m==0) // s_{p,k} does not depend on index m
707  } // end of if(fCalculate2DDiffFlow)
708  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
709  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
710  // Checking if RP particle is also POI particle:
711  if(aftsTrack->InPOISelection())
712  {
713  // Calculate q_{m*n,k} and s_{p,k} ('q-vector' and 's' for RPs && POIs):
714  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
715  {
716  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
717  {
719  {
720  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
721  {
722  fReRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
723  fImRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
724  if(m==0) // s_{p,k} does not depend on index m
725  {
726  fs1dEBE[2][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
727  } // end of if(m==0) // s_{p,k} does not depend on index m
728  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
729  } // end of if(fCalculateDiffFlow)
731  {
732  fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
733  fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
734  if(m==0) // s_{p,k} does not depend on index m
735  {
736  fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
737  } // end of if(m==0) // s_{p,k} does not depend on index m
738  } // end of if(fCalculate2DDiffFlow)
739  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
740  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
741  } // end of if(aftsTrack->InPOISelection())
742  } // end of if(fCalculateDiffFlow || fCalculate2DDiffFlow)
743 
744  } // end of if(pTrack->InRPSelection())
745 
746  // POIs ********************************************************************************************************
747 
748  if(aftsTrack->InPOISelection()) {
749  dPhi = aftsTrack->Phi();
750  dPt = aftsTrack->Pt();
751  dEta = aftsTrack->Eta();
752  dCharge = aftsTrack->Charge();
753  if (dCharge > 0.) cw = 0;
754  else if (dCharge < 0.) cw = 1;
755  wPhi = 1.;
756  wPt = 1.;
757  wEta = 1.;
758  wTrack = 1.;
759  wPhiEta = 1.;
760  // if(fUsePhiWeights && fPhiWeightsRPs && fnBinsPhi) // determine phi weight for POI:
761  // {
762  // wPhi = fPhiWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
763  // }
764  // if(fUsePtWeights) // determine pt weight for POI:
765  // {
766  // wPt = 1.;
767  // }
768  // if(fUseEtaWeights && fEtaWeightsRPs && fEtaBinWidth) // determine eta weight for POI:
769  // {
770  // wEta = fEtaWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
771  // }
772  if(fUsePhiEtaWeights && fPhiEtaWeights[cw]) // determine phieta weight for POI:
773  {
774  wPhiEta = fPhiEtaWeights[cw]->GetBinContent(fPhiEtaWeights[cw]->FindBin(dPhi,dEta));
775  }
777  if(dPt>0.2 && dPt<20.) wPhiEta = 1./fPtWeightsHist[fCenBin]->Interpolate(dPt);
778  else wPhiEta = 1.;
779  }
780  if(fUseEtaWeights && fEtaWeightsHist[fCenBin][0][0]) {
781  Int_t ptbin = GetCRCPtBin(dPt);
782  if(ptbin==-1) continue;
783  wPhiEta *= 1./fEtaWeightsHist[fCenBin][ptbin][cw]->GetBinContent(fEtaWeightsHist[fCenBin][ptbin][cw]->FindBin(dEta));
784  }
785 
786  ptEta[0] = dPt;
787  ptEta[1] = dEta;
788  // Calculate p_{m*n,k} ('p-vector' for POIs):
789  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
790  {
791  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
792  {
794  {
795  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
796  {
797  fReRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
798  fImRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
799  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
800  } // end of if(fCalculateDiffFlow)
802  {
803  fReRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
804  fImRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
805  } // end of if(fCalculate2DDiffFlow)
806  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
807  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
808 
809  // Charge-Rapidity Correlations
810  for (Int_t h=0;h<fCRCnHar;h++) {
811 
812  fCRCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
813  fCRCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
814  fCRCMult[cw][h]->Fill(dEta,wPhiEta);
815 
816  fCRC2QRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
817  fCRC2QIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
818  fCRC2Mul[cw][h]->Fill(dEta,wPhiEta);
819 
820  fCRCZDCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
821  fCRCZDCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
822  fCRCZDCMult[cw][h]->Fill(dEta,wPhiEta);
823 
824  if(gRandom->Integer(2)>0.5) {
825  fCRC2QRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
826  fCRC2QIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
827  fCRC2Mul[2][h]->Fill(dEta,wPhiEta);
828  }
829 
830  if(gRandom->Integer(2)>0.5) {
831  fCRCZDCQRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
832  fCRCZDCQIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
833  fCRCZDCMult[2][h]->Fill(dEta,wPhiEta);
834  } else {
835  fCRCZDCQRe[3][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
836  fCRCZDCQIm[3][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
837  fCRCZDCMult[3][h]->Fill(dEta,wPhiEta);
838  }
839 
840  if(fCalculateCME) {
841  Double_t SpecWeig = 1.;
842  if(fUseZDCESESpecWeights && fZDCESESpecWeightsHist[fZDCESEclEbE] && dPt>0.2 && dPt<20.) {
844  if(std::isfinite(1./weraw)) SpecWeig = 1./weraw;
845  }
846  fCMEQRe[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Cos((h+1.)*dPhi));
847  fCMEQIm[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Sin((h+1.)*dPhi));
848  fCMEMult[cw][h]->Fill(dEta,SpecWeig*wPhiEta);
849  fCMEQRe[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Cos((h+1.)*dPhi));
850  fCMEQIm[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Sin((h+1.)*dPhi));
851  fCMEMult[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.));
852 
853  // spectra
854  fhCenvsSpec[fZDCESEclEbE]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
855  fhCenvsSpec[fZDCESEnCl]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
856  }
857 
858  } // end of for (Int_t h=0;h<fCRCnHar;h++)
859 
860  // Flow SP ZDC
861  for (Int_t k=0; k<fQVecPower; k++) {
862  for (Int_t h=0;h<fFlowNHarmMax;h++) {
863  fPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
864  fPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
865  fPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
866  if(fabs(dEta)>fFlowQCDeltaEta/2.) {
867  Int_t keta = (dEta<0.?0:1);
868  fPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
869  fPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
870  fPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
871  }
872  }
873  }
874 
875  for (Int_t h=0;h<fFlowNHarmMax;h++) {
876  fEtaDiffQRe[h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
877  fEtaDiffQIm[h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
878  fEtaDiffMul[h]->Fill(dEta,wPhiEta);
879  }
880 
881  if(fUsePhiEtaWeights && fCRCPhiHist[fRunBin][fCenBin][cw]) {
882  fCRCPhiHist[fRunBin][fCenBin][cw]->Fill(dPt,dEta,wPhiEta);
883  }
884 
886 
887  fFlowSPZDCIntPro[fRunBin][0][4]->Fill(fCentralityEBE,TMath::Cos(2.*dPhi)*(ZARe*ZCRe-ZAIm*ZCIm)+TMath::Sin(2.*dPhi)*(ZARe*ZCIm+ZCRe*ZAIm),ZCM*ZAM);
888  fFlowSPZDCIntPro[fRunBin][0][5]->Fill(fCentralityEBE,TMath::Cos(2.*dPhi)*(ZARe*ZCRe-ZAIm*ZCIm)+TMath::Sin(2.*dPhi)*(ZARe*ZCIm+ZCRe*ZAIm));
889  fFlowSPZDCIntPro[fRunBin][0][6]->Fill(fCentralityEBE,TMath::Cos(2.*dPhi)*(ZARe*ZCRe-ZAIm*ZCIm)+TMath::Sin(2.*dPhi)*(ZARe*ZCIm+ZCRe*ZAIm),wPhiEta*ZCM*ZAM);
890  fFlowSPZDCIntPro[fRunBin][0][7]->Fill(fCentralityEBE,TMath::Cos(2.*dPhi)*(ZARe*ZCRe-ZAIm*ZCIm)+TMath::Sin(2.*dPhi)*(ZARe*ZCIm+ZCRe*ZAIm),wPhiEta);
891 
892  if(!fQAZDCCuts || (fQAZDCCuts && fQAZDCCutsFlag)) {
893  fFlowQCSpectra[fCenBin]->Fill(dPt,wPhiEta);
895  fFlowQCCenSpec[fZDCESEclEbE]->Fill(dPt,fCentralityEBE,wPhiEta);
897  }
898  }
899  }
900 
901  if(fCalculateEbEFlow) {
902  if(fEBEFlowMulBin>=0) fEbEFlowAzimDis[fEBEFlowMulBin]->Fill(dPhi,wPhiEta);
903  }
904 
905  } // end of if(pTrack->InPOISelection())
906  } else // to if(aftsTrack)
907  {
908  printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
909  }
910  } // end of for(Int_t i=0;i<nPrim;i++)
911 
912  // ************************************************************************************************************
913 
914 
915  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
916  for(Int_t p=0;p<8;p++)
917  {
918  for(Int_t k=0;k<9;k++)
919  {
920  (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
921  }
922  }
923 
924  // f) Call the methods which calculate correlations for reference flow:
926  {
928  {
929  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelations();} // without using particle weights
930  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
931  {
932  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
933  }
934  // Whether or not using particle weights the following is calculated in the same way:
938  // Non-isotropic terms:
940  {
943  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
944  {
947  }
948  // Whether or not using particle weights the following is calculated in the same way:
952  // Mixed harmonics:
954  } // end of if(!fEvaluateIntFlowNestedLoops)
955 
956  // g) Call the methods which calculate correlations for differential flow:
958  {
960  {
961  // Without using particle weights:
962  this->CalculateDiffFlowCorrelations("RP","Pt");
964  this->CalculateDiffFlowCorrelations("POI","Pt");
966  // Non-isotropic terms:
975  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
976  {
977  // With using particle weights:
982  // Non-isotropic terms:
991  }
992  // Whether or not using particle weights the following is calculated in the same way:
995  this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
997  this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
999  this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
1005  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
1006 
1007  // h) Call the methods which calculate correlations for 2D differential flow:
1009  {
1011  {
1012  // Without using particle weights:
1013  this->Calculate2DDiffFlowCorrelations("RP");
1014  this->Calculate2DDiffFlowCorrelations("POI");
1015  // Non-isotropic terms:
1016  // ... to be ctd ...
1017  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1018  {
1019  // With using particle weights:
1020  // ... to be ctd ...
1021  // Non-isotropic terms:
1022  // ... to be ctd ...
1023  }
1024  // Whether or not using particle weights the following is calculated in the same way:
1025  // ... to be ctd ...
1026  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
1027 
1028  // i) Call the methods which calculate other differential correlators:
1030  {
1032  {
1033  // Without using particle weights:
1034  this->CalculateOtherDiffCorrelators("RP","Pt");
1036  this->CalculateOtherDiffCorrelators("POI","Pt");
1038  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1039  {
1040  // With using particle weights:
1041  // ... to be ctd ...
1042  }
1043  // Whether or not using particle weights the following is calculated in the same way:
1044  // ... to be ctd ...
1045  } // end of if(!fEvaluateDiffFlowNestedLoops)
1046 
1047  // i.2) Calculate CRC quantities:
1048  if(fCalculateCRC) {
1049  if(fUseCRCRecenter) this->RecenterCRCQVec();
1050  if(fCalculateCRC2) this->CalculateCRCCorr();
1051  if(fCalculateCRC2) this->CalculateCRC2Cor();
1053  if(fCalculateCRCZDC && fUseZDC) this->CalculateCRCZDC();
1054  if(fCalculateCRCPt) this->CalculateCRCPtCorr();
1055 // if(fUseVZERO && fUseZDC) this->CalculateVZvsZDC();
1056  if(fCalculateCME && fUseZDC) {
1057  this->CalculateCMETPC();
1058  this->CalculateCMEZDC();
1059  }
1060  }
1061  // WARNING: do not invert order of SPZDC and QC, used in SC
1063  if(fCalculateFlowQC) this->CalculateFlowQC();
1065  if(fCalculateEbEFlow) this->FitEbEFlow();
1066 
1067  // j) Distributions of correlations:
1069 
1070  // l) Cross-check with nested loops correlators for reference flow:
1072 
1073  // m) Cross-check with nested loops correlators for differential flow:
1075 
1076  // n) Store multiplicity in various:
1077  if(fStoreVarious) this->FillVarious();
1078 
1079  // o) Reset all event-by-event quantities (very important !!!!):
1081 
1082  // p) cache run number
1084 
1085  fQAZDCCutsFlag = kTRUE;
1086  // printf("Make done \n");
1087 
1088 } // end of AliFlowAnalysisCRC::Make(AliFlowEventSimple* anEvent)
1089 
1090 //=======================================================================================================================
1091 
1093 {
1094  // Calculate the final results.
1095 
1096  // a) Check all pointers used in this method;
1097  // b) Access the constants;
1098  // c) Access the flags;
1099  // d) Calculate reference cumulants (not corrected for detector effects);
1100  // e) Correct reference cumulants for detector effects;
1101  // f) Calculate reference flow;
1102  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen;
1103  // h) Calculate the final results for differential flow (without/with weights);
1104  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA);
1105  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults;
1106  // k) Store results for differential flow in AliFlowCommonHistResults;
1107  // l) Print the final results for integrated flow (RP/POI) on the screen;
1108  // m) Cross-checking: Results from Q-vectors vs results from nested loops;
1109  // n) Calculate cumulants for mixed harmonics;
1110  // o) Calculate charge-rapidity correlations;
1111  // p) Calculate cumulants for bootstrap;
1112  // q) Finalize various;
1113 
1114  // a) Check all pointers used in this method:
1115  this->CheckPointersUsedInFinish();
1116 
1117  // b) Access the constants:
1118  this->CommonConstants("Finish");
1119 
1121  fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
1122  }
1123 
1124  // c) Access the flags: // tbi (implement a method for this? should I store again the flags because they can get modified with redoFinish?)
1125  fUsePhiWeights = (Bool_t)fUseParticleWeights->GetBinContent(1);
1126  fUsePtWeights = (Bool_t)fUseParticleWeights->GetBinContent(2);
1127  fUseEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(3);
1128  fUseTrackWeights = (Bool_t)fUseParticleWeights->GetBinContent(4);
1129  fUsePhiEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(5);
1130  fApplyCorrectionForNUA = (Bool_t)fIntFlowFlags->GetBinContent(3);
1131  fPrintFinalResults[0] = (Bool_t)fIntFlowFlags->GetBinContent(4);
1132  fPrintFinalResults[1] = (Bool_t)fIntFlowFlags->GetBinContent(5);
1133  fPrintFinalResults[2] = (Bool_t)fIntFlowFlags->GetBinContent(6);
1134  fPrintFinalResults[3] = (Bool_t)fIntFlowFlags->GetBinContent(7);
1135  fApplyCorrectionForNUAVsM = (Bool_t)fIntFlowFlags->GetBinContent(8);
1136  fPropagateErrorAlsoFromNIT = (Bool_t)fIntFlowFlags->GetBinContent(9);
1137  fCalculateCumulantsVsM = (Bool_t)fIntFlowFlags->GetBinContent(10);
1138  fMinimumBiasReferenceFlow = (Bool_t)fIntFlowFlags->GetBinContent(11);
1139  fForgetAboutCovariances = (Bool_t)fIntFlowFlags->GetBinContent(12);
1140  fStoreVarious = (Bool_t)fIntFlowFlags->GetBinContent(13);
1141  fFillMultipleControlHistograms = (Bool_t)fIntFlowFlags->GetBinContent(14);
1142  fCalculateAllCorrelationsVsM = (Bool_t)fIntFlowFlags->GetBinContent(15);
1143  fUse2DHistograms = (Bool_t)fIntFlowFlags->GetBinContent(18);
1144  fFillProfilesVsMUsingWeights = (Bool_t)fIntFlowFlags->GetBinContent(19);
1145  fUseQvectorTerms = (Bool_t)fIntFlowFlags->GetBinContent(20);
1148  fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);
1149  fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4);
1151  //fHarmonic = (Int_t)fMixedHarmonicsFlags->GetBinContent(2); // TBI should I add inpdependent generic harmonic here?
1153  fUseBootstrap = (Bool_t)fBootstrapFlags->GetBinContent(1);
1154  fUseBootstrapVsM = (Bool_t)fBootstrapFlags->GetBinContent(2);
1155  fnSubsamples = (Int_t)fBootstrapFlags->GetBinContent(3);
1156 
1157  // d) Calculate reference cumulants (not corrected for detector effects):
1160  this->CalculateCumulantsIntFlow();
1161 
1162  // e) Correct reference cumulants for detector effects:
1166 
1167  // f) Calculate reference flow:
1168  this->CalculateReferenceFlow();
1169 
1170  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen:
1174 
1175  // h) Calculate the final results for differential flow (without/with weights):
1176  if(fCalculateDiffFlow)
1177  {
1178  this->FinalizeReducedCorrelations("RP","Pt");
1180  this->FinalizeReducedCorrelations("POI","Pt");
1181  if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("POI","Eta");}
1182  this->CalculateDiffFlowCovariances("RP","Pt");
1184  this->CalculateDiffFlowCovariances("POI","Pt");
1185  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("POI","Eta");}
1186  this->CalculateDiffFlowCumulants("RP","Pt");
1187  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("RP","Eta");}
1188  this->CalculateDiffFlowCumulants("POI","Pt");
1189  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("POI","Eta");}
1190  this->CalculateDiffFlow("RP","Pt");
1191  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("RP","Eta");}
1192  this->CalculateDiffFlow("POI","Pt");
1193  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("POI","Eta");}
1194  } // if(fCalculateDiffFlow)
1195 
1196  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA):
1197  if(fCalculateDiffFlow)
1198  {
1199  this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");
1201  this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");
1208  {
1209  this->CalculateDiffFlowCorrectedForNUA("RP","Pt");
1211  this->CalculateDiffFlowCorrectedForNUA("POI","Pt");
1213  }
1214  } // end of if(fCalculateDiffFlow && fApplyCorrectionForNUA)
1215 
1216  // i) Calcualate final results for 2D differential flow:
1218  {
1219  this->Calculate2DDiffFlowCumulants("RP");
1220  this->Calculate2DDiffFlowCumulants("POI");
1221  this->Calculate2DDiffFlow("RP");
1222  this->Calculate2DDiffFlow("POI");
1223  } // end of if(fCalculate2DDiffFlow)
1224 
1225  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults:
1226  if(fCalculateDiffFlow)
1227  {
1230  }
1231 
1232  // k) Store results for differential flow in AliFlowCommonHistResults:
1233  if(fCalculateDiffFlow)
1234  {
1235  this->FillCommonHistResultsDiffFlow("RP");
1236  this->FillCommonHistResultsDiffFlow("POI");
1237  }
1238 
1239  // l) Print the final results for integrated flow (RP/POI) on the screen:
1242 
1243  // m) Cross-checking: Results from Q-vectors vs results from nested loops:
1244  // m1) Reference flow:
1246  {
1251  } // end of if(fEvaluateIntFlowNestedLoops)
1252  // m2) Differential flow:
1254  {
1255  // Correlations:
1257  this->CrossCheckDiffFlowCorrelations("RP","Pt");
1259  this->CrossCheckDiffFlowCorrelations("POI","Pt");
1261  // Correction terms for non-uniform acceptance:
1262  this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt");
1264  this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");
1266  // Other differential correlators:
1267  this->CrossCheckOtherDiffCorrelators("RP","Pt");
1269  this->CrossCheckOtherDiffCorrelators("POI","Pt");
1271  } // end of if(fEvaluateDiffFlowNestedLoops)
1272 
1273  // n) Calculate cumulants for mixed harmonics:
1275 
1276  // o) Calculate charge-rapidity correlations:
1277  if(fCalculateCRC) {
1278  if(fCalculateCRC2) this->FinalizeCRCCorr();
1279  if(fCalculateCRC2) this->FinalizeCRC2Cor();
1281  if(fCalculateCRCZDC && fUseZDC) this->FinalizeCRCZDC();
1282  if(fCalculateCRCPt) this->FinalizeCRCPtCorr();
1283  if(fCalculateCME && fUseZDC) {
1284  this->FinalizeCMETPC();
1285  this->FinalizeCMEZDC();
1286  }
1287  }
1288  // WARNING: do not invert order of SPZDC and QC, used in SC
1290  if(fCalculateFlowQC) this->FinalizeFlowQC();
1292 
1293  // p) Calculate cumulants for bootstrap:
1295 
1296  // q) Finalize various:
1297  if(fStoreVarious) this->FinalizeVarious();
1298 
1299 } // end of AliFlowAnalysisCRC::Finish()
1300 
1301 //=======================================================================================================================
1302 
1304 {
1305  // Evaluate all correlators for reference flow with nested loops.
1306 
1307  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1308  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1309  {
1310  // Without using particle weights:
1312  {
1313  // Correlations:
1314  this->CalculateIntFlowCorrelations(); // from Q-vectors
1315  this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1316  // Correction for non-uniform acceptance:
1317  this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)
1318  this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)
1319  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)
1320  // Mixed harmonics:
1322  {
1323  this->CalculateMixedHarmonics(); // from Q-vectors
1324  this->EvaluateMixedHarmonicsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1325  } // end of if(fCalculateMixedHarmonics)
1326  }
1327  // Using particle weights:
1329  {
1330  // Correlations
1331  this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors
1332  this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
1333  // Correction for non-uniform acceptance:
1334  this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)
1335  this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)
1336  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
1337  }
1338  } else if(nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)
1339  {
1340  cout<<endl;
1341  cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;
1342  } else
1343  {
1344  cout<<endl;
1345  cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;
1346  }
1347 
1348 } // end of void AliFlowAnalysisCRC::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
1349 
1350 //=======================================================================================================================
1351 
1353 {
1354  // Evalauted all correlators for differential flow with nested loops.
1355 
1356  if(!fCalculateDiffFlow){return;}
1357 
1358  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1359  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1360  {
1361  // Without using particle weights:
1363  {
1364  // 1.) Reduced correlations:
1365  // Q-vectors:
1366  this->CalculateDiffFlowCorrelations("RP","Pt");
1367  this->CalculateDiffFlowCorrelations("RP","Eta");
1368  this->CalculateDiffFlowCorrelations("POI","Pt");
1369  this->CalculateDiffFlowCorrelations("POI","Eta");
1370  // Nested loops:
1371  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt");
1372  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta");
1373  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt");
1374  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta");
1375  // 2.) Reduced corrections for non-uniform acceptance:
1376  // Q-vectors:
1380  this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");
1384  this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
1385  // Nested loops:
1387  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta");
1388  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt");
1389  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta");
1390  // 3.) Other differential correlators:
1391  // Q-vectors:
1392  this->CalculateOtherDiffCorrelators("RP","Pt");
1393  this->CalculateOtherDiffCorrelators("RP","Eta");
1394  this->CalculateOtherDiffCorrelators("POI","Pt");
1395  this->CalculateOtherDiffCorrelators("POI","Eta");
1396  // Nested loops:
1397  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Pt");
1398  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Eta");
1399  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Pt");
1400  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Eta");
1401  } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1402  // Using particle weights:
1404  {
1425  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1426  } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1427 
1428 } // end of void AliFlowAnalysisCRC::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
1429 
1430 //=======================================================================================================================
1431 
1433 {
1434  // Calculate correction terms for non-uniform acceptance of the detector for reference flow (cos terms).
1435 
1436  // multiplicity:
1437  Double_t dMult = (*fSpk)(0,0);
1438 
1439  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1440  Double_t dReQ1n = (*fReQ)(0,0);
1441  Double_t dReQ2n = (*fReQ)(1,0);
1442  //Double_t dReQ3n = (*fReQ)(2,0);
1443  //Double_t dReQ4n = (*fReQ)(3,0);
1444  Double_t dImQ1n = (*fImQ)(0,0);
1445  Double_t dImQ2n = (*fImQ)(1,0);
1446  //Double_t dImQ3n = (*fImQ)(2,0);
1447  //Double_t dImQ4n = (*fImQ)(3,0);
1448 
1449  // Multiplicity bin of an event (relevant for all histos vs M):
1450  Double_t dMultiplicityBin = 0.;
1452  {
1453  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1455  {
1456  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1458  {
1459  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1460  }
1461 
1462  // *************************************************************
1463  // **** corrections for non-uniform acceptance (cos terms): ****
1464  // *************************************************************
1465  //
1466  // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors
1467  // are stored in 1D profile fQCorrectionsCos.
1468  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
1469  // --------------------------------------------------------------------------------------------------------------------
1470  // 1st bin: <<cos(n*(phi1))>> = cosP1n
1471  // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n
1472  // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n
1473  // 4th bin: <<cos(n*(2phi1-phi2))>> = cosP2nM1n
1474  // --------------------------------------------------------------------------------------------------------------------
1475 
1476  // 1-particle:
1477  Double_t cosP1n = 0.; // <<cos(n*(phi1))>>
1478 
1479  if(dMult>0)
1480  {
1481  cosP1n = dReQ1n/dMult;
1482 
1483  // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
1484  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);
1485  // event weights for NUA terms:
1486  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(1,dMult);
1487 
1488  // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
1489  fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);
1490  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][0]->Fill(dMultiplicityBin,cosP1n,dMult);}
1491  }
1492 
1493  // 2-particle:
1494  Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>
1495  Double_t cosP2nM1n = 0.; // <<cos(n*(2phi1-phi2))>>
1496 
1497  if(dMult>1)
1498  {
1499  cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1));
1500  cosP2nM1n = (dReQ2n*dReQ1n+dImQ2n*dImQ1n-dReQ1n)/(dMult*(dMult-1));
1501 
1502  // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
1503  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);
1504  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(4,cosP2nM1n);
1505  // event weights for NUA terms:
1506  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(2,dMult*(dMult-1));
1507  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(4,dMult*(dMult-1));
1508 
1509  // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
1510  fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));
1511  fIntFlowCorrectionTermsForNUAPro[1]->Fill(3.5,cosP2nM1n,dMult*(dMult-1));
1513  {
1514  fIntFlowCorrectionTermsForNUAVsMPro[1][1]->Fill(dMultiplicityBin,cosP1nP1n,dMult*(dMult-1));
1515  fIntFlowCorrectionTermsForNUAVsMPro[1][3]->Fill(dMultiplicityBin,cosP2nM1n,dMult*(dMult-1));
1516  }
1517  }
1518 
1519  // 3-particle:
1520  Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>
1521 
1522  if(dMult>2)
1523  {
1524  cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)
1525  / (dMult*(dMult-1)*(dMult-2));
1526 
1527  // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
1528  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);
1529  // event weights for NUA terms:
1530  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1531 
1532  // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
1533  fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1534  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][2]->Fill(dMultiplicityBin,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1535  }
1536 
1537 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUACosTerms()
1538 
1539 //=======================================================================================================================
1540 
1542 {
1543  // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
1544 
1545  // multiplicity:
1546  Double_t dMult = (*fSpk)(0,0);
1547 
1548  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1549  Double_t dReQ1n = (*fReQ)(0,0);
1550  Double_t dReQ2n = (*fReQ)(1,0);
1551  //Double_t dReQ3n = (*fReQ)(2,0);
1552  //Double_t dReQ4n = (*fReQ)(3,0);
1553  Double_t dImQ1n = (*fImQ)(0,0);
1554  Double_t dImQ2n = (*fImQ)(1,0);
1555  //Double_t dImQ3n = (*fImQ)(2,0);
1556  //Double_t dImQ4n = (*fImQ)(3,0);
1557 
1558  // Multiplicity bin of an event (relevant for all histos vs M):
1559  Double_t dMultiplicityBin = 0.;
1561  {
1562  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1564  {
1565  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1567  {
1568  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1569  }
1570 
1571  // *************************************************************
1572  // **** corrections for non-uniform acceptance (sin terms): ****
1573  // *************************************************************
1574  //
1575  // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors
1576  // are stored in 1D profile fQCorrectionsSin.
1577  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
1578  // --------------------------------------------------------------------------------------------------------------------
1579  // 1st bin: <<sin(n*(phi1))>> = sinP1n
1580  // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n
1581  // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n
1582  // 4th bin: <<sin(n*(2phi1-phi2))>> = sinP2nM1n
1583  // --------------------------------------------------------------------------------------------------------------------
1584 
1585  // 1-particle:
1586  Double_t sinP1n = 0.; // <sin(n*(phi1))>
1587 
1588  if(dMult>0)
1589  {
1590  sinP1n = dImQ1n/dMult;
1591 
1592  // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
1593  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);
1594  // event weights for NUA terms:
1595  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(1,dMult);
1596 
1597  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1598  fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);
1599  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][0]->Fill(dMultiplicityBin,sinP1n,dMult);}
1600  }
1601 
1602  // 2-particle:
1603  Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>
1604  Double_t sinP2nM1n = 0.; // <<sin(n*(2phi1-phi2))>>
1605  if(dMult>1)
1606  {
1607  sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1));
1608  sinP2nM1n = (dImQ2n*dReQ1n-dReQ2n*dImQ1n-dImQ1n)/(dMult*(dMult-1));
1609 
1610  // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
1611  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);
1612  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(4,sinP2nM1n);
1613  // event weights for NUA terms:
1614  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(2,dMult*(dMult-1));
1615  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(4,dMult*(dMult-1));
1616 
1617  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1618  fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));
1619  fIntFlowCorrectionTermsForNUAPro[0]->Fill(3.5,sinP2nM1n,dMult*(dMult-1));
1621  {
1622  fIntFlowCorrectionTermsForNUAVsMPro[0][1]->Fill(dMultiplicityBin,sinP1nP1n,dMult*(dMult-1));
1623  fIntFlowCorrectionTermsForNUAVsMPro[0][3]->Fill(dMultiplicityBin,sinP2nM1n,dMult*(dMult-1));
1624  }
1625  }
1626 
1627  // 3-particle:
1628  Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>
1629 
1630  if(dMult>2)
1631  {
1632  sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)
1633  / (dMult*(dMult-1)*(dMult-2));
1634 
1635  // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
1636  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);
1637  // event weights for NUA terms:
1638  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1639 
1640  // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
1641  fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1642  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][2]->Fill(dMultiplicityBin,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1643  }
1644 
1645 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUASinTerms()
1646 
1647 //=======================================================================================================================
1648 
1650 {
1651  // a) Get pointers for common control and common result histograms;
1652  // b) Get pointers for histograms holding particle weights;
1653  // c) Get pointers for reference flow histograms;
1654  // d) Get pointers for differential flow histograms;
1655  // e) Get pointers for 2D differential flow histograms;
1656  // f) Get pointers for other differential correlators;
1657  // g) Get pointers for mixed harmonics histograms;
1658  // h) Get pointers for nested loops' histograms;
1659  // i) Get pointers for control histograms;
1660  // j) Get pointers for bootstrap.
1661  // k) Get pointers for CRC histograms;
1662 
1663  if(outputListHistos)
1664  {
1665  this->SetHistList(outputListHistos);
1666  if(!fHistList)
1667  {
1668  printf("\n WARNING (QC): fHistList is NULL in AFAWQC::GOH() !!!!\n\n");
1669  exit(0);
1670  }
1680  this->GetPointersForBootstrap();
1681  this->GetPointersForCRC();
1682  this->GetPointersForCRCVZ();
1683  this->GetPointersForCRCZDC();
1684  this->GetPointersForCRCPt();
1685  this->GetPointersForCRC2();
1686  this->GetPointersForQVec();
1687  this->GetPointersForCME();
1688  this->GetPointersForFlowQC();
1689  this->GetPointersForFlowSPZDC();
1690  this->GetPointersForFlowSPVZ();
1691  this->GetPointersForEbEFlow();
1692  this->GetPointersForVarious();
1693  } else
1694  {
1695  printf("\n WARNING (QC): outputListHistos is NULL in AFAWQC::GOH() !!!!\n\n");
1696  exit(0);
1697  }
1698 
1699 } // end of void AliFlowAnalysisCRC::GetOutputHistograms(TList *outputListHistos)
1700 
1701 //=======================================================================================================================
1702 
1703 TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta) const
1704 {
1705  // project 2D profile onto pt axis to get 1D profile
1706 
1707  Int_t nBinsPt = profilePtEta->GetNbinsX();
1708  Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();
1709  Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();
1710 
1711  Int_t nBinsEta = profilePtEta->GetNbinsY();
1712 
1713  TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax);
1714 
1715  for(Int_t p=1;p<=nBinsPt;p++)
1716  {
1717  Double_t contentPt = 0.;
1718  Double_t entryPt = 0.;
1719  Double_t spreadPt = 0.;
1720  Double_t sum1 = 0.;
1721  Double_t sum2 = 0.;
1722  Double_t sum3 = 0.;
1723  for(Int_t e=1;e<=nBinsEta;e++)
1724  {
1725  contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1726  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1727  entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1728 
1729  sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1730  * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)
1731  + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.));
1732  sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1733  sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1734  * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));
1735  }
1736  if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)
1737  {
1738  spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);
1739  }
1740  profilePt->SetBinContent(p,contentPt);
1741  profilePt->SetBinEntries(p,entryPt);
1742  {
1743  profilePt->SetBinError(p,spreadPt);
1744  }
1745 
1746  }
1747 
1748  return profilePt;
1749 
1750 } // end of TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta)
1751 
1752 
1753 //=======================================================================================================================
1754 
1755 
1756 TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta) const
1757 {
1758  // project 2D profile onto eta axis to get 1D profile
1759 
1760  Int_t nBinsEta = profilePtEta->GetNbinsY();
1761  Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();
1762  Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();
1763 
1764  Int_t nBinsPt = profilePtEta->GetNbinsX();
1765 
1766  TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax);
1767 
1768  for(Int_t e=1;e<=nBinsEta;e++)
1769  {
1770  Double_t contentEta = 0.;
1771  Double_t entryEta = 0.;
1772  for(Int_t p=1;p<=nBinsPt;p++)
1773  {
1774  contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1775  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1776  entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1777  }
1778  profileEta->SetBinContent(e,contentEta);
1779  profileEta->SetBinEntries(e,entryEta);
1780  }
1781 
1782  return profileEta;
1783 
1784 } // end of TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta)
1785 
1786 //=======================================================================================================================
1787 
1789 {
1790  // Printing on the screen the final results for integrated flow (RF, POI and RP).
1791 
1792  Int_t n = fHarmonic;
1793 
1794  Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}
1795  Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}
1796 
1797  if(type == "RF")
1798  {
1799  for(Int_t b=0;b<4;b++)
1800  {
1801  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1);
1802  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1);
1803  dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1);
1804  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1);
1805  dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1);
1806  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1);
1807  dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1);
1808  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1);
1809  }
1810  } else if(type == "RP")
1811  {
1812  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1);
1813  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1);
1814  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1);
1815  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1);
1816  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1);
1817  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1);
1818  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1);
1819  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1);
1820  } else if(type == "POI")
1821  {
1822  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1);
1823  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1);
1824  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1);
1825  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1);
1826  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1);
1827  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1);
1828  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1);
1829  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1);
1830  } else if(type == "RF, rebinned in M" && fCalculateCumulantsVsM)
1831  {
1832  for(Int_t b=0;b<4;b++)
1833  {
1834  dVn[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
1835  dVnErr[b] = fIntFlowRebinnedInM->GetBinError(b+1);
1836  }
1837  }
1838 
1839  TString title = " flow estimates from Q-cumulants";
1840  TString subtitle = " (";
1841  TString subtitle2 = " (rebinned in M)";
1842 
1843  if(type != "RF, rebinned in M")
1844  {
1846  {
1847  subtitle.Append(type);
1848  subtitle.Append(", without weights)");
1849  } else
1850  {
1851  subtitle.Append(type);
1852  subtitle.Append(", with weights)");
1853  }
1854  } else
1855  {
1857  {
1858  subtitle.Append("RF");
1859  subtitle.Append(", without weights)");
1860  } else
1861  {
1862  subtitle.Append("RF");
1863  subtitle.Append(", with weights)");
1864  }
1865  }
1866 
1867  cout<<endl;
1868  cout<<"*************************************"<<endl;
1869  cout<<"*************************************"<<endl;
1870  cout<<title.Data()<<endl;
1871  cout<<subtitle.Data()<<endl;
1872  if(type == "RF, rebinned in M"){cout<<subtitle2.Data()<<endl;}
1873  cout<<endl;
1874 
1875  for(Int_t i=0;i<4;i++)
1876  {
1877  cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
1878  }
1879 
1880  cout<<endl;
1881  if(type == "RF")
1882  {
1884  {
1885  cout<<" detector bias (corrected for): "<<endl;
1886  } else
1887  {
1888  cout<<" detector bias (not corrected for):"<<endl;
1889  }
1890  cout<<" to QC{2}: "<<fIntFlowDetectorBias->GetBinContent(1)<<" +/- "<<fIntFlowDetectorBias->GetBinError(1)<<endl;
1891  cout<<" to QC{4}: "<<fIntFlowDetectorBias->GetBinContent(2)<<" +/- "<<fIntFlowDetectorBias->GetBinError(2)<<endl;
1892  cout<<endl;
1893  }
1894  if(type == "RF" || type == "RF, rebinned in M")
1895  {
1896  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
1897  }
1898  else if (type == "RP")
1899  {
1900  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
1901  }
1902  else if (type == "POI")
1903  {
1904  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
1905  }
1906 
1907  cout<<"*************************************"<<endl;
1908  cout<<"*************************************"<<endl;
1909  cout<<endl;
1910 
1911 }// end of AliFlowAnalysisCRC::PrintFinalResultsForIntegratedFlow(TString type="RF");
1912 
1913 //=======================================================================================================================
1914 
1916 {
1917  //store the final results in output .root file
1918  TFile *output = new TFile(outputFileName.Data(),"RECREATE");
1919  //output->WriteObject(fHistList, "cobjQC","SingleKey");
1920  fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
1921  delete output;
1922 }
1923 
1924 
1925 //=======================================================================================================================
1926 
1927 
1928 void AliFlowAnalysisCRC::WriteHistograms(TDirectoryFile *outputFileName)
1929 {
1930  //store the final results in output .root file
1931  fHistList->SetName("cobjQC");
1932  fHistList->SetOwner(kTRUE);
1933  outputFileName->Add(fHistList);
1934  outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
1935 }
1936 
1937 //=======================================================================================================================
1938 
1940 {
1941  // Book common control histograms and common histograms for final results.
1942  // a) Book common control histograms;
1943  // b) Book common result histograms.
1944 
1945  // a) Book common control histograms:
1946  // Common control histograms (all events):
1947  TString commonHistsName = "AliFlowCommonHistQC";
1948  commonHistsName += fAnalysisLabel->Data();
1949  fCommonHists = new AliFlowCommonHist(commonHistsName.Data(),commonHistsName.Data(),fBookOnlyBasicCCH);
1950  fHistList->Add(fCommonHists);
1951  // Common control histograms (selected events):
1953  {
1954  // Common control histogram filled for events with 2 and more reference particles:
1955  TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
1956  commonHists2ndOrderName += fAnalysisLabel->Data();
1957  fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data(),commonHists2ndOrderName.Data(),fBookOnlyBasicCCH);
1958  fHistList->Add(fCommonHists2nd);
1959  // Common control histogram filled for events with 2 and more reference particles:
1960  TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
1961  commonHists4thOrderName += fAnalysisLabel->Data();
1962  fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data(),commonHists4thOrderName.Data(),fBookOnlyBasicCCH);
1963  fHistList->Add(fCommonHists4th);
1964  // Common control histogram filled for events with 6 and more reference particles:
1965  TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
1966  commonHists6thOrderName += fAnalysisLabel->Data();
1967  fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data(),commonHists6thOrderName.Data(),fBookOnlyBasicCCH);
1968  fHistList->Add(fCommonHists6th);
1969  // Common control histogram filled for events with 8 and more reference particles:
1970  TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
1971  commonHists8thOrderName += fAnalysisLabel->Data();
1972  fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data(),commonHists8thOrderName.Data(),fBookOnlyBasicCCH);
1973  fHistList->Add(fCommonHists8th);
1974  } // end of if(fFillMultipleControlHistograms)
1975 
1976  // b) Book common result histograms:
1977  // Common result histograms for QC{2}:
1978  TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
1979  commonHistResults2ndOrderName += fAnalysisLabel->Data();
1980  fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
1982  // Common result histograms for QC{4}:
1983  TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
1984  commonHistResults4thOrderName += fAnalysisLabel->Data();
1985  fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
1987  // Common result histograms for QC{6}:
1988  TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
1989  commonHistResults6thOrderName += fAnalysisLabel->Data();
1990  fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
1992  // Common result histograms for QC{8}:
1993  TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
1994  commonHistResults8thOrderName += fAnalysisLabel->Data();
1995  fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
1997 
1998 } // end of void AliFlowAnalysisCRC::BookCommonHistograms()
1999 
2000 //=======================================================================================================================
2001 
2003 {
2004  // Book and fill histograms which hold phi, pt and eta weights.
2005 
2006  if(!fWeightsList)
2007  {
2008  printf("\n WARNING (QC): fWeightsList is NULL in AFAWQC::BAFWH() !!!! \n\n");
2009  exit(0);
2010  }
2011 
2012  TString fUseParticleWeightsName = "fUseParticleWeightsQC";
2013  fUseParticleWeightsName += fAnalysisLabel->Data();
2014  fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",5,0,5);
2015  fUseParticleWeights->SetLabelSize(0.06);
2016  fUseParticleWeights->SetStats(kFALSE);
2017  (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");
2018  (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");
2019  (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");
2020  (fUseParticleWeights->GetXaxis())->SetBinLabel(4,"w_{track}");
2027 
2028  for(Int_t c=0; c<2; c++) {
2029  fPhiEtaWeights[c] = new TH2D(Form("fPhiEtaWeights[%d]",c),
2030  Form("fPhiEtaWeights[%d]",c),32,0.,TMath::TwoPi(),32,-0.8,0.8);
2031  }
2032 
2033  // // POIs
2034  // for(Int_t c=0; c<2; c++)
2035  // {
2036  // fPhiWeightsPOIs[c] = new TH1F(Form("fPhiWeightsPOIs[%d][%d]",c,h),Form("fPhiWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax);
2037  // fPhiWeightsPOIs[c]->Sumw2();
2038  // fEtaWeightsPOIs[c] = new TH1D(Form("fEtaWeightsPOIs[%d][%d]",c,h),Form("fEtaWeightsPOIs[%d][%d]",c,h),fnBinsEta,fEtaMin,fEtaMax);
2039  // fEtaWeightsPOIs[c]->Sumw2();
2040  // fPhiEtaWeightsPOIs[c] = new TH2D(Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax,fnBinsEta,fEtaMin,fEtaMax);
2041  // fPhiEtaWeightsPOIs[c]->Sumw2();
2042  //
2043  // if(fUsePhiWeights)
2044  // {
2045  // if(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)))
2046  // {
2047  // fPhiDistrRefPOIs[c] = dynamic_cast<TH1F*>(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)));
2048  // if(!fPhiDistrRefPOIs[c])
2049  // {
2050  // printf("\n WARNING (QC): fPhiDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2051  // exit(0);
2052  // }
2053  // if(TMath::Abs(fPhiDistrRefPOIs[c]->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2054  // {
2055  // cout<<endl;
2056  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2057  // cout<<endl;
2058  // //exit(0);
2059  // }
2060  // } else
2061  // {
2062  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2063  // exit(0);
2064  // }
2065  // } // end of if(fUsePhiWeights)
2066  //
2067  // if(fUsePtWeights)
2068  // {
2069  // if(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)))
2070  // {
2071  // fPtDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)));
2072  // if(!fPtDistrRefPOIs[c])
2073  // {
2074  // printf("\n WARNING (QC): fPtDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2075  // exit(0);
2076  // }
2077  // if(TMath::Abs(fPtDistrRefPOIs[c]->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2078  // {
2079  // cout<<endl;
2080  // cout<<"WARNING (QC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
2081  // cout<<endl;
2082  // //exit(0);
2083  // }
2084  // } else
2085  // {
2086  // cout<<"WARNING: fWeightsList->FindObject(\"fPtHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2087  // exit(0);
2088  // }
2089  // } // end of if(fUsePtWeights)
2090  //
2091  // if(fUseEtaWeights)
2092  // {
2093  // if(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)))
2094  // {
2095  // fEtaDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)));
2096  // if(!fEtaDistrRefPOIs[c])
2097  // {
2098  // printf("\n WARNING (QC): fEtaDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2099  // exit(0);
2100  // }
2101  // if(TMath::Abs(fEtaDistrRefPOIs[c]->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2102  // {
2103  // cout<<endl;
2104  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2105  // cout<<endl;
2106  // //exit(0);
2107  // }
2108  // } else
2109  // {
2110  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2111  // exit(0);
2112  // }
2113  // } // end of if(fUseEtaWeights)
2114  //
2115  // if(fUsePhiEtaWeights)
2116  // {
2117  // if(fWeightsList->FindObject(Form("fPhiEtaHist[%d][%d]",c,h)))
2118  // {
2119  // fPhiEtaDistrRefPOIs[c] = dynamic_cast<TH2D*>(fWeightsList->FindObject(Form("fPhiEtaHist[%d][%d]",c,h)));
2120  // if(!fPhiEtaDistrRefPOIs[c])
2121  // {
2122  // printf("\n WARNING (QC): fPhiEtaDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2123  // exit(0);
2124  // }
2125  // } else
2126  // {
2127  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiEtaHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2128  // exit(0);
2129  // }
2130  // } // end of if(fUsePhiEtaWeights)
2131  //
2132  // } // end of for(Int_t c=0; c<2; c++)
2133 
2134  //**********************************************************************************************************
2135 
2136  // RPs
2137 
2138  // fPhiWeightsRPs = new TH1F("fPhiWeightsRPs","fPhiWeightsRPs",fnBinsPhi,fPhiMin,fPhiMax);
2139  // fEtaWeightsRPs = new TH1D("fEtaWeightsRPs","fEtaWeightsRPs",fnBinsEta,fEtaMin,fEtaMax);
2140  //
2141  // if(fUsePhiWeights)
2142  // {
2143  // if(fWeightsList->FindObject("fPhiDistrRPs"))
2144  // {
2145  // fPhiDistrRefRPs = dynamic_cast<TH1F*>(fWeightsList->FindObject("fPhiDistrRPs"));
2146  // if(!fPhiDistrRefRPs)
2147  // {
2148  // printf("\n WARNING (QC): fPhiDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2149  // exit(0);
2150  // }
2151  // if(TMath::Abs(fPhiDistrRefRPs->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2152  // {
2153  // cout<<endl;
2154  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2155  // cout<<endl;
2156  // //exit(0);
2157  // }
2158  // } else
2159  // {
2160  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2161  // exit(0);
2162  // }
2163  // } // end of if(fUsePhiWeights)
2164  //
2165  // if(fUsePtWeights)
2166  // {
2167  // if(fWeightsList->FindObject("fPtDistrRPs"))
2168  // {
2169  // fPtDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fPtDistrRPs"));
2170  // if(!fPtDistrRefRPs)
2171  // {
2172  // printf("\n WARNING (QC): fPtDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2173  // exit(0);
2174  // }
2175  // if(TMath::Abs(fPtDistrRefRPs->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2176  // {
2177  // cout<<endl;
2178  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2179  // cout<<endl;
2180  // //exit(0);
2181  // }
2182  // } else
2183  // {
2184  // cout<<"WARNING: fWeightsList->FindObject(\"fPtDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2185  // exit(0);
2186  // }
2187  // } // end of if(fUsePtWeights)
2188  //
2189  // if(fUseEtaWeights)
2190  // {
2191  // if(fWeightsList->FindObject("fEtaDistrRPs"))
2192  // {
2193  // fEtaDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fEtaDistrRPs"));
2194  // if(!fEtaDistrRefRPs)
2195  // {
2196  // printf("\n WARNING (QC): fEtaDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2197  // exit(0);
2198  // }
2199  // if(TMath::Abs(fEtaDistrRefRPs->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2200  // {
2201  // cout<<endl;
2202  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2203  // cout<<endl;
2204  // //exit(0);
2205  // }
2206  // } else
2207  // {
2208  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2209  // exit(0);
2210  // }
2211  // } // end of if(fUseEtaWeights)
2212  //
2213  // if(fUsePhiEtaWeights)
2214  // {
2215  // if(fWeightsList->FindObject("fPhiEtaDistrRPs"))
2216  // {
2217  // fPhiEtaDistrRefRPs = dynamic_cast<TH2D*>(fWeightsList->FindObject("fPhiEtaDistrRPs"));
2218  // if(!fPhiEtaDistrRefRPs)
2219  // {
2220  // printf("\n WARNING (QC): fPhiEtaDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2221  // exit(0);
2222  // }
2223  // } else
2224  // {
2225  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiEtaDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2226  // exit(0);
2227  // }
2228  // } // end of if(fUsePhiEtaWeights)
2229 
2230 } // end of AliFlowAnalysisCRC::BookAndFillWeightsHistograms()
2231 
2232 //=======================================================================================================================
2233 
2235 {
2236  if(!fCenWeightsHist) return;
2237  fCenWeigCalHist = (TH1D*)(fCenWeightsHist->Clone("fCenWeigCalHist"));
2238  TF1 *CenFit = new TF1("CenFit","pol0", 0., 100.);
2240  fCenWeigCalHist->Fit("CenFit","QNR","",0.,50.);
2241  Double_t CenAv = CenFit->GetParameter(0);
2242  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2243  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2244  if(newbin) {
2245  fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2246  } else {
2247  fCenWeigCalHist->SetBinContent(b,1.);
2248  }
2249  }
2250  }
2252  fCenWeigCalHist->Fit("CenFit","QNR","",0.,8.);
2253  Double_t CenAv = CenFit->GetParameter(0);
2254  fCenWeigCalHist->Fit("CenFit","QNR","",12.,50.);
2255  Double_t SemiCenAv = CenFit->GetParameter(0);
2256  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2257  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2258  if(newbin) {
2259  if(b<=10) fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2260  if(b>10 && b<=50) fCenWeigCalHist->SetBinContent(b,SemiCenAv/newbin);
2261  if(b>50) fCenWeigCalHist->SetBinContent(b,1.);
2262  } else {
2263  fCenWeigCalHist->SetBinContent(b,1.);
2264  }
2265  }
2266  }
2267  fCenWeigCalHist->SetName("CenWeights");
2269 } // end of AliFlowAnalysisCRC::SetCentralityWeights()
2270 
2271 //=======================================================================================================================
2272 
2274 {
2275  // Book all objects for integrated flow:
2276  // a) Book profile to hold all flags for integrated flow;
2277  // b) Book event-by-event quantities;
2278  // c) Book profiles; // to be improved (comment)
2279  // d) Book histograms holding the final results.
2280 
2281  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
2282  TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)
2283 
2284  // a) Book profile to hold all flags for integrated flow:
2285  TString intFlowFlagsName = "fIntFlowFlags";
2286  intFlowFlagsName += fAnalysisLabel->Data();
2287  fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",20,0.,20.);
2288  fIntFlowFlags->SetTickLength(-0.01,"Y");
2289  fIntFlowFlags->SetMarkerStyle(25);
2290  fIntFlowFlags->SetLabelSize(0.04);
2291  fIntFlowFlags->SetLabelOffset(0.02,"Y");
2292  fIntFlowFlags->SetStats(kFALSE);
2293  fIntFlowFlags->GetXaxis()->SetBinLabel(1,"Particle Weights");
2294  fIntFlowFlags->GetXaxis()->SetBinLabel(2,"Event Weights");
2295  fIntFlowFlags->GetXaxis()->SetBinLabel(3,"Corrected for NUA?");
2296  fIntFlowFlags->GetXaxis()->SetBinLabel(4,"Print RF results");
2297  fIntFlowFlags->GetXaxis()->SetBinLabel(5,"Print RP results");
2298  fIntFlowFlags->GetXaxis()->SetBinLabel(6,"Print POI results");
2299  fIntFlowFlags->GetXaxis()->SetBinLabel(7,"Print RF (rebinned in M) results");
2300  fIntFlowFlags->GetXaxis()->SetBinLabel(8,"Corrected for NUA vs M?");
2301  fIntFlowFlags->GetXaxis()->SetBinLabel(9,"Propagate errors to v_{n} from correlations?");
2302  fIntFlowFlags->GetXaxis()->SetBinLabel(10,"Calculate cumulants vs M");
2303  fIntFlowFlags->GetXaxis()->SetBinLabel(11,"fMinimumBiasReferenceFlow");
2304  fIntFlowFlags->GetXaxis()->SetBinLabel(12,"fForgetAboutCovariances");
2305  fIntFlowFlags->GetXaxis()->SetBinLabel(13,"fStoreVarious");
2306  fIntFlowFlags->GetXaxis()->SetBinLabel(14,"fFillMultipleControlHistograms");
2307  fIntFlowFlags->GetXaxis()->SetBinLabel(15,"Calculate all correlations vs M");
2308  fIntFlowFlags->GetXaxis()->SetBinLabel(16,"fMultiplicityIs");
2309  fIntFlowFlags->GetXaxis()->SetBinLabel(17,"fExactNoRPs");
2310  fIntFlowFlags->GetXaxis()->SetBinLabel(18,"fUse2DHistograms");
2311  fIntFlowFlags->GetXaxis()->SetBinLabel(19,"fFillProfilesVsMUsingWeights");
2312  fIntFlowFlags->GetXaxis()->SetBinLabel(20,"fUseQvectorTerms");
2314 
2315  // b) Book event-by-event quantities:
2316  // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M:
2317  fReQ = new TMatrixD(12,9);
2318  fImQ = new TMatrixD(12,9);
2319  fSpk = new TMatrixD(8,9);
2320  // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):
2321  TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";
2322  intFlowCorrelationsEBEName += fAnalysisLabel->Data();
2323  fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);
2324  // weights for average correlations <2>, <4>, <6> and <8> for single event:
2325  TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";
2326  intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
2327  fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);
2328  // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):
2329  TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";
2330  intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();
2331  fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),64,0,64);
2332  // average correction terms for non-uniform acceptance for single event
2333  // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):
2334  TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";
2335  fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2336  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2337  {
2338  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);
2339  }
2340  // event weights for terms for non-uniform acceptance:
2341  TString fIntFlowEventWeightForCorrectionTermsForNUAEBEName = "fIntFlowEventWeightForCorrectionTermsForNUAEBE";
2342  fIntFlowEventWeightForCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2343  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2344  {
2345  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
2346  }
2347  // c) Book profiles: // to be improved (comment)
2348  // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:
2349  TString avMultiplicityName = "fAvMultiplicity";
2350  avMultiplicityName += fAnalysisLabel->Data();
2351  fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average multiplicities of reference particles (RPs)",9,0,9);
2352  fAvMultiplicity->SetTickLength(-0.01,"Y");
2353  fAvMultiplicity->SetMarkerStyle(25);
2354  fAvMultiplicity->SetLabelSize(0.05);
2355  fAvMultiplicity->SetLabelOffset(0.02,"Y");
2356  fAvMultiplicity->SetYTitle("Average multiplicity");
2357  (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");
2358  (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");
2359  (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");
2360  (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");
2361  (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");
2362  (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");
2363  (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");
2364  (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");
2365  (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");
2367  // Average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):
2368  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
2369  TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
2370  intFlowCorrelationsProName += fAnalysisLabel->Data();
2371  fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");
2372  fIntFlowCorrelationsPro->Sumw2();
2373  fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");
2374  fIntFlowCorrelationsPro->SetMarkerStyle(25);
2375  fIntFlowCorrelationsPro->SetLabelSize(0.06);
2376  fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");
2377  for(Int_t b=0;b<4;b++)
2378  {
2379  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(b+1,correlationFlag[b].Data());
2380  }
2382  // Average correlations squared <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> for all events:
2383  TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"};
2384  TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
2385  intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
2386  fIntFlowSquaredCorrelationsPro = new TProfile(intFlowSquaredCorrelationsProName.Data(),"Average squared correlations for all events",4,0,4,"s");
2388  fIntFlowSquaredCorrelationsPro->SetTickLength(-0.01,"Y");
2389  fIntFlowSquaredCorrelationsPro->SetMarkerStyle(25);
2390  fIntFlowSquaredCorrelationsPro->SetLabelSize(0.06);
2391  fIntFlowSquaredCorrelationsPro->SetLabelOffset(0.01,"Y");
2392  for(Int_t b=0;b<4;b++)
2393  {
2394  (fIntFlowSquaredCorrelationsPro->GetXaxis())->SetBinLabel(b+1,squaredCorrelationFlag[b].Data());
2395  }
2398  {
2399  for(Int_t ci=0;ci<4;ci++) // correlation index
2400  {
2401  // average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (with wrong errors):
2402  TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
2403  intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
2404  fIntFlowCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data()),
2405  Form("%s vs multiplicity",correlationFlag[ci].Data()),
2407  fIntFlowCorrelationsVsMPro[ci]->Sumw2();
2408  fIntFlowCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2410  {
2411  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2413  {
2414  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2416  {
2417  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2418  }
2420  // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
2421  TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
2422  intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
2423  fIntFlowSquaredCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data()),
2424  Form("%s vs multiplicity",squaredCorrelationFlag[ci].Data()),
2426  fIntFlowSquaredCorrelationsVsMPro[ci]->Sumw2();
2427  fIntFlowSquaredCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(squaredCorrelationFlag[ci].Data());
2429  {
2430  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2432  {
2433  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2435  {
2436  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2437  }
2439  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2440  } // end of if(fCalculateCumulantsVsM)
2441  // averaged all correlations for all events (with wrong errors!):
2442  TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
2443  intFlowCorrelationsAllProName += fAnalysisLabel->Data();
2444  fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average all correlations for all events",64,0,64);
2445  fIntFlowCorrelationsAllPro->Sumw2();
2446  fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");
2447  fIntFlowCorrelationsAllPro->SetMarkerStyle(25);
2448  fIntFlowCorrelationsAllPro->SetLabelSize(0.03);
2449  fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");
2450  // 2-p correlations:
2451  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT_{n|n}");
2452  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"#LT#LT2#GT#GT_{2n|2n}");
2453  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"#LT#LT2#GT#GT_{3n|3n}");
2454  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"#LT#LT2#GT#GT_{4n|4n}");
2455  // 3-p correlations:
2456  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"#LT#LT3#GT#GT_{2n|n,n}");
2457  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"#LT#LT3#GT#GT_{3n|2n,n}");
2458  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"#LT#LT3#GT#GT_{4n|2n,2n}");
2459  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"#LT#LT3#GT#GT_{4n|3n,n}");
2460  // 4-p correlations:
2461  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"#LT#LT4#GT#GT_{n,n|n,n}");
2462  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"#LT#LT4#GT#GT_{2n,n|2n,n}");
2463  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"#LT#LT4#GT#GT_{2n,2n|2n,2n}");
2464  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"#LT#LT4#GT#GT_{3n|n,n,n}");
2465  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"#LT#LT4#GT#GT_{3n,n|3n,n}");
2466  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"#LT#LT4#GT#GT_{3n,n|2n,2n}");
2467  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"#LT#LT4#GT#GT_{4n|2n,n,n}");
2468  // 5-p correlations:
2469  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"#LT#LT5#GT#GT_{2n,n|n,n,n}");
2470  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"#LT#LT5#GT#GT_{2n,2n|2n,n,n}");
2471  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"#LT#LT5#GT#GT_{3n,n|2n,n,n}");
2472  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"#LT#LT5#GT#GT_{4n|n,n,n,n}");
2473  // 6-p correlations:
2474  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"#LT#LT6#GT#GT_{n,n,n|n,n,n}");
2475  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"#LT#LT6#GT#GT_{2n,n,n|2n,n,n}");
2476  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"#LT#LT6#GT#GT_{2n,2n|n,n,n,n}");
2477  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"#LT#LT6#GT#GT_{3n,n|n,n,n,n}");
2478  // 7-p correlations:
2479  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}");
2480  // 8-p correlations:
2481  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}");
2482  // EXTRA correlations for v3{5} study:
2483  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(33,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2484  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(34,"#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}");
2485  // EXTRA correlations for Teaney-Yan study:
2486  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(35,"#LT#LT2#GT#GT_{5n|5n}");
2487  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(36,"#LT#LT2#GT#GT_{6n|6n}");
2488  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(37,"#LT#LT3#GT#GT_{5n|3n,2n}");
2489  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(38,"#LT#LT3#GT#GT_{5n|4n,1n}");
2490  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(39,"#LT#LT3#GT#GT_{6n|3n,3n}");
2491  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(40,"#LT#LT3#GT#GT_{6n|4n,2n}");
2492  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(41,"#LT#LT3#GT#GT_{6n|5n,1n}");
2493  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(42,"#LT#LT4#GT#GT_{6n|3n,2n,1n}");
2494  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(43,"#LT#LT4#GT#GT_{3n,2n|3n,2n}");
2495  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(44,"#LT#LT4#GT#GT_{4n,1n|3n,2n}");
2496  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(45,"#LT#LT4#GT#GT_{3n,3n|3n,3n}");
2497  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(46,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2498  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(47,"#LT#LT4#GT#GT_{5n,1n|3n,3n}");
2499  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(48,"#LT#LT4#GT#GT_{4n,2n|4n,2n}");
2500  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(49,"#LT#LT4#GT#GT_{5n,1n|4n,2n}");
2501  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(50,"#LT#LT4#GT#GT_{5n|3n,1n,1n}");
2502  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(51,"#LT#LT4#GT#GT_{5n|2n,2n,1n}");
2503  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(52,"#LT#LT4#GT#GT_{5n,1n|5n,1n}");
2504  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(53,"#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}");
2505  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(54,"#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}");
2506  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(55,"#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}");
2507  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(56,"#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}");
2508  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(57,"#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}");
2509  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(58,"#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}");
2510  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(59,"#LT#LT4#GT#GT_{6n|4n,1n,1n}");
2511  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(60,"#LT#LT4#GT#GT_{6n|2n,2n,2n}");
2512  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(61,"#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}");
2513  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(62,"#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}");
2514  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(63,"#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}");
2516  // average all correlations versus multiplicity (errors via Sumw2 - to be improved):
2518  {
2519  // 2-p correlations vs M:
2520  fIntFlowCorrelationsAllVsMPro[0] = new TProfile("two1n1n","#LT#LT2#GT#GT_{n|n}",fnBinsMult,fMinMult,fMaxMult);
2521  fIntFlowCorrelationsAllVsMPro[1] = new TProfile("two2n2n","#LT#LT2#GT#GT_{2n|2n}",fnBinsMult,fMinMult,fMaxMult);
2522  fIntFlowCorrelationsAllVsMPro[2] = new TProfile("two3n3n","#LT#LT2#GT#GT_{3n|3n}",fnBinsMult,fMinMult,fMaxMult);
2523  fIntFlowCorrelationsAllVsMPro[3] = new TProfile("two4n4n","#LT#LT2#GT#GT_{4n|4n}",fnBinsMult,fMinMult,fMaxMult);
2524  // 3-p correlations vs M:
2525  fIntFlowCorrelationsAllVsMPro[5] = new TProfile("three2n1n1n","#LT#LT3#GT#GT_{2n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2526  fIntFlowCorrelationsAllVsMPro[6] = new TProfile("three3n2n1n","#LT#LT3#GT#GT_{3n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2527  fIntFlowCorrelationsAllVsMPro[7] = new TProfile("three4n2n2n","#LT#LT3#GT#GT_{4n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2528  fIntFlowCorrelationsAllVsMPro[8] = new TProfile("three4n3n1n","#LT#LT3#GT#GT_{4n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2529  // 4-p correlations vs M:
2530  fIntFlowCorrelationsAllVsMPro[10] = new TProfile("four1n1n1n1n","#LT#LT4#GT#GT_{n,n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2531  fIntFlowCorrelationsAllVsMPro[11] = new TProfile("four2n1n2n1n","#LT#LT4#GT#GT_{2n,n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2532  fIntFlowCorrelationsAllVsMPro[12] = new TProfile("four2n2n2n2n","#LT#LT4#GT#GT_{2n,2n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2533  fIntFlowCorrelationsAllVsMPro[13] = new TProfile("four3n1n1n1n","#LT#LT4#GT#GT_{3n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2534  fIntFlowCorrelationsAllVsMPro[14] = new TProfile("four3n1n3n1n","#LT#LT4#GT#GT_{3n,n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2535  fIntFlowCorrelationsAllVsMPro[15] = new TProfile("four3n1n2n2n","#LT#LT4#GT#GT_{3n,n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2536  fIntFlowCorrelationsAllVsMPro[16] = new TProfile("four4n2n1n1n","#LT#LT4#GT#GT_{4n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2537  // 5-p correlations vs M:
2538  fIntFlowCorrelationsAllVsMPro[18] = new TProfile("five2n1n1n1n1n","#LT#LT5#GT#GT_{2n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2539  fIntFlowCorrelationsAllVsMPro[19] = new TProfile("five2n2n2n1n1n","#LT#LT5#GT#GT_{2n,2n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2540  fIntFlowCorrelationsAllVsMPro[20] = new TProfile("five3n1n2n1n1n","#LT#LT5#GT#GT_{3n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2541  fIntFlowCorrelationsAllVsMPro[21] = new TProfile("five4n1n1n1n1n","#LT#LT5#GT#GT_{4n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2542  // 6-p correlations vs M:
2543  fIntFlowCorrelationsAllVsMPro[23] = new TProfile("six1n1n1n1n1n1n","#LT#LT6#GT#GT_{n,n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2544  fIntFlowCorrelationsAllVsMPro[24] = new TProfile("six2n1n1n2n1n1n","#LT#LT6#GT#GT_{2n,n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2545  fIntFlowCorrelationsAllVsMPro[25] = new TProfile("six2n2n1n1n1n1n","#LT#LT6#GT#GT_{2n,2n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2546  fIntFlowCorrelationsAllVsMPro[26] = new TProfile("six3n1n1n1n1n1n","#LT#LT6#GT#GT_{3n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2547  // 7-p correlations vs M:
2548  fIntFlowCorrelationsAllVsMPro[28] = new TProfile("seven2n1n1n1n1n1n1n","#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2549  // 8-p correlations vs M:
2550  fIntFlowCorrelationsAllVsMPro[30] = new TProfile("eight1n1n1n1n1n1n1n1n","#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2551  // EXTRA correlations vs M for v3{5} study (to be improved - put them in a right order somewhere):
2552  fIntFlowCorrelationsAllVsMPro[32] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2553  fIntFlowCorrelationsAllVsMPro[33] = new TProfile("five3n3n2n2n2n","#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2554  // EXTRA correlations vs M for Teaney-Yan study (to be improved - put them in a right order somewhere):
2555  fIntFlowCorrelationsAllVsMPro[34] = new TProfile("two5n5n","#LT#LT2#GT#GT_{5n|5n}",fnBinsMult,fMinMult,fMaxMult);
2556  fIntFlowCorrelationsAllVsMPro[35] = new TProfile("two6n6n","#LT#LT2#GT#GT_{6n|6n}",fnBinsMult,fMinMult,fMaxMult);
2557  fIntFlowCorrelationsAllVsMPro[36] = new TProfile("three5n3n2n","#LT#LT3#GT#GT_{5n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2558  fIntFlowCorrelationsAllVsMPro[37] = new TProfile("three5n4n1n","#LT#LT3#GT#GT_{5n|4n,1n}",fnBinsMult,fMinMult,fMaxMult);
2559  fIntFlowCorrelationsAllVsMPro[38] = new TProfile("three6n3n3n","#LT#LT3#GT#GT_{6n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2560  fIntFlowCorrelationsAllVsMPro[39] = new TProfile("three6n4n2n","#LT#LT3#GT#GT_{6n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2561  fIntFlowCorrelationsAllVsMPro[40] = new TProfile("three6n5n1n","#LT#LT3#GT#GT_{6n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2562  fIntFlowCorrelationsAllVsMPro[41] = new TProfile("four6n3n2n1n","#LT#LT4#GT#GT_{6n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2563  fIntFlowCorrelationsAllVsMPro[42] = new TProfile("four3n2n3n2n","#LT#LT4#GT#GT_{3n,2n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2564  fIntFlowCorrelationsAllVsMPro[43] = new TProfile("four4n1n3n2n","#LT#LT4#GT#GT_{4n,1n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2565  fIntFlowCorrelationsAllVsMPro[44] = new TProfile("four3n3n3n3n","#LT#LT4#GT#GT_{3n,3n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2566  fIntFlowCorrelationsAllVsMPro[45] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2567  fIntFlowCorrelationsAllVsMPro[46] = new TProfile("four5n1n3n3n","#LT#LT4#GT#GT_{5n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2568  fIntFlowCorrelationsAllVsMPro[47] = new TProfile("four4n2n4n2n","#LT#LT4#GT#GT_{4n,2n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2569  fIntFlowCorrelationsAllVsMPro[48] = new TProfile("four5n1n4n2n","#LT#LT4#GT#GT_{5n,1n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2570  fIntFlowCorrelationsAllVsMPro[49] = new TProfile("four5n3n1n1n","#LT#LT4#GT#GT_{5n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2571  fIntFlowCorrelationsAllVsMPro[50] = new TProfile("four5n2n2n1n","#LT#LT4#GT#GT_{5n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2572  fIntFlowCorrelationsAllVsMPro[51] = new TProfile("four5n1n5n1n","#LT#LT4#GT#GT_{5n,1n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2573  fIntFlowCorrelationsAllVsMPro[52] = new TProfile("five3n3n3n2n1n","#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2574  fIntFlowCorrelationsAllVsMPro[53] = new TProfile("five4n2n3n2n1n","#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2575  fIntFlowCorrelationsAllVsMPro[54] = new TProfile("five3n2n3n1n1n","#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2576  fIntFlowCorrelationsAllVsMPro[55] = new TProfile("five3n2n2n2n1n","#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2577  fIntFlowCorrelationsAllVsMPro[56] = new TProfile("five5n1n3n2n1n","#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2578  fIntFlowCorrelationsAllVsMPro[57] = new TProfile("six3n2n1n3n2n1n","#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2579  fIntFlowCorrelationsAllVsMPro[58] = new TProfile("four6n4n1n1n","#LT#LT4#GT#GT_{6n|4n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2580  fIntFlowCorrelationsAllVsMPro[59] = new TProfile("four6n2n2n2n","#LT#LT4#GT#GT_{6n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2581  fIntFlowCorrelationsAllVsMPro[60] = new TProfile("five6n2n2n1n1n","#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2582  fIntFlowCorrelationsAllVsMPro[61] = new TProfile("five4n1n1n3n3n","#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2583  fIntFlowCorrelationsAllVsMPro[62] = new TProfile("six3n3n2n2n1n1n","#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2584  for(Int_t n=0;n<63;n++)
2585  {
2587  {
2588  fIntFlowCorrelationsAllVsMPro[n]->Sumw2();
2590  {
2591  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# RPs");
2593  {
2594  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2596  {
2597  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# POIs");
2598  }
2600  } // end of if(fIntFlowCorrelationsAllVsMPro[n])
2601  } // end of for(Int_t n=0;n<63;n++)
2602  } // end of if(fCalculateAllCorrelationsVsM)
2603  // when particle weights are used some extra correlations appear:
2605  {
2606  TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
2607  intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
2608  fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");
2609  fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");
2610  fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);
2611  fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);
2612  fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");
2613  // extra 2-p correlations:
2614  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");
2615  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");
2617  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
2618  // average product of correlations <2>, <4>, <6> and <8>:
2619  TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
2620  "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
2621  TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
2622  intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
2623  fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);
2624  fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");
2625  fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25);
2626  fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);
2627  fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");
2628  for(Int_t b=0;b<6;b++)
2629  {
2630  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(b+1,productFlag[b].Data());
2631  }
2633  // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
2634  // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
2636  {
2637  TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
2638  intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
2639  for(Int_t pi=0;pi<6;pi++)
2640  {
2641  fIntFlowProductOfCorrelationsVsMPro[pi] = new TProfile(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data()),
2642  Form("%s versus multiplicity",productFlag[pi].Data()),
2645  {
2646  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# RPs");
2648  {
2649  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2651  {
2652  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# POIs");
2653  }
2655  } // end of for(Int_t pi=0;pi<6;pi++)
2656  } // end of if(fCalculateCumulantsVsM)
2657  // average product of correction terms for NUA:
2658  TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
2659  intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2660  fIntFlowProductOfCorrectionTermsForNUAPro = new TProfile(intFlowProductOfCorrectionTermsForNUAProName.Data(),"Average products of correction terms for NUA",27,0,27);
2661  fIntFlowProductOfCorrectionTermsForNUAPro->SetTickLength(-0.01,"Y");
2662  fIntFlowProductOfCorrectionTermsForNUAPro->SetMarkerStyle(25);
2663  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelSize(0.03);
2664  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelOffset(0.01,"Y");
2665  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(1,"<<2><cos(#phi)>>");
2666  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(2,"<<2><sin(#phi)>>");
2667  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(3,"<<cos(#phi)><sin(#phi)>>");
2668  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2669  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2670  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2671  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2672  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2673  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2674  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2675  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2676  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2677  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2678  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2679  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2680  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2681  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2682  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2683  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2684  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2685  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2686  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2687  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2688  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2689  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2690  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2691  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2693  // average correction terms for non-uniform acceptance (with wrong errors!):
2694  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2695  {
2696  TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
2697  intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2698  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");
2699  fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");
2700  fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);
2701  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.05);
2702  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");
2703  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2704  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2705  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2706  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2708  // versus multiplicity:
2710  {
2711  TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
2712  for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2713  {
2714  TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
2715  intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
2716  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");
2718  }
2719  } // end of if(fCalculateCumulantsVsM)
2720  } // end of for(Int_t sc=0;sc<2;sc++)
2721 
2722  // d) Book histograms holding the final results:
2723  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):
2724  TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
2725  intFlowCorrelationsHistName += fAnalysisLabel->Data();
2726  fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);
2727  fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");
2728  fIntFlowCorrelationsHist->SetMarkerStyle(25);
2729  fIntFlowCorrelationsHist->SetLabelSize(0.06);
2730  fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");
2731  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT");
2732  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"#LT#LT4#GT#GT");
2733  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"#LT#LT6#GT#GT");
2734  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"#LT#LT8#GT#GT");
2736  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!) vs M:
2738  {
2739  for(Int_t ci=0;ci<4;ci++) // correlation index
2740  {
2741  TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
2742  intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
2743  fIntFlowCorrelationsVsMHist[ci] = new TH1D(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data()),
2744  Form("%s vs multiplicity",correlationFlag[ci].Data()),
2746  fIntFlowCorrelationsVsMHist[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2748  {
2749  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# RPs");
2751  {
2752  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2754  {
2755  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# POIs");
2756  }
2758  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2759  } // end of if(fCalculateCumulantsVsM)
2760  // average all correlations for all events (with correct errors!):
2761  TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
2762  intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
2763  fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",34,0,34);
2764  fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");
2765  fIntFlowCorrelationsAllHist->SetMarkerStyle(25);
2766  fIntFlowCorrelationsAllHist->SetLabelSize(0.03);
2767  fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");
2768  // 2-p correlations:
2769  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");
2770  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");
2771  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");
2772  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");
2773  // 3-p correlations:
2774  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");
2775  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");
2776  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");
2777  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");
2778  // 4-p correlations:
2779  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}");
2780  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");
2781  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");
2782  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");
2783  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");
2784  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}");
2785  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");
2786  // 5-p correlations:
2787  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}");
2788  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");
2789  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");
2790  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");
2791  // 6-p correlations:
2792  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");
2793  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");
2794  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");
2795  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");
2796  // 7-p correlations:
2797  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");
2798  // 8-p correlations:
2799  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");
2801  // average correction terms for non-uniform acceptance (with correct errors!):
2802  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2803  {
2804  TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
2805  intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
2806  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);
2807  fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");
2808  fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);
2809  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.05);
2810  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");
2811  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2812  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2813  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2814  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2816  } // end of for(Int_t sc=0;sc<2;sc++)
2817  // covariances (multiplied with weight dependent prefactor):
2818  TString intFlowCovariancesName = "fIntFlowCovariances";
2819  intFlowCovariancesName += fAnalysisLabel->Data();
2820  fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);
2821  fIntFlowCovariances->SetLabelSize(0.04);
2822  fIntFlowCovariances->SetMarkerStyle(25);
2823  (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(#LT2#GT,#LT4#GT)");
2824  (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(#LT2#GT,#LT6#GT)");
2825  (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(#LT2#GT,#LT8#GT)");
2826  (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(#LT4#GT,#LT6#GT)");
2827  (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(#LT4#GT,#LT8#GT)");
2828  (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(#LT6#GT,#LT8#GT)");
2830  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
2831  TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
2832  intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
2833  for(Int_t power=0;power<2;power++)
2834  {
2835  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);
2836  fIntFlowSumOfEventWeights[power]->SetLabelSize(0.04);
2837  fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);
2838  if(power == 0)
2839  {
2840  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}");
2841  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}");
2842  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}");
2843  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}");
2844  } else if (power == 1)
2845  {
2846  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}^{2}");
2847  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}^{2}");
2848  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}^{2}");
2849  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}^{2}");
2850  }
2852  }
2853  // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
2854  TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
2855  intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
2856  fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);
2857  fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.04);
2858  fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);
2859  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT4#GT}");
2860  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT6#GT}");
2861  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT8#GT}");
2862  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT6#GT}");
2863  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT8#GT}");
2864  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT6#GT} w_{#LT8#GT}");
2866  // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
2867  // [0=Cov(2,4),1=Cov(2,6),2=Cov(2,8),3=Cov(4,6),4=Cov(4,8),5=Cov(6,8)]:
2869  {
2870  TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
2871  intFlowCovariancesVsMName += fAnalysisLabel->Data();
2872  TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
2873  for(Int_t ci=0;ci<6;ci++)
2874  {
2875  fIntFlowCovariancesVsM[ci] = new TH1D(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data()),
2876  Form("%s vs multiplicity",covarianceFlag[ci].Data()),
2878  fIntFlowCovariancesVsM[ci]->GetYaxis()->SetTitle(covarianceFlag[ci].Data());
2880  {
2881  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# RPs");
2883  {
2884  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2886  {
2887  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# POIs");
2888  }
2890  }
2891  } // end of if(fCalculateCumulantsVsM)
2892  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
2893  // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
2895  {
2896  TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
2897  intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
2898  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>}"},
2899  {"#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}"}};
2900  for(Int_t si=0;si<4;si++)
2901  {
2902  for(Int_t power=0;power<2;power++)
2903  {
2904  fIntFlowSumOfEventWeightsVsM[si][power] = new TH1D(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data()),
2905  Form("%s vs multiplicity",sumFlag[power][si].Data()),
2907  fIntFlowSumOfEventWeightsVsM[si][power]->GetYaxis()->SetTitle(sumFlag[power][si].Data());
2909  {
2910  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# RPs");
2912  {
2913  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2915  {
2916  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# POIs");
2917  }
2919  } // end of for(Int_t power=0;power<2;power++)
2920  } // end of for(Int_t si=0;si<4;si++)
2921  } // end of if(fCalculateCumulantsVsM)
2922  // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
2923  // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
2924  // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
2926  {
2927  TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
2928  intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
2929  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>}",
2930  "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
2931  for(Int_t pi=0;pi<6;pi++)
2932  {
2933  fIntFlowSumOfProductOfEventWeightsVsM[pi] = new TH1D(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data()),
2934  Form("%s versus multiplicity",sopowFlag[pi].Data()),
2937  {
2938  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# RPs");
2940  {
2941  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2943  {
2944  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# POIs");
2945  }
2946  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetYaxis()->SetTitle(sopowFlag[pi].Data());
2948  } // end of for(Int_t pi=0;pi<6;pi++)
2949  } // end of if(fCalculateCumulantsVsM)
2950  // covariances of NUA terms (multiplied with weight dependent prefactor):
2951  TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
2952  intFlowCovariancesNUAName += fAnalysisLabel->Data();
2953  fIntFlowCovariancesNUA = new TH1D(intFlowCovariancesNUAName.Data(),"Covariances for NUA (multiplied with weight dependent prefactor)",27,0,27);
2954  fIntFlowCovariancesNUA->SetLabelSize(0.04);
2955  fIntFlowCovariancesNUA->SetMarkerStyle(25);
2956  fIntFlowCovariancesNUA->GetXaxis()->SetLabelSize(0.02);
2957  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(1,"Cov(<2>,<cos(#phi)>");
2958  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(2,"Cov(<2>,<sin(#phi)>)");
2959  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(3,"Cov(<cos(#phi)>,<sin(#phi)>)");
2960  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2961  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2962  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2963  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2964  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2965  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2966  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2967  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2968  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2969  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2970  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2971  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2972  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2973  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2974  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2975  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2976  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2977  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2978  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2979  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2980  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2981  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2982  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2983  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2985  // sum of linear and quadratic event weights for NUA terms:
2986  TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
2987  intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
2988  for(Int_t sc=0;sc<2;sc++)
2989  {
2990  for(Int_t power=0;power<2;power++)
2991  {
2992  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
2993  fIntFlowSumOfEventWeightsNUA[sc][power]->SetLabelSize(0.05);
2994  fIntFlowSumOfEventWeightsNUA[sc][power]->SetMarkerStyle(25);
2995  if(power == 0)
2996  {
2997  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}",sinCosFlag[sc].Data()));
2998  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}",sinCosFlag[sc].Data()));
2999  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}",sinCosFlag[sc].Data()));
3000  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}",sinCosFlag[sc].Data()));
3001  } else if(power == 1)
3002  {
3003  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}^{2}",sinCosFlag[sc].Data()));
3004  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
3005  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}^{2}",sinCosFlag[sc].Data()));
3006  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
3007  }
3009  }
3010  }
3011  // sum of products of event weights for NUA terms:
3012  TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
3013  intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
3014  fIntFlowSumOfProductOfEventWeightsNUA = new TH1D(intFlowSumOfProductOfEventWeightsNUAName.Data(),"Sum of product of event weights for NUA terms",27,0,27);
3015  fIntFlowSumOfProductOfEventWeightsNUA->SetLabelSize(0.02);
3016  fIntFlowSumOfProductOfEventWeightsNUA->SetMarkerStyle(25);
3017  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi)#GT}");
3018  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi)#GT}");
3019  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi)#GT}");
3020  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3021  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3022  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3023  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(7,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3024  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(8,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi)#GT}");
3025  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(9,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi)#GT}");
3026  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(10,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3027  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(11,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3028  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(12,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3029  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(13,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3030  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(14,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3031  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(15,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3032  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(16,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3033  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(17,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3034  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(18,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3035  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(19,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3036  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(20,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3037  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(21,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3038  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(22,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3039  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(23,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3040  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(24,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3041  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(25,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3042  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(26,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3043  (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}");
3045  // Final results for reference Q-cumulants:
3046  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3047  TString intFlowQcumulantsName = "fIntFlowQcumulants";
3048  intFlowQcumulantsName += fAnalysisLabel->Data();
3049  fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Reference Q-cumulants",4,0,4);
3051  {
3052  fIntFlowQcumulants->SetTitle("Reference Q-cumulants (error from non-isotropic terms also propagated)");
3053  }
3054  fIntFlowQcumulants->SetLabelSize(0.05);
3055  fIntFlowQcumulants->SetMarkerStyle(25);
3056  for(Int_t b=0;b<4;b++)
3057  {
3058  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3059  }
3061  // Final results for reference Q-cumulants rebinned in M:
3063  {
3064  TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
3065  intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
3066  fIntFlowQcumulantsRebinnedInM = new TH1D(intFlowQcumulantsRebinnedInMName.Data(),"Reference Q-cumulants rebinned in M",4,0,4);
3067  fIntFlowQcumulantsRebinnedInM->SetLabelSize(0.05);
3068  fIntFlowQcumulantsRebinnedInM->SetMarkerStyle(25);
3069  for(Int_t b=0;b<4;b++)
3070  {
3071  (fIntFlowQcumulantsRebinnedInM->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3072  }
3074  } // end of if(fCalculateCumulantsVsM)
3075  // Ratio between error squared: with/without non-isotropic terms:
3076  TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
3077  intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
3078  fIntFlowQcumulantsErrorSquaredRatio = new TH1D(intFlowQcumulantsErrorSquaredRatioName.Data(),"Error squared of reference Q-cumulants: #frac{with NUA terms}{without NUA terms}",4,0,4);
3079  fIntFlowQcumulantsErrorSquaredRatio->SetLabelSize(0.05);
3080  fIntFlowQcumulantsErrorSquaredRatio->SetMarkerStyle(25);
3081  for(Int_t b=0;b<4;b++)
3082  {
3083  (fIntFlowQcumulantsErrorSquaredRatio->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3084  }
3086  // final results for integrated Q-cumulants versus multiplicity:
3088  {
3089  TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
3090  intFlowQcumulantsVsMName += fAnalysisLabel->Data();
3091  for(Int_t co=0;co<4;co++) // cumulant order
3092  {
3093  fIntFlowQcumulantsVsM[co] = new TH1D(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data()),
3094  Form("%s vs multiplicity",cumulantFlag[co].Data()),
3097  {
3098  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# RPs");
3100  {
3101  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3103  {
3104  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# POIs");
3105  }
3106  fIntFlowQcumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());
3108  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3109  } // end of if(fCalculateCumulantsVsM)
3110  // final integrated flow estimates from Q-cumulants:
3111  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)};
3112  TString intFlowName = "fIntFlow";
3113  intFlowName += fAnalysisLabel->Data();
3114  // integrated flow from Q-cumulants:
3115  fIntFlow = new TH1D(intFlowName.Data(),"Reference flow estimates from Q-cumulants",4,0,4);
3116  fIntFlow->SetLabelSize(0.05);
3117  fIntFlow->SetMarkerStyle(25);
3118  for(Int_t b=0;b<4;b++)
3119  {
3120  (fIntFlow->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3121  }
3122  fIntFlowResults->Add(fIntFlow);
3123  // Reference flow vs M rebinned in one huge bin:
3125  {
3126  TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
3127  intFlowRebinnedInMName += fAnalysisLabel->Data();
3128  fIntFlowRebinnedInM = new TH1D(intFlowRebinnedInMName.Data(),"Reference flow estimates from Q-cumulants (rebinned in M)",4,0,4);
3129  fIntFlowRebinnedInM->SetLabelSize(0.05);
3130  fIntFlowRebinnedInM->SetMarkerStyle(25);
3131  for(Int_t b=0;b<4;b++)
3132  {
3133  (fIntFlowRebinnedInM->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3134  }
3136  }
3137  // integrated flow from Q-cumulants: versus multiplicity:
3139  {
3140  TString intFlowVsMName = "fIntFlowVsM";
3141  intFlowVsMName += fAnalysisLabel->Data();
3142  for(Int_t co=0;co<4;co++) // cumulant order
3143  {
3144  fIntFlowVsM[co] = new TH1D(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data()),
3145  Form("%s vs multiplicity",flowFlag[co].Data()),
3148  {
3149  fIntFlowVsM[co]->GetXaxis()->SetTitle("# RPs");
3151  {
3152  fIntFlowVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3154  {
3155  fIntFlowVsM[co]->GetXaxis()->SetTitle("# POIs");
3156  }
3157  fIntFlowVsM[co]->GetYaxis()->SetTitle(flowFlag[co].Data());
3158  fIntFlowResults->Add(fIntFlowVsM[co]);
3159  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3160  } // end of if(fCalculateCumulantsVsM)
3161  // quantifying detector effects effects to correlations:
3162  TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
3163  intFlowDetectorBiasName += fAnalysisLabel->Data();
3164  fIntFlowDetectorBias = new TH1D(intFlowDetectorBiasName.Data(),"Quantifying detector bias",4,0,4);
3165  fIntFlowDetectorBias->SetLabelSize(0.05);
3166  fIntFlowDetectorBias->SetMarkerStyle(25);
3167  for(Int_t ci=0;ci<4;ci++)
3168  {
3169  (fIntFlowDetectorBias->GetXaxis())->SetBinLabel(ci+1,Form("#frac{corrected}{measured} %s",cumulantFlag[ci].Data()));
3170  }
3172  // quantifying detector effects to correlations versus multiplicity:
3174  {
3175  TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
3176  intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
3177  for(Int_t ci=0;ci<4;ci++) // correlation index
3178  {
3179  fIntFlowDetectorBiasVsM[ci] = new TH1D(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data()),
3180  Form("Quantifying detector bias for %s vs multiplicity",cumulantFlag[ci].Data()),
3183  {
3184  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# RPs");
3186  {
3187  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3189  {
3190  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# POIs");
3191  }
3192  fIntFlowDetectorBiasVsM[ci]->GetYaxis()->SetTitle("#frac{corrected}{measured}");
3194  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3195  } // end of if(fCalculateCumulantsVsM)
3196 
3197 } // end of AliFlowAnalysisCRC::BookEverythingForIntegratedFlow()
3198 
3199 //=======================================================================================================================
3200 
3202 {
3203  // Book all objects for control histograms.
3204 
3205  // a) Book profile to hold all flags for control histograms;
3206  // b) Book all control histograms.
3207 
3208  // a) Book profile to hold all flags for control histograms:
3209  TString controlHistogramsFlagsName = "fControlHistogramsFlags";
3210  controlHistogramsFlagsName += fAnalysisLabel->Data();
3211  fControlHistogramsFlags = new TProfile(controlHistogramsFlagsName.Data(),"Flags for Control Histograms",2,0,2);
3212  fControlHistogramsFlags->SetTickLength(-0.01,"Y");
3213  fControlHistogramsFlags->SetMarkerStyle(25);
3214  fControlHistogramsFlags->SetLabelSize(0.04);
3215  fControlHistogramsFlags->SetLabelOffset(0.02,"Y");
3216  fControlHistogramsFlags->SetStats(kFALSE);
3217  fControlHistogramsFlags->GetXaxis()->SetBinLabel(1,"fStoreControlHistograms");
3218  fControlHistogramsFlags->GetXaxis()->SetBinLabel(2,"fUseQvectorTerms");
3220 
3221  if(!fStoreControlHistograms){return;}
3222 
3223  // b) Book all control histograms:
3224  // b1) Correlation between # RPs and ref. mult. determined centrally:
3225  TString sCorrelationNoRPsVsRefMultName = "fCorrelationNoRPsVsRefMult";
3226  sCorrelationNoRPsVsRefMultName += fAnalysisLabel->Data();
3227  fCorrelationNoRPsVsRefMult = new TH2D(sCorrelationNoRPsVsRefMultName.Data(),"# RPs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3228  fCorrelationNoRPsVsRefMult->SetTickLength(-0.01,"Y");
3229  fCorrelationNoRPsVsRefMult->SetLabelSize(0.04);
3230  fCorrelationNoRPsVsRefMult->SetLabelOffset(0.02,"Y");
3231  fCorrelationNoRPsVsRefMult->SetStats(kTRUE);
3232  fCorrelationNoRPsVsRefMult->GetXaxis()->SetTitle("# RPs");
3233  fCorrelationNoRPsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3235  // b2) Correlation between # POIs and ref. mult. determined centrally:
3236  TString sCorrelationNoPOIsVsRefMultName = "fCorrelationNoPOIsVsRefMult";
3237  sCorrelationNoPOIsVsRefMultName += fAnalysisLabel->Data();
3238  fCorrelationNoPOIsVsRefMult = new TH2D(sCorrelationNoPOIsVsRefMultName.Data(),"# POIs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3239  fCorrelationNoPOIsVsRefMult->SetTickLength(-0.01,"Y");
3240  fCorrelationNoPOIsVsRefMult->SetLabelSize(0.04);
3241  fCorrelationNoPOIsVsRefMult->SetLabelOffset(0.02,"Y");
3242  fCorrelationNoPOIsVsRefMult->SetStats(kTRUE);
3243  fCorrelationNoPOIsVsRefMult->GetXaxis()->SetTitle("# POIs");
3244  fCorrelationNoPOIsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3246  // b3) Correlation between # RPs and # POIs:
3247  TString sCorrelationNoRPsVsNoPOIsName = "fCorrelationNoRPsVsNoPOIs";
3248  sCorrelationNoRPsVsNoPOIsName += fAnalysisLabel->Data();
3249  fCorrelationNoRPsVsNoPOIs = new TH2D(sCorrelationNoRPsVsNoPOIsName.Data(),"# RPs vs. # POIs",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3250  fCorrelationNoRPsVsNoPOIs->SetTickLength(-0.01,"Y");
3251  fCorrelationNoRPsVsNoPOIs->SetLabelSize(0.04);
3252  fCorrelationNoRPsVsNoPOIs->SetLabelOffset(0.02,"Y");
3253  fCorrelationNoRPsVsNoPOIs->SetStats(kTRUE);
3254  fCorrelationNoRPsVsNoPOIs->GetXaxis()->SetTitle("# RPs");
3255  fCorrelationNoRPsVsNoPOIs->GetYaxis()->SetTitle("# POIs");
3257  // b4) <2>, <4>, <6> and <8> vs multiplicity (#RPs, #POIs or external):
3258  TString sCorrelation[4] = {"#LT2#GT","#LT4#GT","#LT6#GT","#LT8#GT"};
3259  TString sMultiplicity = "";
3261  {
3262  sMultiplicity = "# RPs";
3264  {
3265  sMultiplicity = "Reference multiplicity (from ESD)";
3267  {
3268  sMultiplicity = "# POIs";
3269  }
3270  for(Int_t ci=0;ci<4;ci++)
3271  {
3272  fCorrelation2468VsMult[ci] = new TH2D(Form("%s vs M",sCorrelation[ci].Data()),Form("%s vs M",sCorrelation[ci].Data()),fnBinsMult,fMinMult,fMaxMult,fnBinsForCorrelations,fMinValueOfCorrelation[ci],fMaxValueOfCorrelation[ci]);
3273  fCorrelation2468VsMult[ci]->SetTickLength(-0.01,"Y");
3274  fCorrelation2468VsMult[ci]->SetLabelSize(0.04);
3275  fCorrelation2468VsMult[ci]->SetLabelOffset(0.02,"Y");
3276  fCorrelation2468VsMult[ci]->SetStats(kTRUE);
3277  fCorrelation2468VsMult[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3278  fCorrelation2468VsMult[ci]->GetYaxis()->SetTitle(sCorrelation[ci].Data());
3280  } // end of for(Int_t ci=0;ci<4;ci++)
3281  // b5) <2><4>, <2><6>, <2><8>, <4><6> etc. vs multiplicity (#RPs, #POIs or external):
3282  TString sCorrelationProduct[1] = {"#LT2#GT#LT4#GT"}; // TBI: add the other ones when needed first time
3283  for(Int_t cpi=0;cpi<1;cpi++) // TBI: hardwired 1
3284  {
3285  fCorrelationProduct2468VsMult[cpi] = new TH2D(Form("%s vs M",sCorrelationProduct[cpi].Data()),Form("%s vs M",sCorrelationProduct[cpi].Data()),fnBinsMult,fMinMult,fMaxMult,fnBinsForCorrelations,fMinValueOfCorrelationProduct[cpi],fMaxValueOfCorrelationProduct[cpi]);
3286  fCorrelationProduct2468VsMult[cpi]->SetTickLength(-0.01,"Y");
3287  fCorrelationProduct2468VsMult[cpi]->SetLabelSize(0.04);
3288  fCorrelationProduct2468VsMult[cpi]->SetLabelOffset(0.02,"Y");
3289  fCorrelationProduct2468VsMult[cpi]->SetStats(kTRUE);
3290  fCorrelationProduct2468VsMult[cpi]->GetXaxis()->SetTitle(sMultiplicity.Data());
3291  fCorrelationProduct2468VsMult[cpi]->GetYaxis()->SetTitle(sCorrelationProduct[cpi].Data());
3293  } // end of for(Int_t cpi=0;cpi<4;cpi++)
3294  // b6) |Qn|^2/M, |Q2n|^2/M, |Qn|^4/(M(2M-1)), Re[Q2nQn^*Qn^*]/M, ... vs multiplicity (#RPs, #POIs or external)
3295  if(fUseQvectorTerms)
3296  {
3297  TString sQvectorTerms[4] = {"#frac{|Q_{n}|^{2}}{M}","#frac{|Q_{2n}|^{2}}{M}","#frac{|Q_{n}|^{4}}{M(2M-1)}","#frac{Re[Q_{2n}Q_{n}^{*}Q_{n}^{*}]}{M^{3/2}}"}; // TBI: add the other ones when needed first time
3298  for(Int_t qvti=0;qvti<4;qvti++) // TBI: hardwired 4
3299  {
3300  fQvectorTermsVsMult[qvti] = new TH2D(Form("%s vs M",sQvectorTerms[qvti].Data()),Form("%s vs M",sQvectorTerms[qvti].Data()),fnBinsMult,fMinMult,fMaxMult,fnBinsForCorrelations,fMinValueOfQvectorTerms[qvti],fMaxValueOfQvectorTerms[qvti]);
3301  fQvectorTermsVsMult[qvti]->SetTickLength(-0.01,"Y");
3302  fQvectorTermsVsMult[qvti]->SetLabelSize(0.04);
3303  fQvectorTermsVsMult[qvti]->SetLabelOffset(0.02,"Y");
3304  fQvectorTermsVsMult[qvti]->SetStats(kTRUE);
3305  fQvectorTermsVsMult[qvti]->GetXaxis()->SetTitle(sMultiplicity.Data());
3306  fQvectorTermsVsMult[qvti]->GetYaxis()->SetTitle(sQvectorTerms[qvti].Data());
3308  } // end of for(Int_t qvti=0;qvti<4;qvti++)
3309  } // end of if(fUseQvectorTerms)
3310 
3311 } // end of void AliFlowAnalysisCRC::BookEverythingForControlHistograms()
3312 
3313 //=======================================================================================================================
3314 
3316 {
3317  // Book all objects needed for bootstrap.
3318 
3319  // a) Book profile to hold all flags for bootstrap;
3320  // b) Book local random generator;
3321  // c) Book all bootstrap objects;
3322  // d) Book all bootstrap objects 'vs M'.
3323 
3324  // a) Book profile to hold all flags for bootstrap;
3325  TString bootstrapFlagsName = "fBootstrapFlags";
3326  bootstrapFlagsName += fAnalysisLabel->Data();
3327  fBootstrapFlags = new TProfile(bootstrapFlagsName.Data(),"Flags for bootstrap",3,0,3);
3328  fBootstrapFlags->SetTickLength(-0.01,"Y");
3329  fBootstrapFlags->SetMarkerStyle(25);
3330  fBootstrapFlags->SetLabelSize(0.04);
3331  fBootstrapFlags->SetLabelOffset(0.02,"Y");
3332  fBootstrapFlags->SetStats(kFALSE);
3333  fBootstrapFlags->GetXaxis()->SetBinLabel(1,"fUseBootstrap");
3334  fBootstrapFlags->GetXaxis()->SetBinLabel(2,"fUseBootstrapVsM");
3335  fBootstrapFlags->GetXaxis()->SetBinLabel(3,"fnSubsamples");
3337 
3338  // b) Book local random generator:
3340  {
3341  fRandom = new TRandom3(0); // if uiSeed is 0, the seed is determined uniquely in space and time via TUUID
3342  }
3343 
3344  // c) Book all bootstrap objects:
3345  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
3346  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3347  if(fUseBootstrap)
3348  {
3349  // ....
3350  TString bootstrapCorrelationsName = "fBootstrapCorrelations";
3351  bootstrapCorrelationsName += fAnalysisLabel->Data();
3352  fBootstrapCorrelations = new TProfile2D(bootstrapCorrelationsName.Data(),"Bootstrap Correlations",4,0.,4.,fnSubsamples,0,fnSubsamples); // x-axis => <2>, <4>, <6>, <8>; y-axis => subsample #
3353  fBootstrapCorrelations->SetStats(kFALSE);
3354  for(Int_t ci=0;ci<4;ci++) // correlation index
3355  {
3356  fBootstrapCorrelations->GetXaxis()->SetBinLabel(ci+1,correlationFlag[ci].Data());
3357  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3358  for(Int_t ss=0;ss<fnSubsamples;ss++)
3359  {
3360  fBootstrapCorrelations->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3361  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3363  // ....
3364  TString bootstrapCumulantsName = "fBootstrapCumulants";
3365  bootstrapCumulantsName += fAnalysisLabel->Data();
3366  fBootstrapCumulants = new TH2D(bootstrapCumulantsName.Data(),"Bootstrap Cumulants",4,0.,4.,fnSubsamples,0,fnSubsamples); // x-axis => QC{2}, QC{4}, QC{6}, QC{8}; y-axis => subsample #
3367  fBootstrapCumulants->SetStats(kFALSE);
3368  for(Int_t co=0;co<4;co++) // cumulant order
3369  {
3370  fBootstrapCumulants->GetXaxis()->SetBinLabel(co+1,cumulantFlag[co].Data());
3371  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3372  for(Int_t ss=0;ss<fnSubsamples;ss++)
3373  {
3374  fBootstrapCumulants->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3375  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3377  } // end of if(fUseBootstrap)
3378 
3379  // d) Book all bootstrap objects 'vs M':
3380  TString sMultiplicity = "";
3382  {
3383  sMultiplicity = "# RPs";
3385  {
3386  sMultiplicity = "Reference multiplicity (from ESD)";
3388  {
3389  sMultiplicity = "# POIs";
3390  }
3391  if(fUseBootstrapVsM)
3392  {
3393  // ....
3394  TString bootstrapCorrelationsVsMName = "fBootstrapCorrelationsVsM";
3395  bootstrapCorrelationsVsMName += fAnalysisLabel->Data();
3396  for(Int_t ci=0;ci<4;ci++) // correlation index
3397  {
3398  fBootstrapCorrelationsVsM[ci] = new TProfile2D(Form("%s, %s",bootstrapCorrelationsVsMName.Data(),correlationFlag[ci].Data()),
3399  Form("Bootstrap Correlations Vs. M, %s",correlationFlag[ci].Data()),
3400  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3401  fBootstrapCorrelationsVsM[ci]->SetStats(kFALSE);
3402  fBootstrapCorrelationsVsM[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3403  for(Int_t ss=0;ss<fnSubsamples;ss++)
3404  {
3405  fBootstrapCorrelationsVsM[ci]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3406  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3408  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3409  // ....
3410  TString bootstrapCumulantsVsMName = "fBootstrapCumulantsVsM";
3411  bootstrapCumulantsVsMName += fAnalysisLabel->Data();
3412  for(Int_t co=0;co<4;co++) // cumulant order
3413  {
3414  fBootstrapCumulantsVsM[co] = new TH2D(Form("%s, %s",bootstrapCumulantsVsMName.Data(),cumulantFlag[co].Data()),
3415  Form("Bootstrap Cumulants Vs. M, %s",cumulantFlag[co].Data()),
3416  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3417  fBootstrapCumulantsVsM[co]->SetStats(kFALSE);
3418  fBootstrapCumulantsVsM[co]->GetXaxis()->SetTitle(sMultiplicity.Data());
3419  for(Int_t ss=0;ss<fnSubsamples;ss++)
3420  {
3421  fBootstrapCumulantsVsM[co]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3422  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3424  } // end of for(Int_t co=0;co<4;co++) // correlation index
3425  } // end of if(fUseBootstrapVsM)
3426 
3427 } // end of void AliFlowAnalysisCRC::BookEverythingForBootstrap()
3428 
3429 //=======================================================================================================================
3430 
3432 {
3433  // Book all objects for mixed harmonics.
3434 
3435  // a) Book profile to hold all flags for mixed harmonics;
3436  // b) Book all objects in TList fMixedHarmonicsProfiles;
3437  // c) Book all objects in TList fMixedHarmonicsResults;
3438  // d) Book all objects in TList fMixedHarmonicsErrorPropagation.
3439 
3440  // a) Book profile to hold all flags for mixed harmonics:
3441  TString mixedHarmonicsFlagsName = "fMixedHarmonicsFlags";
3442  mixedHarmonicsFlagsName += fAnalysisLabel->Data();
3443  fMixedHarmonicsFlags = new TProfile(mixedHarmonicsFlagsName.Data(),"Flags for Mixed Harmonics",4,0,4);
3444  fMixedHarmonicsFlags->SetTickLength(-0.01,"Y");
3445  fMixedHarmonicsFlags->SetMarkerStyle(25);
3446  fMixedHarmonicsFlags->SetLabelSize(0.04);
3447  fMixedHarmonicsFlags->SetLabelOffset(0.02,"Y");
3448  fMixedHarmonicsFlags->SetStats(kFALSE);
3449  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(1,"Calculate Mixed Harmonics");
3450  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(2,"Generic Harmonic");
3451  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(3,"Calculate vs Multiplicity");
3452  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(4,"Multiplicity Weight");
3454 
3455  if(!fCalculateMixedHarmonics){return;}
3456 
3457  // b) Book all objects in TList fMixedHarmonicsProfiles:
3458  // b1) 2-p correlations:
3459  TString s2pCorrelationsName = "f2pCorrelations";
3460  s2pCorrelationsName += fAnalysisLabel->Data();
3461  f2pCorrelations = new TProfile(s2pCorrelationsName.Data(),Form("2-particle correlations (n = %d)",fHarmonic),6,0,6,"s");
3462  f2pCorrelations->SetTickLength(-0.01,"Y");
3463  f2pCorrelations->SetMarkerStyle(25);
3464  f2pCorrelations->SetLabelSize(0.04);
3465  f2pCorrelations->SetLabelOffset(0.02,"Y");
3466  f2pCorrelations->SetStats(kFALSE);
3467  f2pCorrelations->Sumw2();
3468  f2pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
3469  f2pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
3470  f2pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
3471  f2pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
3472  f2pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
3473  f2pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT2#GT#GT_{%dn|%dn}",6*fHarmonic,6*fHarmonic));
3475  // b2) 3-p correlations (3+6):
3476  TString s3pCorrelationsName = "f3pCorrelations";
3477  s3pCorrelationsName += fAnalysisLabel->Data();
3478  f3pCorrelations = new TProfile(s3pCorrelationsName.Data(),Form("3-particle correlations (n = %d)",fHarmonic),10,0,10,"s");
3479  f3pCorrelations->SetTickLength(-0.01,"Y");
3480  f3pCorrelations->SetMarkerStyle(25);
3481  f3pCorrelations->SetLabelSize(0.04);
3482  f3pCorrelations->SetLabelOffset(0.02,"Y");
3483  f3pCorrelations->SetStats(kFALSE);
3484  f3pCorrelations->Sumw2();
3485  // 3-p correlations sensitive to two distinct harmonics (3):
3486  f3pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic));
3487  f3pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic));
3488  f3pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic));
3489  f3pCorrelations->GetXaxis()->SetBinLabel(4,""); // empty
3490  // 3-p correlations sensitive to three distinct harmonics (6):
3491  f3pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,1*fHarmonic));
3492  f3pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,1*fHarmonic));
3493  f3pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,2*fHarmonic));
3494  f3pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,1*fHarmonic));
3495  f3pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,2*fHarmonic));
3496  f3pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,1*fHarmonic));
3498  // b3) 4-p correlations (6+15+2+10+8):
3499  TString s4pCorrelationsName = "f4pCorrelations";
3500  s4pCorrelationsName += fAnalysisLabel->Data();
3501  f4pCorrelations = new TProfile(s4pCorrelationsName.Data(),Form("4-particle correlations (n = %d)",fHarmonic),45,0,45,"s");
3502  f4pCorrelations->SetTickLength(-0.01,"Y");
3503  f4pCorrelations->SetMarkerStyle(25);
3504  f4pCorrelations->SetLabelSize(0.03);
3505  f4pCorrelations->SetLabelOffset(0.02,"Y");
3506  f4pCorrelations->SetStats(kFALSE);
3507  f4pCorrelations->Sumw2();
3508  // "same harmonic" (6):
3509  f4pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3510  f4pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3511  f4pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3512  f4pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3513  f4pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic));
3514  f4pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,6*fHarmonic));
3515  f4pCorrelations->GetXaxis()->SetBinLabel(7,""); // empty
3516  // "standard candles" (15):
3517  f4pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic));
3518  f4pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic));
3519  f4pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic));
3520  f4pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic));
3521  f4pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic));
3522  f4pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic));
3523  f4pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic));
3524  f4pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic));
3525  f4pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic));
3526  f4pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic));
3527  f4pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,6*fHarmonic,1*fHarmonic));
3528  f4pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,2*fHarmonic));
3529  f4pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,3*fHarmonic));
3530  f4pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,4*fHarmonic));
3531  f4pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,5*fHarmonic));
3532  f4pCorrelations->GetXaxis()->SetBinLabel(23,""); // empty
3533  // 4-p correlations sensitive to two distinct harmonics (2):
3534  f4pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3535  f4pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3536  f4pCorrelations->GetXaxis()->SetBinLabel(26,""); // empty
3537  // 4-p correlations sensitive to three distinct harmonics (10):
3538  f4pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic));
3539  f4pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3540  f4pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic));
3541  f4pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3542  f4pCorrelations->GetXaxis()->SetBinLabel(31,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3543  f4pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3544  f4pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic));
3545  f4pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3546  f4pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,4*fHarmonic));
3547  f4pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,5*fHarmonic));
3548  f4pCorrelations->GetXaxis()->SetBinLabel(37,""); // empty
3549  // 4-p correlations sensitive to four distinct harmonics (8):
3550  f4pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic));
3551  f4pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic));
3552  f4pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic));
3553  f4pCorrelations->GetXaxis()->SetBinLabel(41,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3554  f4pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,2*fHarmonic));
3555  f4pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3556  f4pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,3*fHarmonic));
3557  f4pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,4*fHarmonic));
3559  // b3) 5-p correlations (30+9+30+11+3):
3560  TString s5pCorrelationsName = "f5pCorrelations";
3561  s5pCorrelationsName += fAnalysisLabel->Data();
3562  f5pCorrelations = new TProfile(s5pCorrelationsName.Data(),Form("5-particle correlations (n = %d)",fHarmonic),87,0,87,"s");
3563  f5pCorrelations->SetTickLength(-0.01,"Y");
3564  f5pCorrelations->SetMarkerStyle(25);
3565  f5pCorrelations->SetLabelSize(0.02);
3566  f5pCorrelations->SetLabelOffset(0.02,"Y");
3567  f5pCorrelations->SetStats(kFALSE);
3568  f5pCorrelations->Sumw2();
3569  // "standard candles" (30):
3570  f5pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3571  f5pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3572  f5pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3573  f5pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3574  f5pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3575  f5pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3576  f5pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3577  f5pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3578  f5pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3579  f5pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3580  f5pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3581  f5pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3582  f5pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3583  f5pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3584  f5pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3585  f5pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3586  f5pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3587  f5pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3588  f5pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3589  f5pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3590  f5pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3591  f5pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3592  f5pCorrelations->GetXaxis()->SetBinLabel(23,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,3*fHarmonic));
3593  f5pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,1*fHarmonic,1*fHarmonic));
3594  f5pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,2*fHarmonic,1*fHarmonic));
3595  f5pCorrelations->GetXaxis()->SetBinLabel(26,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,2*fHarmonic,2*fHarmonic));
3596  f5pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,3*fHarmonic,1*fHarmonic));
3597  f5pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,2*fHarmonic));
3598  f5pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,3*fHarmonic,2*fHarmonic));
3599  f5pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,4*fHarmonic,1*fHarmonic));
3600  f5pCorrelations->GetXaxis()->SetBinLabel(31,""); // empty
3601  // 5-p correlations sensitive to two distinct harmonics (9):
3602  f5pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3603  f5pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3604  f5pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3605  f5pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3606  f5pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3607  f5pCorrelations->GetXaxis()->SetBinLabel(37,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3608  f5pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3609  f5pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3610  f5pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,3*fHarmonic,3*fHarmonic));
3611  f5pCorrelations->GetXaxis()->SetBinLabel(41,""); // empty
3612  // 5-p correlations sensitive to three distinct harmonics (30):
3613  f5pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3614  f5pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3615  f5pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3616  f5pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3617  f5pCorrelations->GetXaxis()->SetBinLabel(46,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3618  f5pCorrelations->GetXaxis()->SetBinLabel(47,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3619  f5pCorrelations->GetXaxis()->SetBinLabel(48,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3620  f5pCorrelations->GetXaxis()->SetBinLabel(49,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3621  f5pCorrelations->GetXaxis()->SetBinLabel(50,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3622  f5pCorrelations->GetXaxis()->SetBinLabel(51,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3623  f5pCorrelations->GetXaxis()->SetBinLabel(52,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3624  f5pCorrelations->GetXaxis()->SetBinLabel(53,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3625  f5pCorrelations->GetXaxis()->SetBinLabel(54,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3626  f5pCorrelations->GetXaxis()->SetBinLabel(55,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3627  f5pCorrelations->GetXaxis()->SetBinLabel(56,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3628  f5pCorrelations->GetXaxis()->SetBinLabel(57,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3629  f5pCorrelations->GetXaxis()->SetBinLabel(58,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3630  f5pCorrelations->GetXaxis()->SetBinLabel(59,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3631  f5pCorrelations->GetXaxis()->SetBinLabel(60,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3632  f5pCorrelations->GetXaxis()->SetBinLabel(61,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3633  f5pCorrelations->GetXaxis()->SetBinLabel(62,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3634  f5pCorrelations->GetXaxis()->SetBinLabel(63,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3635  f5pCorrelations->GetXaxis()->SetBinLabel(64,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3636  f5pCorrelations->GetXaxis()->SetBinLabel(65,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3637  f5pCorrelations->GetXaxis()->SetBinLabel(66,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3638  f5pCorrelations->GetXaxis()->SetBinLabel(67,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,5*fHarmonic,5*fHarmonic));
3639  f5pCorrelations->GetXaxis()->SetBinLabel(68,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic,1*fHarmonic));
3640  f5pCorrelations->GetXaxis()->SetBinLabel(69,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,5*fHarmonic,2*fHarmonic));
3641  f5pCorrelations->GetXaxis()->SetBinLabel(70,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,4*fHarmonic,2*fHarmonic));
3642  f5pCorrelations->GetXaxis()->SetBinLabel(71,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,5*fHarmonic,1*fHarmonic));
3643  f5pCorrelations->GetXaxis()->SetBinLabel(72,""); // empty
3644  // 5-p correlations sensitive to four distinct harmonics (11):
3645  f5pCorrelations->GetXaxis()->SetBinLabel(73,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3646  f5pCorrelations->GetXaxis()->SetBinLabel(74,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3647  f5pCorrelations->GetXaxis()->SetBinLabel(75,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3648  f5pCorrelations->GetXaxis()->SetBinLabel(76,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3649  f5pCorrelations->GetXaxis()->SetBinLabel(77,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3650  f5pCorrelations->GetXaxis()->SetBinLabel(78,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3651  f5pCorrelations->GetXaxis()->SetBinLabel(79,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,5*fHarmonic,3*fHarmonic));
3652  f5pCorrelations->GetXaxis()->SetBinLabel(80,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3653  f5pCorrelations->GetXaxis()->SetBinLabel(81,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic));
3654  f5pCorrelations->GetXaxis()->SetBinLabel(82,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,5*fHarmonic,5*fHarmonic));
3655  f5pCorrelations->GetXaxis()->SetBinLabel(83,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic));
3656  f5pCorrelations->GetXaxis()->SetBinLabel(84,""); // empty
3657  // 5-p correlations sensitive to five distinct harmonics (3):
3658  f5pCorrelations->GetXaxis()->SetBinLabel(85,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3659  f5pCorrelations->GetXaxis()->SetBinLabel(86,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,1*fHarmonic,5*fHarmonic,4*fHarmonic));
3660  f5pCorrelations->GetXaxis()->SetBinLabel(87,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3662  // b4) 6-p correlations (??+??+??+??+??):
3663  TString s6pCorrelationsName = "f6pCorrelations";
3664  s6pCorrelationsName += fAnalysisLabel->Data();
3665  f6pCorrelations = new TProfile(s6pCorrelationsName.Data(),Form("6-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3666  f6pCorrelations->SetTickLength(-0.01,"Y");
3667  f6pCorrelations->SetMarkerStyle(25);
3668  f6pCorrelations->SetLabelSize(0.02);
3669  f6pCorrelations->SetLabelOffset(0.02,"Y");
3670  f6pCorrelations->SetStats(kFALSE);
3671  f6pCorrelations->Sumw2();
3672  //fMixedHarmonicsProfiles->Add(f6pCorrelations); // TBI
3673  // b5) 7-p correlations (??+??+??+??+??):
3674  TString s7pCorrelationsName = "f7pCorrelations";
3675  s7pCorrelationsName += fAnalysisLabel->Data();
3676  f7pCorrelations = new TProfile(s7pCorrelationsName.Data(),Form("7-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3677  f7pCorrelations->SetTickLength(-0.01,"Y");
3678  f7pCorrelations->SetMarkerStyle(25);
3679  f7pCorrelations->SetLabelSize(0.02);
3680  f7pCorrelations->SetLabelOffset(0.02,"Y");
3681  f7pCorrelations->SetStats(kFALSE);
3682  f7pCorrelations->Sumw2();
3683  //fMixedHarmonicsProfiles->Add(f7pCorrelations); // TBI
3684  // b6) 8-p correlations (??+??+??+??+??):
3685  TString s8pCorrelationsName = "f8pCorrelations";
3686  s8pCorrelationsName += fAnalysisLabel->Data();
3687  f8pCorrelations = new TProfile(s8pCorrelationsName.Data(),Form("8-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3688  f8pCorrelations->SetTickLength(-0.01,"Y");
3689  f8pCorrelations->SetMarkerStyle(25);
3690  f8pCorrelations->SetLabelSize(0.02);
3691  f8pCorrelations->SetLabelOffset(0.02,"Y");
3692  f8pCorrelations->SetStats(kFALSE);
3693  f8pCorrelations->Sumw2();
3694  //fMixedHarmonicsProfiles->Add(f8pCorrelations); // TBI
3695 
3696  // c) Book all objects in TList fMixedHarmonicsResults:
3697  // QC{2}:
3698  f2pCumulants = f2pCorrelations->ProjectionX("f2pCumulants");
3699  f2pCumulants->SetTitle(Form("2-particle cumulants (n = %d)",fHarmonic));
3700  f2pCumulants->SetStats(kFALSE);
3701  f2pCumulants->SetMarkerStyle(kFullSquare);
3702  f2pCumulants->SetMarkerColor(kBlack);
3703  f2pCumulants->SetLineColor(kBlack);
3705  // QC{3}:
3706  f3pCumulants = f3pCorrelations->ProjectionX("f3pCumulants");
3707  f3pCumulants->SetTitle(Form("3-particle cumulants (n = %d)",fHarmonic));
3708  f3pCumulants->SetStats(kFALSE);
3709  f3pCumulants->SetMarkerStyle(kFullSquare);
3710  f3pCumulants->SetMarkerColor(kGreen+2);
3711  f3pCumulants->SetLineColor(kGreen+2);
3713  // QC{4}:
3714  f4pCumulants = f4pCorrelations->ProjectionX("f4pCumulants");
3715  f4pCumulants->SetTitle(Form("4-particle cumulants (n = %d)",fHarmonic));
3716  f4pCumulants->SetStats(kFALSE);
3717  f4pCumulants->SetMarkerStyle(kFullSquare);
3718  f4pCumulants->SetMarkerColor(kRed);
3719  f4pCumulants->SetLineColor(kRed);
3721  // QC{5}:
3722  f5pCumulants = f5pCorrelations->ProjectionX("f5pCumulants");
3723  f5pCumulants->SetTitle(Form("5-particle cumulants (n = %d)",fHarmonic));
3724  f5pCumulants->SetStats(kFALSE);
3725  f5pCumulants->SetMarkerStyle(kFullSquare);
3726  f5pCumulants->SetMarkerColor(kBlue);
3727  f5pCumulants->SetLineColor(kBlue);
3729 
3730  // d) Book all objects in TList fMixedHarmonicsErrorPropagation:
3731  // Sum of linear and quadratic event weights for mixed harmonics => [0=linear 1,1=quadratic]:
3732  TString mixedHarmonicEventWeightsName = "fMixedHarmonicEventWeights";
3733  mixedHarmonicEventWeightsName += fAnalysisLabel->Data();
3734  TString powerFlag[2] = {"linear","quadratic"};
3735  for(Int_t power=0;power<2;power++)
3736  {
3737  fMixedHarmonicEventWeights[power] = new TH1D(Form("%s: %s",mixedHarmonicEventWeightsName.Data(),powerFlag[power].Data()),Form("Sum of %s event weights for correlations",powerFlag[power].Data()),8,0.,8.);
3738  fMixedHarmonicEventWeights[power]->SetLabelSize(0.04);
3739  fMixedHarmonicEventWeights[power]->SetMarkerStyle(25);
3740  fMixedHarmonicEventWeights[power]->SetStats(kFALSE);
3741  if(power == 0)
3742  {
3743  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}");
3744  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}");
3745  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}");
3746  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}");
3747  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}");
3748  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}");
3749  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}");
3750  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}");
3751  } else if (power == 1)
3752  {
3753  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}^{2}");
3754  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}^{2}");
3755  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}^{2}");
3756  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}^{2}");
3757  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}^{2}");
3758  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}^{2}");
3759  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}^{2}");
3760  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}^{2}");
3761  }
3763  } // end of for(Int_t power=0;power<2;power++)
3764 
3765  // Sums of products of event weights for mixed harmonics:
3766  TString mixedHarmonicProductOfEventWeightsName = "fMixedHarmonicProductOfEventWeights";
3767  mixedHarmonicProductOfEventWeightsName += fAnalysisLabel->Data();
3768  fMixedHarmonicProductOfEventWeights = new TH2D(mixedHarmonicProductOfEventWeightsName.Data(),"Sums of products of event weights",8,0.,8.,8,0.,8.);
3769  fMixedHarmonicProductOfEventWeights->SetStats(kFALSE);
3770  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetLabelSize(0.05);
3771  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetLabelSize(0.05);
3772  for(Int_t b=1;b<=8;b++)
3773  {
3774  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
3775  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
3776  }
3778 
3779  // Averages of products of mixed harmonics correlations:
3780  TString mixedHarmonicProductOfCorrelationsName = "fMixedHarmonicProductOfCorrelations";
3781  mixedHarmonicProductOfCorrelationsName += fAnalysisLabel->Data();
3782  fMixedHarmonicProductOfCorrelations = new TProfile2D(mixedHarmonicProductOfCorrelationsName.Data(),"Averages of products of mixed correlators",139,0.,139.,139,0.,139.);
3784  fMixedHarmonicProductOfCorrelations->SetStats(kFALSE);
3785  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetLabelSize(0.015);
3786  fMixedHarmonicProductOfCorrelations->GetYaxis()->SetLabelSize(0.015);
3787  // x-axis:
3788  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
3789  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
3790  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
3791  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
3792  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
3793  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT2#GT#GT_{%dn|%dn}",6*fHarmonic,6*fHarmonic));
3794  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic));
3795  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic));
3796  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic));
3797  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,1*fHarmonic));
3798  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,1*fHarmonic));
3799  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,2*fHarmonic));
3800  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,1*fHarmonic));
3801  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,2*fHarmonic));
3802  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,1*fHarmonic));
3803  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3804  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3805  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3806  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3807  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic));
3808  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,6*fHarmonic));
3809  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic));
3810  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(23,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic));
3811  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic));
3812  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic));
3813  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(26,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic));
3814  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic));
3815  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic));
3816  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic));
3817  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic));
3818  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(31,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic));
3819  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,6*fHarmonic,1*fHarmonic));
3820  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,2*fHarmonic));
3821  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,3*fHarmonic));
3822  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,4*fHarmonic));
3823  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,5*fHarmonic));
3824  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(37,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3825  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3826  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic));
3827  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3828  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(41,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic));
3829  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3830  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3831  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3832  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic));
3833  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(46,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3834  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(47,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,4*fHarmonic));
3835  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(48,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,5*fHarmonic));
3836  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(49,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic));
3837  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(50,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic));
3838  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(51,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic));
3839  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(52,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3840  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(53,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,2*fHarmonic));
3841  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(54,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3842  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(55,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,3*fHarmonic));
3843  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(56,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,4*fHarmonic));
3844  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(57,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3845  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(58,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3846  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(59,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3847  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(60,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3848  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(61,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3849  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(62,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3850  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(63,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3851  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(64,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3852  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(65,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3853  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(66,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3854  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(67,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3855  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(68,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3856  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(69,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3857  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(70,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3858  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(71,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3859  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(72,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3860  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(73,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3861  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(74,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3862  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(75,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3863  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(76,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3864  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(77,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3865  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(78,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3866  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(79,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,3*fHarmonic));
3867  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(80,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,1*fHarmonic,1*fHarmonic));
3868  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(81,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,2*fHarmonic,1*fHarmonic));
3869  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(82,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,2*fHarmonic,2*fHarmonic));
3870  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(83,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,3*fHarmonic,1*fHarmonic));
3871  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(84,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,2*fHarmonic));
3872  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(85,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,3*fHarmonic,2*fHarmonic));
3873  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(86,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,4*fHarmonic,1*fHarmonic));
3874  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(87,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3875  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(88,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3876  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(89,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3877  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(90,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3878  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(91,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3879  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(92,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3880  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(93,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3881  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(94,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3882