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