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