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