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