AliPhysics  1a228f7 (1a228f7)
 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 fMPolSelec(kMAll),
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  wPhi = 1.;
633  wPt = 1.;
634  wEta = 1.;
635  wPhiEta = 1.;
636  wTrack = 1.;
637  // if(fUsePhiWeights && fPhiWeightsRPs && fnBinsPhi) // determine phi weight for POI:
638  // {
639  // wPhi = fPhiWeightsRPs->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
640  // }
641  // if(fUsePtWeights) // determine pt weight for POI:
642  // {
643  // wPt = 1.;
644  // }
645  // if(fUseEtaWeights && fEtaWeightsRPs && fEtaBinWidth) // determine eta weight for POI:
646  // {
647  // wEta = fEtaWeightsRPs->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
648  // }
649  // if(fUsePhiEtaWeights && fPhiEtaWeightsPOIs[cw] && fnBinsPhi && fEtaBinWidth) // determine eta weight for POI:
650  // {
651  // wPhiEta = fPhiEtaWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())),1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
652  // }
653  // if(aftsTrack->InPOISelection() && fUseTrackWeights) // Access track weight for POI && RP particle:
654  // {
655  // wTrack = aftsTrack->Weight();
656  // }
657  // Calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}] for this event (m = 1,2,...,12, k = 0,1,...,8):
658  for(Int_t m=0;m<12;m++) // to be improved - hardwired 6
659  {
660  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
661  {
662  (*fReQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1)*n*dPhi);
663  (*fImQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1)*n*dPhi);
664  }
665  }
666  // Calculate S_{p,k} for this event (Remark: final calculation of S_{p,k} follows after the loop over data bellow):
667  for(Int_t p=0;p<8;p++)
668  {
669  for(Int_t k=0;k<9;k++)
670  {
671  (*fSpk)(p,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k);
672  }
673  }
674  // Differential flow:
676  {
677  ptEta[0] = dPt;
678  ptEta[1] = dEta;
679  // Calculate r_{m*n,k} and s_{p,k} (r_{m,k} is 'p-vector' for RPs):
680  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
681  {
682  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
683  {
685  {
686  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
687  {
688  fReRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
689  fImRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
690  if(m==0) // s_{p,k} does not depend on index m
691  {
692  fs1dEBE[0][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
693  } // end of if(m==0) // s_{p,k} does not depend on index m
694  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
695  } // end of if(fCalculateDiffFlow)
697  {
698  fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
699  fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
700  if(m==0) // s_{p,k} does not depend on index m
701  {
702  fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
703  } // end of if(m==0) // s_{p,k} does not depend on index m
704  } // end of if(fCalculate2DDiffFlow)
705  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
706  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
707  // Checking if RP particle is also POI particle:
708  if(aftsTrack->InPOISelection())
709  {
710  // Calculate q_{m*n,k} and s_{p,k} ('q-vector' and 's' for RPs && POIs):
711  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
712  {
713  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
714  {
716  {
717  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
718  {
719  fReRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
720  fImRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
721  if(m==0) // s_{p,k} does not depend on index m
722  {
723  fs1dEBE[2][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
724  } // end of if(m==0) // s_{p,k} does not depend on index m
725  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
726  } // end of if(fCalculateDiffFlow)
728  {
729  fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
730  fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
731  if(m==0) // s_{p,k} does not depend on index m
732  {
733  fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
734  } // end of if(m==0) // s_{p,k} does not depend on index m
735  } // end of if(fCalculate2DDiffFlow)
736  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
737  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
738  } // end of if(aftsTrack->InPOISelection())
739  } // end of if(fCalculateDiffFlow || fCalculate2DDiffFlow)
740 
741  } // end of if(pTrack->InRPSelection())
742 
743  // POIs ********************************************************************************************************
744 
745  if(aftsTrack->InPOISelection()) {
746  dPhi = aftsTrack->Phi();
747  dPt = aftsTrack->Pt();
748  dEta = aftsTrack->Eta();
749  dCharge = aftsTrack->Charge();
750  cw = (dCharge > 0. ? 0 : 1);
751  wPhi = 1.;
752  wPt = 1.;
753  wEta = 1.;
754  wTrack = 1.;
755  wPhiEta = 1.;
756  wProbCut = 0.;
757  // if(fUsePhiWeights && fPhiWeightsRPs && fnBinsPhi) // determine phi weight for POI:
758  // {
759  // wPhi = fPhiWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
760  // }
761  // if(fUsePtWeights) // determine pt weight for POI:
762  // {
763  // wPt = 1.;
764  // }
765  // if(fUseEtaWeights && fEtaWeightsRPs && fEtaBinWidth) // determine eta weight for POI:
766  // {
767  // wEta = fEtaWeightsPOIs[cw]->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth)));
768  // }
769  if(fUsePhiEtaWeights && fPhiEtaWeights) // determine phieta weight for POI:
770  {
771  wt = fPhiEtaWeights->GetBinContent(fPhiEtaWeights->FindBin(fCentralityEBE,dPhi,dEta));
772  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
773  }
775  if(dPt>0.2 && dPt<20.) wPhiEta *= 1./fPtWeightsHist[fCenBin]->Interpolate(dPt);
776  }
777  if(fUsePhiEtaCuts && fPhiEtaCuts) // determine phieta weight for POI:
778  {
779  wProbCut = fPhiEtaCuts->GetBinContent(fPhiEtaCuts->FindBin(fCentralityEBE,dPhi,dEta));
780  if(fRandom->Uniform(1.)>wProbCut) continue;
781  }
782  if(fUseEtaWeights && fEtaWeightsHist[fCenBin][0][0]) {
783 // Int_t ptbin = GetCRCPtBin(dPt);
784 // if(ptbin==-1) continue;
785 // wPhiEta *= 1./fEtaWeightsHist[fCenBin][ptbin][cw]->GetBinContent(fEtaWeightsHist[fCenBin][ptbin][cw]->FindBin(dEta));
786  }
787 
788  ptEta[0] = dPt;
789  ptEta[1] = dEta;
790  // Calculate p_{m*n,k} ('p-vector' for POIs):
791  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
792  {
793  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
794  {
796  {
797  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
798  {
799  fReRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
800  fImRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
801  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
802  } // end of if(fCalculateDiffFlow)
804  {
805  fReRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
806  fImRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
807  } // end of if(fCalculate2DDiffFlow)
808  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
809  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
810 
811  // Charge-Rapidity Correlations
812  for (Int_t h=0;h<fCRCnHar;h++) {
813 
814  fCRCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
815  fCRCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
816  fCRCMult[cw][h]->Fill(dEta,wPhiEta);
817 
818  fCRC2QRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
819  fCRC2QIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
820  fCRC2Mul[cw][h]->Fill(dEta,wPhiEta);
821 
822  fCRCZDCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
823  fCRCZDCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
824  fCRCZDCMult[cw][h]->Fill(dEta,wPhiEta);
825 
826  if(fRandom->Integer(2)>0.5) {
827  fCRC2QRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
828  fCRC2QIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
829  fCRC2Mul[2][h]->Fill(dEta,wPhiEta);
830  }
831 
832  if(fRandom->Integer(2)>0.5) {
833  fCRCZDCQRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
834  fCRCZDCQIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
835  fCRCZDCMult[2][h]->Fill(dEta,wPhiEta);
836  } else {
837  fCRCZDCQRe[3][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
838  fCRCZDCQIm[3][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
839  fCRCZDCMult[3][h]->Fill(dEta,wPhiEta);
840  }
841 
842  if(fCalculateCME) {
843  Double_t SpecWeig = 1.;
844  if(fUseZDCESESpecWeights && fZDCESESpecWeightsHist[fZDCESEclEbE] && dPt>0.2 && dPt<20.2) {
846  if(weraw > 0.) SpecWeig = 1./weraw;
847  }
848  fCMEQRe[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Cos((h+1.)*dPhi));
849  fCMEQIm[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Sin((h+1.)*dPhi));
850  fCMEMult[cw][h]->Fill(dEta,SpecWeig*wPhiEta);
851  fCMEQRe[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Cos((h+1.)*dPhi));
852  fCMEQIm[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Sin((h+1.)*dPhi));
853  fCMEMult[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.));
854 
855  // spectra
856  fhCenvsSpec[fZDCESEclEbE]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
857  fhCenvsSpec[fZDCESEnCl]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
858  }
859 
860  } // end of for (Int_t h=0;h<fCRCnHar;h++)
861 
862  // Flow SP ZDC
863  for (Int_t k=0; k<fQVecPower; k++) {
864  for (Int_t h=0;h<fFlowNHarmMax;h++) {
865  fPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
866  fPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
867  fPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
868  if(fabs(dEta)>fFlowQCDeltaEta/2.) {
869  Int_t keta = (dEta<0.?0:1);
870  fPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
871  fPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
872  fPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
873  }
874  }
875  }
876 
877  for (Int_t h=0;h<fFlowNHarmMax;h++) {
878  fEtaDiffQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
879  fEtaDiffQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
880  fEtaDiffMul[cw][h]->Fill(dEta,wPhiEta);
881  }
882 
884 
885  if(!fQAZDCCuts || (fQAZDCCuts && fQAZDCCutsFlag)) {
886  fFlowQCSpectra[fCenBin]->Fill(dPt,wPhiEta);
888  fFlowQCCenSpec[fZDCESEclEbE]->Fill(dPt,fCentralityEBE,wPhiEta);
890  }
891  }
892  }
893 
894  if(fCalculateEbEFlow) {
895  if(fEBEFlowMulBin>=0) fEbEFlowAzimDis[fEBEFlowMulBin]->Fill(dPhi,wPhiEta);
896  }
897  fCRCQVecPhiHist[fRunBin]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
898  } // end of if(pTrack->InPOISelection())
899  } else // to if(aftsTrack)
900  {
901  printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
902  }
903  } // end of for(Int_t i=0;i<nPrim;i++)
904 
905  // ************************************************************************************************************
906 
907 
908  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
909  for(Int_t p=0;p<8;p++)
910  {
911  for(Int_t k=0;k<9;k++)
912  {
913  (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
914  }
915  }
916 
917  // f) Call the methods which calculate correlations for reference flow:
919  {
921  {
922  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelations();} // without using particle weights
923  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
924  {
925  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
926  }
927  // Whether or not using particle weights the following is calculated in the same way:
931  // Non-isotropic terms:
933  {
936  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
937  {
940  }
941  // Whether or not using particle weights the following is calculated in the same way:
945  // Mixed harmonics:
947  } // end of if(!fEvaluateIntFlowNestedLoops)
948 
949  // g) Call the methods which calculate correlations for differential flow:
951  {
953  {
954  // Without using particle weights:
955  this->CalculateDiffFlowCorrelations("RP","Pt");
957  this->CalculateDiffFlowCorrelations("POI","Pt");
959  // Non-isotropic terms:
968  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
969  {
970  // With using particle weights:
975  // Non-isotropic terms:
984  }
985  // Whether or not using particle weights the following is calculated in the same way:
988  this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
990  this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
992  this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
998  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
999 
1000  // h) Call the methods which calculate correlations for 2D differential flow:
1002  {
1004  {
1005  // Without using particle weights:
1006  this->Calculate2DDiffFlowCorrelations("RP");
1007  this->Calculate2DDiffFlowCorrelations("POI");
1008  // Non-isotropic terms:
1009  // ... to be ctd ...
1010  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1011  {
1012  // With using particle weights:
1013  // ... to be ctd ...
1014  // Non-isotropic terms:
1015  // ... to be ctd ...
1016  }
1017  // Whether or not using particle weights the following is calculated in the same way:
1018  // ... to be ctd ...
1019  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
1020 
1021  // i) Call the methods which calculate other differential correlators:
1023  {
1025  {
1026  // Without using particle weights:
1027  this->CalculateOtherDiffCorrelators("RP","Pt");
1029  this->CalculateOtherDiffCorrelators("POI","Pt");
1031  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1032  {
1033  // With using particle weights:
1034  // ... to be ctd ...
1035  }
1036  // Whether or not using particle weights the following is calculated in the same way:
1037  // ... to be ctd ...
1038  } // end of if(!fEvaluateDiffFlowNestedLoops)
1039 
1040  // i.2) Calculate CRC quantities:
1041  if(fCalculateCRC) {
1042 // if(fUseCRCRecenter) this->RecenterCRCQVec();
1043  if(fCalculateCRC2) this->CalculateCRCCorr();
1044  if(fCalculateCRC2) this->CalculateCRC2Cor();
1046  if(fCalculateCRCZDC && fUseZDC) this->CalculateCRCZDC();
1047  if(fCalculateCRCPt) this->CalculateCRCPtCorr();
1048  // if(fUseVZERO && fUseZDC) this->CalculateVZvsZDC();
1049  if(fCalculateCME && fUseZDC) {
1050  this->CalculateCMETPC();
1051  this->CalculateCMEZDC();
1052  }
1053  }
1054  // WARNING: do not invert order of SPZDC and QC, used in SC
1056  if(fCalculateFlowQC) {
1057  this->CalculateFlowQC();
1058  this->CalculateFlowQCHighOrders();
1059  }
1061  if(fCalculateEbEFlow) this->FitEbEFlow();
1062 
1063  // j) Distributions of correlations:
1065 
1066  // l) Cross-check with nested loops correlators for reference flow:
1068 
1069  // m) Cross-check with nested loops correlators for differential flow:
1071 
1072  // n) Store multiplicity in various:
1073  if(fStoreVarious) this->FillVarious();
1074 
1075  // o) Reset all event-by-event quantities (very important !!!!):
1077 
1078  // p) cache run number
1080 
1081  fQAZDCCutsFlag = kTRUE;
1082  // printf("Make done \n");
1083 
1084 } // end of AliFlowAnalysisCRC::Make(AliFlowEventSimple* anEvent)
1085 
1086 //=======================================================================================================================
1087 
1089 {
1090  // Calculate the final results.
1091 
1092  // a) Check all pointers used in this method;
1093  // b) Access the constants;
1094  // c) Access the flags;
1095  // d) Calculate reference cumulants (not corrected for detector effects);
1096  // e) Correct reference cumulants for detector effects;
1097  // f) Calculate reference flow;
1098  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen;
1099  // h) Calculate the final results for differential flow (without/with weights);
1100  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA);
1101  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults;
1102  // k) Store results for differential flow in AliFlowCommonHistResults;
1103  // l) Print the final results for integrated flow (RP/POI) on the screen;
1104  // m) Cross-checking: Results from Q-vectors vs results from nested loops;
1105  // n) Calculate cumulants for mixed harmonics;
1106  // o) Calculate charge-rapidity correlations;
1107  // p) Calculate cumulants for bootstrap;
1108  // q) Finalize various;
1109 
1110  // a) Check all pointers used in this method:
1111  this->CheckPointersUsedInFinish();
1112 
1113  // b) Access the constants:
1114  this->CommonConstants("Finish");
1115 
1117  fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
1118  }
1119 
1120  // c) Access the flags: // tbi (implement a method for this? should I store again the flags because they can get modified with redoFinish?)
1121  fUsePhiWeights = (Bool_t)fUseParticleWeights->GetBinContent(1);
1122  fUsePtWeights = (Bool_t)fUseParticleWeights->GetBinContent(2);
1123  fUseEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(3);
1124  fUseTrackWeights = (Bool_t)fUseParticleWeights->GetBinContent(4);
1125  fUsePhiEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(5);
1126  fApplyCorrectionForNUA = (Bool_t)fIntFlowFlags->GetBinContent(3);
1127  fPrintFinalResults[0] = (Bool_t)fIntFlowFlags->GetBinContent(4);
1128  fPrintFinalResults[1] = (Bool_t)fIntFlowFlags->GetBinContent(5);
1129  fPrintFinalResults[2] = (Bool_t)fIntFlowFlags->GetBinContent(6);
1130  fPrintFinalResults[3] = (Bool_t)fIntFlowFlags->GetBinContent(7);
1131  fApplyCorrectionForNUAVsM = (Bool_t)fIntFlowFlags->GetBinContent(8);
1132  fPropagateErrorAlsoFromNIT = (Bool_t)fIntFlowFlags->GetBinContent(9);
1133  fCalculateCumulantsVsM = (Bool_t)fIntFlowFlags->GetBinContent(10);
1134  fMinimumBiasReferenceFlow = (Bool_t)fIntFlowFlags->GetBinContent(11);
1135  fForgetAboutCovariances = (Bool_t)fIntFlowFlags->GetBinContent(12);
1136  fStoreVarious = (Bool_t)fIntFlowFlags->GetBinContent(13);
1137  fFillMultipleControlHistograms = (Bool_t)fIntFlowFlags->GetBinContent(14);
1138  fCalculateAllCorrelationsVsM = (Bool_t)fIntFlowFlags->GetBinContent(15);
1139  fUse2DHistograms = (Bool_t)fIntFlowFlags->GetBinContent(18);
1140  fFillProfilesVsMUsingWeights = (Bool_t)fIntFlowFlags->GetBinContent(19);
1141  fUseQvectorTerms = (Bool_t)fIntFlowFlags->GetBinContent(20);
1144  fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);
1145  fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4);
1147  //fHarmonic = (Int_t)fMixedHarmonicsFlags->GetBinContent(2); // TBI should I add inpdependent generic harmonic here?
1149  fUseBootstrap = (Bool_t)fBootstrapFlags->GetBinContent(1);
1150  fUseBootstrapVsM = (Bool_t)fBootstrapFlags->GetBinContent(2);
1151  fnSubsamples = (Int_t)fBootstrapFlags->GetBinContent(3);
1152 
1153  // d) Calculate reference cumulants (not corrected for detector effects):
1156  this->CalculateCumulantsIntFlow();
1157 
1158  // e) Correct reference cumulants for detector effects:
1162 
1163  // f) Calculate reference flow:
1164  this->CalculateReferenceFlow();
1165 
1166  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen:
1170 
1171  // h) Calculate the final results for differential flow (without/with weights):
1172  if(fCalculateDiffFlow)
1173  {
1174  this->FinalizeReducedCorrelations("RP","Pt");
1176  this->FinalizeReducedCorrelations("POI","Pt");
1177  if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("POI","Eta");}
1178  this->CalculateDiffFlowCovariances("RP","Pt");
1180  this->CalculateDiffFlowCovariances("POI","Pt");
1181  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("POI","Eta");}
1182  this->CalculateDiffFlowCumulants("RP","Pt");
1183  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("RP","Eta");}
1184  this->CalculateDiffFlowCumulants("POI","Pt");
1185  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("POI","Eta");}
1186  this->CalculateDiffFlow("RP","Pt");
1187  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("RP","Eta");}
1188  this->CalculateDiffFlow("POI","Pt");
1189  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("POI","Eta");}
1190  } // if(fCalculateDiffFlow)
1191 
1192  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA):
1193  if(fCalculateDiffFlow)
1194  {
1195  this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");
1197  this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");
1204  {
1205  this->CalculateDiffFlowCorrectedForNUA("RP","Pt");
1207  this->CalculateDiffFlowCorrectedForNUA("POI","Pt");
1209  }
1210  } // end of if(fCalculateDiffFlow && fApplyCorrectionForNUA)
1211 
1212  // i) Calcualate final results for 2D differential flow:
1214  {
1215  this->Calculate2DDiffFlowCumulants("RP");
1216  this->Calculate2DDiffFlowCumulants("POI");
1217  this->Calculate2DDiffFlow("RP");
1218  this->Calculate2DDiffFlow("POI");
1219  } // end of if(fCalculate2DDiffFlow)
1220 
1221  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults:
1222  if(fCalculateDiffFlow)
1223  {
1226  }
1227 
1228  // k) Store results for differential flow in AliFlowCommonHistResults:
1229  if(fCalculateDiffFlow)
1230  {
1231  this->FillCommonHistResultsDiffFlow("RP");
1232  this->FillCommonHistResultsDiffFlow("POI");
1233  }
1234 
1235  // l) Print the final results for integrated flow (RP/POI) on the screen:
1238 
1239  // m) Cross-checking: Results from Q-vectors vs results from nested loops:
1240  // m1) Reference flow:
1242  {
1247  } // end of if(fEvaluateIntFlowNestedLoops)
1248  // m2) Differential flow:
1250  {
1251  // Correlations:
1253  this->CrossCheckDiffFlowCorrelations("RP","Pt");
1255  this->CrossCheckDiffFlowCorrelations("POI","Pt");
1257  // Correction terms for non-uniform acceptance:
1258  this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt");
1260  this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");
1262  // Other differential correlators:
1263  this->CrossCheckOtherDiffCorrelators("RP","Pt");
1265  this->CrossCheckOtherDiffCorrelators("POI","Pt");
1267  } // end of if(fEvaluateDiffFlowNestedLoops)
1268 
1269  // n) Calculate cumulants for mixed harmonics:
1271 
1272  // o) Calculate charge-rapidity correlations:
1273  if(fCalculateCRC) {
1274  if(fCalculateCRC2) this->FinalizeCRCCorr();
1275  if(fCalculateCRC2) this->FinalizeCRC2Cor();
1277  if(fCalculateCRCZDC && fUseZDC) this->FinalizeCRCZDC();
1278  if(fCalculateCRCPt) this->FinalizeCRCPtCorr();
1279  if(fCalculateCME && fUseZDC) {
1280  this->FinalizeCMETPC();
1281  this->FinalizeCMEZDC();
1282  }
1283  }
1284  // WARNING: do not invert order of SPZDC and QC, used in SC
1286  if(fCalculateFlowQC) {
1287  this->FinalizeFlowQC();
1288  this->FinalizeFlowQCHighOrders();
1289  }
1291 
1292  // p) Calculate cumulants for bootstrap:
1294 
1295  // q) Finalize various:
1296  if(fStoreVarious) this->FinalizeVarious();
1297 
1298 } // end of AliFlowAnalysisCRC::Finish()
1299 
1300 //=======================================================================================================================
1301 
1303 {
1304  // Evaluate all correlators for reference flow with nested loops.
1305 
1306  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1307  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1308  {
1309  // Without using particle weights:
1311  {
1312  // Correlations:
1313  this->CalculateIntFlowCorrelations(); // from Q-vectors
1314  this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1315  // Correction for non-uniform acceptance:
1316  this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)
1317  this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)
1318  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)
1319  // Mixed harmonics:
1321  {
1322  this->CalculateMixedHarmonics(); // from Q-vectors
1323  this->EvaluateMixedHarmonicsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1324  } // end of if(fCalculateMixedHarmonics)
1325  }
1326  // Using particle weights:
1328  {
1329  // Correlations
1330  this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors
1331  this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
1332  // Correction for non-uniform acceptance:
1333  this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)
1334  this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)
1335  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
1336  }
1337  } else if(nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)
1338  {
1339  cout<<endl;
1340  cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;
1341  } else
1342  {
1343  cout<<endl;
1344  cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;
1345  }
1346 
1347 } // end of void AliFlowAnalysisCRC::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
1348 
1349 //=======================================================================================================================
1350 
1352 {
1353  // Evalauted all correlators for differential flow with nested loops.
1354 
1355  if(!fCalculateDiffFlow){return;}
1356 
1357  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1358  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1359  {
1360  // Without using particle weights:
1362  {
1363  // 1.) Reduced correlations:
1364  // Q-vectors:
1365  this->CalculateDiffFlowCorrelations("RP","Pt");
1366  this->CalculateDiffFlowCorrelations("RP","Eta");
1367  this->CalculateDiffFlowCorrelations("POI","Pt");
1368  this->CalculateDiffFlowCorrelations("POI","Eta");
1369  // Nested loops:
1370  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt");
1371  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta");
1372  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt");
1373  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta");
1374  // 2.) Reduced corrections for non-uniform acceptance:
1375  // Q-vectors:
1379  this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");
1383  this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
1384  // Nested loops:
1386  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta");
1387  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt");
1388  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta");
1389  // 3.) Other differential correlators:
1390  // Q-vectors:
1391  this->CalculateOtherDiffCorrelators("RP","Pt");
1392  this->CalculateOtherDiffCorrelators("RP","Eta");
1393  this->CalculateOtherDiffCorrelators("POI","Pt");
1394  this->CalculateOtherDiffCorrelators("POI","Eta");
1395  // Nested loops:
1396  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Pt");
1397  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Eta");
1398  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Pt");
1399  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Eta");
1400  } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1401  // Using particle weights:
1403  {
1424  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1425  } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1426 
1427 } // end of void AliFlowAnalysisCRC::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
1428 
1429 //=======================================================================================================================
1430 
1432 {
1433  // Calculate correction terms for non-uniform acceptance of the detector for reference flow (cos terms).
1434 
1435  // multiplicity:
1436  Double_t dMult = (*fSpk)(0,0);
1437 
1438  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1439  Double_t dReQ1n = (*fReQ)(0,0);
1440  Double_t dReQ2n = (*fReQ)(1,0);
1441  //Double_t dReQ3n = (*fReQ)(2,0);
1442  //Double_t dReQ4n = (*fReQ)(3,0);
1443  Double_t dImQ1n = (*fImQ)(0,0);
1444  Double_t dImQ2n = (*fImQ)(1,0);
1445  //Double_t dImQ3n = (*fImQ)(2,0);
1446  //Double_t dImQ4n = (*fImQ)(3,0);
1447 
1448  // Multiplicity bin of an event (relevant for all histos vs M):
1449  Double_t dMultiplicityBin = 0.;
1451  {
1452  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1454  {
1455  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1457  {
1458  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1459  }
1460 
1461  // *************************************************************
1462  // **** corrections for non-uniform acceptance (cos terms): ****
1463  // *************************************************************
1464  //
1465  // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors
1466  // are stored in 1D profile fQCorrectionsCos.
1467  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
1468  // --------------------------------------------------------------------------------------------------------------------
1469  // 1st bin: <<cos(n*(phi1))>> = cosP1n
1470  // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n
1471  // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n
1472  // 4th bin: <<cos(n*(2phi1-phi2))>> = cosP2nM1n
1473  // --------------------------------------------------------------------------------------------------------------------
1474 
1475  // 1-particle:
1476  Double_t cosP1n = 0.; // <<cos(n*(phi1))>>
1477 
1478  if(dMult>0)
1479  {
1480  cosP1n = dReQ1n/dMult;
1481 
1482  // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
1483  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);
1484  // event weights for NUA terms:
1485  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(1,dMult);
1486 
1487  // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
1488  fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);
1489  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][0]->Fill(dMultiplicityBin,cosP1n,dMult);}
1490  }
1491 
1492  // 2-particle:
1493  Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>
1494  Double_t cosP2nM1n = 0.; // <<cos(n*(2phi1-phi2))>>
1495 
1496  if(dMult>1)
1497  {
1498  cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1));
1499  cosP2nM1n = (dReQ2n*dReQ1n+dImQ2n*dImQ1n-dReQ1n)/(dMult*(dMult-1));
1500 
1501  // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
1502  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);
1503  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(4,cosP2nM1n);
1504  // event weights for NUA terms:
1505  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(2,dMult*(dMult-1));
1506  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(4,dMult*(dMult-1));
1507 
1508  // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
1509  fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));
1510  fIntFlowCorrectionTermsForNUAPro[1]->Fill(3.5,cosP2nM1n,dMult*(dMult-1));
1512  {
1513  fIntFlowCorrectionTermsForNUAVsMPro[1][1]->Fill(dMultiplicityBin,cosP1nP1n,dMult*(dMult-1));
1514  fIntFlowCorrectionTermsForNUAVsMPro[1][3]->Fill(dMultiplicityBin,cosP2nM1n,dMult*(dMult-1));
1515  }
1516  }
1517 
1518  // 3-particle:
1519  Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>
1520 
1521  if(dMult>2)
1522  {
1523  cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)
1524  / (dMult*(dMult-1)*(dMult-2));
1525 
1526  // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
1527  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);
1528  // event weights for NUA terms:
1529  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1530 
1531  // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
1532  fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1533  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][2]->Fill(dMultiplicityBin,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1534  }
1535 
1536 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUACosTerms()
1537 
1538 //=======================================================================================================================
1539 
1541 {
1542  // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
1543 
1544  // multiplicity:
1545  Double_t dMult = (*fSpk)(0,0);
1546 
1547  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1548  Double_t dReQ1n = (*fReQ)(0,0);
1549  Double_t dReQ2n = (*fReQ)(1,0);
1550  //Double_t dReQ3n = (*fReQ)(2,0);
1551  //Double_t dReQ4n = (*fReQ)(3,0);
1552  Double_t dImQ1n = (*fImQ)(0,0);
1553  Double_t dImQ2n = (*fImQ)(1,0);
1554  //Double_t dImQ3n = (*fImQ)(2,0);
1555  //Double_t dImQ4n = (*fImQ)(3,0);
1556 
1557  // Multiplicity bin of an event (relevant for all histos vs M):
1558  Double_t dMultiplicityBin = 0.;
1560  {
1561  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1563  {
1564  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1566  {
1567  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1568  }
1569 
1570  // *************************************************************
1571  // **** corrections for non-uniform acceptance (sin terms): ****
1572  // *************************************************************
1573  //
1574  // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors
1575  // are stored in 1D profile fQCorrectionsSin.
1576  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
1577  // --------------------------------------------------------------------------------------------------------------------
1578  // 1st bin: <<sin(n*(phi1))>> = sinP1n
1579  // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n
1580  // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n
1581  // 4th bin: <<sin(n*(2phi1-phi2))>> = sinP2nM1n
1582  // --------------------------------------------------------------------------------------------------------------------
1583 
1584  // 1-particle:
1585  Double_t sinP1n = 0.; // <sin(n*(phi1))>
1586 
1587  if(dMult>0)
1588  {
1589  sinP1n = dImQ1n/dMult;
1590 
1591  // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
1592  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);
1593  // event weights for NUA terms:
1594  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(1,dMult);
1595 
1596  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1597  fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);
1598  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][0]->Fill(dMultiplicityBin,sinP1n,dMult);}
1599  }
1600 
1601  // 2-particle:
1602  Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>
1603  Double_t sinP2nM1n = 0.; // <<sin(n*(2phi1-phi2))>>
1604  if(dMult>1)
1605  {
1606  sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1));
1607  sinP2nM1n = (dImQ2n*dReQ1n-dReQ2n*dImQ1n-dImQ1n)/(dMult*(dMult-1));
1608 
1609  // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
1610  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);
1611  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(4,sinP2nM1n);
1612  // event weights for NUA terms:
1613  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(2,dMult*(dMult-1));
1614  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(4,dMult*(dMult-1));
1615 
1616  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1617  fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));
1618  fIntFlowCorrectionTermsForNUAPro[0]->Fill(3.5,sinP2nM1n,dMult*(dMult-1));
1620  {
1621  fIntFlowCorrectionTermsForNUAVsMPro[0][1]->Fill(dMultiplicityBin,sinP1nP1n,dMult*(dMult-1));
1622  fIntFlowCorrectionTermsForNUAVsMPro[0][3]->Fill(dMultiplicityBin,sinP2nM1n,dMult*(dMult-1));
1623  }
1624  }
1625 
1626  // 3-particle:
1627  Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>
1628 
1629  if(dMult>2)
1630  {
1631  sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)
1632  / (dMult*(dMult-1)*(dMult-2));
1633 
1634  // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
1635  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);
1636  // event weights for NUA terms:
1637  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1638 
1639  // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
1640  fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1641  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][2]->Fill(dMultiplicityBin,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1642  }
1643 
1644 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUASinTerms()
1645 
1646 //=======================================================================================================================
1647 
1649 {
1650  // a) Get pointers for common control and common result histograms;
1651  // b) Get pointers for histograms holding particle weights;
1652  // c) Get pointers for reference flow histograms;
1653  // d) Get pointers for differential flow histograms;
1654  // e) Get pointers for 2D differential flow histograms;
1655  // f) Get pointers for other differential correlators;
1656  // g) Get pointers for mixed harmonics histograms;
1657  // h) Get pointers for nested loops' histograms;
1658  // i) Get pointers for control histograms;
1659  // j) Get pointers for bootstrap.
1660  // k) Get pointers for CRC histograms;
1661 
1662  if(outputListHistos)
1663  {
1664  this->SetHistList(outputListHistos);
1665  if(!fHistList)
1666  {
1667  printf("\n WARNING (QC): fHistList is NULL in AFAWQC::GOH() !!!!\n\n");
1668  exit(0);
1669  }
1679  this->GetPointersForBootstrap();
1680  this->GetPointersForCRC();
1681  this->GetPointersForCRCVZ();
1682  this->GetPointersForCRCZDC();
1683  this->GetPointersForCRCPt();
1684  this->GetPointersForCRC2();
1685  this->GetPointersForQVec();
1686  this->GetPointersForCME();
1687  this->GetPointersForFlowQC();
1689  this->GetPointersForFlowSPZDC();
1690  this->GetPointersForFlowSPVZ();
1691  this->GetPointersForEbEFlow();
1692  this->GetPointersForVarious();
1693  } else
1694  {
1695  printf("\n WARNING (QC): outputListHistos is NULL in AFAWQC::GOH() !!!!\n\n");
1696  exit(0);
1697  }
1698 
1699 } // end of void AliFlowAnalysisCRC::GetOutputHistograms(TList *outputListHistos)
1700 
1701 //=======================================================================================================================
1702 
1703 TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta) const
1704 {
1705  // project 2D profile onto pt axis to get 1D profile
1706 
1707  Int_t nBinsPt = profilePtEta->GetNbinsX();
1708  Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();
1709  Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();
1710 
1711  Int_t nBinsEta = profilePtEta->GetNbinsY();
1712 
1713  TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax);
1714 
1715  for(Int_t p=1;p<=nBinsPt;p++)
1716  {
1717  Double_t contentPt = 0.;
1718  Double_t entryPt = 0.;
1719  Double_t spreadPt = 0.;
1720  Double_t sum1 = 0.;
1721  Double_t sum2 = 0.;
1722  Double_t sum3 = 0.;
1723  for(Int_t e=1;e<=nBinsEta;e++)
1724  {
1725  contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1726  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1727  entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1728 
1729  sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1730  * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)
1731  + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.));
1732  sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1733  sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
1734  * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));
1735  }
1736  if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)
1737  {
1738  spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);
1739  }
1740  profilePt->SetBinContent(p,contentPt);
1741  profilePt->SetBinEntries(p,entryPt);
1742  {
1743  profilePt->SetBinError(p,spreadPt);
1744  }
1745 
1746  }
1747 
1748  return profilePt;
1749 
1750 } // end of TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta)
1751 
1752 
1753 //=======================================================================================================================
1754 
1755 
1756 TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta) const
1757 {
1758  // project 2D profile onto eta axis to get 1D profile
1759 
1760  Int_t nBinsEta = profilePtEta->GetNbinsY();
1761  Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();
1762  Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();
1763 
1764  Int_t nBinsPt = profilePtEta->GetNbinsX();
1765 
1766  TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax);
1767 
1768  for(Int_t e=1;e<=nBinsEta;e++)
1769  {
1770  Double_t contentEta = 0.;
1771  Double_t entryEta = 0.;
1772  for(Int_t p=1;p<=nBinsPt;p++)
1773  {
1774  contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
1775  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1776  entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
1777  }
1778  profileEta->SetBinContent(e,contentEta);
1779  profileEta->SetBinEntries(e,entryEta);
1780  }
1781 
1782  return profileEta;
1783 
1784 } // end of TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta)
1785 
1786 //=======================================================================================================================
1787 
1789 {
1790  // Printing on the screen the final results for integrated flow (RF, POI and RP).
1791 
1792  Int_t n = fHarmonic;
1793 
1794  Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}
1795  Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}
1796 
1797  if(type == "RF")
1798  {
1799  for(Int_t b=0;b<4;b++)
1800  {
1801  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1);
1802  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1);
1803  dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1);
1804  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1);
1805  dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1);
1806  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1);
1807  dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1);
1808  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1);
1809  }
1810  } else if(type == "RP")
1811  {
1812  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1);
1813  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1);
1814  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1);
1815  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1);
1816  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1);
1817  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1);
1818  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1);
1819  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1);
1820  } else if(type == "POI")
1821  {
1822  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1);
1823  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1);
1824  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1);
1825  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1);
1826  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1);
1827  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1);
1828  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1);
1829  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1);
1830  } else if(type == "RF, rebinned in M" && fCalculateCumulantsVsM)
1831  {
1832  for(Int_t b=0;b<4;b++)
1833  {
1834  dVn[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
1835  dVnErr[b] = fIntFlowRebinnedInM->GetBinError(b+1);
1836  }
1837  }
1838 
1839  TString title = " flow estimates from Q-cumulants";
1840  TString subtitle = " (";
1841  TString subtitle2 = " (rebinned in M)";
1842 
1843  if(type != "RF, rebinned in M")
1844  {
1846  {
1847  subtitle.Append(type);
1848  subtitle.Append(", without weights)");
1849  } else
1850  {
1851  subtitle.Append(type);
1852  subtitle.Append(", with weights)");
1853  }
1854  } else
1855  {
1857  {
1858  subtitle.Append("RF");
1859  subtitle.Append(", without weights)");
1860  } else
1861  {
1862  subtitle.Append("RF");
1863  subtitle.Append(", with weights)");
1864  }
1865  }
1866 
1867  cout<<endl;
1868  cout<<"*************************************"<<endl;
1869  cout<<"*************************************"<<endl;
1870  cout<<title.Data()<<endl;
1871  cout<<subtitle.Data()<<endl;
1872  if(type == "RF, rebinned in M"){cout<<subtitle2.Data()<<endl;}
1873  cout<<endl;
1874 
1875  for(Int_t i=0;i<4;i++)
1876  {
1877  cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
1878  }
1879 
1880  cout<<endl;
1881  if(type == "RF")
1882  {
1884  {
1885  cout<<" detector bias (corrected for): "<<endl;
1886  } else
1887  {
1888  cout<<" detector bias (not corrected for):"<<endl;
1889  }
1890  cout<<" to QC{2}: "<<fIntFlowDetectorBias->GetBinContent(1)<<" +/- "<<fIntFlowDetectorBias->GetBinError(1)<<endl;
1891  cout<<" to QC{4}: "<<fIntFlowDetectorBias->GetBinContent(2)<<" +/- "<<fIntFlowDetectorBias->GetBinError(2)<<endl;
1892  cout<<endl;
1893  }
1894  if(type == "RF" || type == "RF, rebinned in M")
1895  {
1896  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
1897  }
1898  else if (type == "RP")
1899  {
1900  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
1901  }
1902  else if (type == "POI")
1903  {
1904  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
1905  }
1906 
1907  cout<<"*************************************"<<endl;
1908  cout<<"*************************************"<<endl;
1909  cout<<endl;
1910 
1911 }// end of AliFlowAnalysisCRC::PrintFinalResultsForIntegratedFlow(TString type="RF");
1912 
1913 //=======================================================================================================================
1914 
1916 {
1917  //store the final results in output .root file
1918  TFile *output = new TFile(outputFileName.Data(),"RECREATE");
1919  //output->WriteObject(fHistList, "cobjQC","SingleKey");
1920  fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
1921  delete output;
1922 }
1923 
1924 
1925 //=======================================================================================================================
1926 
1927 
1928 void AliFlowAnalysisCRC::WriteHistograms(TDirectoryFile *outputFileName)
1929 {
1930  //store the final results in output .root file
1931  fHistList->SetName("cobjQC");
1932  fHistList->SetOwner(kTRUE);
1933  outputFileName->Add(fHistList);
1934  outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
1935 }
1936 
1937 //=======================================================================================================================
1938 
1940 {
1941  // Book common control histograms and common histograms for final results.
1942  // a) Book common control histograms;
1943  // b) Book common result histograms.
1944 
1945  // a) Book common control histograms:
1946  // Common control histograms (all events):
1947  TString commonHistsName = "AliFlowCommonHistQC";
1948  commonHistsName += fAnalysisLabel->Data();
1949  fCommonHists = new AliFlowCommonHist(commonHistsName.Data(),commonHistsName.Data(),fBookOnlyBasicCCH);
1950  fHistList->Add(fCommonHists);
1951  // Common control histograms (selected events):
1953  {
1954  // Common control histogram filled for events with 2 and more reference particles:
1955  TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
1956  commonHists2ndOrderName += fAnalysisLabel->Data();
1957  fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data(),commonHists2ndOrderName.Data(),fBookOnlyBasicCCH);
1958  fHistList->Add(fCommonHists2nd);
1959  // Common control histogram filled for events with 2 and more reference particles:
1960  TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
1961  commonHists4thOrderName += fAnalysisLabel->Data();
1962  fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data(),commonHists4thOrderName.Data(),fBookOnlyBasicCCH);
1963  fHistList->Add(fCommonHists4th);
1964  // Common control histogram filled for events with 6 and more reference particles:
1965  TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
1966  commonHists6thOrderName += fAnalysisLabel->Data();
1967  fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data(),commonHists6thOrderName.Data(),fBookOnlyBasicCCH);
1968  fHistList->Add(fCommonHists6th);
1969  // Common control histogram filled for events with 8 and more reference particles:
1970  TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
1971  commonHists8thOrderName += fAnalysisLabel->Data();
1972  fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data(),commonHists8thOrderName.Data(),fBookOnlyBasicCCH);
1973  fHistList->Add(fCommonHists8th);
1974  } // end of if(fFillMultipleControlHistograms)
1975 
1976  // b) Book common result histograms:
1977  // Common result histograms for QC{2}:
1978  TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
1979  commonHistResults2ndOrderName += fAnalysisLabel->Data();
1980  fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
1982  // Common result histograms for QC{4}:
1983  TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
1984  commonHistResults4thOrderName += fAnalysisLabel->Data();
1985  fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
1987  // Common result histograms for QC{6}:
1988  TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
1989  commonHistResults6thOrderName += fAnalysisLabel->Data();
1990  fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
1992  // Common result histograms for QC{8}:
1993  TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
1994  commonHistResults8thOrderName += fAnalysisLabel->Data();
1995  fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
1997 
1998 } // end of void AliFlowAnalysisCRC::BookCommonHistograms()
1999 
2000 //=======================================================================================================================
2001 
2003 {
2004  // Book and fill histograms which hold phi, pt and eta weights.
2005 
2006  if(!fWeightsList)
2007  {
2008  printf("\n WARNING (QC): fWeightsList is NULL in AFAWQC::BAFWH() !!!! \n\n");
2009  exit(0);
2010  }
2011 
2012  TString fUseParticleWeightsName = "fUseParticleWeightsQC";
2013  fUseParticleWeightsName += fAnalysisLabel->Data();
2014  fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",5,0,5);
2015  fUseParticleWeights->SetLabelSize(0.06);
2016  fUseParticleWeights->SetStats(kFALSE);
2017  (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");
2018  (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");
2019  (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");
2020  (fUseParticleWeights->GetXaxis())->SetBinLabel(4,"w_{track}");
2027 
2028  // // POIs
2029  // for(Int_t c=0; c<2; c++)
2030  // {
2031  // fPhiWeightsPOIs[c] = new TH1F(Form("fPhiWeightsPOIs[%d][%d]",c,h),Form("fPhiWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax);
2032  // fPhiWeightsPOIs[c]->Sumw2();
2033  // fEtaWeightsPOIs[c] = new TH1D(Form("fEtaWeightsPOIs[%d][%d]",c,h),Form("fEtaWeightsPOIs[%d][%d]",c,h),fnBinsEta,fEtaMin,fEtaMax);
2034  // fEtaWeightsPOIs[c]->Sumw2();
2035  // fPhiEtaWeightsPOIs[c] = new TH2D(Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax,fnBinsEta,fEtaMin,fEtaMax);
2036  // fPhiEtaWeightsPOIs[c]->Sumw2();
2037  //
2038  // if(fUsePhiWeights)
2039  // {
2040  // if(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)))
2041  // {
2042  // fPhiDistrRefPOIs[c] = dynamic_cast<TH1F*>(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)));
2043  // if(!fPhiDistrRefPOIs[c])
2044  // {
2045  // printf("\n WARNING (QC): fPhiDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2046  // exit(0);
2047  // }
2048  // if(TMath::Abs(fPhiDistrRefPOIs[c]->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2049  // {
2050  // cout<<endl;
2051  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2052  // cout<<endl;
2053  // //exit(0);
2054  // }
2055  // } else
2056  // {
2057  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2058  // exit(0);
2059  // }
2060  // } // end of if(fUsePhiWeights)
2061  //
2062  // if(fUsePtWeights)
2063  // {
2064  // if(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)))
2065  // {
2066  // fPtDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)));
2067  // if(!fPtDistrRefPOIs[c])
2068  // {
2069  // printf("\n WARNING (QC): fPtDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2070  // exit(0);
2071  // }
2072  // if(TMath::Abs(fPtDistrRefPOIs[c]->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2073  // {
2074  // cout<<endl;
2075  // cout<<"WARNING (QC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
2076  // cout<<endl;
2077  // //exit(0);
2078  // }
2079  // } else
2080  // {
2081  // cout<<"WARNING: fWeightsList->FindObject(\"fPtHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2082  // exit(0);
2083  // }
2084  // } // end of if(fUsePtWeights)
2085  //
2086  // if(fUseEtaWeights)
2087  // {
2088  // if(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)))
2089  // {
2090  // fEtaDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)));
2091  // if(!fEtaDistrRefPOIs[c])
2092  // {
2093  // printf("\n WARNING (QC): fEtaDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2094  // exit(0);
2095  // }
2096  // if(TMath::Abs(fEtaDistrRefPOIs[c]->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2097  // {
2098  // cout<<endl;
2099  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2100  // cout<<endl;
2101  // //exit(0);
2102  // }
2103  // } else
2104  // {
2105  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2106  // exit(0);
2107  // }
2108  // } // end of if(fUseEtaWeights)
2109  //
2110  //
2111  // } // end of for(Int_t c=0; c<2; c++)
2112 
2113  //**********************************************************************************************************
2114 
2115  // RPs
2116 
2117  // fPhiWeightsRPs = new TH1F("fPhiWeightsRPs","fPhiWeightsRPs",fnBinsPhi,fPhiMin,fPhiMax);
2118  // fEtaWeightsRPs = new TH1D("fEtaWeightsRPs","fEtaWeightsRPs",fnBinsEta,fEtaMin,fEtaMax);
2119  //
2120  // if(fUsePhiWeights)
2121  // {
2122  // if(fWeightsList->FindObject("fPhiDistrRPs"))
2123  // {
2124  // fPhiDistrRefRPs = dynamic_cast<TH1F*>(fWeightsList->FindObject("fPhiDistrRPs"));
2125  // if(!fPhiDistrRefRPs)
2126  // {
2127  // printf("\n WARNING (QC): fPhiDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2128  // exit(0);
2129  // }
2130  // if(TMath::Abs(fPhiDistrRefRPs->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2131  // {
2132  // cout<<endl;
2133  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2134  // cout<<endl;
2135  // //exit(0);
2136  // }
2137  // } else
2138  // {
2139  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2140  // exit(0);
2141  // }
2142  // } // end of if(fUsePhiWeights)
2143  //
2144  // if(fUsePtWeights)
2145  // {
2146  // if(fWeightsList->FindObject("fPtDistrRPs"))
2147  // {
2148  // fPtDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fPtDistrRPs"));
2149  // if(!fPtDistrRefRPs)
2150  // {
2151  // printf("\n WARNING (QC): fPtDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2152  // exit(0);
2153  // }
2154  // if(TMath::Abs(fPtDistrRefRPs->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2155  // {
2156  // cout<<endl;
2157  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2158  // cout<<endl;
2159  // //exit(0);
2160  // }
2161  // } else
2162  // {
2163  // cout<<"WARNING: fWeightsList->FindObject(\"fPtDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2164  // exit(0);
2165  // }
2166  // } // end of if(fUsePtWeights)
2167  //
2168  // if(fUseEtaWeights)
2169  // {
2170  // if(fWeightsList->FindObject("fEtaDistrRPs"))
2171  // {
2172  // fEtaDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fEtaDistrRPs"));
2173  // if(!fEtaDistrRefRPs)
2174  // {
2175  // printf("\n WARNING (QC): fEtaDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2176  // exit(0);
2177  // }
2178  // if(TMath::Abs(fEtaDistrRefRPs->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2179  // {
2180  // cout<<endl;
2181  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2182  // cout<<endl;
2183  // //exit(0);
2184  // }
2185  // } else
2186  // {
2187  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2188  // exit(0);
2189  // }
2190  // } // end of if(fUseEtaWeights)
2191  //
2192 
2193 } // end of AliFlowAnalysisCRC::BookAndFillWeightsHistograms()
2194 
2195 //=======================================================================================================================
2196 
2198 {
2199  if(!fCenWeightsHist) return;
2200  fCenWeigCalHist = (TH1D*)(fCenWeightsHist->Clone("fCenWeigCalHist"));
2201  TF1 *CenFit = new TF1("CenFit","pol0", 0., 100.);
2203  fCenWeigCalHist->Fit("CenFit","QNR","",0.,50.);
2204  Double_t CenAv = CenFit->GetParameter(0);
2205  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2206  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2207  if(newbin) {
2208  fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2209  } else {
2210  fCenWeigCalHist->SetBinContent(b,1.);
2211  }
2212  }
2213  }
2214  else {
2215  fCenWeigCalHist->Fit("CenFit","QNR","",0.,8.);
2216  Double_t CenAv = CenFit->GetParameter(0);
2217  fCenWeigCalHist->Fit("CenFit","QNR","",12.,50.);
2218  Double_t SemiCenAv = CenFit->GetParameter(0);
2219  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2220  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2221  if(newbin) {
2222  if(b<=10) fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2223  if(b>10 && b<=50) fCenWeigCalHist->SetBinContent(b,SemiCenAv/newbin);
2224  if(b>50) fCenWeigCalHist->SetBinContent(b,1.);
2225  } else {
2226  fCenWeigCalHist->SetBinContent(b,1.);
2227  }
2228  }
2229  }
2230  fCenWeigCalHist->SetName("CenWeights");
2232 } // end of AliFlowAnalysisCRC::SetCentralityWeights()
2233 
2234 //=======================================================================================================================
2235 
2237 {
2238  // Book all objects for integrated flow:
2239  // a) Book profile to hold all flags for integrated flow;
2240  // b) Book event-by-event quantities;
2241  // c) Book profiles; // to be improved (comment)
2242  // d) Book histograms holding the final results.
2243 
2244  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
2245  TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)
2246 
2247  // a) Book profile to hold all flags for integrated flow:
2248  TString intFlowFlagsName = "fIntFlowFlags";
2249  intFlowFlagsName += fAnalysisLabel->Data();
2250  fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",20,0.,20.);
2251  fIntFlowFlags->SetTickLength(-0.01,"Y");
2252  fIntFlowFlags->SetMarkerStyle(25);
2253  fIntFlowFlags->SetLabelSize(0.04);
2254  fIntFlowFlags->SetLabelOffset(0.02,"Y");
2255  fIntFlowFlags->SetStats(kFALSE);
2256  fIntFlowFlags->GetXaxis()->SetBinLabel(1,"Particle Weights");
2257  fIntFlowFlags->GetXaxis()->SetBinLabel(2,"Event Weights");
2258  fIntFlowFlags->GetXaxis()->SetBinLabel(3,"Corrected for NUA?");
2259  fIntFlowFlags->GetXaxis()->SetBinLabel(4,"Print RF results");
2260  fIntFlowFlags->GetXaxis()->SetBinLabel(5,"Print RP results");
2261  fIntFlowFlags->GetXaxis()->SetBinLabel(6,"Print POI results");
2262  fIntFlowFlags->GetXaxis()->SetBinLabel(7,"Print RF (rebinned in M) results");
2263  fIntFlowFlags->GetXaxis()->SetBinLabel(8,"Corrected for NUA vs M?");
2264  fIntFlowFlags->GetXaxis()->SetBinLabel(9,"Propagate errors to v_{n} from correlations?");
2265  fIntFlowFlags->GetXaxis()->SetBinLabel(10,"Calculate cumulants vs M");
2266  fIntFlowFlags->GetXaxis()->SetBinLabel(11,"fMinimumBiasReferenceFlow");
2267  fIntFlowFlags->GetXaxis()->SetBinLabel(12,"fForgetAboutCovariances");
2268  fIntFlowFlags->GetXaxis()->SetBinLabel(13,"fStoreVarious");
2269  fIntFlowFlags->GetXaxis()->SetBinLabel(14,"fFillMultipleControlHistograms");
2270  fIntFlowFlags->GetXaxis()->SetBinLabel(15,"Calculate all correlations vs M");
2271  fIntFlowFlags->GetXaxis()->SetBinLabel(16,"fMultiplicityIs");
2272  fIntFlowFlags->GetXaxis()->SetBinLabel(17,"fExactNoRPs");
2273  fIntFlowFlags->GetXaxis()->SetBinLabel(18,"fUse2DHistograms");
2274  fIntFlowFlags->GetXaxis()->SetBinLabel(19,"fFillProfilesVsMUsingWeights");
2275  fIntFlowFlags->GetXaxis()->SetBinLabel(20,"fUseQvectorTerms");
2277 
2278  // b) Book event-by-event quantities:
2279  // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M:
2280  fReQ = new TMatrixD(12,9);
2281  fImQ = new TMatrixD(12,9);
2282  fSpk = new TMatrixD(8,9);
2283  // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):
2284  TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";
2285  intFlowCorrelationsEBEName += fAnalysisLabel->Data();
2286  fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);
2287  // weights for average correlations <2>, <4>, <6> and <8> for single event:
2288  TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";
2289  intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
2290  fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);
2291  // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):
2292  TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";
2293  intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();
2294  fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),64,0,64);
2295  // average correction terms for non-uniform acceptance for single event
2296  // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):
2297  TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";
2298  fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2299  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2300  {
2301  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);
2302  }
2303  // event weights for terms for non-uniform acceptance:
2304  TString fIntFlowEventWeightForCorrectionTermsForNUAEBEName = "fIntFlowEventWeightForCorrectionTermsForNUAEBE";
2305  fIntFlowEventWeightForCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2306  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2307  {
2308  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
2309  }
2310  // c) Book profiles: // to be improved (comment)
2311  // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:
2312  TString avMultiplicityName = "fAvMultiplicity";
2313  avMultiplicityName += fAnalysisLabel->Data();
2314  fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average multiplicities of reference particles (RPs)",9,0,9);
2315  fAvMultiplicity->SetTickLength(-0.01,"Y");
2316  fAvMultiplicity->SetMarkerStyle(25);
2317  fAvMultiplicity->SetLabelSize(0.05);
2318  fAvMultiplicity->SetLabelOffset(0.02,"Y");
2319  fAvMultiplicity->SetYTitle("Average multiplicity");
2320  (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");
2321  (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");
2322  (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");
2323  (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");
2324  (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");
2325  (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");
2326  (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");
2327  (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");
2328  (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");
2330  // Average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):
2331  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
2332  TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
2333  intFlowCorrelationsProName += fAnalysisLabel->Data();
2334  fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");
2335  fIntFlowCorrelationsPro->Sumw2();
2336  fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");
2337  fIntFlowCorrelationsPro->SetMarkerStyle(25);
2338  fIntFlowCorrelationsPro->SetLabelSize(0.06);
2339  fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");
2340  for(Int_t b=0;b<4;b++)
2341  {
2342  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(b+1,correlationFlag[b].Data());
2343  }
2345  // Average correlations squared <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> for all events:
2346  TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"};
2347  TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
2348  intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
2349  fIntFlowSquaredCorrelationsPro = new TProfile(intFlowSquaredCorrelationsProName.Data(),"Average squared correlations for all events",4,0,4,"s");
2351  fIntFlowSquaredCorrelationsPro->SetTickLength(-0.01,"Y");
2352  fIntFlowSquaredCorrelationsPro->SetMarkerStyle(25);
2353  fIntFlowSquaredCorrelationsPro->SetLabelSize(0.06);
2354  fIntFlowSquaredCorrelationsPro->SetLabelOffset(0.01,"Y");
2355  for(Int_t b=0;b<4;b++)
2356  {
2357  (fIntFlowSquaredCorrelationsPro->GetXaxis())->SetBinLabel(b+1,squaredCorrelationFlag[b].Data());
2358  }
2361  {
2362  for(Int_t ci=0;ci<4;ci++) // correlation index
2363  {
2364  // average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (with wrong errors):
2365  TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
2366  intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
2367  fIntFlowCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data()),
2368  Form("%s vs multiplicity",correlationFlag[ci].Data()),
2370  fIntFlowCorrelationsVsMPro[ci]->Sumw2();
2371  fIntFlowCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2373  {
2374  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2376  {
2377  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2379  {
2380  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2381  }
2383  // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
2384  TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
2385  intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
2386  fIntFlowSquaredCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data()),
2387  Form("%s vs multiplicity",squaredCorrelationFlag[ci].Data()),
2389  fIntFlowSquaredCorrelationsVsMPro[ci]->Sumw2();
2390  fIntFlowSquaredCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(squaredCorrelationFlag[ci].Data());
2392  {
2393  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2395  {
2396  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2398  {
2399  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2400  }
2402  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2403  } // end of if(fCalculateCumulantsVsM)
2404  // averaged all correlations for all events (with wrong errors!):
2405  TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
2406  intFlowCorrelationsAllProName += fAnalysisLabel->Data();
2407  fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average all correlations for all events",64,0,64);
2408  fIntFlowCorrelationsAllPro->Sumw2();
2409  fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");
2410  fIntFlowCorrelationsAllPro->SetMarkerStyle(25);
2411  fIntFlowCorrelationsAllPro->SetLabelSize(0.03);
2412  fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");
2413  // 2-p correlations:
2414  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT_{n|n}");
2415  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"#LT#LT2#GT#GT_{2n|2n}");
2416  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"#LT#LT2#GT#GT_{3n|3n}");
2417  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"#LT#LT2#GT#GT_{4n|4n}");
2418  // 3-p correlations:
2419  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"#LT#LT3#GT#GT_{2n|n,n}");
2420  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"#LT#LT3#GT#GT_{3n|2n,n}");
2421  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"#LT#LT3#GT#GT_{4n|2n,2n}");
2422  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"#LT#LT3#GT#GT_{4n|3n,n}");
2423  // 4-p correlations:
2424  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"#LT#LT4#GT#GT_{n,n|n,n}");
2425  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"#LT#LT4#GT#GT_{2n,n|2n,n}");
2426  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"#LT#LT4#GT#GT_{2n,2n|2n,2n}");
2427  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"#LT#LT4#GT#GT_{3n|n,n,n}");
2428  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"#LT#LT4#GT#GT_{3n,n|3n,n}");
2429  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"#LT#LT4#GT#GT_{3n,n|2n,2n}");
2430  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"#LT#LT4#GT#GT_{4n|2n,n,n}");
2431  // 5-p correlations:
2432  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"#LT#LT5#GT#GT_{2n,n|n,n,n}");
2433  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"#LT#LT5#GT#GT_{2n,2n|2n,n,n}");
2434  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"#LT#LT5#GT#GT_{3n,n|2n,n,n}");
2435  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"#LT#LT5#GT#GT_{4n|n,n,n,n}");
2436  // 6-p correlations:
2437  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"#LT#LT6#GT#GT_{n,n,n|n,n,n}");
2438  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"#LT#LT6#GT#GT_{2n,n,n|2n,n,n}");
2439  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"#LT#LT6#GT#GT_{2n,2n|n,n,n,n}");
2440  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"#LT#LT6#GT#GT_{3n,n|n,n,n,n}");
2441  // 7-p correlations:
2442  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}");
2443  // 8-p correlations:
2444  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}");
2445  // EXTRA correlations for v3{5} study:
2446  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(33,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2447  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(34,"#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}");
2448  // EXTRA correlations for Teaney-Yan study:
2449  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(35,"#LT#LT2#GT#GT_{5n|5n}");
2450  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(36,"#LT#LT2#GT#GT_{6n|6n}");
2451  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(37,"#LT#LT3#GT#GT_{5n|3n,2n}");
2452  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(38,"#LT#LT3#GT#GT_{5n|4n,1n}");
2453  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(39,"#LT#LT3#GT#GT_{6n|3n,3n}");
2454  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(40,"#LT#LT3#GT#GT_{6n|4n,2n}");
2455  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(41,"#LT#LT3#GT#GT_{6n|5n,1n}");
2456  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(42,"#LT#LT4#GT#GT_{6n|3n,2n,1n}");
2457  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(43,"#LT#LT4#GT#GT_{3n,2n|3n,2n}");
2458  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(44,"#LT#LT4#GT#GT_{4n,1n|3n,2n}");
2459  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(45,"#LT#LT4#GT#GT_{3n,3n|3n,3n}");
2460  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(46,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2461  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(47,"#LT#LT4#GT#GT_{5n,1n|3n,3n}");
2462  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(48,"#LT#LT4#GT#GT_{4n,2n|4n,2n}");
2463  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(49,"#LT#LT4#GT#GT_{5n,1n|4n,2n}");
2464  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(50,"#LT#LT4#GT#GT_{5n|3n,1n,1n}");
2465  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(51,"#LT#LT4#GT#GT_{5n|2n,2n,1n}");
2466  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(52,"#LT#LT4#GT#GT_{5n,1n|5n,1n}");
2467  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(53,"#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}");
2468  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(54,"#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}");
2469  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(55,"#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}");
2470  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(56,"#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}");
2471  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(57,"#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}");
2472  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(58,"#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}");
2473  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(59,"#LT#LT4#GT#GT_{6n|4n,1n,1n}");
2474  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(60,"#LT#LT4#GT#GT_{6n|2n,2n,2n}");
2475  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(61,"#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}");
2476  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(62,"#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}");
2477  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(63,"#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}");
2479  // average all correlations versus multiplicity (errors via Sumw2 - to be improved):
2481  {
2482  // 2-p correlations vs M:
2483  fIntFlowCorrelationsAllVsMPro[0] = new TProfile("two1n1n","#LT#LT2#GT#GT_{n|n}",fnBinsMult,fMinMult,fMaxMult);
2484  fIntFlowCorrelationsAllVsMPro[1] = new TProfile("two2n2n","#LT#LT2#GT#GT_{2n|2n}",fnBinsMult,fMinMult,fMaxMult);
2485  fIntFlowCorrelationsAllVsMPro[2] = new TProfile("two3n3n","#LT#LT2#GT#GT_{3n|3n}",fnBinsMult,fMinMult,fMaxMult);
2486  fIntFlowCorrelationsAllVsMPro[3] = new TProfile("two4n4n","#LT#LT2#GT#GT_{4n|4n}",fnBinsMult,fMinMult,fMaxMult);
2487  // 3-p correlations vs M:
2488  fIntFlowCorrelationsAllVsMPro[5] = new TProfile("three2n1n1n","#LT#LT3#GT#GT_{2n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2489  fIntFlowCorrelationsAllVsMPro[6] = new TProfile("three3n2n1n","#LT#LT3#GT#GT_{3n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2490  fIntFlowCorrelationsAllVsMPro[7] = new TProfile("three4n2n2n","#LT#LT3#GT#GT_{4n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2491  fIntFlowCorrelationsAllVsMPro[8] = new TProfile("three4n3n1n","#LT#LT3#GT#GT_{4n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2492  // 4-p correlations vs M:
2493  fIntFlowCorrelationsAllVsMPro[10] = new TProfile("four1n1n1n1n","#LT#LT4#GT#GT_{n,n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2494  fIntFlowCorrelationsAllVsMPro[11] = new TProfile("four2n1n2n1n","#LT#LT4#GT#GT_{2n,n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2495  fIntFlowCorrelationsAllVsMPro[12] = new TProfile("four2n2n2n2n","#LT#LT4#GT#GT_{2n,2n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2496  fIntFlowCorrelationsAllVsMPro[13] = new TProfile("four3n1n1n1n","#LT#LT4#GT#GT_{3n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2497  fIntFlowCorrelationsAllVsMPro[14] = new TProfile("four3n1n3n1n","#LT#LT4#GT#GT_{3n,n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2498  fIntFlowCorrelationsAllVsMPro[15] = new TProfile("four3n1n2n2n","#LT#LT4#GT#GT_{3n,n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2499  fIntFlowCorrelationsAllVsMPro[16] = new TProfile("four4n2n1n1n","#LT#LT4#GT#GT_{4n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2500  // 5-p correlations vs M:
2501  fIntFlowCorrelationsAllVsMPro[18] = new TProfile("five2n1n1n1n1n","#LT#LT5#GT#GT_{2n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2502  fIntFlowCorrelationsAllVsMPro[19] = new TProfile("five2n2n2n1n1n","#LT#LT5#GT#GT_{2n,2n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2503  fIntFlowCorrelationsAllVsMPro[20] = new TProfile("five3n1n2n1n1n","#LT#LT5#GT#GT_{3n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2504  fIntFlowCorrelationsAllVsMPro[21] = new TProfile("five4n1n1n1n1n","#LT#LT5#GT#GT_{4n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2505  // 6-p correlations vs M:
2506  fIntFlowCorrelationsAllVsMPro[23] = new TProfile("six1n1n1n1n1n1n","#LT#LT6#GT#GT_{n,n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2507  fIntFlowCorrelationsAllVsMPro[24] = new TProfile("six2n1n1n2n1n1n","#LT#LT6#GT#GT_{2n,n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2508  fIntFlowCorrelationsAllVsMPro[25] = new TProfile("six2n2n1n1n1n1n","#LT#LT6#GT#GT_{2n,2n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2509  fIntFlowCorrelationsAllVsMPro[26] = new TProfile("six3n1n1n1n1n1n","#LT#LT6#GT#GT_{3n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2510  // 7-p correlations vs M:
2511  fIntFlowCorrelationsAllVsMPro[28] = new TProfile("seven2n1n1n1n1n1n1n","#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2512  // 8-p correlations vs M:
2513  fIntFlowCorrelationsAllVsMPro[30] = new TProfile("eight1n1n1n1n1n1n1n1n","#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2514  // EXTRA correlations vs M for v3{5} study (to be improved - put them in a right order somewhere):
2515  fIntFlowCorrelationsAllVsMPro[32] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2516  fIntFlowCorrelationsAllVsMPro[33] = new TProfile("five3n3n2n2n2n","#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2517  // EXTRA correlations vs M for Teaney-Yan study (to be improved - put them in a right order somewhere):
2518  fIntFlowCorrelationsAllVsMPro[34] = new TProfile("two5n5n","#LT#LT2#GT#GT_{5n|5n}",fnBinsMult,fMinMult,fMaxMult);
2519  fIntFlowCorrelationsAllVsMPro[35] = new TProfile("two6n6n","#LT#LT2#GT#GT_{6n|6n}",fnBinsMult,fMinMult,fMaxMult);
2520  fIntFlowCorrelationsAllVsMPro[36] = new TProfile("three5n3n2n","#LT#LT3#GT#GT_{5n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2521  fIntFlowCorrelationsAllVsMPro[37] = new TProfile("three5n4n1n","#LT#LT3#GT#GT_{5n|4n,1n}",fnBinsMult,fMinMult,fMaxMult);
2522  fIntFlowCorrelationsAllVsMPro[38] = new TProfile("three6n3n3n","#LT#LT3#GT#GT_{6n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2523  fIntFlowCorrelationsAllVsMPro[39] = new TProfile("three6n4n2n","#LT#LT3#GT#GT_{6n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2524  fIntFlowCorrelationsAllVsMPro[40] = new TProfile("three6n5n1n","#LT#LT3#GT#GT_{6n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2525  fIntFlowCorrelationsAllVsMPro[41] = new TProfile("four6n3n2n1n","#LT#LT4#GT#GT_{6n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2526  fIntFlowCorrelationsAllVsMPro[42] = new TProfile("four3n2n3n2n","#LT#LT4#GT#GT_{3n,2n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2527  fIntFlowCorrelationsAllVsMPro[43] = new TProfile("four4n1n3n2n","#LT#LT4#GT#GT_{4n,1n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2528  fIntFlowCorrelationsAllVsMPro[44] = new TProfile("four3n3n3n3n","#LT#LT4#GT#GT_{3n,3n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2529  fIntFlowCorrelationsAllVsMPro[45] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2530  fIntFlowCorrelationsAllVsMPro[46] = new TProfile("four5n1n3n3n","#LT#LT4#GT#GT_{5n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2531  fIntFlowCorrelationsAllVsMPro[47] = new TProfile("four4n2n4n2n","#LT#LT4#GT#GT_{4n,2n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2532  fIntFlowCorrelationsAllVsMPro[48] = new TProfile("four5n1n4n2n","#LT#LT4#GT#GT_{5n,1n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2533  fIntFlowCorrelationsAllVsMPro[49] = new TProfile("four5n3n1n1n","#LT#LT4#GT#GT_{5n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2534  fIntFlowCorrelationsAllVsMPro[50] = new TProfile("four5n2n2n1n","#LT#LT4#GT#GT_{5n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2535  fIntFlowCorrelationsAllVsMPro[51] = new TProfile("four5n1n5n1n","#LT#LT4#GT#GT_{5n,1n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2536  fIntFlowCorrelationsAllVsMPro[52] = new TProfile("five3n3n3n2n1n","#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2537  fIntFlowCorrelationsAllVsMPro[53] = new TProfile("five4n2n3n2n1n","#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2538  fIntFlowCorrelationsAllVsMPro[54] = new TProfile("five3n2n3n1n1n","#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2539  fIntFlowCorrelationsAllVsMPro[55] = new TProfile("five3n2n2n2n1n","#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2540  fIntFlowCorrelationsAllVsMPro[56] = new TProfile("five5n1n3n2n1n","#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2541  fIntFlowCorrelationsAllVsMPro[57] = new TProfile("six3n2n1n3n2n1n","#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2542  fIntFlowCorrelationsAllVsMPro[58] = new TProfile("four6n4n1n1n","#LT#LT4#GT#GT_{6n|4n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2543  fIntFlowCorrelationsAllVsMPro[59] = new TProfile("four6n2n2n2n","#LT#LT4#GT#GT_{6n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2544  fIntFlowCorrelationsAllVsMPro[60] = new TProfile("five6n2n2n1n1n","#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2545  fIntFlowCorrelationsAllVsMPro[61] = new TProfile("five4n1n1n3n3n","#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2546  fIntFlowCorrelationsAllVsMPro[62] = new TProfile("six3n3n2n2n1n1n","#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2547  for(Int_t n=0;n<63;n++)
2548  {
2550  {
2551  fIntFlowCorrelationsAllVsMPro[n]->Sumw2();
2553  {
2554  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# RPs");
2556  {
2557  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2559  {
2560  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# POIs");
2561  }
2563  } // end of if(fIntFlowCorrelationsAllVsMPro[n])
2564  } // end of for(Int_t n=0;n<63;n++)
2565  } // end of if(fCalculateAllCorrelationsVsM)
2566  // when particle weights are used some extra correlations appear:
2568  {
2569  TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
2570  intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
2571  fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");
2572  fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");
2573  fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);
2574  fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);
2575  fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");
2576  // extra 2-p correlations:
2577  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");
2578  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");
2580  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
2581  // average product of correlations <2>, <4>, <6> and <8>:
2582  TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
2583  "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
2584  TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
2585  intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
2586  fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);
2587  fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");
2588  fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25);
2589  fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);
2590  fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");
2591  for(Int_t b=0;b<6;b++)
2592  {
2593  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(b+1,productFlag[b].Data());
2594  }
2596  // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
2597  // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
2599  {
2600  TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
2601  intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
2602  for(Int_t pi=0;pi<6;pi++)
2603  {
2604  fIntFlowProductOfCorrelationsVsMPro[pi] = new TProfile(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data()),
2605  Form("%s versus multiplicity",productFlag[pi].Data()),
2608  {
2609  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# RPs");
2611  {
2612  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2614  {
2615  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# POIs");
2616  }
2618  } // end of for(Int_t pi=0;pi<6;pi++)
2619  } // end of if(fCalculateCumulantsVsM)
2620  // average product of correction terms for NUA:
2621  TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
2622  intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2623  fIntFlowProductOfCorrectionTermsForNUAPro = new TProfile(intFlowProductOfCorrectionTermsForNUAProName.Data(),"Average products of correction terms for NUA",27,0,27);
2624  fIntFlowProductOfCorrectionTermsForNUAPro->SetTickLength(-0.01,"Y");
2625  fIntFlowProductOfCorrectionTermsForNUAPro->SetMarkerStyle(25);
2626  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelSize(0.03);
2627  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelOffset(0.01,"Y");
2628  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(1,"<<2><cos(#phi)>>");
2629  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(2,"<<2><sin(#phi)>>");
2630  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(3,"<<cos(#phi)><sin(#phi)>>");
2631  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2632  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2633  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2634  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2635  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2636  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2637  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2638  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2639  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2640  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2641  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2642  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2643  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2644  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2645  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2646  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2647  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2648  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2649  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2650  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2651  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2652  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2653  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2654  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2656  // average correction terms for non-uniform acceptance (with wrong errors!):
2657  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2658  {
2659  TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
2660  intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2661  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");
2662  fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");
2663  fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);
2664  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.05);
2665  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");
2666  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2667  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2668  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2669  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2671  // versus multiplicity:
2673  {
2674  TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
2675  for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
2676  {
2677  TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
2678  intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
2679  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");
2681  }
2682  } // end of if(fCalculateCumulantsVsM)
2683  } // end of for(Int_t sc=0;sc<2;sc++)
2684 
2685  // d) Book histograms holding the final results:
2686  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):
2687  TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
2688  intFlowCorrelationsHistName += fAnalysisLabel->Data();
2689  fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);
2690  fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");
2691  fIntFlowCorrelationsHist->SetMarkerStyle(25);
2692  fIntFlowCorrelationsHist->SetLabelSize(0.06);
2693  fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");
2694  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT");
2695  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"#LT#LT4#GT#GT");
2696  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"#LT#LT6#GT#GT");
2697  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"#LT#LT8#GT#GT");
2699  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!) vs M:
2701  {
2702  for(Int_t ci=0;ci<4;ci++) // correlation index
2703  {
2704  TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
2705  intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
2706  fIntFlowCorrelationsVsMHist[ci] = new TH1D(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data()),
2707  Form("%s vs multiplicity",correlationFlag[ci].Data()),
2709  fIntFlowCorrelationsVsMHist[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2711  {
2712  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# RPs");
2714  {
2715  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2717  {
2718  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# POIs");
2719  }
2721  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2722  } // end of if(fCalculateCumulantsVsM)
2723  // average all correlations for all events (with correct errors!):
2724  TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
2725  intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
2726  fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",34,0,34);
2727  fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");
2728  fIntFlowCorrelationsAllHist->SetMarkerStyle(25);
2729  fIntFlowCorrelationsAllHist->SetLabelSize(0.03);
2730  fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");
2731  // 2-p correlations:
2732  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");
2733  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");
2734  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");
2735  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");
2736  // 3-p correlations:
2737  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");
2738  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");
2739  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");
2740  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");
2741  // 4-p correlations:
2742  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}");
2743  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");
2744  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");
2745  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");
2746  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");
2747  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}");
2748  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");
2749  // 5-p correlations:
2750  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}");
2751  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");
2752  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");
2753  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");
2754  // 6-p correlations:
2755  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");
2756  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");
2757  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");
2758  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");
2759  // 7-p correlations:
2760  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");
2761  // 8-p correlations:
2762  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");
2764  // average correction terms for non-uniform acceptance (with correct errors!):
2765  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2766  {
2767  TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
2768  intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
2769  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);
2770  fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");
2771  fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);
2772  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.05);
2773  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");
2774  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
2775  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2776  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
2777  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
2779  } // end of for(Int_t sc=0;sc<2;sc++)
2780  // covariances (multiplied with weight dependent prefactor):
2781  TString intFlowCovariancesName = "fIntFlowCovariances";
2782  intFlowCovariancesName += fAnalysisLabel->Data();
2783  fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);
2784  fIntFlowCovariances->SetLabelSize(0.04);
2785  fIntFlowCovariances->SetMarkerStyle(25);
2786  (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(#LT2#GT,#LT4#GT)");
2787  (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(#LT2#GT,#LT6#GT)");
2788  (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(#LT2#GT,#LT8#GT)");
2789  (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(#LT4#GT,#LT6#GT)");
2790  (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(#LT4#GT,#LT8#GT)");
2791  (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(#LT6#GT,#LT8#GT)");
2793  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
2794  TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
2795  intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
2796  for(Int_t power=0;power<2;power++)
2797  {
2798  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);
2799  fIntFlowSumOfEventWeights[power]->SetLabelSize(0.04);
2800  fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);
2801  if(power == 0)
2802  {
2803  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}");
2804  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}");
2805  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}");
2806  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}");
2807  } else if (power == 1)
2808  {
2809  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}^{2}");
2810  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}^{2}");
2811  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}^{2}");
2812  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}^{2}");
2813  }
2815  }
2816  // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
2817  TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
2818  intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
2819  fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);
2820  fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.04);
2821  fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);
2822  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT4#GT}");
2823  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT6#GT}");
2824  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT8#GT}");
2825  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT6#GT}");
2826  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT8#GT}");
2827  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT6#GT} w_{#LT8#GT}");
2829  // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
2830  // [0=Cov(2,4),1=Cov(2,6),2=Cov(2,8),3=Cov(4,6),4=Cov(4,8),5=Cov(6,8)]:
2832  {
2833  TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
2834  intFlowCovariancesVsMName += fAnalysisLabel->Data();
2835  TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
2836  for(Int_t ci=0;ci<6;ci++)
2837  {
2838  fIntFlowCovariancesVsM[ci] = new TH1D(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data()),
2839  Form("%s vs multiplicity",covarianceFlag[ci].Data()),
2841  fIntFlowCovariancesVsM[ci]->GetYaxis()->SetTitle(covarianceFlag[ci].Data());
2843  {
2844  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# RPs");
2846  {
2847  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2849  {
2850  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# POIs");
2851  }
2853  }
2854  } // end of if(fCalculateCumulantsVsM)
2855  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
2856  // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
2858  {
2859  TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
2860  intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
2861  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>}"},
2862  {"#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}"}};
2863  for(Int_t si=0;si<4;si++)
2864  {
2865  for(Int_t power=0;power<2;power++)
2866  {
2867  fIntFlowSumOfEventWeightsVsM[si][power] = new TH1D(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data()),
2868  Form("%s vs multiplicity",sumFlag[power][si].Data()),
2870  fIntFlowSumOfEventWeightsVsM[si][power]->GetYaxis()->SetTitle(sumFlag[power][si].Data());
2872  {
2873  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# RPs");
2875  {
2876  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2878  {
2879  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# POIs");
2880  }
2882  } // end of for(Int_t power=0;power<2;power++)
2883  } // end of for(Int_t si=0;si<4;si++)
2884  } // end of if(fCalculateCumulantsVsM)
2885  // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
2886  // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
2887  // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
2889  {
2890  TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
2891  intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
2892  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>}",
2893  "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
2894  for(Int_t pi=0;pi<6;pi++)
2895  {
2896  fIntFlowSumOfProductOfEventWeightsVsM[pi] = new TH1D(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data()),
2897  Form("%s versus multiplicity",sopowFlag[pi].Data()),
2900  {
2901  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# RPs");
2903  {
2904  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2906  {
2907  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# POIs");
2908  }
2909  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetYaxis()->SetTitle(sopowFlag[pi].Data());
2911  } // end of for(Int_t pi=0;pi<6;pi++)
2912  } // end of if(fCalculateCumulantsVsM)
2913  // covariances of NUA terms (multiplied with weight dependent prefactor):
2914  TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
2915  intFlowCovariancesNUAName += fAnalysisLabel->Data();
2916  fIntFlowCovariancesNUA = new TH1D(intFlowCovariancesNUAName.Data(),"Covariances for NUA (multiplied with weight dependent prefactor)",27,0,27);
2917  fIntFlowCovariancesNUA->SetLabelSize(0.04);
2918  fIntFlowCovariancesNUA->SetMarkerStyle(25);
2919  fIntFlowCovariancesNUA->GetXaxis()->SetLabelSize(0.02);
2920  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(1,"Cov(<2>,<cos(#phi)>");
2921  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(2,"Cov(<2>,<sin(#phi)>)");
2922  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(3,"Cov(<cos(#phi)>,<sin(#phi)>)");
2923  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2924  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2925  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2926  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2927  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2928  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2929  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2930  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2931  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2932  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2933  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2934  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2935  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2936  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2937  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2938  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2939  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2940  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2941  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2942  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2943  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2944  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2945  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2946  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2948  // sum of linear and quadratic event weights for NUA terms:
2949  TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
2950  intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
2951  for(Int_t sc=0;sc<2;sc++)
2952  {
2953  for(Int_t power=0;power<2;power++)
2954  {
2955  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
2956  fIntFlowSumOfEventWeightsNUA[sc][power]->SetLabelSize(0.05);
2957  fIntFlowSumOfEventWeightsNUA[sc][power]->SetMarkerStyle(25);
2958  if(power == 0)
2959  {
2960  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}",sinCosFlag[sc].Data()));
2961  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}",sinCosFlag[sc].Data()));
2962  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}",sinCosFlag[sc].Data()));
2963  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}",sinCosFlag[sc].Data()));
2964  } else if(power == 1)
2965  {
2966  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}^{2}",sinCosFlag[sc].Data()));
2967  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
2968  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}^{2}",sinCosFlag[sc].Data()));
2969  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
2970  }
2972  }
2973  }
2974  // sum of products of event weights for NUA terms:
2975  TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
2976  intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
2977  fIntFlowSumOfProductOfEventWeightsNUA = new TH1D(intFlowSumOfProductOfEventWeightsNUAName.Data(),"Sum of product of event weights for NUA terms",27,0,27);
2978  fIntFlowSumOfProductOfEventWeightsNUA->SetLabelSize(0.02);
2979  fIntFlowSumOfProductOfEventWeightsNUA->SetMarkerStyle(25);
2980  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi)#GT}");
2981  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi)#GT}");
2982  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi)#GT}");
2983  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2984  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2985  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2986  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(7,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2987  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(8,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi)#GT}");
2988  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(9,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi)#GT}");
2989  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(10,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2990  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(11,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2991  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(12,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2992  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(13,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2993  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(14,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2994  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(15,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2995  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(16,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2996  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(17,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
2997  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(18,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
2998  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(19,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
2999  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(20,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3000  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(21,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3001  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(22,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3002  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(23,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3003  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(24,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3004  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(25,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3005  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(26,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3006  (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}");
3008  // Final results for reference Q-cumulants:
3009  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3010  TString intFlowQcumulantsName = "fIntFlowQcumulants";
3011  intFlowQcumulantsName += fAnalysisLabel->Data();
3012  fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Reference Q-cumulants",4,0,4);
3014  {
3015  fIntFlowQcumulants->SetTitle("Reference Q-cumulants (error from non-isotropic terms also propagated)");
3016  }
3017  fIntFlowQcumulants->SetLabelSize(0.05);
3018  fIntFlowQcumulants->SetMarkerStyle(25);
3019  for(Int_t b=0;b<4;b++)
3020  {
3021  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3022  }
3024  // Final results for reference Q-cumulants rebinned in M:
3026  {
3027  TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
3028  intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
3029  fIntFlowQcumulantsRebinnedInM = new TH1D(intFlowQcumulantsRebinnedInMName.Data(),"Reference Q-cumulants rebinned in M",4,0,4);
3030  fIntFlowQcumulantsRebinnedInM->SetLabelSize(0.05);
3031  fIntFlowQcumulantsRebinnedInM->SetMarkerStyle(25);
3032  for(Int_t b=0;b<4;b++)
3033  {
3034  (fIntFlowQcumulantsRebinnedInM->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3035  }
3037  } // end of if(fCalculateCumulantsVsM)
3038  // Ratio between error squared: with/without non-isotropic terms:
3039  TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
3040  intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
3041  fIntFlowQcumulantsErrorSquaredRatio = new TH1D(intFlowQcumulantsErrorSquaredRatioName.Data(),"Error squared of reference Q-cumulants: #frac{with NUA terms}{without NUA terms}",4,0,4);
3042  fIntFlowQcumulantsErrorSquaredRatio->SetLabelSize(0.05);
3043  fIntFlowQcumulantsErrorSquaredRatio->SetMarkerStyle(25);
3044  for(Int_t b=0;b<4;b++)
3045  {
3046  (fIntFlowQcumulantsErrorSquaredRatio->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3047  }
3049  // final results for integrated Q-cumulants versus multiplicity:
3051  {
3052  TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
3053  intFlowQcumulantsVsMName += fAnalysisLabel->Data();
3054  for(Int_t co=0;co<4;co++) // cumulant order
3055  {
3056  fIntFlowQcumulantsVsM[co] = new TH1D(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data()),
3057  Form("%s vs multiplicity",cumulantFlag[co].Data()),
3060  {
3061  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# RPs");
3063  {
3064  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3066  {
3067  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# POIs");
3068  }
3069  fIntFlowQcumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());
3071  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3072  } // end of if(fCalculateCumulantsVsM)
3073  // final integrated flow estimates from Q-cumulants:
3074  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)};
3075  TString intFlowName = "fIntFlow";
3076  intFlowName += fAnalysisLabel->Data();
3077  // integrated flow from Q-cumulants:
3078  fIntFlow = new TH1D(intFlowName.Data(),"Reference flow estimates from Q-cumulants",4,0,4);
3079  fIntFlow->SetLabelSize(0.05);
3080  fIntFlow->SetMarkerStyle(25);
3081  for(Int_t b=0;b<4;b++)
3082  {
3083  (fIntFlow->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3084  }
3085  fIntFlowResults->Add(fIntFlow);
3086  // Reference flow vs M rebinned in one huge bin:
3088  {
3089  TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
3090  intFlowRebinnedInMName += fAnalysisLabel->Data();
3091  fIntFlowRebinnedInM = new TH1D(intFlowRebinnedInMName.Data(),"Reference flow estimates from Q-cumulants (rebinned in M)",4,0,4);
3092  fIntFlowRebinnedInM->SetLabelSize(0.05);
3093  fIntFlowRebinnedInM->SetMarkerStyle(25);
3094  for(Int_t b=0;b<4;b++)
3095  {
3096  (fIntFlowRebinnedInM->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3097  }
3099  }
3100  // integrated flow from Q-cumulants: versus multiplicity:
3102  {
3103  TString intFlowVsMName = "fIntFlowVsM";
3104  intFlowVsMName += fAnalysisLabel->Data();
3105  for(Int_t co=0;co<4;co++) // cumulant order
3106  {
3107  fIntFlowVsM[co] = new TH1D(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data()),
3108  Form("%s vs multiplicity",flowFlag[co].Data()),
3111  {
3112  fIntFlowVsM[co]->GetXaxis()->SetTitle("# RPs");
3114  {
3115  fIntFlowVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3117  {
3118  fIntFlowVsM[co]->GetXaxis()->SetTitle("# POIs");
3119  }
3120  fIntFlowVsM[co]->GetYaxis()->SetTitle(flowFlag[co].Data());
3121  fIntFlowResults->Add(fIntFlowVsM[co]);
3122  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3123  } // end of if(fCalculateCumulantsVsM)
3124  // quantifying detector effects effects to correlations:
3125  TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
3126  intFlowDetectorBiasName += fAnalysisLabel->Data();
3127  fIntFlowDetectorBias = new TH1D(intFlowDetectorBiasName.Data(),"Quantifying detector bias",4,0,4);
3128  fIntFlowDetectorBias->SetLabelSize(0.05);
3129  fIntFlowDetectorBias->SetMarkerStyle(25);
3130  for(Int_t ci=0;ci<4;ci++)
3131  {
3132  (fIntFlowDetectorBias->GetXaxis())->SetBinLabel(ci+1,Form("#frac{corrected}{measured} %s",cumulantFlag[ci].Data()));
3133  }
3135  // quantifying detector effects to correlations versus multiplicity:
3137  {
3138  TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
3139  intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
3140  for(Int_t ci=0;ci<4;ci++) // correlation index
3141  {
3142  fIntFlowDetectorBiasVsM[ci] = new TH1D(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data()),
3143  Form("Quantifying detector bias for %s vs multiplicity",cumulantFlag[ci].Data()),
3146  {
3147  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# RPs");
3149  {
3150  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3152  {
3153  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# POIs");
3154  }
3155  fIntFlowDetectorBiasVsM[ci]->GetYaxis()->SetTitle("#frac{corrected}{measured}");
3157  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3158  } // end of if(fCalculateCumulantsVsM)
3159 
3160 } // end of AliFlowAnalysisCRC::BookEverythingForIntegratedFlow()
3161 
3162 //=======================================================================================================================
3163 
3165 {
3166  // Book all objects for control histograms.
3167 
3168  // a) Book profile to hold all flags for control histograms;
3169  // b) Book all control histograms.
3170 
3171  // a) Book profile to hold all flags for control histograms:
3172  TString controlHistogramsFlagsName = "fControlHistogramsFlags";
3173  controlHistogramsFlagsName += fAnalysisLabel->Data();
3174  fControlHistogramsFlags = new TProfile(controlHistogramsFlagsName.Data(),"Flags for Control Histograms",2,0,2);
3175  fControlHistogramsFlags->SetTickLength(-0.01,"Y");
3176  fControlHistogramsFlags->SetMarkerStyle(25);
3177  fControlHistogramsFlags->SetLabelSize(0.04);
3178  fControlHistogramsFlags->SetLabelOffset(0.02,"Y");
3179  fControlHistogramsFlags->SetStats(kFALSE);
3180  fControlHistogramsFlags->GetXaxis()->SetBinLabel(1,"fStoreControlHistograms");
3181  fControlHistogramsFlags->GetXaxis()->SetBinLabel(2,"fUseQvectorTerms");
3183 
3184  if(!fStoreControlHistograms){return;}
3185 
3186  // b) Book all control histograms:
3187  // b1) Correlation between # RPs and ref. mult. determined centrally:
3188  TString sCorrelationNoRPsVsRefMultName = "fCorrelationNoRPsVsRefMult";
3189  sCorrelationNoRPsVsRefMultName += fAnalysisLabel->Data();
3190  fCorrelationNoRPsVsRefMult = new TH2D(sCorrelationNoRPsVsRefMultName.Data(),"# RPs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3191  fCorrelationNoRPsVsRefMult->SetTickLength(-0.01,"Y");
3192  fCorrelationNoRPsVsRefMult->SetLabelSize(0.04);
3193  fCorrelationNoRPsVsRefMult->SetLabelOffset(0.02,"Y");
3194  fCorrelationNoRPsVsRefMult->SetStats(kTRUE);
3195  fCorrelationNoRPsVsRefMult->GetXaxis()->SetTitle("# RPs");
3196  fCorrelationNoRPsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3198  // b2) Correlation between # POIs and ref. mult. determined centrally:
3199  TString sCorrelationNoPOIsVsRefMultName = "fCorrelationNoPOIsVsRefMult";
3200  sCorrelationNoPOIsVsRefMultName += fAnalysisLabel->Data();
3201  fCorrelationNoPOIsVsRefMult = new TH2D(sCorrelationNoPOIsVsRefMultName.Data(),"# POIs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3202  fCorrelationNoPOIsVsRefMult->SetTickLength(-0.01,"Y");
3203  fCorrelationNoPOIsVsRefMult->SetLabelSize(0.04);
3204  fCorrelationNoPOIsVsRefMult->SetLabelOffset(0.02,"Y");
3205  fCorrelationNoPOIsVsRefMult->SetStats(kTRUE);
3206  fCorrelationNoPOIsVsRefMult->GetXaxis()->SetTitle("# POIs");
3207  fCorrelationNoPOIsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3209  // b3) Correlation between # RPs and # POIs:
3210  TString sCorrelationNoRPsVsNoPOIsName = "fCorrelationNoRPsVsNoPOIs";
3211  sCorrelationNoRPsVsNoPOIsName += fAnalysisLabel->Data();
3212  fCorrelationNoRPsVsNoPOIs = new TH2D(sCorrelationNoRPsVsNoPOIsName.Data(),"# RPs vs. # POIs",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3213  fCorrelationNoRPsVsNoPOIs->SetTickLength(-0.01,"Y");
3214  fCorrelationNoRPsVsNoPOIs->SetLabelSize(0.04);
3215  fCorrelationNoRPsVsNoPOIs->SetLabelOffset(0.02,"Y");
3216  fCorrelationNoRPsVsNoPOIs->SetStats(kTRUE);
3217  fCorrelationNoRPsVsNoPOIs->GetXaxis()->SetTitle("# RPs");
3218  fCorrelationNoRPsVsNoPOIs->GetYaxis()->SetTitle("# POIs");
3220  // b4) <2>, <4>, <6> and <8> vs multiplicity (#RPs, #POIs or external):
3221  TString sCorrelation[4] = {"#LT2#GT","#LT4#GT","#LT6#GT","#LT8#GT"};
3222  TString sMultiplicity = "";
3224  {
3225  sMultiplicity = "# RPs";
3227  {
3228  sMultiplicity = "Reference multiplicity (from ESD)";
3230  {
3231  sMultiplicity = "# POIs";
3232  }
3233  for(Int_t ci=0;ci<4;ci++)
3234  {
3235  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]);
3236  fCorrelation2468VsMult[ci]->SetTickLength(-0.01,"Y");
3237  fCorrelation2468VsMult[ci]->SetLabelSize(0.04);
3238  fCorrelation2468VsMult[ci]->SetLabelOffset(0.02,"Y");
3239  fCorrelation2468VsMult[ci]->SetStats(kTRUE);
3240  fCorrelation2468VsMult[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3241  fCorrelation2468VsMult[ci]->GetYaxis()->SetTitle(sCorrelation[ci].Data());
3243  } // end of for(Int_t ci=0;ci<4;ci++)
3244  // b5) <2><4>, <2><6>, <2><8>, <4><6> etc. vs multiplicity (#RPs, #POIs or external):
3245  TString sCorrelationProduct[1] = {"#LT2#GT#LT4#GT"}; // TBI: add the other ones when needed first time
3246  for(Int_t cpi=0;cpi<1;cpi++) // TBI: hardwired 1
3247  {
3248  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]);
3249  fCorrelationProduct2468VsMult[cpi]->SetTickLength(-0.01,"Y");
3250  fCorrelationProduct2468VsMult[cpi]->SetLabelSize(0.04);
3251  fCorrelationProduct2468VsMult[cpi]->SetLabelOffset(0.02,"Y");
3252  fCorrelationProduct2468VsMult[cpi]->SetStats(kTRUE);
3253  fCorrelationProduct2468VsMult[cpi]->GetXaxis()->SetTitle(sMultiplicity.Data());
3254  fCorrelationProduct2468VsMult[cpi]->GetYaxis()->SetTitle(sCorrelationProduct[cpi].Data());
3256  } // end of for(Int_t cpi=0;cpi<4;cpi++)
3257  // b6) |Qn|^2/M, |Q2n|^2/M, |Qn|^4/(M(2M-1)), Re[Q2nQn^*Qn^*]/M, ... vs multiplicity (#RPs, #POIs or external)
3258  if(fUseQvectorTerms)
3259  {
3260  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
3261  for(Int_t qvti=0;qvti<4;qvti++) // TBI: hardwired 4
3262  {
3263  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]);
3264  fQvectorTermsVsMult[qvti]->SetTickLength(-0.01,"Y");
3265  fQvectorTermsVsMult[qvti]->SetLabelSize(0.04);
3266  fQvectorTermsVsMult[qvti]->SetLabelOffset(0.02,"Y");
3267  fQvectorTermsVsMult[qvti]->SetStats(kTRUE);
3268  fQvectorTermsVsMult[qvti]->GetXaxis()->SetTitle(sMultiplicity.Data());
3269  fQvectorTermsVsMult[qvti]->GetYaxis()->SetTitle(sQvectorTerms[qvti].Data());
3271  } // end of for(Int_t qvti=0;qvti<4;qvti++)
3272  } // end of if(fUseQvectorTerms)
3273 
3274 } // end of void AliFlowAnalysisCRC::BookEverythingForControlHistograms()
3275 
3276 //=======================================================================================================================
3277 
3279 {
3280  // Book all objects needed for bootstrap.
3281 
3282  // a) Book profile to hold all flags for bootstrap;
3283  // b) Book local random generator;
3284  // c) Book all bootstrap objects;
3285  // d) Book all bootstrap objects 'vs M'.
3286 
3287  // a) Book profile to hold all flags for bootstrap;
3288  TString bootstrapFlagsName = "fBootstrapFlags";
3289  bootstrapFlagsName += fAnalysisLabel->Data();
3290  fBootstrapFlags = new TProfile(bootstrapFlagsName.Data(),"Flags for bootstrap",3,0,3);
3291  fBootstrapFlags->SetTickLength(-0.01,"Y");
3292  fBootstrapFlags->SetMarkerStyle(25);
3293  fBootstrapFlags->SetLabelSize(0.04);
3294  fBootstrapFlags->SetLabelOffset(0.02,"Y");
3295  fBootstrapFlags->SetStats(kFALSE);
3296  fBootstrapFlags->GetXaxis()->SetBinLabel(1,"fUseBootstrap");
3297  fBootstrapFlags->GetXaxis()->SetBinLabel(2,"fUseBootstrapVsM");
3298  fBootstrapFlags->GetXaxis()->SetBinLabel(3,"fnSubsamples");
3300 
3301  // c) Book all bootstrap objects:
3302  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
3303  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3304  if(fUseBootstrap)
3305  {
3306  // ....
3307  TString bootstrapCorrelationsName = "fBootstrapCorrelations";
3308  bootstrapCorrelationsName += fAnalysisLabel->Data();
3309  fBootstrapCorrelations = new TProfile2D(bootstrapCorrelationsName.Data(),"Bootstrap Correlations",4,0.,4.,fnSubsamples,0,fnSubsamples); // x-axis => <2>, <4>, <6>, <8>; y-axis => subsample #
3310  fBootstrapCorrelations->SetStats(kFALSE);
3311  for(Int_t ci=0;ci<4;ci++) // correlation index
3312  {
3313  fBootstrapCorrelations->GetXaxis()->SetBinLabel(ci+1,correlationFlag[ci].Data());
3314  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3315  for(Int_t ss=0;ss<fnSubsamples;ss++)
3316  {
3317  fBootstrapCorrelations->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3318  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3320  // ....
3321  TString bootstrapCumulantsName = "fBootstrapCumulants";
3322  bootstrapCumulantsName += fAnalysisLabel->Data();
3323  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 #
3324  fBootstrapCumulants->SetStats(kFALSE);
3325  for(Int_t co=0;co<4;co++) // cumulant order
3326  {
3327  fBootstrapCumulants->GetXaxis()->SetBinLabel(co+1,cumulantFlag[co].Data());
3328  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3329  for(Int_t ss=0;ss<fnSubsamples;ss++)
3330  {
3331  fBootstrapCumulants->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3332  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3334  } // end of if(fUseBootstrap)
3335 
3336  // d) Book all bootstrap objects 'vs M':
3337  TString sMultiplicity = "";
3339  {
3340  sMultiplicity = "# RPs";
3342  {
3343  sMultiplicity = "Reference multiplicity (from ESD)";
3345  {
3346  sMultiplicity = "# POIs";
3347  }
3348  if(fUseBootstrapVsM)
3349  {
3350  // ....
3351  TString bootstrapCorrelationsVsMName = "fBootstrapCorrelationsVsM";
3352  bootstrapCorrelationsVsMName += fAnalysisLabel->Data();
3353  for(Int_t ci=0;ci<4;ci++) // correlation index
3354  {
3355  fBootstrapCorrelationsVsM[ci] = new TProfile2D(Form("%s, %s",bootstrapCorrelationsVsMName.Data(),correlationFlag[ci].Data()),
3356  Form("Bootstrap Correlations Vs. M, %s",correlationFlag[ci].Data()),
3357  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3358  fBootstrapCorrelationsVsM[ci]->SetStats(kFALSE);
3359  fBootstrapCorrelationsVsM[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3360  for(Int_t ss=0;ss<fnSubsamples;ss++)
3361  {
3362  fBootstrapCorrelationsVsM[ci]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3363  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3365  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3366  // ....
3367  TString bootstrapCumulantsVsMName = "fBootstrapCumulantsVsM";
3368  bootstrapCumulantsVsMName += fAnalysisLabel->Data();
3369  for(Int_t co=0;co<4;co++) // cumulant order
3370  {
3371  fBootstrapCumulantsVsM[co] = new TH2D(Form("%s, %s",bootstrapCumulantsVsMName.Data(),cumulantFlag[co].Data()),
3372  Form("Bootstrap Cumulants Vs. M, %s",cumulantFlag[co].Data()),
3373  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3374  fBootstrapCumulantsVsM[co]->SetStats(kFALSE);
3375  fBootstrapCumulantsVsM[co]->GetXaxis()->SetTitle(sMultiplicity.Data());
3376  for(Int_t ss=0;ss<fnSubsamples;ss++)
3377  {
3378  fBootstrapCumulantsVsM[co]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3379  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3381  } // end of for(Int_t co=0;co<4;co++) // correlation index
3382  } // end of if(fUseBootstrapVsM)
3383 
3384 } // end of void AliFlowAnalysisCRC::BookEverythingForBootstrap()
3385 
3386 //=======================================================================================================================
3387 
3389 {
3390  // Book all objects for mixed harmonics.
3391 
3392  // a) Book profile to hold all flags for mixed harmonics;
3393  // b) Book all objects in TList fMixedHarmonicsProfiles;
3394  // c) Book all objects in TList fMixedHarmonicsResults;
3395  // d) Book all objects in TList fMixedHarmonicsErrorPropagation.
3396 
3397  // a) Book profile to hold all flags for mixed harmonics:
3398  TString mixedHarmonicsFlagsName = "fMixedHarmonicsFlags";
3399  mixedHarmonicsFlagsName += fAnalysisLabel->Data();
3400  fMixedHarmonicsFlags = new TProfile(mixedHarmonicsFlagsName.Data(),"Flags for Mixed Harmonics",4,0,4);
3401  fMixedHarmonicsFlags->SetTickLength(-0.01,"Y");
3402  fMixedHarmonicsFlags->SetMarkerStyle(25);
3403  fMixedHarmonicsFlags->SetLabelSize(0.04);
3404  fMixedHarmonicsFlags->SetLabelOffset(0.02,"Y");
3405  fMixedHarmonicsFlags->SetStats(kFALSE);
3406  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(1,"Calculate Mixed Harmonics");
3407  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(2,"Generic Harmonic");
3408  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(3,"Calculate vs Multiplicity");
3409  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(4,"Multiplicity Weight");
3411 
3412  if(!fCalculateMixedHarmonics){return;}
3413 
3414  // b) Book all objects in TList fMixedHarmonicsProfiles:
3415  // b1) 2-p correlations:
3416  TString s2pCorrelationsName = "f2pCorrelations";
3417  s2pCorrelationsName += fAnalysisLabel->Data();
3418  f2pCorrelations = new TProfile(s2pCorrelationsName.Data(),Form("2-particle correlations (n = %d)",fHarmonic),6,0,6,"s");
3419  f2pCorrelations->SetTickLength(-0.01,"Y");
3420  f2pCorrelations->SetMarkerStyle(25);
3421  f2pCorrelations->SetLabelSize(0.04);
3422  f2pCorrelations->SetLabelOffset(0.02,"Y");
3423  f2pCorrelations->SetStats(kFALSE);
3424  f2pCorrelations->Sumw2();
3425  f2pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
3426  f2pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
3427  f2pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
3428  f2pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
3429  f2pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
3430  f2pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT2#GT#GT_{%dn|%dn}",6*fHarmonic,6*fHarmonic));
3432  // b2) 3-p correlations (3+6):
3433  TString s3pCorrelationsName = "f3pCorrelations";
3434  s3pCorrelationsName += fAnalysisLabel->Data();
3435  f3pCorrelations = new TProfile(s3pCorrelationsName.Data(),Form("3-particle correlations (n = %d)",fHarmonic),10,0,10,"s");
3436  f3pCorrelations->SetTickLength(-0.01,"Y");
3437  f3pCorrelations->SetMarkerStyle(25);
3438  f3pCorrelations->SetLabelSize(0.04);
3439  f3pCorrelations->SetLabelOffset(0.02,"Y");
3440  f3pCorrelations->SetStats(kFALSE);
3441  f3pCorrelations->Sumw2();
3442  // 3-p correlations sensitive to two distinct harmonics (3):
3443  f3pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic));
3444  f3pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic));
3445  f3pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic));
3446  f3pCorrelations->GetXaxis()->SetBinLabel(4,""); // empty
3447  // 3-p correlations sensitive to three distinct harmonics (6):
3448  f3pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,1*fHarmonic));
3449  f3pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,1*fHarmonic));
3450  f3pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,2*fHarmonic));
3451  f3pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,1*fHarmonic));
3452  f3pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,2*fHarmonic));
3453  f3pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,1*fHarmonic));
3455  // b3) 4-p correlations (6+15+2+10+8):
3456  TString s4pCorrelationsName = "f4pCorrelations";
3457  s4pCorrelationsName += fAnalysisLabel->Data();
3458  f4pCorrelations = new TProfile(s4pCorrelationsName.Data(),Form("4-particle correlations (n = %d)",fHarmonic),45,0,45,"s");
3459  f4pCorrelations->SetTickLength(-0.01,"Y");
3460  f4pCorrelations->SetMarkerStyle(25);
3461  f4pCorrelations->SetLabelSize(0.03);
3462  f4pCorrelations->SetLabelOffset(0.02,"Y");
3463  f4pCorrelations->SetStats(kFALSE);
3464  f4pCorrelations->Sumw2();
3465  // "same harmonic" (6):
3466  f4pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3467  f4pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3468  f4pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3469  f4pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3470  f4pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic));
3471  f4pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,6*fHarmonic));
3472  f4pCorrelations->GetXaxis()->SetBinLabel(7,""); // empty
3473  // "standard candles" (15):
3474  f4pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic));
3475  f4pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic));
3476  f4pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic));
3477  f4pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic));
3478  f4pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic));
3479  f4pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic));
3480  f4pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic));
3481  f4pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic));
3482  f4pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic));
3483  f4pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic));
3484  f4pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,6*fHarmonic,1*fHarmonic));
3485  f4pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,2*fHarmonic));
3486  f4pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,3*fHarmonic));
3487  f4pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,4*fHarmonic));
3488  f4pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,5*fHarmonic));
3489  f4pCorrelations->GetXaxis()->SetBinLabel(23,""); // empty
3490  // 4-p correlations sensitive to two distinct harmonics (2):
3491  f4pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3492  f4pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3493  f4pCorrelations->GetXaxis()->SetBinLabel(26,""); // empty
3494  // 4-p correlations sensitive to three distinct harmonics (10):
3495  f4pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic));
3496  f4pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3497  f4pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic));
3498  f4pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3499  f4pCorrelations->GetXaxis()->SetBinLabel(31,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3500  f4pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3501  f4pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic));
3502  f4pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3503  f4pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,4*fHarmonic));
3504  f4pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,5*fHarmonic));
3505  f4pCorrelations->GetXaxis()->SetBinLabel(37,""); // empty
3506  // 4-p correlations sensitive to four distinct harmonics (8):
3507  f4pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic));
3508  f4pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic));
3509  f4pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic));
3510  f4pCorrelations->GetXaxis()->SetBinLabel(41,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3511  f4pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,2*fHarmonic));
3512  f4pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3513  f4pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,3*fHarmonic));
3514  f4pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,4*fHarmonic));
3516  // b3) 5-p correlations (30+9+30+11+3):
3517  TString s5pCorrelationsName = "f5pCorrelations";
3518  s5pCorrelationsName += fAnalysisLabel->Data();
3519  f5pCorrelations = new TProfile(s5pCorrelationsName.Data(),Form("5-particle correlations (n = %d)",fHarmonic),87,0,87,"s");
3520  f5pCorrelations->SetTickLength(-0.01,"Y");
3521  f5pCorrelations->SetMarkerStyle(25);
3522  f5pCorrelations->SetLabelSize(0.02);
3523  f5pCorrelations->SetLabelOffset(0.02,"Y");
3524  f5pCorrelations->SetStats(kFALSE);
3525  f5pCorrelations->Sumw2();
3526  // "standard candles" (30):
3527  f5pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3528  f5pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3529  f5pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3530  f5pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3531  f5pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3532  f5pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3533  f5pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3534  f5pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3535  f5pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3536  f5pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3537  f5pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3538  f5pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3539  f5pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3540  f5pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3541  f5pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3542  f5pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3543  f5pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3544  f5pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3545  f5pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3546  f5pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3547  f5pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3548  f5pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3549  f5pCorrelations->GetXaxis()->SetBinLabel(23,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,3*fHarmonic));
3550  f5pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,1*fHarmonic,1*fHarmonic));
3551  f5pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,2*fHarmonic,1*fHarmonic));
3552  f5pCorrelations->GetXaxis()->SetBinLabel(26,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,2*fHarmonic,2*fHarmonic));
3553  f5pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,3*fHarmonic,1*fHarmonic));
3554  f5pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,2*fHarmonic));
3555  f5pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,3*fHarmonic,2*fHarmonic));
3556  f5pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,4*fHarmonic,1*fHarmonic));
3557  f5pCorrelations->GetXaxis()->SetBinLabel(31,""); // empty
3558  // 5-p correlations sensitive to two distinct harmonics (9):
3559  f5pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3560  f5pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3561  f5pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3562  f5pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3563  f5pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3564  f5pCorrelations->GetXaxis()->SetBinLabel(37,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3565  f5pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3566  f5pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3567  f5pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,3*fHarmonic,3*fHarmonic));
3568  f5pCorrelations->GetXaxis()->SetBinLabel(41,""); // empty
3569  // 5-p correlations sensitive to three distinct harmonics (30):
3570  f5pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3571  f5pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3572  f5pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3573  f5pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3574  f5pCorrelations->GetXaxis()->SetBinLabel(46,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3575  f5pCorrelations->GetXaxis()->SetBinLabel(47,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3576  f5pCorrelations->GetXaxis()->SetBinLabel(48,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3577  f5pCorrelations->GetXaxis()->SetBinLabel(49,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3578  f5pCorrelations->GetXaxis()->SetBinLabel(50,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3579  f5pCorrelations->GetXaxis()->SetBinLabel(51,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3580  f5pCorrelations->GetXaxis()->SetBinLabel(52,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3581  f5pCorrelations->GetXaxis()->SetBinLabel(53,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3582  f5pCorrelations->GetXaxis()->SetBinLabel(54,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3583  f5pCorrelations->GetXaxis()->SetBinLabel(55,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3584  f5pCorrelations->GetXaxis()->SetBinLabel(56,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3585  f5pCorrelations->GetXaxis()->SetBinLabel(57,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3586  f5pCorrelations->GetXaxis()->SetBinLabel(58,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3587  f5pCorrelations->GetXaxis()->SetBinLabel(59,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3588  f5pCorrelations->GetXaxis()->SetBinLabel(60,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3589  f5pCorrelations->GetXaxis()->SetBinLabel(61,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3590  f5pCorrelations->GetXaxis()->SetBinLabel(62,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3591  f5pCorrelations->GetXaxis()->SetBinLabel(63,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3592  f5pCorrelations->GetXaxis()->SetBinLabel(64,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3593  f5pCorrelations->GetXaxis()->SetBinLabel(65,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3594  f5pCorrelations->GetXaxis()->SetBinLabel(66,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3595  f5pCorrelations->GetXaxis()->SetBinLabel(67,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,5*fHarmonic,5*fHarmonic));
3596  f5pCorrelations->GetXaxis()->SetBinLabel(68,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic,1*fHarmonic));
3597  f5pCorrelations->GetXaxis()->SetBinLabel(69,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,5*fHarmonic,2*fHarmonic));
3598  f5pCorrelations->GetXaxis()->SetBinLabel(70,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,4*fHarmonic,2*fHarmonic));
3599  f5pCorrelations->GetXaxis()->SetBinLabel(71,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,5*fHarmonic,1*fHarmonic));
3600  f5pCorrelations->GetXaxis()->SetBinLabel(72,""); // empty
3601  // 5-p correlations sensitive to four distinct harmonics (11):
3602  f5pCorrelations->GetXaxis()->SetBinLabel(73,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3603  f5pCorrelations->GetXaxis()->SetBinLabel(74,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3604  f5pCorrelations->GetXaxis()->SetBinLabel(75,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3605  f5pCorrelations->GetXaxis()->SetBinLabel(76,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3606  f5pCorrelations->GetXaxis()->SetBinLabel(77,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3607  f5pCorrelations->GetXaxis()->SetBinLabel(78,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3608  f5pCorrelations->GetXaxis()->SetBinLabel(79,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,5*fHarmonic,3*fHarmonic));
3609  f5pCorrelations->GetXaxis()->SetBinLabel(80,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3610  f5pCorrelations->GetXaxis()->SetBinLabel(81,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic));
3611  f5pCorrelations->GetXaxis()->SetBinLabel(82,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,5*fHarmonic,5*fHarmonic));
3612  f5pCorrelations->GetXaxis()->SetBinLabel(83,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic));
3613  f5pCorrelations->GetXaxis()->SetBinLabel(84,""); // empty
3614  // 5-p correlations sensitive to five distinct harmonics (3):
3615  f5pCorrelations->GetXaxis()->SetBinLabel(85,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3616  f5pCorrelations->GetXaxis()->SetBinLabel(86,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,1*fHarmonic,5*fHarmonic,4*fHarmonic));
3617  f5pCorrelations->GetXaxis()->SetBinLabel(87,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3619  // b4) 6-p correlations (??+??+??+??+??):
3620  TString s6pCorrelationsName = "f6pCorrelations";
3621  s6pCorrelationsName += fAnalysisLabel->Data();
3622  f6pCorrelations = new TProfile(s6pCorrelationsName.Data(),Form("6-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3623  f6pCorrelations->SetTickLength(-0.01,"Y");
3624  f6pCorrelations->SetMarkerStyle(25);
3625  f6pCorrelations->SetLabelSize(0.02);
3626  f6pCorrelations->SetLabelOffset(0.02,"Y");
3627  f6pCorrelations->SetStats(kFALSE);
3628  f6pCorrelations->Sumw2();
3629  //fMixedHarmonicsProfiles->Add(f6pCorrelations); // TBI
3630  // b5) 7-p correlations (??+??+??+??+??):
3631  TString s7pCorrelationsName = "f7pCorrelations";
3632  s7pCorrelationsName += fAnalysisLabel->Data();
3633  f7pCorrelations = new TProfile(s7pCorrelationsName.Data(),Form("7-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3634  f7pCorrelations->SetTickLength(-0.01,"Y");
3635  f7pCorrelations->SetMarkerStyle(25);
3636  f7pCorrelations->SetLabelSize(0.02);
3637  f7pCorrelations->SetLabelOffset(0.02,"Y");
3638  f7pCorrelations->SetStats(kFALSE);
3639  f7pCorrelations->Sumw2();
3640  //fMixedHarmonicsProfiles->Add(f7pCorrelations); // TBI
3641  // b6) 8-p correlations (??+??+??+??+??):
3642  TString s8pCorrelationsName = "f8pCorrelations";
3643  s8pCorrelationsName += fAnalysisLabel->Data();
3644  f8pCorrelations = new TProfile(s8pCorrelationsName.Data(),Form("8-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3645  f8pCorrelations->SetTickLength(-0.01,"Y");
3646  f8pCorrelations->SetMarkerStyle(25);
3647  f8pCorrelations->SetLabelSize(0.02);
3648  f8pCorrelations->SetLabelOffset(0.02,"Y");
3649  f8pCorrelations->SetStats(kFALSE);
3650  f8pCorrelations->Sumw2();
3651  //fMixedHarmonicsProfiles->Add(f8pCorrelations); // TBI
3652 
3653  // c) Book all objects in TList fMixedHarmonicsResults:
3654  // QC{2}:
3655  f2pCumulants = f2pCorrelations->ProjectionX("f2pCumulants");
3656  f2pCumulants->SetTitle(Form("2-particle cumulants (n = %d)",fHarmonic));
3657  f2pCumulants->SetStats(kFALSE);
3658  f2pCumulants->SetMarkerStyle(kFullSquare);
3659  f2pCumulants->SetMarkerColor(kBlack);
3660  f2pCumulants->SetLineColor(kBlack);
3662  // QC{3}:
3663  f3pCumulants = f3pCorrelations->ProjectionX("f3pCumulants");
3664  f3pCumulants->SetTitle(Form("3-particle cumulants (n = %d)",fHarmonic));
3665  f3pCumulants->SetStats(kFALSE);
3666  f3pCumulants->SetMarkerStyle(kFullSquare);
3667  f3pCumulants->SetMarkerColor(kGreen+2);
3668  f3pCumulants->SetLineColor(kGreen+2);
3670  // QC{4}:
3671  f4pCumulants = f4pCorrelations->ProjectionX("f4pCumulants");
3672  f4pCumulants->SetTitle(Form("4-particle cumulants (n = %d)",fHarmonic));
3673  f4pCumulants->SetStats(kFALSE);
3674  f4pCumulants->SetMarkerStyle(kFullSquare);
3675  f4pCumulants->SetMarkerColor(kRed);
3676  f4pCumulants->SetLineColor(kRed);
3678  // QC{5}:
3679  f5pCumulants = f5pCorrelations->ProjectionX("f5pCumulants");
3680  f5pCumulants->SetTitle(Form("5-particle cumulants (n = %d)",fHarmonic));
3681  f5pCumulants->SetStats(kFALSE);
3682  f5pCumulants->SetMarkerStyle(kFullSquare);
3683  f5pCumulants->SetMarkerColor(kBlue);
3684  f5pCumulants->SetLineColor(kBlue);
3686 
3687  // d) Book all objects in TList fMixedHarmonicsErrorPropagation:
3688  // Sum of linear and quadratic event weights for mixed harmonics => [0=linear 1,1=quadratic]:
3689  TString mixedHarmonicEventWeightsName = "fMixedHarmonicEventWeights";
3690  mixedHarmonicEventWeightsName += fAnalysisLabel->Data();
3691  TString powerFlag[2] = {"linear","quadratic"};
3692  for(Int_t power=0;power<2;power++)
3693  {
3694  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.);
3695  fMixedHarmonicEventWeights[power]->SetLabelSize(0.04);
3696  fMixedHarmonicEventWeights[power]->SetMarkerStyle(25);
3697  fMixedHarmonicEventWeights[power]->SetStats(kFALSE);
3698  if(power == 0)
3699  {
3700  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}");
3701  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}");
3702  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}");
3703  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}");
3704  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}");
3705  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}");
3706  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}");
3707  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}");
3708  } else if (power == 1)
3709  {
3710  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}^{2}");
3711  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}^{2}");
3712  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}^{2}");
3713  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}^{2}");
3714  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}^{2}");
3715  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}^{2}");
3716  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}^{2}");
3717  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}^{2}");
3718  }
3720  } // end of for(Int_t power=0;power<2;power++)
3721 
3722  // Sums of products of event weights for mixed harmonics:
3723  TString mixedHarmonicProductOfEventWeightsName = "fMixedHarmonicProductOfEventWeights";
3724  mixedHarmonicProductOfEventWeightsName += fAnalysisLabel->Data();
3725  fMixedHarmonicProductOfEventWeights = new TH2D(mixedHarmonicProductOfEventWeightsName.Data(),"Sums of products of event weights",8,0.,8.,8,0.,8.);
3726  fMixedHarmonicProductOfEventWeights->SetStats(kFALSE);
3727  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetLabelSize(0.05);
3728  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetLabelSize(0.05);
3729  for(Int_t b=1;b<=8;b++)
3730  {
3731  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
3732  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
3733  }
3735 
3736  // Averages of products of mixed harmonics correlations:
3737  TString mixedHarmonicProductOfCorrelationsName = "fMixedHarmonicProductOfCorrelations";
3738  mixedHarmonicProductOfCorrelationsName += fAnalysisLabel->Data();
3739  fMixedHarmonicProductOfCorrelations = new TProfile2D(mixedHarmonicProductOfCorrelationsName.Data(),"Averages of products of mixed correlators",139,0.,139.,139,0.,139.);
3741  fMixedHarmonicProductOfCorrelations->SetStats(kFALSE);
3742  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetLabelSize(0.015);
3743  fMixedHarmonicProductOfCorrelations->GetYaxis()->SetLabelSize(0.015);
3744  // x-axis:
3745  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
3746  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
3747  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
3748  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
3749  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
3750  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT2#GT#GT_{%dn|%dn}",6*fHarmonic,6*fHarmonic));
3751  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic));
3752  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic));
3753  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic));
3754  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,1*fHarmonic));
3755  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,1*fHarmonic));
3756  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,2*fHarmonic));
3757  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,1*fHarmonic));
3758  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,2*fHarmonic));
3759  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,1*fHarmonic));
3760  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3761  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3762  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3763  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3764  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic));
3765  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,6*fHarmonic));
3766  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic));
3767  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(23,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic));
3768  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic));
3769  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic));
3770  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(26,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic));
3771  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic));
3772  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic));
3773  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic));
3774  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic));
3775  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(31,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic));
3776  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,6*fHarmonic,1*fHarmonic));
3777  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,2*fHarmonic));
3778  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,3*fHarmonic));
3779  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,4*fHarmonic));
3780  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,5*fHarmonic));
3781  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(37,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3782  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3783  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic));
3784  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3785  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(41,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic));
3786  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3787  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3788  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3789  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic));
3790  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(46,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3791  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(47,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,4*fHarmonic));
3792  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(48,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,5*fHarmonic));
3793  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(49,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic));
3794  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(50,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic));
3795  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(51,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic));
3796  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(52,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3797  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(53,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,2*fHarmonic));
3798  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(54,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3799  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(55,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,3*fHarmonic));
3800  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(56,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,4*fHarmonic));
3801  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(57,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3802  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(58,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3803  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(59,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3804  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(60,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3805  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(61,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3806  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(62,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3807  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(63,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3808  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(64,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3809  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(65,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3810  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(66,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3811  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(67,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3812  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(68,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3813  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(69,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3814  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(70,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3815  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(71,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3816  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(72,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3817  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(73,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3818  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(74,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3819  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(75,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3820  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(76,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3821  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(77,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3822  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(78,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3823  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(79,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,3*fHarmonic));
3824  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(80,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,1*fHarmonic,1*fHarmonic));
3825  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(81,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,2*fHarmonic,1*fHarmonic));
3826  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(82,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,2*fHarmonic,2*fHarmonic));
3827  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(83,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,3*fHarmonic,1*fHarmonic));
3828  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(84,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,2*fHarmonic));
3829  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(85,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,3*fHarmonic,2*fHarmonic));
3830  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(86,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,4*fHarmonic,1*fHarmonic));
3831  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(87,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3832  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(88,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3833  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(89,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3834  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(90,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3835  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(91,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3836  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(92,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3837  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(93,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3838  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(94,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3839  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(95,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,3*fHarmonic,3*fHarmonic));
3840  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(96,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3841  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(97,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3842  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(98,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3843  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(99,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3844  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(100,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3845  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(101,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3846  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(102,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3847  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(103,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3848  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(104,Form("#LT#LT5#GT#GT_{%dn|%dn,