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