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