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