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