AliPhysics  1168478 (1168478)
 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  fPOIPhiEtaDiffQRe[k][h]->Fill(dPhi,dEta,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1019  fPOIPhiEtaDiffQIm[k][h]->Fill(dPhi,dEta,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1020  fPOIPhiEtaDiffMul[k][h]->Fill(dPhi,dEta,pow(wPhiEta,k));
1021 
1022  if(fabs(dEta)>fFlowQCDeltaEta/2.) {
1023  Int_t keta = (dEta<0.?0:1);
1024  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1025  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1026  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1027  fPOIPhiDiffQReEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1028  fPOIPhiDiffQImEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1029  fPOIPhiDiffMulEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k));
1030  }
1031 
1032  } else if(fFlowQCDeltaEta<0. && fFlowQCDeltaEta>-1.) {
1033 
1034  if(dEta>0.) {
1035  fPOIPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1036  fPOIPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1037  fPOIPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
1038 
1039  fPOIPhiDiffQRe[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1040  fPOIPhiDiffQIm[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1041  fPOIPhiDiffMul[k][h]->Fill(dPhi,pow(wPhiEta,k));
1042 
1043  Double_t boundetagap = fabs(fFlowQCDeltaEta);
1044 
1045  if((dEta>0. && dEta<0.4-boundetagap/2.) || (dEta>0.4+boundetagap/2. && dEta<0.8)) {
1046  Int_t keta;
1047  if(dEta>0. && dEta<0.4-boundetagap/2.) keta = 0;
1048  else keta = 1;
1049  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1050  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1051  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1052  }
1053  } else {
1054  bFillDis = kFALSE;
1055  continue;
1056  }
1057 
1058  } else if(fFlowQCDeltaEta<-1. && fFlowQCDeltaEta>-2.) {
1059 
1060  if(dEta<0.) {
1061  fPOIPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1062  fPOIPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1063  fPOIPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
1064 
1065  fPOIPhiDiffQRe[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1066  fPOIPhiDiffQIm[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1067  fPOIPhiDiffMul[k][h]->Fill(dPhi,pow(wPhiEta,k));
1068 
1069  Double_t boundetagap = fabs(fFlowQCDeltaEta)-1.;
1070 
1071  if((dEta<0. && dEta>-0.4+boundetagap/2.) || (dEta<-0.4-boundetagap/2. && dEta>-0.8)) {
1072  Int_t keta;
1073  if(dEta<0. && dEta>-0.4+boundetagap/2.) keta = 0;
1074  else keta = 1;
1075  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1076  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1077  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1078  }
1079  } else {
1080  bFillDis = kFALSE;
1081  continue;
1082  }
1083 
1084  }
1085  }
1086  }
1087 
1088  for (Int_t h=0;h<fFlowNHarmMax;h++) {
1089  fEtaDiffQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1090  fEtaDiffQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1091  fEtaDiffMul[cw][h]->Fill(dEta,pow(wPhiEta,h+1));
1092  fPOIEtaPtQRe[cw][h]->Fill(dEta,dPt,wPhiEta*TMath::Cos((h+1.)*dPhi));
1093  fPOIEtaPtQIm[cw][h]->Fill(dEta,dPt,wPhiEta*TMath::Sin((h+1.)*dPhi));
1094  fPOIEtaPtMul[cw][h]->Fill(dEta,dPt,wPhiEta);
1095  }
1096 
1097  if(fCalculateEbEFlow) {
1098  if(fEBEFlowMulBin>=0) fEbEFlowAzimDis[fEBEFlowMulBin]->Fill(dPhi,wPhiEta);
1099  }
1100  if(bFillDis && bPassZDCcuts && fCalculateFlowZDC && fUseZDC) {
1101 
1102  fFlowSPZDCv1etaPro[fCenBin][0][7]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1103  fFlowSPZDCv1etaPro[fCenBin][0][8]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1104  if(cw==0) {
1105  fFlowSPZDCv1etaPro[fCenBin][0][9]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1106  fFlowSPZDCv1etaPro[fCenBin][0][10]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1107  } else {
1108  fFlowSPZDCv1etaPro[fCenBin][0][11]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1109  fFlowSPZDCv1etaPro[fCenBin][0][12]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1110  }
1111 
1112  if(fStoreZDCQVecVtxPos) {
1113  if(fCentralityEBE>5. && fCentralityEBE<40.) {
1114  Int_t bw = (fbFlagIsPosMagField==kTRUE?0:1);
1115  fCRCZDCQVecResv1QA[bw][0]->Fill(ZARe,ZAIm,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1116  fCRCZDCQVecResv1QA[bw][1]->Fill(ZARe,ZAIm,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1117  if(i==0) fCRCZDCQVecResv1QA[bw][2]->Fill(ZARe,ZAIm,ZARe*ZAIm+ZCRe*ZCIm);
1118 
1119  fCRCZDCQVecResv1QC[bw][0]->Fill(ZCRe,ZCIm,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1120  fCRCZDCQVecResv1QC[bw][1]->Fill(ZCRe,ZCIm,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1121  if(i==0) fCRCZDCQVecResv1QC[bw][2]->Fill(ZCRe,ZCIm,ZARe*ZAIm+ZCRe*ZCIm);
1122 
1123  fCRCZDCQVecResv1Cross[bw][0]->Fill(ZCRe*ZAIm,ZCIm*ZARe,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1124  fCRCZDCQVecResv1Cross[bw][1]->Fill(ZCRe*ZAIm,ZCIm*ZARe,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1125  if(i==0) fCRCZDCQVecResv1Cross[bw][2]->Fill(ZCRe*ZAIm,ZCIm*ZARe,ZARe*ZAIm+ZCRe*ZCIm);
1126  }
1127  }
1128 
1129 // if(fCentralityEBE>5. && fCentralityEBE<40.) {
1130 // if(fbFlagIsPosMagField) {
1131 // fFlowSPZDCv1etaProPhi[0]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1132 // fFlowSPZDCv1etaProPhi[1]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1133 // if(cw==0) {
1134 // fFlowSPZDCv1etaProPhi[2]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1135 // fFlowSPZDCv1etaProPhi[3]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1136 // } else {
1137 // fFlowSPZDCv1etaProPhi[4]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1138 // fFlowSPZDCv1etaProPhi[5]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1139 // }
1140 // } else {
1141 // fFlowSPZDCv1etaProPhi[6]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1142 // fFlowSPZDCv1etaProPhi[7]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1143 // if(cw==0) {
1144 // fFlowSPZDCv1etaProPhi[8]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1145 // fFlowSPZDCv1etaProPhi[9]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1146 // } else {
1147 // fFlowSPZDCv1etaProPhi[10]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1148 // fFlowSPZDCv1etaProPhi[11]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1149 // }
1150 // }
1151 // }
1152 // if(fCentralityEBE>5. && fCentralityEBE<40.) {
1153 // Double_t dITStype = ITStype+0.5;
1154 // if(fbFlagIsPosMagField) {
1155 // fFlowSPZDCv1etaProITS[0]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1156 // fFlowSPZDCv1etaProITS[1]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1157 // if(cw==0) {
1158 // fFlowSPZDCv1etaProITS[2]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1159 // fFlowSPZDCv1etaProITS[3]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1160 // } else {
1161 // fFlowSPZDCv1etaProITS[4]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1162 // fFlowSPZDCv1etaProITS[5]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1163 // }
1164 // } else {
1165 // fFlowSPZDCv1etaProITS[6]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1166 // fFlowSPZDCv1etaProITS[7]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1167 // if(cw==0) {
1168 // fFlowSPZDCv1etaProITS[8]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1169 // fFlowSPZDCv1etaProITS[9]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1170 // } else {
1171 // fFlowSPZDCv1etaProITS[10]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1172 // fFlowSPZDCv1etaProITS[11]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1173 // }
1174 // }
1175 // if(fbFlagIsPosMagField) {
1176 // fFlowSPZDCv1etaProITSDis[0][ITStype]->Fill(dEta,dPhi,wPhiEta);
1177 // } else {
1178 // fFlowSPZDCv1etaProITSDis[1][ITStype]->Fill(dEta,dPhi,wPhiEta);
1179 // }
1180 // }
1181 
1182  // all runs
1183  fCRCQVecPhiHist->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1184  fCRCQVecPhiHistCh[cw]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1185  Int_t ptbebe = (dPt>1.? 2 : (dPt>0.5 ? 1 : 0)); // hardcoded
1186  fCRCQVecPhiHistChPt[cw][ptbebe]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1187  for (Int_t h=0;h<6;h++) {
1188  fCRCQVecHarCosProCh[cw]->Fill(fCentralityEBE,(Double_t)h+0.5,dEta,TMath::Cos((h+1.)*dPhi),wPhiEta);
1189  fCRCQVecHarSinProCh[cw]->Fill(fCentralityEBE,(Double_t)h+0.5,dEta,TMath::Sin((h+1.)*dPhi),wPhiEta);
1190  }
1191  Double_t FillCw = (fbFlagIsPosMagField==kTRUE?(cw==0?0.5:1.5):(cw==0?2.5:3.5));
1192  if(fCentralityEBE>5. && fCentralityEBE<40.) {
1193  fCRCQVecPtHistMagField->Fill(dPt,FillCw,wPhiEta);
1194  }
1195 
1196  // run-by-run
1197 // fCRCQVecPhiRbRHist[fRunBin]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1198 // fCRCQVecPhiRbRHistCh[fRunBin][cw]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1199  if(fCentralityEBE>0. && fCentralityEBE<70.) {
1200 // fCRCQVecPhiVtxHist[etab]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],dPhi,wPhiEta);
1201 // fCRCQVecEtaHist[fRunBin][0]->Fill(dEta,fVtxPosCor[0],TMath::Cos(dPhi),wPhiEta*fCenWeightEbE);
1202 // fCRCQVecEtaHist[fRunBin][1]->Fill(dEta,fVtxPosCor[1],TMath::Cos(dPhi),wPhiEta*fCenWeightEbE);
1203 // fCRCQVecEtaHist[fRunBin][2]->Fill(dEta,fVtxPosCor[2],TMath::Cos(dPhi),wPhiEta*fCenWeightEbE);
1204 // fCRCQVecEtaHist[fRunBin][3]->Fill(dEta,fVtxPosCor[0],TMath::Sin(dPhi),wPhiEta*fCenWeightEbE);
1205 // fCRCQVecEtaHist[fRunBin][4]->Fill(dEta,fVtxPosCor[1],TMath::Sin(dPhi),wPhiEta*fCenWeightEbE);
1206 // fCRCQVecEtaHist[fRunBin][5]->Fill(dEta,fVtxPosCor[2],TMath::Sin(dPhi),wPhiEta*fCenWeightEbE);
1207  }
1208 
1209 // fCRCTPCQVecCenEComTot[fRunBin][0+cw*2]->Fill(fCentralityEBE,(ZCM+ZAM)/2.,TMath::Cos(dPhi),wPhiEta);
1210 // fCRCTPCQVecCenEComTot[fRunBin][1+cw*2]->Fill(fCentralityEBE,(ZCM+ZAM)/2.,TMath::Sin(dPhi),wPhiEta);
1211 // fCRCTPCQVecCenRefMulTot[fRunBin][0+cw*2]->Fill(fCentralityEBE,fReferenceMultiplicityRecEBE,TMath::Cos(dPhi),wPhiEta);
1212 // fCRCTPCQVecCenRefMulTot[fRunBin][1+cw*2]->Fill(fCentralityEBE,fReferenceMultiplicityRecEBE,TMath::Sin(dPhi),wPhiEta);
1213 // Int_t bw = (fbFlagIsPosMagField==kTRUE?0:1);
1214 // fCRCTPCQVecCenEtaRefMulTot[bw][0+cw*2]->Fill(fCentralityEBE,dEta,fReferenceMultiplicityEBE,TMath::Cos(dPhi),wPhiEta);
1215 // fCRCTPCQVecCenEtaRefMulTot[bw][1+cw*2]->Fill(fCentralityEBE,dEta,fReferenceMultiplicityEBE,TMath::Sin(dPhi),wPhiEta);
1216 
1217  }
1218 // fCRCQVecPhiHistVtxDep[fRunBin][fCenBin]->Fill(fVtxPos[2],dPhi,dEta,wPhiEta);
1220  fFlowQCSpectraCharge[cw]->Fill(fCentralityEBE,dPt,wPhiEta*fCenWeightEbE);
1221 
1222  } // end of if(pTrack->InPOISelection())
1223  } else // to if(aftsTrack)
1224  {
1225  printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
1226  }
1227  } // end of for(Int_t i=0;i<nPrim;i++)
1228 
1229  // ************************************************************************************************************
1230 
1231  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
1232  for(Int_t p=0;p<8;p++)
1233  {
1234  for(Int_t k=0;k<9;k++)
1235  {
1236  (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
1237  }
1238  }
1239 
1240  // f) Call the methods which calculate correlations for reference flow:
1242  {
1244  {
1245  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelations();} // without using particle weights
1246  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1247  {
1248  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
1249  }
1250  // Whether or not using particle weights the following is calculated in the same way:
1254  // Non-isotropic terms:
1256  {
1259  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1260  {
1263  }
1264  // Whether or not using particle weights the following is calculated in the same way:
1268  // Mixed harmonics:
1270  } // end of if(!fEvaluateIntFlowNestedLoops)
1271 
1272  // g) Call the methods which calculate correlations for differential flow:
1274  {
1276  {
1277  // Without using particle weights:
1278  this->CalculateDiffFlowCorrelations("RP","Pt");
1280  this->CalculateDiffFlowCorrelations("POI","Pt");
1282  // Non-isotropic terms:
1291  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1292  {
1293  // With using particle weights:
1298  // Non-isotropic terms:
1307  }
1308  // Whether or not using particle weights the following is calculated in the same way:
1309  this->CalculateDiffFlowProductOfCorrelations("RP","Pt");
1311  this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
1313  this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
1315  this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
1321  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
1322 
1323  // h) Call the methods which calculate correlations for 2D differential flow:
1325  {
1327  {
1328  // Without using particle weights:
1329  this->Calculate2DDiffFlowCorrelations("RP");
1330  this->Calculate2DDiffFlowCorrelations("POI");
1331  // Non-isotropic terms:
1332  // ... to be ctd ...
1333  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1334  {
1335  // With using particle weights:
1336  // ... to be ctd ...
1337  // Non-isotropic terms:
1338  // ... to be ctd ...
1339  }
1340  // Whether or not using particle weights the following is calculated in the same way:
1341  // ... to be ctd ...
1342  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
1343 
1344  // i) Call the methods which calculate other differential correlators:
1346  {
1348  {
1349  // Without using particle weights:
1350  this->CalculateOtherDiffCorrelators("RP","Pt");
1352  this->CalculateOtherDiffCorrelators("POI","Pt");
1354  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1355  {
1356  // With using particle weights:
1357  // ... to be ctd ...
1358  }
1359  // Whether or not using particle weights the following is calculated in the same way:
1360  // ... to be ctd ...
1361  } // end of if(!fEvaluateDiffFlowNestedLoops)
1362 
1363  // i.2) Calculate CRC quantities:
1364  if(fCalculateCRC) {
1365  if(fCalculateCRCInt) this->CalculateCRCCorr();
1366  if(fCalculateCRC2) this->CalculateCRC2Cor();
1368  if(fCalculateCRCZDC && fUseZDC) this->CalculateCRCZDC();
1369  if(fCalculateCRCPt) this->CalculateCRCPtCorr();
1370  // if(fUseVZERO && fUseZDC) this->CalculateVZvsZDC();
1371  if(fCalculateCME && fUseZDC) {
1372  this->CalculateCMETPC();
1373  this->CalculateCMEZDC();
1374  }
1375  }
1376  // WARNING: do not invert order of SPZDC and QC, used in SC
1378  if(fCalculateFlowQC) {
1379  this->CalculateFlowQC();
1380  this->CalculateFlowQCHighOrders();
1381  }
1383  if(fCalculateEbEFlow) this->FitEbEFlow();
1384 
1385  // j) Distributions of correlations:
1387 
1388  // l) Cross-check with nested loops correlators for reference flow:
1390 
1391  // m) Cross-check with nested loops correlators for differential flow:
1393 
1394  // n) Store multiplicity in various:
1395  if(fStoreVarious) this->FillVarious();
1396 
1397  // o) Reset all event-by-event quantities (very important !!!!):
1399 
1400  // p) cache run number
1402 
1403  fQAZDCCutsFlag = kTRUE;
1404 
1405 // printf("end AliFlowAnalysisCRC::Make \n");
1406 
1407 } // end of AliFlowAnalysisCRC::Make(AliFlowEventSimple* anEvent)
1408 
1409 //=======================================================================================================================
1410 
1412 {
1413  // Calculate the final results.
1414 
1415  // a) Check all pointers used in this method;
1416  // b) Access the constants;
1417  // c) Access the flags;
1418  // d) Calculate reference cumulants (not corrected for detector effects);
1419  // e) Correct reference cumulants for detector effects;
1420  // f) Calculate reference flow;
1421  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen;
1422  // h) Calculate the final results for differential flow (without/with weights);
1423  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA);
1424  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults;
1425  // k) Store results for differential flow in AliFlowCommonHistResults;
1426  // l) Print the final results for integrated flow (RP/POI) on the screen;
1427  // m) Cross-checking: Results from Q-vectors vs results from nested loops;
1428  // n) Calculate cumulants for mixed harmonics;
1429  // o) Calculate charge-rapidity correlations;
1430  // p) Calculate cumulants for bootstrap;
1431  // q) Finalize various;
1432 
1433  // a) Check all pointers used in this method:
1434  this->CheckPointersUsedInFinish();
1435 
1436  // b) Access the constants:
1437  this->CommonConstants("Finish");
1438 
1440  fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1);
1441  }
1442 
1443  // c) Access the flags: // tbi (implement a method for this? should I store again the flags because they can get modified with redoFinish?)
1444  fUsePhiWeights = (Bool_t)fUseParticleWeights->GetBinContent(1);
1445  fUsePtWeights = (Bool_t)fUseParticleWeights->GetBinContent(2);
1446  fUseEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(3);
1447  fUseTrackWeights = (Bool_t)fUseParticleWeights->GetBinContent(4);
1448  fUsePhiEtaWeights = (Bool_t)fUseParticleWeights->GetBinContent(5);
1449  fUsePhiEtaWeightsChDep = (Bool_t)fUseParticleWeights->GetBinContent(6);
1450  fUsePhiEtaWeightsVtxDep = (Bool_t)fUseParticleWeights->GetBinContent(7);
1452  fApplyCorrectionForNUA = (Bool_t)fIntFlowFlags->GetBinContent(3);
1453  fPrintFinalResults[0] = (Bool_t)fIntFlowFlags->GetBinContent(4);
1454  fPrintFinalResults[1] = (Bool_t)fIntFlowFlags->GetBinContent(5);
1455  fPrintFinalResults[2] = (Bool_t)fIntFlowFlags->GetBinContent(6);
1456  fPrintFinalResults[3] = (Bool_t)fIntFlowFlags->GetBinContent(7);
1457  fApplyCorrectionForNUAVsM = (Bool_t)fIntFlowFlags->GetBinContent(8);
1458  fPropagateErrorAlsoFromNIT = (Bool_t)fIntFlowFlags->GetBinContent(9);
1459  fCalculateCumulantsVsM = (Bool_t)fIntFlowFlags->GetBinContent(10);
1460  fMinimumBiasReferenceFlow = (Bool_t)fIntFlowFlags->GetBinContent(11);
1461  fForgetAboutCovariances = (Bool_t)fIntFlowFlags->GetBinContent(12);
1462  fStoreVarious = (Bool_t)fIntFlowFlags->GetBinContent(13);
1463  fFillMultipleControlHistograms = (Bool_t)fIntFlowFlags->GetBinContent(14);
1464  fCalculateAllCorrelationsVsM = (Bool_t)fIntFlowFlags->GetBinContent(15);
1465  fUse2DHistograms = (Bool_t)fIntFlowFlags->GetBinContent(18);
1466  fFillProfilesVsMUsingWeights = (Bool_t)fIntFlowFlags->GetBinContent(19);
1467  fUseQvectorTerms = (Bool_t)fIntFlowFlags->GetBinContent(20);
1470  fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);
1471  fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4);
1473  //fHarmonic = (Int_t)fMixedHarmonicsFlags->GetBinContent(2); // TBI should I add inpdependent generic harmonic here?
1475  fUseBootstrap = (Bool_t)fBootstrapFlags->GetBinContent(1);
1476  fUseBootstrapVsM = (Bool_t)fBootstrapFlags->GetBinContent(2);
1477  fnSubsamples = (Int_t)fBootstrapFlags->GetBinContent(3);
1478 
1479  // d) Calculate reference cumulants (not corrected for detector effects):
1482  this->CalculateCumulantsIntFlow();
1483 
1484  // e) Correct reference cumulants for detector effects:
1488 
1489  // f) Calculate reference flow:
1490  this->CalculateReferenceFlow();
1491 
1492  // g) Store results for reference flow in AliFlowCommonHistResults and print them on the screen:
1496 
1497  // h) Calculate the final results for differential flow (without/with weights):
1498  if(fCalculateDiffFlow)
1499  {
1500  this->FinalizeReducedCorrelations("RP","Pt");
1502  this->FinalizeReducedCorrelations("POI","Pt");
1503  if(fCalculateDiffFlowVsEta){this->FinalizeReducedCorrelations("POI","Eta");}
1504  this->CalculateDiffFlowCovariances("RP","Pt");
1506  this->CalculateDiffFlowCovariances("POI","Pt");
1507  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCovariances("POI","Eta");}
1508  this->CalculateDiffFlowCumulants("RP","Pt");
1509  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("RP","Eta");}
1510  this->CalculateDiffFlowCumulants("POI","Pt");
1511  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlowCumulants("POI","Eta");}
1512  this->CalculateDiffFlow("RP","Pt");
1513  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("RP","Eta");}
1514  this->CalculateDiffFlow("POI","Pt");
1515  if(fCalculateDiffFlowVsEta){this->CalculateDiffFlow("POI","Eta");}
1516  } // if(fCalculateDiffFlow)
1517 
1518  // i) Correct the results for differential flow (without/with weights) for effects of non-uniform acceptance (NUA):
1519  if(fCalculateDiffFlow)
1520  {
1521  this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");
1523  this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");
1530  {
1531  this->CalculateDiffFlowCorrectedForNUA("RP","Pt");
1533  this->CalculateDiffFlowCorrectedForNUA("POI","Pt");
1535  }
1536  } // end of if(fCalculateDiffFlow && fApplyCorrectionForNUA)
1537 
1538  // i) Calcualate final results for 2D differential flow:
1540  {
1541  this->Calculate2DDiffFlowCumulants("RP");
1542  this->Calculate2DDiffFlowCumulants("POI");
1543  this->Calculate2DDiffFlow("RP");
1544  this->Calculate2DDiffFlow("POI");
1545  } // end of if(fCalculate2DDiffFlow)
1546 
1547  // j) Calculate the final results for integrated flow (RP/POI) and store in AliFlowCommonHistResults:
1548  if(fCalculateDiffFlow)
1549  {
1552  }
1553 
1554  // k) Store results for differential flow in AliFlowCommonHistResults:
1555  if(fCalculateDiffFlow)
1556  {
1557  this->FillCommonHistResultsDiffFlow("RP");
1558  this->FillCommonHistResultsDiffFlow("POI");
1559  }
1560 
1561  // l) Print the final results for integrated flow (RP/POI) on the screen:
1564 
1565  // m) Cross-checking: Results from Q-vectors vs results from nested loops:
1566  // m1) Reference flow:
1568  {
1573  } // end of if(fEvaluateIntFlowNestedLoops)
1574  // m2) Differential flow:
1576  {
1577  // Correlations:
1579  this->CrossCheckDiffFlowCorrelations("RP","Pt");
1581  this->CrossCheckDiffFlowCorrelations("POI","Pt");
1583  // Correction terms for non-uniform acceptance:
1584  this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt");
1586  this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");
1588  // Other differential correlators:
1589  this->CrossCheckOtherDiffCorrelators("RP","Pt");
1591  this->CrossCheckOtherDiffCorrelators("POI","Pt");
1593  } // end of if(fEvaluateDiffFlowNestedLoops)
1594 
1595  // n) Calculate cumulants for mixed harmonics:
1597 
1598  // o) Calculate charge-rapidity correlations:
1599  if(fCalculateCRC) {
1600  if(fCalculateCRCInt) this->FinalizeCRCCorr();
1601  if(fCalculateCRC2) this->FinalizeCRC2Cor();
1603  if(fCalculateCRCZDC && fUseZDC) this->FinalizeCRCZDC();
1604  if(fCalculateCRCPt) this->FinalizeCRCPtCorr();
1605  if(fCalculateCME && fUseZDC) {
1606  this->FinalizeCMETPC();
1607  this->FinalizeCMEZDC();
1608  }
1609  }
1610  // WARNING: do not invert order of SPZDC and QC, used in SC
1612  if(fCalculateFlowQC) {
1613  this->FinalizeFlowQC();
1614  this->FinalizeFlowQCHighOrders();
1615  }
1617 
1618  // p) Calculate cumulants for bootstrap:
1620 
1621  // q) Finalize various:
1622  if(fStoreVarious) this->FinalizeVarious();
1623 
1624 } // end of AliFlowAnalysisCRC::Finish()
1625 
1626 //=======================================================================================================================
1627 
1629 {
1630  // Evaluate all correlators for reference flow with nested loops.
1631 
1632  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1633  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1634  {
1635  // Without using particle weights:
1637  {
1638  // Correlations:
1639  this->CalculateIntFlowCorrelations(); // from Q-vectors
1640  this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1641  // Correction for non-uniform acceptance:
1642  this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)
1643  this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)
1644  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)
1645  // Mixed harmonics:
1647  {
1648  this->CalculateMixedHarmonics(); // from Q-vectors
1649  this->EvaluateMixedHarmonicsWithNestedLoops(anEvent); // from nested loops (TBI: do I have to pass here anEvent or not?)
1650  } // end of if(fCalculateMixedHarmonics)
1651  }
1652  // Using particle weights:
1654  {
1655  // Correlations
1656  this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors
1657  this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)
1658  // Correction for non-uniform acceptance:
1659  this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)
1660  this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)
1661  this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
1662  }
1663  } else if(nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)
1664  {
1665  cout<<endl;
1666  cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;
1667  } else
1668  {
1669  cout<<endl;
1670  cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;
1671  }
1672 
1673 } // end of void AliFlowAnalysisCRC::EvaluateIntFlowNestedLoops(AliFlowEventSimple* anEvent)
1674 
1675 //=======================================================================================================================
1676 
1678 {
1679  // Evalauted all correlators for differential flow with nested loops.
1680 
1681  if(!fCalculateDiffFlow){return;}
1682 
1683  Int_t nPrim = anEvent->NumberOfTracks(); // number of primaries
1684  if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1685  {
1686  // Without using particle weights:
1688  {
1689  // 1.) Reduced correlations:
1690  // Q-vectors:
1691  this->CalculateDiffFlowCorrelations("RP","Pt");
1692  this->CalculateDiffFlowCorrelations("RP","Eta");
1693  this->CalculateDiffFlowCorrelations("POI","Pt");
1694  this->CalculateDiffFlowCorrelations("POI","Eta");
1695  // Nested loops:
1696  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt");
1697  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta");
1698  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt");
1699  this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta");
1700  // 2.) Reduced corrections for non-uniform acceptance:
1701  // Q-vectors:
1705  this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");
1709  this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
1710  // Nested loops:
1712  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta");
1713  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt");
1714  this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta");
1715  // 3.) Other differential correlators:
1716  // Q-vectors:
1717  this->CalculateOtherDiffCorrelators("RP","Pt");
1718  this->CalculateOtherDiffCorrelators("RP","Eta");
1719  this->CalculateOtherDiffCorrelators("POI","Pt");
1720  this->CalculateOtherDiffCorrelators("POI","Eta");
1721  // Nested loops:
1722  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Pt");
1723  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"RP","Eta");
1724  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Pt");
1725  this->EvaluateOtherDiffCorrelatorsWithNestedLoops(anEvent,"POI","Eta");
1726  } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1727  // Using particle weights:
1729  {
1750  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
1751  } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10
1752 
1753 } // end of void AliFlowAnalysisCRC::EvaluateDiffFlowNestedLoops(AliFlowEventSimple* anEvent)
1754 
1755 //=======================================================================================================================
1756 
1758 {
1759  // Calculate correction terms for non-uniform acceptance of the detector for reference flow (cos terms).
1760 
1761  // multiplicity:
1762  Double_t dMult = (*fSpk)(0,0);
1763 
1764  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1765  Double_t dReQ1n = (*fReQ)(0,0);
1766  Double_t dReQ2n = (*fReQ)(1,0);
1767  //Double_t dReQ3n = (*fReQ)(2,0);
1768  //Double_t dReQ4n = (*fReQ)(3,0);
1769  Double_t dImQ1n = (*fImQ)(0,0);
1770  Double_t dImQ2n = (*fImQ)(1,0);
1771  //Double_t dImQ3n = (*fImQ)(2,0);
1772  //Double_t dImQ4n = (*fImQ)(3,0);
1773 
1774  // Multiplicity bin of an event (relevant for all histos vs M):
1775  Double_t dMultiplicityBin = 0.;
1777  {
1778  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1780  {
1781  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1783  {
1784  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1785  }
1786 
1787  // *************************************************************
1788  // **** corrections for non-uniform acceptance (cos terms): ****
1789  // *************************************************************
1790  //
1791  // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors
1792  // are stored in 1D profile fQCorrectionsCos.
1793  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:
1794  // --------------------------------------------------------------------------------------------------------------------
1795  // 1st bin: <<cos(n*(phi1))>> = cosP1n
1796  // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n
1797  // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n
1798  // 4th bin: <<cos(n*(2phi1-phi2))>> = cosP2nM1n
1799  // --------------------------------------------------------------------------------------------------------------------
1800 
1801  // 1-particle:
1802  Double_t cosP1n = 0.; // <<cos(n*(phi1))>>
1803 
1804  if(dMult>0)
1805  {
1806  cosP1n = dReQ1n/dMult;
1807 
1808  // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:
1809  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);
1810  // event weights for NUA terms:
1811  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(1,dMult);
1812 
1813  // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:
1814  fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);
1815  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][0]->Fill(dMultiplicityBin,cosP1n,dMult);}
1816  }
1817 
1818  // 2-particle:
1819  Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>
1820  Double_t cosP2nM1n = 0.; // <<cos(n*(2phi1-phi2))>>
1821 
1822  if(dMult>1)
1823  {
1824  cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1));
1825  cosP2nM1n = (dReQ2n*dReQ1n+dImQ2n*dImQ1n-dReQ1n)/(dMult*(dMult-1));
1826 
1827  // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:
1828  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);
1829  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(4,cosP2nM1n);
1830  // event weights for NUA terms:
1831  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(2,dMult*(dMult-1));
1832  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(4,dMult*(dMult-1));
1833 
1834  // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:
1835  fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));
1836  fIntFlowCorrectionTermsForNUAPro[1]->Fill(3.5,cosP2nM1n,dMult*(dMult-1));
1838  {
1839  fIntFlowCorrectionTermsForNUAVsMPro[1][1]->Fill(dMultiplicityBin,cosP1nP1n,dMult*(dMult-1));
1840  fIntFlowCorrectionTermsForNUAVsMPro[1][3]->Fill(dMultiplicityBin,cosP2nM1n,dMult*(dMult-1));
1841  }
1842  }
1843 
1844  // 3-particle:
1845  Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>
1846 
1847  if(dMult>2)
1848  {
1849  cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)
1850  / (dMult*(dMult-1)*(dMult-2));
1851 
1852  // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:
1853  fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);
1854  // event weights for NUA terms:
1855  fIntFlowEventWeightForCorrectionTermsForNUAEBE[1]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1856 
1857  // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:
1858  fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1859  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[1][2]->Fill(dMultiplicityBin,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1860  }
1861 
1862 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUACosTerms()
1863 
1864 //=======================================================================================================================
1865 
1867 {
1868  // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)
1869 
1870  // multiplicity:
1871  Double_t dMult = (*fSpk)(0,0);
1872 
1873  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n:
1874  Double_t dReQ1n = (*fReQ)(0,0);
1875  Double_t dReQ2n = (*fReQ)(1,0);
1876  //Double_t dReQ3n = (*fReQ)(2,0);
1877  //Double_t dReQ4n = (*fReQ)(3,0);
1878  Double_t dImQ1n = (*fImQ)(0,0);
1879  Double_t dImQ2n = (*fImQ)(1,0);
1880  //Double_t dImQ3n = (*fImQ)(2,0);
1881  //Double_t dImQ4n = (*fImQ)(3,0);
1882 
1883  // Multiplicity bin of an event (relevant for all histos vs M):
1884  Double_t dMultiplicityBin = 0.;
1886  {
1887  dMultiplicityBin = fNumberOfRPsEBE+0.5;
1889  {
1890  dMultiplicityBin = fReferenceMultiplicityEBE+0.5;
1892  {
1893  dMultiplicityBin = fNumberOfPOIsEBE+0.5;
1894  }
1895 
1896  // *************************************************************
1897  // **** corrections for non-uniform acceptance (sin terms): ****
1898  // *************************************************************
1899  //
1900  // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors
1901  // are stored in 1D profile fQCorrectionsSin.
1902  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:
1903  // --------------------------------------------------------------------------------------------------------------------
1904  // 1st bin: <<sin(n*(phi1))>> = sinP1n
1905  // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n
1906  // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n
1907  // 4th bin: <<sin(n*(2phi1-phi2))>> = sinP2nM1n
1908  // --------------------------------------------------------------------------------------------------------------------
1909 
1910  // 1-particle:
1911  Double_t sinP1n = 0.; // <sin(n*(phi1))>
1912 
1913  if(dMult>0)
1914  {
1915  sinP1n = dImQ1n/dMult;
1916 
1917  // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:
1918  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);
1919  // event weights for NUA terms:
1920  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(1,dMult);
1921 
1922  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1923  fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);
1924  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][0]->Fill(dMultiplicityBin,sinP1n,dMult);}
1925  }
1926 
1927  // 2-particle:
1928  Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>
1929  Double_t sinP2nM1n = 0.; // <<sin(n*(2phi1-phi2))>>
1930  if(dMult>1)
1931  {
1932  sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1));
1933  sinP2nM1n = (dImQ2n*dReQ1n-dReQ2n*dImQ1n-dImQ1n)/(dMult*(dMult-1));
1934 
1935  // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:
1936  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);
1937  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(4,sinP2nM1n);
1938  // event weights for NUA terms:
1939  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(2,dMult*(dMult-1));
1940  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(4,dMult*(dMult-1));
1941 
1942  // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:
1943  fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));
1944  fIntFlowCorrectionTermsForNUAPro[0]->Fill(3.5,sinP2nM1n,dMult*(dMult-1));
1946  {
1947  fIntFlowCorrectionTermsForNUAVsMPro[0][1]->Fill(dMultiplicityBin,sinP1nP1n,dMult*(dMult-1));
1948  fIntFlowCorrectionTermsForNUAVsMPro[0][3]->Fill(dMultiplicityBin,sinP2nM1n,dMult*(dMult-1));
1949  }
1950  }
1951 
1952  // 3-particle:
1953  Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>
1954 
1955  if(dMult>2)
1956  {
1957  sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)
1958  / (dMult*(dMult-1)*(dMult-2));
1959 
1960  // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:
1961  fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);
1962  // event weights for NUA terms:
1963  fIntFlowEventWeightForCorrectionTermsForNUAEBE[0]->SetBinContent(3,dMult*(dMult-1)*(dMult-2));
1964 
1965  // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:
1966  fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));
1967  if(fCalculateCumulantsVsM){fIntFlowCorrectionTermsForNUAVsMPro[0][2]->Fill(dMultiplicityBin,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));}
1968  }
1969 
1970 } // end of AliFlowAnalysisCRC::CalculateIntFlowCorrectionsForNUASinTerms()
1971 
1972 //=======================================================================================================================
1973 
1975 {
1976  // a) Get pointers for common control and common result histograms;
1977  // b) Get pointers for histograms holding particle weights;
1978  // c) Get pointers for reference flow histograms;
1979  // d) Get pointers for differential flow histograms;
1980  // e) Get pointers for 2D differential flow histograms;
1981  // f) Get pointers for other differential correlators;
1982  // g) Get pointers for mixed harmonics histograms;
1983  // h) Get pointers for nested loops' histograms;
1984  // i) Get pointers for control histograms;
1985  // j) Get pointers for bootstrap.
1986  // k) Get pointers for CRC histograms;
1987 
1988  if(outputListHistos)
1989  {
1990  this->SetHistList(outputListHistos);
1991  if(!fHistList)
1992  {
1993  printf("\n WARNING (QC): fHistList is NULL in AFAWQC::GOH() !!!!\n\n");
1994  exit(0);
1995  }
2005  this->GetPointersForBootstrap();
2006  this->GetPointersForCRC();
2007  this->GetPointersForCRCVZ();
2008  this->GetPointersForCRCZDC();
2009  this->GetPointersForCRCPt();
2010  this->GetPointersForCRC2();
2011  this->GetPointersForQVec();
2012  this->GetPointersForCME();
2013  this->GetPointersForFlowQC();
2015  this->GetPointersForFlowSPZDC();
2016  this->GetPointersForFlowSPVZ();
2017  this->GetPointersForEbEFlow();
2018  this->GetPointersForVarious();
2019  } else
2020  {
2021  printf("\n WARNING (QC): outputListHistos is NULL in AFAWQC::GOH() !!!!\n\n");
2022  exit(0);
2023  }
2024 
2025 } // end of void AliFlowAnalysisCRC::GetOutputHistograms(TList *outputListHistos)
2026 
2027 //=======================================================================================================================
2028 
2029 TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta) const
2030 {
2031  // project 2D profile onto pt axis to get 1D profile
2032 
2033  Int_t nBinsPt = profilePtEta->GetNbinsX();
2034  Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();
2035  Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();
2036 
2037  Int_t nBinsEta = profilePtEta->GetNbinsY();
2038 
2039  TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax);
2040 
2041  for(Int_t p=1;p<=nBinsPt;p++)
2042  {
2043  Double_t contentPt = 0.;
2044  Double_t entryPt = 0.;
2045  Double_t spreadPt = 0.;
2046  Double_t sum1 = 0.;
2047  Double_t sum2 = 0.;
2048  Double_t sum3 = 0.;
2049  for(Int_t e=1;e<=nBinsEta;e++)
2050  {
2051  contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
2052  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
2053  entryPt += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
2054 
2055  sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
2056  * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)
2057  + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.));
2058  sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
2059  sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))
2060  * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));
2061  }
2062  if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)
2063  {
2064  spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);
2065  }
2066  profilePt->SetBinContent(p,contentPt);
2067  profilePt->SetBinEntries(p,entryPt);
2068  {
2069  profilePt->SetBinError(p,spreadPt);
2070  }
2071 
2072  }
2073 
2074  return profilePt;
2075 
2076 } // end of TProfile* AliFlowAnalysisCRC::MakePtProjection(TProfile2D *profilePtEta)
2077 
2078 
2079 //=======================================================================================================================
2080 
2081 
2082 TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta) const
2083 {
2084  // project 2D profile onto eta axis to get 1D profile
2085 
2086  Int_t nBinsEta = profilePtEta->GetNbinsY();
2087  Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();
2088  Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();
2089 
2090  Int_t nBinsPt = profilePtEta->GetNbinsX();
2091 
2092  TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax);
2093 
2094  for(Int_t e=1;e<=nBinsEta;e++)
2095  {
2096  Double_t contentEta = 0.;
2097  Double_t entryEta = 0.;
2098  for(Int_t p=1;p<=nBinsPt;p++)
2099  {
2100  contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))
2101  * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
2102  entryEta += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));
2103  }
2104  profileEta->SetBinContent(e,contentEta);
2105  profileEta->SetBinEntries(e,entryEta);
2106  }
2107 
2108  return profileEta;
2109 
2110 } // end of TProfile* AliFlowAnalysisCRC::MakeEtaProjection(TProfile2D *profilePtEta)
2111 
2112 //=======================================================================================================================
2113 
2115 {
2116  // Printing on the screen the final results for integrated flow (RF, POI and RP).
2117 
2118  Int_t n = fHarmonic;
2119 
2120  Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}
2121  Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}
2122 
2123  if(type == "RF")
2124  {
2125  for(Int_t b=0;b<4;b++)
2126  {
2127  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1);
2128  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1);
2129  dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1);
2130  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1);
2131  dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1);
2132  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1);
2133  dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1);
2134  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1);
2135  }
2136  } else if(type == "RP")
2137  {
2138  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1);
2139  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1);
2140  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1);
2141  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1);
2142  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1);
2143  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1);
2144  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1);
2145  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1);
2146  } else if(type == "POI")
2147  {
2148  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1);
2149  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1);
2150  dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1);
2151  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1);
2152  dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1);
2153  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1);
2154  dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1);
2155  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1);
2156  } else if(type == "RF, rebinned in M" && fCalculateCumulantsVsM)
2157  {
2158  for(Int_t b=0;b<4;b++)
2159  {
2160  dVn[b] = fIntFlowRebinnedInM->GetBinContent(b+1);
2161  dVnErr[b] = fIntFlowRebinnedInM->GetBinError(b+1);
2162  }
2163  }
2164 
2165  TString title = " flow estimates from Q-cumulants";
2166  TString subtitle = " (";
2167  TString subtitle2 = " (rebinned in M)";
2168 
2169  if(type != "RF, rebinned in M")
2170  {
2172  {
2173  subtitle.Append(type);
2174  subtitle.Append(", without weights)");
2175  } else
2176  {
2177  subtitle.Append(type);
2178  subtitle.Append(", with weights)");
2179  }
2180  } else
2181  {
2183  {
2184  subtitle.Append("RF");
2185  subtitle.Append(", without weights)");
2186  } else
2187  {
2188  subtitle.Append("RF");
2189  subtitle.Append(", with weights)");
2190  }
2191  }
2192 
2193  cout<<endl;
2194  cout<<"*************************************"<<endl;
2195  cout<<"*************************************"<<endl;
2196  cout<<title.Data()<<endl;
2197  cout<<subtitle.Data()<<endl;
2198  if(type == "RF, rebinned in M"){cout<<subtitle2.Data()<<endl;}
2199  cout<<endl;
2200 
2201  for(Int_t i=0;i<4;i++)
2202  {
2203  cout<<" v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
2204  }
2205 
2206  cout<<endl;
2207  if(type == "RF")
2208  {
2210  {
2211  cout<<" detector bias (corrected for): "<<endl;
2212  } else
2213  {
2214  cout<<" detector bias (not corrected for):"<<endl;
2215  }
2216  cout<<" to QC{2}: "<<fIntFlowDetectorBias->GetBinContent(1)<<" +/- "<<fIntFlowDetectorBias->GetBinError(1)<<endl;
2217  cout<<" to QC{4}: "<<fIntFlowDetectorBias->GetBinContent(2)<<" +/- "<<fIntFlowDetectorBias->GetBinError(2)<<endl;
2218  cout<<endl;
2219  }
2220  if(type == "RF" || type == "RF, rebinned in M")
2221  {
2222  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
2223  }
2224  else if (type == "RP")
2225  {
2226  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;
2227  }
2228  else if (type == "POI")
2229  {
2230  cout<<" nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
2231  }
2232 
2233  cout<<"*************************************"<<endl;
2234  cout<<"*************************************"<<endl;
2235  cout<<endl;
2236 
2237 }// end of AliFlowAnalysisCRC::PrintFinalResultsForIntegratedFlow(TString type="RF");
2238 
2239 //=======================================================================================================================
2240 
2242 {
2243  //store the final results in output .root file
2244  TFile *output = new TFile(outputFileName.Data(),"RECREATE");
2245  //output->WriteObject(fHistList, "cobjQC","SingleKey");
2246  fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
2247  delete output;
2248 }
2249 
2250 
2251 //=======================================================================================================================
2252 
2253 
2254 void AliFlowAnalysisCRC::WriteHistograms(TDirectoryFile *outputFileName)
2255 {
2256  //store the final results in output .root file
2257  fHistList->SetName("cobjQC");
2258  fHistList->SetOwner(kTRUE);
2259  outputFileName->Add(fHistList);
2260  outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
2261 }
2262 
2263 //=======================================================================================================================
2264 
2266 {
2267  // Book common control histograms and common histograms for final results.
2268  // a) Book common control histograms;
2269  // b) Book common result histograms.
2270 
2271  // a) Book common control histograms:
2272  // Common control histograms (all events):
2273  TString commonHistsName = "AliFlowCommonHistQC";
2274  commonHistsName += fAnalysisLabel->Data();
2275  fCommonHists = new AliFlowCommonHist(commonHistsName.Data(),commonHistsName.Data(),fBookOnlyBasicCCH);
2276  fHistList->Add(fCommonHists);
2277  // Common control histograms (selected events):
2279  {
2280  // Common control histogram filled for events with 2 and more reference particles:
2281  TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";
2282  commonHists2ndOrderName += fAnalysisLabel->Data();
2283  fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data(),commonHists2ndOrderName.Data(),fBookOnlyBasicCCH);
2284  fHistList->Add(fCommonHists2nd);
2285  // Common control histogram filled for events with 2 and more reference particles:
2286  TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";
2287  commonHists4thOrderName += fAnalysisLabel->Data();
2288  fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data(),commonHists4thOrderName.Data(),fBookOnlyBasicCCH);
2289  fHistList->Add(fCommonHists4th);
2290  // Common control histogram filled for events with 6 and more reference particles:
2291  TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";
2292  commonHists6thOrderName += fAnalysisLabel->Data();
2293  fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data(),commonHists6thOrderName.Data(),fBookOnlyBasicCCH);
2294  fHistList->Add(fCommonHists6th);
2295  // Common control histogram filled for events with 8 and more reference particles:
2296  TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";
2297  commonHists8thOrderName += fAnalysisLabel->Data();
2298  fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data(),commonHists8thOrderName.Data(),fBookOnlyBasicCCH);
2299  fHistList->Add(fCommonHists8th);
2300  } // end of if(fFillMultipleControlHistograms)
2301 
2302  // b) Book common result histograms:
2303  // Common result histograms for QC{2}:
2304  TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";
2305  commonHistResults2ndOrderName += fAnalysisLabel->Data();
2306  fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
2308  // Common result histograms for QC{4}:
2309  TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";
2310  commonHistResults4thOrderName += fAnalysisLabel->Data();
2311  fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
2313  // Common result histograms for QC{6}:
2314  TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";
2315  commonHistResults6thOrderName += fAnalysisLabel->Data();
2316  fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
2318  // Common result histograms for QC{8}:
2319  TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";
2320  commonHistResults8thOrderName += fAnalysisLabel->Data();
2321  fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
2323 
2324 } // end of void AliFlowAnalysisCRC::BookCommonHistograms()
2325 
2326 //=======================================================================================================================
2327 
2329 {
2330  // Book and fill histograms which hold phi, pt and eta weights.
2331 
2332  if(!fWeightsList)
2333  {
2334  printf("\n WARNING (QC): fWeightsList is NULL in AFAWQC::BAFWH() !!!! \n\n");
2335  exit(0);
2336  }
2337 
2338  TString fUseParticleWeightsName = "fUseParticleWeightsQC";
2339  fUseParticleWeightsName += fAnalysisLabel->Data();
2340  fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",8,0,8);
2341  fUseParticleWeights->SetLabelSize(0.06);
2342  fUseParticleWeights->SetStats(kFALSE);
2343  (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");
2344  (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");
2345  (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");
2346  (fUseParticleWeights->GetXaxis())->SetBinLabel(4,"w_{track}");
2347  (fUseParticleWeights->GetXaxis())->SetBinLabel(5,"w_{#phi,#eta}");
2348  (fUseParticleWeights->GetXaxis())->SetBinLabel(6,"w_{#phi,#eta} ch_dep");
2349  (fUseParticleWeights->GetXaxis())->SetBinLabel(7,"w_{#phi,#eta} vtx_dep");
2350  (fUseParticleWeights->GetXaxis())->SetBinLabel(8,"w_{#phi,#eta} ch_pT_dep");
2360 
2361  // // POIs
2362  // for(Int_t c=0; c<2; c++)
2363  // {
2364  // fPhiWeightsPOIs[c] = new TH1F(Form("fPhiWeightsPOIs[%d][%d]",c,h),Form("fPhiWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax);
2365  // fPhiWeightsPOIs[c]->Sumw2();
2366  // fEtaWeightsPOIs[c] = new TH1D(Form("fEtaWeightsPOIs[%d][%d]",c,h),Form("fEtaWeightsPOIs[%d][%d]",c,h),fnBinsEta,fEtaMin,fEtaMax);
2367  // fEtaWeightsPOIs[c]->Sumw2();
2368  // fPhiEtaWeightsPOIs[c] = new TH2D(Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),Form("fPhiEtaWeightsPOIs[%d][%d]",c,h),fnBinsPhi,fPhiMin,fPhiMax,fnBinsEta,fEtaMin,fEtaMax);
2369  // fPhiEtaWeightsPOIs[c]->Sumw2();
2370  //
2371  // if(fUsePhiWeights)
2372  // {
2373  // if(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)))
2374  // {
2375  // fPhiDistrRefPOIs[c] = dynamic_cast<TH1F*>(fWeightsList->FindObject(Form("fPhiHist[%d][%d]",c,h)));
2376  // if(!fPhiDistrRefPOIs[c])
2377  // {
2378  // printf("\n WARNING (QC): fPhiDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2379  // exit(0);
2380  // }
2381  // if(TMath::Abs(fPhiDistrRefPOIs[c]->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2382  // {
2383  // cout<<endl;
2384  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2385  // cout<<endl;
2386  // //exit(0);
2387  // }
2388  // } else
2389  // {
2390  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2391  // exit(0);
2392  // }
2393  // } // end of if(fUsePhiWeights)
2394  //
2395  // if(fUsePtWeights)
2396  // {
2397  // if(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)))
2398  // {
2399  // fPtDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fPtHist[%d][%d]",c,h)));
2400  // if(!fPtDistrRefPOIs[c])
2401  // {
2402  // printf("\n WARNING (QC): fPtDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2403  // exit(0);
2404  // }
2405  // if(TMath::Abs(fPtDistrRefPOIs[c]->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2406  // {
2407  // cout<<endl;
2408  // cout<<"WARNING (QC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
2409  // cout<<endl;
2410  // //exit(0);
2411  // }
2412  // } else
2413  // {
2414  // cout<<"WARNING: fWeightsList->FindObject(\"fPtHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2415  // exit(0);
2416  // }
2417  // } // end of if(fUsePtWeights)
2418  //
2419  // if(fUseEtaWeights)
2420  // {
2421  // if(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)))
2422  // {
2423  // fEtaDistrRefPOIs[c] = dynamic_cast<TH1D*>(fWeightsList->FindObject(Form("fEtaHist[%d][%d]",c,h)));
2424  // if(!fEtaDistrRefPOIs[c])
2425  // {
2426  // printf("\n WARNING (QC): fEtaDistrRefPOIs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2427  // exit(0);
2428  // }
2429  // if(TMath::Abs(fEtaDistrRefPOIs[c]->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2430  // {
2431  // cout<<endl;
2432  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2433  // cout<<endl;
2434  // //exit(0);
2435  // }
2436  // } else
2437  // {
2438  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaHist\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2439  // exit(0);
2440  // }
2441  // } // end of if(fUseEtaWeights)
2442  //
2443  //
2444  // } // end of for(Int_t c=0; c<2; c++)
2445 
2446  //**********************************************************************************************************
2447 
2448  // RPs
2449 
2450  // fPhiWeightsRPs = new TH1F("fPhiWeightsRPs","fPhiWeightsRPs",fnBinsPhi,fPhiMin,fPhiMax);
2451  // fEtaWeightsRPs = new TH1D("fEtaWeightsRPs","fEtaWeightsRPs",fnBinsEta,fEtaMin,fEtaMax);
2452  //
2453  // if(fUsePhiWeights)
2454  // {
2455  // if(fWeightsList->FindObject("fPhiDistrRPs"))
2456  // {
2457  // fPhiDistrRefRPs = dynamic_cast<TH1F*>(fWeightsList->FindObject("fPhiDistrRPs"));
2458  // if(!fPhiDistrRefRPs)
2459  // {
2460  // printf("\n WARNING (QC): fPhiDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2461  // exit(0);
2462  // }
2463  // if(TMath::Abs(fPhiDistrRefRPs->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
2464  // {
2465  // cout<<endl;
2466  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2467  // cout<<endl;
2468  // //exit(0);
2469  // }
2470  // } else
2471  // {
2472  // cout<<"WARNING: fWeightsList->FindObject(\"fPhiDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2473  // exit(0);
2474  // }
2475  // } // end of if(fUsePhiWeights)
2476  //
2477  // if(fUsePtWeights)
2478  // {
2479  // if(fWeightsList->FindObject("fPtDistrRPs"))
2480  // {
2481  // fPtDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fPtDistrRPs"));
2482  // if(!fPtDistrRefRPs)
2483  // {
2484  // printf("\n WARNING (QC): fPtDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2485  // exit(0);
2486  // }
2487  // if(TMath::Abs(fPtDistrRefRPs->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
2488  // {
2489  // cout<<endl;
2490  // cout<<"WARNING (QC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
2491  // cout<<endl;
2492  // //exit(0);
2493  // }
2494  // } else
2495  // {
2496  // cout<<"WARNING: fWeightsList->FindObject(\"fPtDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2497  // exit(0);
2498  // }
2499  // } // end of if(fUsePtWeights)
2500  //
2501  // if(fUseEtaWeights)
2502  // {
2503  // if(fWeightsList->FindObject("fEtaDistrRPs"))
2504  // {
2505  // fEtaDistrRefRPs = dynamic_cast<TH1D*>(fWeightsList->FindObject("fEtaDistrRPs"));
2506  // if(!fEtaDistrRefRPs)
2507  // {
2508  // printf("\n WARNING (QC): fEtaDistrRefRPs is NULL in AFAWQC::BAFWH() !!!!\n\n");
2509  // exit(0);
2510  // }
2511  // if(TMath::Abs(fEtaDistrRefRPs->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
2512  // {
2513  // cout<<endl;
2514  // cout<<"WARNING (QC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
2515  // cout<<endl;
2516  // //exit(0);
2517  // }
2518  // } else
2519  // {
2520  // cout<<"WARNING: fWeightsList->FindObject(\"fEtaDistrRPs\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;
2521  // exit(0);
2522  // }
2523  // } // end of if(fUseEtaWeights)
2524  //
2525 
2526 } // end of AliFlowAnalysisCRC::BookAndFillWeightsHistograms()
2527 
2528 //=======================================================================================================================
2529 
2531 {
2532  if(!fCenWeightsHist) return;
2533  fCenWeigCalHist = (TH1D*)(fCenWeightsHist->Clone("fCenWeigCalHist"));
2534  TF1 *CenFit = new TF1("CenFit","pol0", 0., 100.);
2536  fCenWeigCalHist->Fit("CenFit","QNR","",0.,50.);
2537  Double_t CenAv = CenFit->GetParameter(0);
2538  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2539  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2540  if(newbin) {
2541  fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2542  } else {
2543  fCenWeigCalHist->SetBinContent(b,1.);
2544  }
2545  }
2546  }
2547  else {
2548  fCenWeigCalHist->Fit("CenFit","QNR","",0.,8.);
2549  Double_t CenAv = CenFit->GetParameter(0);
2550  fCenWeigCalHist->Fit("CenFit","QNR","",12.,50.);
2551  Double_t SemiCenAv = CenFit->GetParameter(0);
2552  for(Int_t b=1; b<=fCenWeigCalHist->GetNbinsX(); b++) {
2553  Double_t newbin = fCenWeigCalHist->GetBinContent(b);
2554  if(newbin) {
2555  if(b<=10) fCenWeigCalHist->SetBinContent(b,CenAv/newbin);
2556  if(b>10 && b<=50) fCenWeigCalHist->SetBinContent(b,SemiCenAv/newbin);
2557  if(b>50) fCenWeigCalHist->SetBinContent(b,1.);
2558  } else {
2559  fCenWeigCalHist->SetBinContent(b,1.);
2560  }
2561  }
2562  }
2563  fCenWeigCalHist->SetName("CenWeights");
2565 } // end of AliFlowAnalysisCRC::SetCentralityWeights()
2566 
2567 //=======================================================================================================================
2568 
2570 {
2571  // Book all objects for integrated flow:
2572  // a) Book profile to hold all flags for integrated flow;
2573  // b) Book event-by-event quantities;
2574  // c) Book profiles; // to be improved (comment)
2575  // d) Book histograms holding the final results.
2576 
2577  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)
2578  TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)
2579 
2580  // a) Book profile to hold all flags for integrated flow:
2581  TString intFlowFlagsName = "fIntFlowFlags";
2582  intFlowFlagsName += fAnalysisLabel->Data();
2583  fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",20,0.,20.);
2584  fIntFlowFlags->SetTickLength(-0.01,"Y");
2585  fIntFlowFlags->SetMarkerStyle(25);
2586  fIntFlowFlags->SetLabelSize(0.04);
2587  fIntFlowFlags->SetLabelOffset(0.02,"Y");
2588  fIntFlowFlags->SetStats(kFALSE);
2589  fIntFlowFlags->GetXaxis()->SetBinLabel(1,"Particle Weights");
2590  fIntFlowFlags->GetXaxis()->SetBinLabel(2,"Event Weights");
2591  fIntFlowFlags->GetXaxis()->SetBinLabel(3,"Corrected for NUA?");
2592  fIntFlowFlags->GetXaxis()->SetBinLabel(4,"Print RF results");
2593  fIntFlowFlags->GetXaxis()->SetBinLabel(5,"Print RP results");
2594  fIntFlowFlags->GetXaxis()->SetBinLabel(6,"Print POI results");
2595  fIntFlowFlags->GetXaxis()->SetBinLabel(7,"Print RF (rebinned in M) results");
2596  fIntFlowFlags->GetXaxis()->SetBinLabel(8,"Corrected for NUA vs M?");
2597  fIntFlowFlags->GetXaxis()->SetBinLabel(9,"Propagate errors to v_{n} from correlations?");
2598  fIntFlowFlags->GetXaxis()->SetBinLabel(10,"Calculate cumulants vs M");
2599  fIntFlowFlags->GetXaxis()->SetBinLabel(11,"fMinimumBiasReferenceFlow");
2600  fIntFlowFlags->GetXaxis()->SetBinLabel(12,"fForgetAboutCovariances");
2601  fIntFlowFlags->GetXaxis()->SetBinLabel(13,"fStoreVarious");
2602  fIntFlowFlags->GetXaxis()->SetBinLabel(14,"fFillMultipleControlHistograms");
2603  fIntFlowFlags->GetXaxis()->SetBinLabel(15,"Calculate all correlations vs M");
2604  fIntFlowFlags->GetXaxis()->SetBinLabel(16,"fMultiplicityIs");
2605  fIntFlowFlags->GetXaxis()->SetBinLabel(17,"fExactNoRPs");
2606  fIntFlowFlags->GetXaxis()->SetBinLabel(18,"fUse2DHistograms");
2607  fIntFlowFlags->GetXaxis()->SetBinLabel(19,"fFillProfilesVsMUsingWeights");
2608  fIntFlowFlags->GetXaxis()->SetBinLabel(20,"fUseQvectorTerms");
2610 
2611  // b) Book event-by-event quantities:
2612  // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M:
2613  fReQ = new TMatrixD(12,9);
2614  fImQ = new TMatrixD(12,9);
2615  fSpk = new TMatrixD(8,9);
2616  // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):
2617  TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";
2618  intFlowCorrelationsEBEName += fAnalysisLabel->Data();
2619  fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);
2620  // weights for average correlations <2>, <4>, <6> and <8> for single event:
2621  TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";
2622  intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();
2623  fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);
2624  // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):
2625  TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";
2626  intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();
2627  fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),64,0,64);
2628  // average correction terms for non-uniform acceptance for single event
2629  // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):
2630  TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";
2631  fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2632  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2633  {
2634  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);
2635  }
2636  // event weights for terms for non-uniform acceptance:
2637  TString fIntFlowEventWeightForCorrectionTermsForNUAEBEName = "fIntFlowEventWeightForCorrectionTermsForNUAEBE";
2638  fIntFlowEventWeightForCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();
2639  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2640  {
2641  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
2642  }
2643  // c) Book profiles: // to be improved (comment)
2644  // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:
2645  TString avMultiplicityName = "fAvMultiplicity";
2646  avMultiplicityName += fAnalysisLabel->Data();
2647  fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average multiplicities of reference particles (RPs)",9,0,9);
2648  fAvMultiplicity->SetTickLength(-0.01,"Y");
2649  fAvMultiplicity->SetMarkerStyle(25);
2650  fAvMultiplicity->SetLabelSize(0.05);
2651  fAvMultiplicity->SetLabelOffset(0.02,"Y");
2652  fAvMultiplicity->SetYTitle("Average multiplicity");
2653  (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");
2654  (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");
2655  (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");
2656  (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");
2657  (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");
2658  (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");
2659  (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");
2660  (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");
2661  (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");
2663  // Average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):
2664  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
2665  TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";
2666  intFlowCorrelationsProName += fAnalysisLabel->Data();
2667  fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");
2668  fIntFlowCorrelationsPro->Sumw2();
2669  fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");
2670  fIntFlowCorrelationsPro->SetMarkerStyle(25);
2671  fIntFlowCorrelationsPro->SetLabelSize(0.06);
2672  fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");
2673  for(Int_t b=0;b<4;b++)
2674  {
2675  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(b+1,correlationFlag[b].Data());
2676  }
2678  // Average correlations squared <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> for all events:
2679  TString squaredCorrelationFlag[4] = {"#LT#LT2#GT^{2}#GT","#LT#LT4#GT^{2}#GT","#LT#LT6#GT^{2}#GT","#LT#LT8#GT^{2}#GT"};
2680  TString intFlowSquaredCorrelationsProName = "fIntFlowSquaredCorrelationsPro";
2681  intFlowSquaredCorrelationsProName += fAnalysisLabel->Data();
2682  fIntFlowSquaredCorrelationsPro = new TProfile(intFlowSquaredCorrelationsProName.Data(),"Average squared correlations for all events",4,0,4,"s");
2684  fIntFlowSquaredCorrelationsPro->SetTickLength(-0.01,"Y");
2685  fIntFlowSquaredCorrelationsPro->SetMarkerStyle(25);
2686  fIntFlowSquaredCorrelationsPro->SetLabelSize(0.06);
2687  fIntFlowSquaredCorrelationsPro->SetLabelOffset(0.01,"Y");
2688  for(Int_t b=0;b<4;b++)
2689  {
2690  (fIntFlowSquaredCorrelationsPro->GetXaxis())->SetBinLabel(b+1,squaredCorrelationFlag[b].Data());
2691  }
2694  {
2695  for(Int_t ci=0;ci<4;ci++) // correlation index
2696  {
2697  // average correlations <<2>>, <<4>>, <<6>> and <<8>> versus multiplicity for all events (with wrong errors):
2698  TString intFlowCorrelationsVsMProName = "fIntFlowCorrelationsVsMPro";
2699  intFlowCorrelationsVsMProName += fAnalysisLabel->Data();
2700  fIntFlowCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowCorrelationsVsMProName.Data(),correlationFlag[ci].Data()),
2701  Form("%s vs multiplicity",correlationFlag[ci].Data()),
2703  fIntFlowCorrelationsVsMPro[ci]->Sumw2();
2704  fIntFlowCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
2706  {
2707  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2709  {
2710  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2712  {
2713  fIntFlowCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2714  }
2716  // average squared correlations <<2>^2>, <<4>^2>, <<6>^2> and <<8>^2> versus multiplicity for all events:
2717  TString intFlowSquaredCorrelationsVsMProName = "fIntFlowSquaredCorrelationsVsMPro";
2718  intFlowSquaredCorrelationsVsMProName += fAnalysisLabel->Data();
2719  fIntFlowSquaredCorrelationsVsMPro[ci] = new TProfile(Form("%s, %s",intFlowSquaredCorrelationsVsMProName.Data(),squaredCorrelationFlag[ci].Data()),
2720  Form("%s vs multiplicity",squaredCorrelationFlag[ci].Data()),
2722  fIntFlowSquaredCorrelationsVsMPro[ci]->Sumw2();
2723  fIntFlowSquaredCorrelationsVsMPro[ci]->GetYaxis()->SetTitle(squaredCorrelationFlag[ci].Data());
2725  {
2726  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# RPs");
2728  {
2729  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2731  {
2732  fIntFlowSquaredCorrelationsVsMPro[ci]->GetXaxis()->SetTitle("# POIs");
2733  }
2735  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
2736  } // end of if(fCalculateCumulantsVsM)
2737  // averaged all correlations for all events (with wrong errors!):
2738  TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";
2739  intFlowCorrelationsAllProName += fAnalysisLabel->Data();
2740  fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average all correlations for all events",64,0,64);
2741  fIntFlowCorrelationsAllPro->Sumw2();
2742  fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");
2743  fIntFlowCorrelationsAllPro->SetMarkerStyle(25);
2744  fIntFlowCorrelationsAllPro->SetLabelSize(0.03);
2745  fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");
2746  // 2-p correlations:
2747  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT_{n|n}");
2748  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"#LT#LT2#GT#GT_{2n|2n}");
2749  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"#LT#LT2#GT#GT_{3n|3n}");
2750  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"#LT#LT2#GT#GT_{4n|4n}");
2751  // 3-p correlations:
2752  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"#LT#LT3#GT#GT_{2n|n,n}");
2753  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"#LT#LT3#GT#GT_{3n|2n,n}");
2754  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"#LT#LT3#GT#GT_{4n|2n,2n}");
2755  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"#LT#LT3#GT#GT_{4n|3n,n}");
2756  // 4-p correlations:
2757  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"#LT#LT4#GT#GT_{n,n|n,n}");
2758  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"#LT#LT4#GT#GT_{2n,n|2n,n}");
2759  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"#LT#LT4#GT#GT_{2n,2n|2n,2n}");
2760  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"#LT#LT4#GT#GT_{3n|n,n,n}");
2761  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"#LT#LT4#GT#GT_{3n,n|3n,n}");
2762  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"#LT#LT4#GT#GT_{3n,n|2n,2n}");
2763  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"#LT#LT4#GT#GT_{4n|2n,n,n}");
2764  // 5-p correlations:
2765  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"#LT#LT5#GT#GT_{2n,n|n,n,n}");
2766  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"#LT#LT5#GT#GT_{2n,2n|2n,n,n}");
2767  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"#LT#LT5#GT#GT_{3n,n|2n,n,n}");
2768  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"#LT#LT5#GT#GT_{4n|n,n,n,n}");
2769  // 6-p correlations:
2770  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"#LT#LT6#GT#GT_{n,n,n|n,n,n}");
2771  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"#LT#LT6#GT#GT_{2n,n,n|2n,n,n}");
2772  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"#LT#LT6#GT#GT_{2n,2n|n,n,n,n}");
2773  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"#LT#LT6#GT#GT_{3n,n|n,n,n,n}");
2774  // 7-p correlations:
2775  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}");
2776  // 8-p correlations:
2777  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}");
2778  // EXTRA correlations for v3{5} study:
2779  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(33,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2780  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(34,"#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}");
2781  // EXTRA correlations for Teaney-Yan study:
2782  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(35,"#LT#LT2#GT#GT_{5n|5n}");
2783  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(36,"#LT#LT2#GT#GT_{6n|6n}");
2784  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(37,"#LT#LT3#GT#GT_{5n|3n,2n}");
2785  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(38,"#LT#LT3#GT#GT_{5n|4n,1n}");
2786  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(39,"#LT#LT3#GT#GT_{6n|3n,3n}");
2787  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(40,"#LT#LT3#GT#GT_{6n|4n,2n}");
2788  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(41,"#LT#LT3#GT#GT_{6n|5n,1n}");
2789  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(42,"#LT#LT4#GT#GT_{6n|3n,2n,1n}");
2790  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(43,"#LT#LT4#GT#GT_{3n,2n|3n,2n}");
2791  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(44,"#LT#LT4#GT#GT_{4n,1n|3n,2n}");
2792  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(45,"#LT#LT4#GT#GT_{3n,3n|3n,3n}");
2793  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(46,"#LT#LT4#GT#GT_{4n,2n|3n,3n}");
2794  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(47,"#LT#LT4#GT#GT_{5n,1n|3n,3n}");
2795  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(48,"#LT#LT4#GT#GT_{4n,2n|4n,2n}");
2796  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(49,"#LT#LT4#GT#GT_{5n,1n|4n,2n}");
2797  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(50,"#LT#LT4#GT#GT_{5n|3n,1n,1n}");
2798  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(51,"#LT#LT4#GT#GT_{5n|2n,2n,1n}");
2799  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(52,"#LT#LT4#GT#GT_{5n,1n|5n,1n}");
2800  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(53,"#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}");
2801  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(54,"#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}");
2802  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(55,"#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}");
2803  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(56,"#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}");
2804  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(57,"#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}");
2805  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(58,"#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}");
2806  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(59,"#LT#LT4#GT#GT_{6n|4n,1n,1n}");
2807  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(60,"#LT#LT4#GT#GT_{6n|2n,2n,2n}");
2808  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(61,"#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}");
2809  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(62,"#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}");
2810  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(63,"#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}");
2812  // average all correlations versus multiplicity (errors via Sumw2 - to be improved):
2814  {
2815  // 2-p correlations vs M:
2816  fIntFlowCorrelationsAllVsMPro[0] = new TProfile("two1n1n","#LT#LT2#GT#GT_{n|n}",fnBinsMult,fMinMult,fMaxMult);
2817  fIntFlowCorrelationsAllVsMPro[1] = new TProfile("two2n2n","#LT#LT2#GT#GT_{2n|2n}",fnBinsMult,fMinMult,fMaxMult);
2818  fIntFlowCorrelationsAllVsMPro[2] = new TProfile("two3n3n","#LT#LT2#GT#GT_{3n|3n}",fnBinsMult,fMinMult,fMaxMult);
2819  fIntFlowCorrelationsAllVsMPro[3] = new TProfile("two4n4n","#LT#LT2#GT#GT_{4n|4n}",fnBinsMult,fMinMult,fMaxMult);
2820  // 3-p correlations vs M:
2821  fIntFlowCorrelationsAllVsMPro[5] = new TProfile("three2n1n1n","#LT#LT3#GT#GT_{2n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2822  fIntFlowCorrelationsAllVsMPro[6] = new TProfile("three3n2n1n","#LT#LT3#GT#GT_{3n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2823  fIntFlowCorrelationsAllVsMPro[7] = new TProfile("three4n2n2n","#LT#LT3#GT#GT_{4n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2824  fIntFlowCorrelationsAllVsMPro[8] = new TProfile("three4n3n1n","#LT#LT3#GT#GT_{4n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2825  // 4-p correlations vs M:
2826  fIntFlowCorrelationsAllVsMPro[10] = new TProfile("four1n1n1n1n","#LT#LT4#GT#GT_{n,n|n,n}",fnBinsMult,fMinMult,fMaxMult);
2827  fIntFlowCorrelationsAllVsMPro[11] = new TProfile("four2n1n2n1n","#LT#LT4#GT#GT_{2n,n|2n,n}",fnBinsMult,fMinMult,fMaxMult);
2828  fIntFlowCorrelationsAllVsMPro[12] = new TProfile("four2n2n2n2n","#LT#LT4#GT#GT_{2n,2n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2829  fIntFlowCorrelationsAllVsMPro[13] = new TProfile("four3n1n1n1n","#LT#LT4#GT#GT_{3n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2830  fIntFlowCorrelationsAllVsMPro[14] = new TProfile("four3n1n3n1n","#LT#LT4#GT#GT_{3n,n|3n,n}",fnBinsMult,fMinMult,fMaxMult);
2831  fIntFlowCorrelationsAllVsMPro[15] = new TProfile("four3n1n2n2n","#LT#LT4#GT#GT_{3n,n|2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2832  fIntFlowCorrelationsAllVsMPro[16] = new TProfile("four4n2n1n1n","#LT#LT4#GT#GT_{4n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2833  // 5-p correlations vs M:
2834  fIntFlowCorrelationsAllVsMPro[18] = new TProfile("five2n1n1n1n1n","#LT#LT5#GT#GT_{2n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2835  fIntFlowCorrelationsAllVsMPro[19] = new TProfile("five2n2n2n1n1n","#LT#LT5#GT#GT_{2n,2n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2836  fIntFlowCorrelationsAllVsMPro[20] = new TProfile("five3n1n2n1n1n","#LT#LT5#GT#GT_{3n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2837  fIntFlowCorrelationsAllVsMPro[21] = new TProfile("five4n1n1n1n1n","#LT#LT5#GT#GT_{4n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2838  // 6-p correlations vs M:
2839  fIntFlowCorrelationsAllVsMPro[23] = new TProfile("six1n1n1n1n1n1n","#LT#LT6#GT#GT_{n,n,n|n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2840  fIntFlowCorrelationsAllVsMPro[24] = new TProfile("six2n1n1n2n1n1n","#LT#LT6#GT#GT_{2n,n,n|2n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2841  fIntFlowCorrelationsAllVsMPro[25] = new TProfile("six2n2n1n1n1n1n","#LT#LT6#GT#GT_{2n,2n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2842  fIntFlowCorrelationsAllVsMPro[26] = new TProfile("six3n1n1n1n1n1n","#LT#LT6#GT#GT_{3n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2843  // 7-p correlations vs M:
2844  fIntFlowCorrelationsAllVsMPro[28] = new TProfile("seven2n1n1n1n1n1n1n","#LT#LT7#GT#GT_{2n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2845  // 8-p correlations vs M:
2846  fIntFlowCorrelationsAllVsMPro[30] = new TProfile("eight1n1n1n1n1n1n1n1n","#LT#LT8#GT#GT_{n,n,n,n|n,n,n,n}",fnBinsMult,fMinMult,fMaxMult);
2847  // EXTRA correlations vs M for v3{5} study (to be improved - put them in a right order somewhere):
2848  fIntFlowCorrelationsAllVsMPro[32] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2849  fIntFlowCorrelationsAllVsMPro[33] = new TProfile("five3n3n2n2n2n","#LT#LT5#GT#GT_{3n,3n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2850  // EXTRA correlations vs M for Teaney-Yan study (to be improved - put them in a right order somewhere):
2851  fIntFlowCorrelationsAllVsMPro[34] = new TProfile("two5n5n","#LT#LT2#GT#GT_{5n|5n}",fnBinsMult,fMinMult,fMaxMult);
2852  fIntFlowCorrelationsAllVsMPro[35] = new TProfile("two6n6n","#LT#LT2#GT#GT_{6n|6n}",fnBinsMult,fMinMult,fMaxMult);
2853  fIntFlowCorrelationsAllVsMPro[36] = new TProfile("three5n3n2n","#LT#LT3#GT#GT_{5n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2854  fIntFlowCorrelationsAllVsMPro[37] = new TProfile("three5n4n1n","#LT#LT3#GT#GT_{5n|4n,1n}",fnBinsMult,fMinMult,fMaxMult);
2855  fIntFlowCorrelationsAllVsMPro[38] = new TProfile("three6n3n3n","#LT#LT3#GT#GT_{6n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2856  fIntFlowCorrelationsAllVsMPro[39] = new TProfile("three6n4n2n","#LT#LT3#GT#GT_{6n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2857  fIntFlowCorrelationsAllVsMPro[40] = new TProfile("three6n5n1n","#LT#LT3#GT#GT_{6n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2858  fIntFlowCorrelationsAllVsMPro[41] = new TProfile("four6n3n2n1n","#LT#LT4#GT#GT_{6n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2859  fIntFlowCorrelationsAllVsMPro[42] = new TProfile("four3n2n3n2n","#LT#LT4#GT#GT_{3n,2n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2860  fIntFlowCorrelationsAllVsMPro[43] = new TProfile("four4n1n3n2n","#LT#LT4#GT#GT_{4n,1n|3n,2n}",fnBinsMult,fMinMult,fMaxMult);
2861  fIntFlowCorrelationsAllVsMPro[44] = new TProfile("four3n3n3n3n","#LT#LT4#GT#GT_{3n,3n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2862  fIntFlowCorrelationsAllVsMPro[45] = new TProfile("four4n2n3n3n","#LT#LT4#GT#GT_{4n,2n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2863  fIntFlowCorrelationsAllVsMPro[46] = new TProfile("four5n1n3n3n","#LT#LT4#GT#GT_{5n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2864  fIntFlowCorrelationsAllVsMPro[47] = new TProfile("four4n2n4n2n","#LT#LT4#GT#GT_{4n,2n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2865  fIntFlowCorrelationsAllVsMPro[48] = new TProfile("four5n1n4n2n","#LT#LT4#GT#GT_{5n,1n|4n,2n}",fnBinsMult,fMinMult,fMaxMult);
2866  fIntFlowCorrelationsAllVsMPro[49] = new TProfile("four5n3n1n1n","#LT#LT4#GT#GT_{5n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2867  fIntFlowCorrelationsAllVsMPro[50] = new TProfile("four5n2n2n1n","#LT#LT4#GT#GT_{5n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2868  fIntFlowCorrelationsAllVsMPro[51] = new TProfile("four5n1n5n1n","#LT#LT4#GT#GT_{5n,1n|5n,1n}",fnBinsMult,fMinMult,fMaxMult);
2869  fIntFlowCorrelationsAllVsMPro[52] = new TProfile("five3n3n3n2n1n","#LT#LT5#GT#GT_{3n,3n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2870  fIntFlowCorrelationsAllVsMPro[53] = new TProfile("five4n2n3n2n1n","#LT#LT5#GT#GT_{4n,2n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2871  fIntFlowCorrelationsAllVsMPro[54] = new TProfile("five3n2n3n1n1n","#LT#LT5#GT#GT_{3n,2n|3n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2872  fIntFlowCorrelationsAllVsMPro[55] = new TProfile("five3n2n2n2n1n","#LT#LT5#GT#GT_{3n,2n|2n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2873  fIntFlowCorrelationsAllVsMPro[56] = new TProfile("five5n1n3n2n1n","#LT#LT5#GT#GT_{5n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2874  fIntFlowCorrelationsAllVsMPro[57] = new TProfile("six3n2n1n3n2n1n","#LT#LT6#GT#GT_{3n,2n,1n|3n,2n,1n}",fnBinsMult,fMinMult,fMaxMult);
2875  fIntFlowCorrelationsAllVsMPro[58] = new TProfile("four6n4n1n1n","#LT#LT4#GT#GT_{6n|4n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2876  fIntFlowCorrelationsAllVsMPro[59] = new TProfile("four6n2n2n2n","#LT#LT4#GT#GT_{6n|2n,2n,2n}",fnBinsMult,fMinMult,fMaxMult);
2877  fIntFlowCorrelationsAllVsMPro[60] = new TProfile("five6n2n2n1n1n","#LT#LT5#GT#GT_{6n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2878  fIntFlowCorrelationsAllVsMPro[61] = new TProfile("five4n1n1n3n3n","#LT#LT5#GT#GT_{4n,1n,1n|3n,3n}",fnBinsMult,fMinMult,fMaxMult);
2879  fIntFlowCorrelationsAllVsMPro[62] = new TProfile("six3n3n2n2n1n1n","#LT#LT6#GT#GT_{3n,3n|2n,2n,1n,1n}",fnBinsMult,fMinMult,fMaxMult);
2880  for(Int_t n=0;n<63;n++)
2881  {
2883  {
2884  fIntFlowCorrelationsAllVsMPro[n]->Sumw2();
2886  {
2887  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# RPs");
2889  {
2890  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2892  {
2893  fIntFlowCorrelationsAllVsMPro[n]->GetXaxis()->SetTitle("# POIs");
2894  }
2896  } // end of if(fIntFlowCorrelationsAllVsMPro[n])
2897  } // end of for(Int_t n=0;n<63;n++)
2898  } // end of if(fCalculateAllCorrelationsVsM)
2899  // when particle weights are used some extra correlations appear:
2901  {
2902  TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";
2903  intFlowExtraCorrelationsProName += fAnalysisLabel->Data();
2904  fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");
2905  fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");
2906  fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);
2907  fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);
2908  fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");
2909  // extra 2-p correlations:
2910  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");
2911  (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");
2913  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights)
2914  // average product of correlations <2>, <4>, <6> and <8>:
2915  TString productFlag[6] = {"#LT#LT2#GT#LT4#GT#GT","#LT#LT2#GT#LT6#GT#GT","#LT#LT2#GT#LT8#GT#GT",
2916  "#LT#LT4#GT#LT6#GT#GT","#LT#LT4#GT#LT8#GT#GT","#LT#LT6#GT#LT8#GT#GT"};
2917  TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";
2918  intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();
2919  fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);
2920  fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");
2921  fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25);
2922  fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);
2923  fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");
2924  for(Int_t b=0;b<6;b++)
2925  {
2926  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(b+1,productFlag[b].Data());
2927  }
2929  // average product of correlations <2>, <4>, <6> and <8> versus multiplicity
2930  // [0=<<2><4>>,1=<<2><6>>,2=<<2><8>>,3=<<4><6>>,4=<<4><8>>,5=<<6><8>>]
2932  {
2933  TString intFlowProductOfCorrelationsVsMProName = "fIntFlowProductOfCorrelationsVsMPro";
2934  intFlowProductOfCorrelationsVsMProName += fAnalysisLabel->Data();
2935  for(Int_t pi=0;pi<6;pi++)
2936  {
2937  fIntFlowProductOfCorrelationsVsMPro[pi] = new TProfile(Form("%s, %s",intFlowProductOfCorrelationsVsMProName.Data(),productFlag[pi].Data()),
2938  Form("%s versus multiplicity",productFlag[pi].Data()),
2941  {
2942  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# RPs");
2944  {
2945  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
2947  {
2948  fIntFlowProductOfCorrelationsVsMPro[pi]->GetXaxis()->SetTitle("# POIs");
2949  }
2951  } // end of for(Int_t pi=0;pi<6;pi++)
2952  } // end of if(fCalculateCumulantsVsM)
2953  // average product of correction terms for NUA:
2954  TString intFlowProductOfCorrectionTermsForNUAProName = "fIntFlowProductOfCorrectionTermsForNUAPro";
2955  intFlowProductOfCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2956  fIntFlowProductOfCorrectionTermsForNUAPro = new TProfile(intFlowProductOfCorrectionTermsForNUAProName.Data(),"Average products of correction terms for NUA",27,0,27);
2957  fIntFlowProductOfCorrectionTermsForNUAPro->SetTickLength(-0.01,"Y");
2958  fIntFlowProductOfCorrectionTermsForNUAPro->SetMarkerStyle(25);
2959  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelSize(0.03);
2960  fIntFlowProductOfCorrectionTermsForNUAPro->SetLabelOffset(0.01,"Y");
2961  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(1,"<<2><cos(#phi)>>");
2962  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(2,"<<2><sin(#phi)>>");
2963  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(3,"<<cos(#phi)><sin(#phi)>>");
2964  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
2965  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
2966  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2967  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2968  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
2969  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
2970  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
2971  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
2972  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2973  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
2974  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2975  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2976  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2977  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2978  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
2979  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
2980  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2981  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2982  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
2983  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2984  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2985  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
2986  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
2987  (fIntFlowProductOfCorrectionTermsForNUAPro->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
2989  // average correction terms for non-uniform acceptance (with wrong errors!):
2990  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
2991  {
2992  TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";
2993  intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();
2994  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");
2995  fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");
2996  fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);
2997  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.05);
2998  fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");
2999  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
3000  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
3001  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
3002  (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
3004  // versus multiplicity:
3006  {
3007  TString correctionTermFlag[4] = {"(n(phi1))","(n(phi1+phi2))","(n(phi1-phi2-phi3))","(n(2phi1-phi2))"}; // to be improved - hardwired 4
3008  for(Int_t ci=0;ci<4;ci++) // correction term index (to be improved - hardwired 4)
3009  {
3010  TString intFlowCorrectionTermsForNUAVsMProName = "fIntFlowCorrectionTermsForNUAVsMPro";
3011  intFlowCorrectionTermsForNUAVsMProName += fAnalysisLabel->Data();
3012  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");
3014  }
3015  } // end of if(fCalculateCumulantsVsM)
3016  } // end of for(Int_t sc=0;sc<2;sc++)
3017 
3018  // d) Book histograms holding the final results:
3019  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):
3020  TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";
3021  intFlowCorrelationsHistName += fAnalysisLabel->Data();
3022  fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);
3023  fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");
3024  fIntFlowCorrelationsHist->SetMarkerStyle(25);
3025  fIntFlowCorrelationsHist->SetLabelSize(0.06);
3026  fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");
3027  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"#LT#LT2#GT#GT");
3028  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"#LT#LT4#GT#GT");
3029  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"#LT#LT6#GT#GT");
3030  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"#LT#LT8#GT#GT");
3032  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!) vs M:
3034  {
3035  for(Int_t ci=0;ci<4;ci++) // correlation index
3036  {
3037  TString intFlowCorrelationsVsMHistName = "fIntFlowCorrelationsVsMHist";
3038  intFlowCorrelationsVsMHistName += fAnalysisLabel->Data();
3039  fIntFlowCorrelationsVsMHist[ci] = new TH1D(Form("%s, %s",intFlowCorrelationsVsMHistName.Data(),correlationFlag[ci].Data()),
3040  Form("%s vs multiplicity",correlationFlag[ci].Data()),
3042  fIntFlowCorrelationsVsMHist[ci]->GetYaxis()->SetTitle(correlationFlag[ci].Data());
3044  {
3045  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# RPs");
3047  {
3048  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3050  {
3051  fIntFlowCorrelationsVsMHist[ci]->GetXaxis()->SetTitle("# POIs");
3052  }
3054  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3055  } // end of if(fCalculateCumulantsVsM)
3056  // average all correlations for all events (with correct errors!):
3057  TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";
3058  intFlowCorrelationsAllHistName += fAnalysisLabel->Data();
3059  fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",34,0,34);
3060  fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");
3061  fIntFlowCorrelationsAllHist->SetMarkerStyle(25);
3062  fIntFlowCorrelationsAllHist->SetLabelSize(0.03);
3063  fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");
3064  // 2-p correlations:
3065  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");
3066  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");
3067  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");
3068  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");
3069  // 3-p correlations:
3070  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");
3071  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");
3072  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");
3073  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");
3074  // 4-p correlations:
3075  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}");
3076  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");
3077  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");
3078  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");
3079  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");
3080  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}");
3081  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");
3082  // 5-p correlations:
3083  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}");
3084  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");
3085  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");
3086  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");
3087  // 6-p correlations:
3088  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");
3089  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");
3090  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");
3091  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");
3092  // 7-p correlations:
3093  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");
3094  // 8-p correlations:
3095  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");
3097  // average correction terms for non-uniform acceptance (with correct errors!):
3098  for(Int_t sc=0;sc<2;sc++) // sin or cos terms
3099  {
3100  TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";
3101  intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();
3102  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);
3103  fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");
3104  fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);
3105  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.05);
3106  fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");
3107  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("#LT#LT%s(n(#phi_{1}))#GT#GT",sinCosFlag[sc].Data()));
3108  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(2,Form("#LT#LT%s(n(#phi_{1}+#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
3109  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(3,Form("#LT#LT%s(n(#phi_{1}-#phi_{2}-#phi_{3}))#GT#GT",sinCosFlag[sc].Data()));
3110  (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(4,Form("#LT#LT%s(n(2#phi_{1}-#phi_{2}))#GT#GT",sinCosFlag[sc].Data()));
3112  } // end of for(Int_t sc=0;sc<2;sc++)
3113  // covariances (multiplied with weight dependent prefactor):
3114  TString intFlowCovariancesName = "fIntFlowCovariances";
3115  intFlowCovariancesName += fAnalysisLabel->Data();
3116  fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);
3117  fIntFlowCovariances->SetLabelSize(0.04);
3118  fIntFlowCovariances->SetMarkerStyle(25);
3119  (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(#LT2#GT,#LT4#GT)");
3120  (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(#LT2#GT,#LT6#GT)");
3121  (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(#LT2#GT,#LT8#GT)");
3122  (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(#LT4#GT,#LT6#GT)");
3123  (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(#LT4#GT,#LT8#GT)");
3124  (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(#LT6#GT,#LT8#GT)");
3126  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:
3127  TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";
3128  intFlowSumOfEventWeightsName += fAnalysisLabel->Data();
3129  for(Int_t power=0;power<2;power++)
3130  {
3131  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);
3132  fIntFlowSumOfEventWeights[power]->SetLabelSize(0.04);
3133  fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);
3134  if(power == 0)
3135  {
3136  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}");
3137  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}");
3138  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}");
3139  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}");
3140  } else if (power == 1)
3141  {
3142  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT}^{2}");
3143  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT4#GT}^{2}");
3144  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT6#GT}^{2}");
3145  (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT8#GT}^{2}");
3146  }
3148  }
3149  // sum of products of event weights for correlations <2>, <4>, <6> and <8>:
3150  TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";
3151  intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();
3152  fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);
3153  fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.04);
3154  fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);
3155  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT4#GT}");
3156  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT6#GT}");
3157  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LT8#GT}");
3158  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT6#GT}");
3159  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LT8#GT}");
3160  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT6#GT} w_{#LT8#GT}");
3162  // final result for covariances of correlations (multiplied with weight dependent prefactor) versus M
3163  // [0=Cov(2,4),1=Cov(2,6),2=Cov(2,8),3=Cov(4,6),4=Cov(4,8),5=Cov(6,8)]:
3165  {
3166  TString intFlowCovariancesVsMName = "fIntFlowCovariancesVsM";
3167  intFlowCovariancesVsMName += fAnalysisLabel->Data();
3168  TString covarianceFlag[6] = {"Cov(<2>,<4>)","Cov(<2>,<6>)","Cov(<2>,<8>)","Cov(<4>,<6>)","Cov(<4>,<8>)","Cov(<6>,<8>)"};
3169  for(Int_t ci=0;ci<6;ci++)
3170  {
3171  fIntFlowCovariancesVsM[ci] = new TH1D(Form("%s, %s",intFlowCovariancesVsMName.Data(),covarianceFlag[ci].Data()),
3172  Form("%s vs multiplicity",covarianceFlag[ci].Data()),
3174  fIntFlowCovariancesVsM[ci]->GetYaxis()->SetTitle(covarianceFlag[ci].Data());
3176  {
3177  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# RPs");
3179  {
3180  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3182  {
3183  fIntFlowCovariancesVsM[ci]->GetXaxis()->SetTitle("# POIs");
3184  }
3186  }
3187  } // end of if(fCalculateCumulantsVsM)
3188  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8> versus multiplicity
3189  // [0=sum{w_{<2>}},1=sum{w_{<4>}},2=sum{w_{<6>}},3=sum{w_{<8>}}][0=linear 1,1=quadratic]:
3191  {
3192  TString intFlowSumOfEventWeightsVsMName = "fIntFlowSumOfEventWeightsVsM";
3193  intFlowSumOfEventWeightsVsMName += fAnalysisLabel->Data();
3194  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>}"},
3195  {"#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}"}};
3196  for(Int_t si=0;si<4;si++)
3197  {
3198  for(Int_t power=0;power<2;power++)
3199  {
3200  fIntFlowSumOfEventWeightsVsM[si][power] = new TH1D(Form("%s, %s",intFlowSumOfEventWeightsVsMName.Data(),sumFlag[power][si].Data()),
3201  Form("%s vs multiplicity",sumFlag[power][si].Data()),
3203  fIntFlowSumOfEventWeightsVsM[si][power]->GetYaxis()->SetTitle(sumFlag[power][si].Data());
3205  {
3206  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# RPs");
3208  {
3209  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3211  {
3212  fIntFlowSumOfEventWeightsVsM[si][power]->GetXaxis()->SetTitle("# POIs");
3213  }
3215  } // end of for(Int_t power=0;power<2;power++)
3216  } // end of for(Int_t si=0;si<4;si++)
3217  } // end of if(fCalculateCumulantsVsM)
3218  // sum of products of event weights for correlations <2>, <4>, <6> and <8> vs M
3219  // [0=sum{w_{<2>}w_{<4>}},1=sum{w_{<2>}w_{<6>}},2=sum{w_{<2>}w_{<8>}},
3220  // 3=sum{w_{<4>}w_{<6>}},4=sum{w_{<4>}w_{<8>}},5=sum{w_{<6>}w_{<8>}}]:
3222  {
3223  TString intFlowSumOfProductOfEventWeightsVsMName = "fIntFlowSumOfProductOfEventWeightsVsM";
3224  intFlowSumOfProductOfEventWeightsVsMName += fAnalysisLabel->Data();
3225  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>}",
3226  "#sum_{i=1}^{N} w_{<4>} w_{<6>}","#sum_{i=1}^{N} w_{<4>} w_{<8>}","#sum_{i=1}^{N} w_{<6>} w_{<8>}"};
3227  for(Int_t pi=0;pi<6;pi++)
3228  {
3229  fIntFlowSumOfProductOfEventWeightsVsM[pi] = new TH1D(Form("%s, %s",intFlowSumOfProductOfEventWeightsVsMName.Data(),sopowFlag[pi].Data()),
3230  Form("%s versus multiplicity",sopowFlag[pi].Data()),
3233  {
3234  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# RPs");
3236  {
3237  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3239  {
3240  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetXaxis()->SetTitle("# POIs");
3241  }
3242  fIntFlowSumOfProductOfEventWeightsVsM[pi]->GetYaxis()->SetTitle(sopowFlag[pi].Data());
3244  } // end of for(Int_t pi=0;pi<6;pi++)
3245  } // end of if(fCalculateCumulantsVsM)
3246  // covariances of NUA terms (multiplied with weight dependent prefactor):
3247  TString intFlowCovariancesNUAName = "fIntFlowCovariancesNUA";
3248  intFlowCovariancesNUAName += fAnalysisLabel->Data();
3249  fIntFlowCovariancesNUA = new TH1D(intFlowCovariancesNUAName.Data(),"Covariances for NUA (multiplied with weight dependent prefactor)",27,0,27);
3250  fIntFlowCovariancesNUA->SetLabelSize(0.04);
3251  fIntFlowCovariancesNUA->SetMarkerStyle(25);
3252  fIntFlowCovariancesNUA->GetXaxis()->SetLabelSize(0.02);
3253  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(1,"Cov(<2>,<cos(#phi)>");
3254  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(2,"Cov(<2>,<sin(#phi)>)");
3255  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(3,"Cov(<cos(#phi)>,<sin(#phi)>)");
3256  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(4,"Cov(<2>,<cos(#phi_{1}+#phi_{2})>)");
3257  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(5,"Cov(<2>,<sin(#phi_{1}+#phi_{2})>)");
3258  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(6,"Cov(<2>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
3259  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(7,"Cov(<2>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
3260  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(8,"Cov(<4>,<cos(#phi)>)");
3261  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(9,"Cov(<4>,<sin(#phi)>)");
3262  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(10,"Cov(<4>,<cos(#phi_{1}+#phi_{2})>)");
3263  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(11,"Cov(<4>,<sin(#phi_{1}+#phi_{2})>)");
3264  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(12,"Cov(<4>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>>)");
3265  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(13,"Cov(<4>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>>)");
3266  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(14,"Cov(<cos(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
3267  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(15,"Cov(<cos(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
3268  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(16,"Cov(<cos(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
3269  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(17,"Cov(<cos(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
3270  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(18,"Cov(<sin(#phi)>,<cos(#phi_{1}+#phi_{2})>)");
3271  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(19,"Cov(<sin(#phi)>,<sin(#phi_{1}+#phi_{2})>)");
3272  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(20,"Cov(<sin(#phi)>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
3273  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(21,"Cov(<sin(#phi)>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
3274  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(22,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}+#phi_{2})>)");
3275  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(23,"Cov(<cos(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
3276  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(24,"Cov(<cos(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
3277  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(25,"Cov(<sin(#phi_{1}+#phi_{2})>,<cos(#phi_{1}-#phi_{2}-#phi_{3})>)");
3278  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(26,"Cov(<sin(#phi_{1}+#phi_{2})>,<sin(#phi_{1}-#phi_{2}-#phi_{3})>)");
3279  (fIntFlowCovariancesNUA->GetXaxis())->SetBinLabel(27,"Cov(<cos(#phi_{1}-#phi_{2}-#phi_{3}>,<sin(#phi_{1}-#phi_{2}-#phi_{3}>)");
3281  // sum of linear and quadratic event weights for NUA terms:
3282  TString intFlowSumOfEventWeightsNUAName = "fIntFlowSumOfEventWeightsNUA";
3283  intFlowSumOfEventWeightsNUAName += fAnalysisLabel->Data();
3284  for(Int_t sc=0;sc<2;sc++)
3285  {
3286  for(Int_t power=0;power<2;power++)
3287  {
3288  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
3289  fIntFlowSumOfEventWeightsNUA[sc][power]->SetLabelSize(0.05);
3290  fIntFlowSumOfEventWeightsNUA[sc][power]->SetMarkerStyle(25);
3291  if(power == 0)
3292  {
3293  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}",sinCosFlag[sc].Data()));
3294  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}",sinCosFlag[sc].Data()));
3295  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}",sinCosFlag[sc].Data()));
3296  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}",sinCosFlag[sc].Data()));
3297  } else if(power == 1)
3298  {
3299  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(1,Form("#sum_{i=1}^{N} w_{<%s(#phi)>}^{2}",sinCosFlag[sc].Data()));
3300  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(2,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}+#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
3301  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(3,Form("#sum_{i=1}^{N} w_{<%s(#phi_{1}-#phi_{2}-#phi_{3})>}^{2}",sinCosFlag[sc].Data()));
3302  (fIntFlowSumOfEventWeightsNUA[sc][power]->GetXaxis())->SetBinLabel(4,Form("#sum_{i=1}^{N} w_{<%s(2#phi_{1}-#phi_{2})>}^{2}",sinCosFlag[sc].Data()));
3303  }
3305  }
3306  }
3307  // sum of products of event weights for NUA terms:
3308  TString intFlowSumOfProductOfEventWeightsNUAName = "fIntFlowSumOfProductOfEventWeightsNUA";
3309  intFlowSumOfProductOfEventWeightsNUAName += fAnalysisLabel->Data();
3310  fIntFlowSumOfProductOfEventWeightsNUA = new TH1D(intFlowSumOfProductOfEventWeightsNUAName.Data(),"Sum of product of event weights for NUA terms",27,0,27);
3311  fIntFlowSumOfProductOfEventWeightsNUA->SetLabelSize(0.02);
3312  fIntFlowSumOfProductOfEventWeightsNUA->SetMarkerStyle(25);
3313  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi)#GT}");
3314  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi)#GT}");
3315  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi)#GT}");
3316  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3317  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3318  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3319  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(7,"#sum_{i=1}^{N} w_{#LT2#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3320  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(8,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi)#GT}");
3321  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(9,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi)#GT}");
3322  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(10,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3323  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(11,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3324  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(12,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3325  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(13,"#sum_{i=1}^{N} w_{#LT4#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3326  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(14,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3327  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(15,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3328  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(16,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3329  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(17,"#sum_{i=1}^{N} w_{#LTcos(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3330  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(18,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}+#phi_{2})#GT}");
3331  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(19,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3332  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(20,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3333  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(21,"#sum_{i=1}^{N} w_{#LTsin(#phi)#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3334  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(22,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}+#phi_{2})#GT}");
3335  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(23,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3336  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(24,"#sum_{i=1}^{N} w_{#LTcos(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3337  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(25,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTcos(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3338  (fIntFlowSumOfProductOfEventWeightsNUA->GetXaxis())->SetBinLabel(26,"#sum_{i=1}^{N} w_{#LTsin(#phi_{1}+#phi_{2})#GT} w_{#LTsin(#phi_{1}-#phi_{2}-#phi_{3})#GT}");
3339  (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}");
3341  // Final results for reference Q-cumulants:
3342  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3343  TString intFlowQcumulantsName = "fIntFlowQcumulants";
3344  intFlowQcumulantsName += fAnalysisLabel->Data();
3345  fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Reference Q-cumulants",4,0,4);
3347  {
3348  fIntFlowQcumulants->SetTitle("Reference Q-cumulants (error from non-isotropic terms also propagated)");
3349  }
3350  fIntFlowQcumulants->SetLabelSize(0.05);
3351  fIntFlowQcumulants->SetMarkerStyle(25);
3352  for(Int_t b=0;b<4;b++)
3353  {
3354  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3355  }
3357  // Final results for reference Q-cumulants rebinned in M:
3359  {
3360  TString intFlowQcumulantsRebinnedInMName = "fIntFlowQcumulantsRebinnedInM";
3361  intFlowQcumulantsRebinnedInMName += fAnalysisLabel->Data();
3362  fIntFlowQcumulantsRebinnedInM = new TH1D(intFlowQcumulantsRebinnedInMName.Data(),"Reference Q-cumulants rebinned in M",4,0,4);
3363  fIntFlowQcumulantsRebinnedInM->SetLabelSize(0.05);
3364  fIntFlowQcumulantsRebinnedInM->SetMarkerStyle(25);
3365  for(Int_t b=0;b<4;b++)
3366  {
3367  (fIntFlowQcumulantsRebinnedInM->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3368  }
3370  } // end of if(fCalculateCumulantsVsM)
3371  // Ratio between error squared: with/without non-isotropic terms:
3372  TString intFlowQcumulantsErrorSquaredRatioName = "fIntFlowQcumulantsErrorSquaredRatio";
3373  intFlowQcumulantsErrorSquaredRatioName += fAnalysisLabel->Data();
3374  fIntFlowQcumulantsErrorSquaredRatio = new TH1D(intFlowQcumulantsErrorSquaredRatioName.Data(),"Error squared of reference Q-cumulants: #frac{with NUA terms}{without NUA terms}",4,0,4);
3375  fIntFlowQcumulantsErrorSquaredRatio->SetLabelSize(0.05);
3376  fIntFlowQcumulantsErrorSquaredRatio->SetMarkerStyle(25);
3377  for(Int_t b=0;b<4;b++)
3378  {
3379  (fIntFlowQcumulantsErrorSquaredRatio->GetXaxis())->SetBinLabel(b+1,cumulantFlag[b].Data());
3380  }
3382  // final results for integrated Q-cumulants versus multiplicity:
3384  {
3385  TString intFlowQcumulantsVsMName = "fIntFlowQcumulantsVsM";
3386  intFlowQcumulantsVsMName += fAnalysisLabel->Data();
3387  for(Int_t co=0;co<4;co++) // cumulant order
3388  {
3389  fIntFlowQcumulantsVsM[co] = new TH1D(Form("%s, %s",intFlowQcumulantsVsMName.Data(),cumulantFlag[co].Data()),
3390  Form("%s vs multiplicity",cumulantFlag[co].Data()),
3393  {
3394  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# RPs");
3396  {
3397  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3399  {
3400  fIntFlowQcumulantsVsM[co]->GetXaxis()->SetTitle("# POIs");
3401  }
3402  fIntFlowQcumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());
3404  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3405  } // end of if(fCalculateCumulantsVsM)
3406  // final integrated flow estimates from Q-cumulants:
3407  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)};
3408  TString intFlowName = "fIntFlow";
3409  intFlowName += fAnalysisLabel->Data();
3410  // integrated flow from Q-cumulants:
3411  fIntFlow = new TH1D(intFlowName.Data(),"Reference flow estimates from Q-cumulants",4,0,4);
3412  fIntFlow->SetLabelSize(0.05);
3413  fIntFlow->SetMarkerStyle(25);
3414  for(Int_t b=0;b<4;b++)
3415  {
3416  (fIntFlow->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3417  }
3418  fIntFlowResults->Add(fIntFlow);
3419  // Reference flow vs M rebinned in one huge bin:
3421  {
3422  TString intFlowRebinnedInMName = "fIntFlowRebinnedInM";
3423  intFlowRebinnedInMName += fAnalysisLabel->Data();
3424  fIntFlowRebinnedInM = new TH1D(intFlowRebinnedInMName.Data(),"Reference flow estimates from Q-cumulants (rebinned in M)",4,0,4);
3425  fIntFlowRebinnedInM->SetLabelSize(0.05);
3426  fIntFlowRebinnedInM->SetMarkerStyle(25);
3427  for(Int_t b=0;b<4;b++)
3428  {
3429  (fIntFlowRebinnedInM->GetXaxis())->SetBinLabel(b+1,flowFlag[b].Data());
3430  }
3432  }
3433  // integrated flow from Q-cumulants: versus multiplicity:
3435  {
3436  TString intFlowVsMName = "fIntFlowVsM";
3437  intFlowVsMName += fAnalysisLabel->Data();
3438  for(Int_t co=0;co<4;co++) // cumulant order
3439  {
3440  fIntFlowVsM[co] = new TH1D(Form("%s, %s",intFlowVsMName.Data(),flowFlag[co].Data()),
3441  Form("%s vs multiplicity",flowFlag[co].Data()),
3444  {
3445  fIntFlowVsM[co]->GetXaxis()->SetTitle("# RPs");
3447  {
3448  fIntFlowVsM[co]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3450  {
3451  fIntFlowVsM[co]->GetXaxis()->SetTitle("# POIs");
3452  }
3453  fIntFlowVsM[co]->GetYaxis()->SetTitle(flowFlag[co].Data());
3454  fIntFlowResults->Add(fIntFlowVsM[co]);
3455  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3456  } // end of if(fCalculateCumulantsVsM)
3457  // quantifying detector effects effects to correlations:
3458  TString intFlowDetectorBiasName = "fIntFlowDetectorBias";
3459  intFlowDetectorBiasName += fAnalysisLabel->Data();
3460  fIntFlowDetectorBias = new TH1D(intFlowDetectorBiasName.Data(),"Quantifying detector bias",4,0,4);
3461  fIntFlowDetectorBias->SetLabelSize(0.05);
3462  fIntFlowDetectorBias->SetMarkerStyle(25);
3463  for(Int_t ci=0;ci<4;ci++)
3464  {
3465  (fIntFlowDetectorBias->GetXaxis())->SetBinLabel(ci+1,Form("#frac{corrected}{measured} %s",cumulantFlag[ci].Data()));
3466  }
3468  // quantifying detector effects to correlations versus multiplicity:
3470  {
3471  TString intFlowDetectorBiasVsMName = "fIntFlowDetectorBiasVsM";
3472  intFlowDetectorBiasVsMName += fAnalysisLabel->Data();
3473  for(Int_t ci=0;ci<4;ci++) // correlation index
3474  {
3475  fIntFlowDetectorBiasVsM[ci] = new TH1D(Form("%s for %s",intFlowDetectorBiasVsMName.Data(),cumulantFlag[ci].Data()),
3476  Form("Quantifying detector bias for %s vs multiplicity",cumulantFlag[ci].Data()),
3479  {
3480  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# RPs");
3482  {
3483  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("Reference multiplicity (from ESD)");
3485  {
3486  fIntFlowDetectorBiasVsM[ci]->GetXaxis()->SetTitle("# POIs");
3487  }
3488  fIntFlowDetectorBiasVsM[ci]->GetYaxis()->SetTitle("#frac{corrected}{measured}");
3490  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3491  } // end of if(fCalculateCumulantsVsM)
3492 
3493 } // end of AliFlowAnalysisCRC::BookEverythingForIntegratedFlow()
3494 
3495 //=======================================================================================================================
3496 
3498 {
3499  // Book all objects for control histograms.
3500 
3501  // a) Book profile to hold all flags for control histograms;
3502  // b) Book all control histograms.
3503 
3504  // a) Book profile to hold all flags for control histograms:
3505  TString controlHistogramsFlagsName = "fControlHistogramsFlags";
3506  controlHistogramsFlagsName += fAnalysisLabel->Data();
3507  fControlHistogramsFlags = new TProfile(controlHistogramsFlagsName.Data(),"Flags for Control Histograms",2,0,2);
3508  fControlHistogramsFlags->SetTickLength(-0.01,"Y");
3509  fControlHistogramsFlags->SetMarkerStyle(25);
3510  fControlHistogramsFlags->SetLabelSize(0.04);
3511  fControlHistogramsFlags->SetLabelOffset(0.02,"Y");
3512  fControlHistogramsFlags->SetStats(kFALSE);
3513  fControlHistogramsFlags->GetXaxis()->SetBinLabel(1,"fStoreControlHistograms");
3514  fControlHistogramsFlags->GetXaxis()->SetBinLabel(2,"fUseQvectorTerms");
3516 
3517  if(!fStoreControlHistograms){return;}
3518 
3519  // b) Book all control histograms:
3520  // b1) Correlation between # RPs and ref. mult. determined centrally:
3521  TString sCorrelationNoRPsVsRefMultName = "fCorrelationNoRPsVsRefMult";
3522  sCorrelationNoRPsVsRefMultName += fAnalysisLabel->Data();
3523  fCorrelationNoRPsVsRefMult = new TH2D(sCorrelationNoRPsVsRefMultName.Data(),"# RPs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3524  fCorrelationNoRPsVsRefMult->SetTickLength(-0.01,"Y");
3525  fCorrelationNoRPsVsRefMult->SetLabelSize(0.04);
3526  fCorrelationNoRPsVsRefMult->SetLabelOffset(0.02,"Y");
3527  fCorrelationNoRPsVsRefMult->SetStats(kTRUE);
3528  fCorrelationNoRPsVsRefMult->GetXaxis()->SetTitle("# RPs");
3529  fCorrelationNoRPsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3531  // b2) Correlation between # POIs and ref. mult. determined centrally:
3532  TString sCorrelationNoPOIsVsRefMultName = "fCorrelationNoPOIsVsRefMult";
3533  sCorrelationNoPOIsVsRefMultName += fAnalysisLabel->Data();
3534  fCorrelationNoPOIsVsRefMult = new TH2D(sCorrelationNoPOIsVsRefMultName.Data(),"# POIs vs. Reference Multiplicity",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3535  fCorrelationNoPOIsVsRefMult->SetTickLength(-0.01,"Y");
3536  fCorrelationNoPOIsVsRefMult->SetLabelSize(0.04);
3537  fCorrelationNoPOIsVsRefMult->SetLabelOffset(0.02,"Y");
3538  fCorrelationNoPOIsVsRefMult->SetStats(kTRUE);
3539  fCorrelationNoPOIsVsRefMult->GetXaxis()->SetTitle("# POIs");
3540  fCorrelationNoPOIsVsRefMult->GetYaxis()->SetTitle("Reference Multiplicity");
3542  // b3) Correlation between # RPs and # POIs:
3543  TString sCorrelationNoRPsVsNoPOIsName = "fCorrelationNoRPsVsNoPOIs";
3544  sCorrelationNoRPsVsNoPOIsName += fAnalysisLabel->Data();
3545  fCorrelationNoRPsVsNoPOIs = new TH2D(sCorrelationNoRPsVsNoPOIsName.Data(),"# RPs vs. # POIs",fnBinsMult,fMinMult,fMaxMult,fnBinsMult,fMinMult,fMaxMult);
3546  fCorrelationNoRPsVsNoPOIs->SetTickLength(-0.01,"Y");
3547  fCorrelationNoRPsVsNoPOIs->SetLabelSize(0.04);
3548  fCorrelationNoRPsVsNoPOIs->SetLabelOffset(0.02,"Y");
3549  fCorrelationNoRPsVsNoPOIs->SetStats(kTRUE);
3550  fCorrelationNoRPsVsNoPOIs->GetXaxis()->SetTitle("# RPs");
3551  fCorrelationNoRPsVsNoPOIs->GetYaxis()->SetTitle("# POIs");
3553  // b4) <2>, <4>, <6> and <8> vs multiplicity (#RPs, #POIs or external):
3554  TString sCorrelation[4] = {"#LT2#GT","#LT4#GT","#LT6#GT","#LT8#GT"};
3555  TString sMultiplicity = "";
3557  {
3558  sMultiplicity = "# RPs";
3560  {
3561  sMultiplicity = "Reference multiplicity (from ESD)";
3563  {
3564  sMultiplicity = "# POIs";
3565  }
3566  for(Int_t ci=0;ci<4;ci++)
3567  {
3568  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]);
3569  fCorrelation2468VsMult[ci]->SetTickLength(-0.01,"Y");
3570  fCorrelation2468VsMult[ci]->SetLabelSize(0.04);
3571  fCorrelation2468VsMult[ci]->SetLabelOffset(0.02,"Y");
3572  fCorrelation2468VsMult[ci]->SetStats(kTRUE);
3573  fCorrelation2468VsMult[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3574  fCorrelation2468VsMult[ci]->GetYaxis()->SetTitle(sCorrelation[ci].Data());
3576  } // end of for(Int_t ci=0;ci<4;ci++)
3577  // b5) <2><4>, <2><6>, <2><8>, <4><6> etc. vs multiplicity (#RPs, #POIs or external):
3578  TString sCorrelationProduct[1] = {"#LT2#GT#LT4#GT"}; // TBI: add the other ones when needed first time
3579  for(Int_t cpi=0;cpi<1;cpi++) // TBI: hardwired 1
3580  {
3581  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]);
3582  fCorrelationProduct2468VsMult[cpi]->SetTickLength(-0.01,"Y");
3583  fCorrelationProduct2468VsMult[cpi]->SetLabelSize(0.04);
3584  fCorrelationProduct2468VsMult[cpi]->SetLabelOffset(0.02,"Y");
3585  fCorrelationProduct2468VsMult[cpi]->SetStats(kTRUE);
3586  fCorrelationProduct2468VsMult[cpi]->GetXaxis()->SetTitle(sMultiplicity.Data());
3587  fCorrelationProduct2468VsMult[cpi]->GetYaxis()->SetTitle(sCorrelationProduct[cpi].Data());
3589  } // end of for(Int_t cpi=0;cpi<4;cpi++)
3590  // b6) |Qn|^2/M, |Q2n|^2/M, |Qn|^4/(M(2M-1)), Re[Q2nQn^*Qn^*]/M, ... vs multiplicity (#RPs, #POIs or external)
3591  if(fUseQvectorTerms)
3592  {
3593  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
3594  for(Int_t qvti=0;qvti<4;qvti++) // TBI: hardwired 4
3595  {
3596  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]);
3597  fQvectorTermsVsMult[qvti]->SetTickLength(-0.01,"Y");
3598  fQvectorTermsVsMult[qvti]->SetLabelSize(0.04);
3599  fQvectorTermsVsMult[qvti]->SetLabelOffset(0.02,"Y");
3600  fQvectorTermsVsMult[qvti]->SetStats(kTRUE);
3601  fQvectorTermsVsMult[qvti]->GetXaxis()->SetTitle(sMultiplicity.Data());
3602  fQvectorTermsVsMult[qvti]->GetYaxis()->SetTitle(sQvectorTerms[qvti].Data());
3604  } // end of for(Int_t qvti=0;qvti<4;qvti++)
3605  } // end of if(fUseQvectorTerms)
3606 
3607 } // end of void AliFlowAnalysisCRC::BookEverythingForControlHistograms()
3608 
3609 //=======================================================================================================================
3610 
3612 {
3613  // Book all objects needed for bootstrap.
3614 
3615  // a) Book profile to hold all flags for bootstrap;
3616  // b) Book local random generator;
3617  // c) Book all bootstrap objects;
3618  // d) Book all bootstrap objects 'vs M'.
3619 
3620  // a) Book profile to hold all flags for bootstrap;
3621  TString bootstrapFlagsName = "fBootstrapFlags";
3622  bootstrapFlagsName += fAnalysisLabel->Data();
3623  fBootstrapFlags = new TProfile(bootstrapFlagsName.Data(),"Flags for bootstrap",3,0,3);
3624  fBootstrapFlags->SetTickLength(-0.01,"Y");
3625  fBootstrapFlags->SetMarkerStyle(25);
3626  fBootstrapFlags->SetLabelSize(0.04);
3627  fBootstrapFlags->SetLabelOffset(0.02,"Y");
3628  fBootstrapFlags->SetStats(kFALSE);
3629  fBootstrapFlags->GetXaxis()->SetBinLabel(1,"fUseBootstrap");
3630  fBootstrapFlags->GetXaxis()->SetBinLabel(2,"fUseBootstrapVsM");
3631  fBootstrapFlags->GetXaxis()->SetBinLabel(3,"fnSubsamples");
3633 
3634  // c) Book all bootstrap objects:
3635  TString correlationFlag[4] = {"#LT#LT2#GT#GT","#LT#LT4#GT#GT","#LT#LT6#GT#GT","#LT#LT8#GT#GT"};
3636  TString cumulantFlag[4] = {"QC{2}","QC{4}","QC{6}","QC{8}"};
3637  if(fUseBootstrap)
3638  {
3639  // ....
3640  TString bootstrapCorrelationsName = "fBootstrapCorrelations";
3641  bootstrapCorrelationsName += fAnalysisLabel->Data();
3642  fBootstrapCorrelations = new TProfile2D(bootstrapCorrelationsName.Data(),"Bootstrap Correlations",4,0.,4.,fnSubsamples,0,fnSubsamples); // x-axis => <2>, <4>, <6>, <8>; y-axis => subsample #
3643  fBootstrapCorrelations->SetStats(kFALSE);
3644  for(Int_t ci=0;ci<4;ci++) // correlation index
3645  {
3646  fBootstrapCorrelations->GetXaxis()->SetBinLabel(ci+1,correlationFlag[ci].Data());
3647  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3648  for(Int_t ss=0;ss<fnSubsamples;ss++)
3649  {
3650  fBootstrapCorrelations->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3651  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3653  // ....
3654  TString bootstrapCumulantsName = "fBootstrapCumulants";
3655  bootstrapCumulantsName += fAnalysisLabel->Data();
3656  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 #
3657  fBootstrapCumulants->SetStats(kFALSE);
3658  for(Int_t co=0;co<4;co++) // cumulant order
3659  {
3660  fBootstrapCumulants->GetXaxis()->SetBinLabel(co+1,cumulantFlag[co].Data());
3661  } // end of for(Int_t co=0;co<4;co++) // cumulant order
3662  for(Int_t ss=0;ss<fnSubsamples;ss++)
3663  {
3664  fBootstrapCumulants->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3665  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3667  } // end of if(fUseBootstrap)
3668 
3669  // d) Book all bootstrap objects 'vs M':
3670  TString sMultiplicity = "";
3672  {
3673  sMultiplicity = "# RPs";
3675  {
3676  sMultiplicity = "Reference multiplicity (from ESD)";
3678  {
3679  sMultiplicity = "# POIs";
3680  }
3681  if(fUseBootstrapVsM)
3682  {
3683  // ....
3684  TString bootstrapCorrelationsVsMName = "fBootstrapCorrelationsVsM";
3685  bootstrapCorrelationsVsMName += fAnalysisLabel->Data();
3686  for(Int_t ci=0;ci<4;ci++) // correlation index
3687  {
3688  fBootstrapCorrelationsVsM[ci] = new TProfile2D(Form("%s, %s",bootstrapCorrelationsVsMName.Data(),correlationFlag[ci].Data()),
3689  Form("Bootstrap Correlations Vs. M, %s",correlationFlag[ci].Data()),
3690  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3691  fBootstrapCorrelationsVsM[ci]->SetStats(kFALSE);
3692  fBootstrapCorrelationsVsM[ci]->GetXaxis()->SetTitle(sMultiplicity.Data());
3693  for(Int_t ss=0;ss<fnSubsamples;ss++)
3694  {
3695  fBootstrapCorrelationsVsM[ci]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3696  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3698  } // end of for(Int_t ci=0;ci<4;ci++) // correlation index
3699  // ....
3700  TString bootstrapCumulantsVsMName = "fBootstrapCumulantsVsM";
3701  bootstrapCumulantsVsMName += fAnalysisLabel->Data();
3702  for(Int_t co=0;co<4;co++) // cumulant order
3703  {
3704  fBootstrapCumulantsVsM[co] = new TH2D(Form("%s, %s",bootstrapCumulantsVsMName.Data(),cumulantFlag[co].Data()),
3705  Form("Bootstrap Cumulants Vs. M, %s",cumulantFlag[co].Data()),
3706  fnBinsMult,fMinMult,fMaxMult,fnSubsamples,0,fnSubsamples); // index => <2>, <4>, <6>, <8>; x-axis => multiplicity; y-axis => subsample #
3707  fBootstrapCumulantsVsM[co]->SetStats(kFALSE);
3708  fBootstrapCumulantsVsM[co]->GetXaxis()->SetTitle(sMultiplicity.Data());
3709  for(Int_t ss=0;ss<fnSubsamples;ss++)
3710  {
3711  fBootstrapCumulantsVsM[co]->GetYaxis()->SetBinLabel(ss+1,Form("#%d",ss));
3712  } // end of for(Int_t ss=0;ss<fnSubsamples;ss++)
3714  } // end of for(Int_t co=0;co<4;co++) // correlation index
3715  } // end of if(fUseBootstrapVsM)
3716 
3717 } // end of void AliFlowAnalysisCRC::BookEverythingForBootstrap()
3718 
3719 //=======================================================================================================================
3720 
3722 {
3723  // Book all objects for mixed harmonics.
3724 
3725  // a) Book profile to hold all flags for mixed harmonics;
3726  // b) Book all objects in TList fMixedHarmonicsProfiles;
3727  // c) Book all objects in TList fMixedHarmonicsResults;
3728  // d) Book all objects in TList fMixedHarmonicsErrorPropagation.
3729 
3730  // a) Book profile to hold all flags for mixed harmonics:
3731  TString mixedHarmonicsFlagsName = "fMixedHarmonicsFlags";
3732  mixedHarmonicsFlagsName += fAnalysisLabel->Data();
3733  fMixedHarmonicsFlags = new TProfile(mixedHarmonicsFlagsName.Data(),"Flags for Mixed Harmonics",4,0,4);
3734  fMixedHarmonicsFlags->SetTickLength(-0.01,"Y");
3735  fMixedHarmonicsFlags->SetMarkerStyle(25);
3736  fMixedHarmonicsFlags->SetLabelSize(0.04);
3737  fMixedHarmonicsFlags->SetLabelOffset(0.02,"Y");
3738  fMixedHarmonicsFlags->SetStats(kFALSE);
3739  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(1,"Calculate Mixed Harmonics");
3740  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(2,"Generic Harmonic");
3741  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(3,"Calculate vs Multiplicity");
3742  fMixedHarmonicsFlags->GetXaxis()->SetBinLabel(4,"Multiplicity Weight");
3744 
3745  if(!fCalculateMixedHarmonics){return;}
3746 
3747  // b) Book all objects in TList fMixedHarmonicsProfiles:
3748  // b1) 2-p correlations:
3749  TString s2pCorrelationsName = "f2pCorrelations";
3750  s2pCorrelationsName += fAnalysisLabel->Data();
3751  f2pCorrelations = new TProfile(s2pCorrelationsName.Data(),Form("2-particle correlations (n = %d)",fHarmonic),6,0,6,"s");
3752  f2pCorrelations->SetTickLength(-0.01,"Y");
3753  f2pCorrelations->SetMarkerStyle(25);
3754  f2pCorrelations->SetLabelSize(0.04);
3755  f2pCorrelations->SetLabelOffset(0.02,"Y");
3756  f2pCorrelations->SetStats(kFALSE);
3757  f2pCorrelations->Sumw2();
3758  f2pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
3759  f2pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
3760  f2pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
3761  f2pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
3762  f2pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
3763  f2pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT2#GT#GT_{%dn|%dn}",6*fHarmonic,6*fHarmonic));
3765  // b2) 3-p correlations (3+6):
3766  TString s3pCorrelationsName = "f3pCorrelations";
3767  s3pCorrelationsName += fAnalysisLabel->Data();
3768  f3pCorrelations = new TProfile(s3pCorrelationsName.Data(),Form("3-particle correlations (n = %d)",fHarmonic),10,0,10,"s");
3769  f3pCorrelations->SetTickLength(-0.01,"Y");
3770  f3pCorrelations->SetMarkerStyle(25);
3771  f3pCorrelations->SetLabelSize(0.04);
3772  f3pCorrelations->SetLabelOffset(0.02,"Y");
3773  f3pCorrelations->SetStats(kFALSE);
3774  f3pCorrelations->Sumw2();
3775  // 3-p correlations sensitive to two distinct harmonics (3):
3776  f3pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic));
3777  f3pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic));
3778  f3pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic));
3779  f3pCorrelations->GetXaxis()->SetBinLabel(4,""); // empty
3780  // 3-p correlations sensitive to three distinct harmonics (6):
3781  f3pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,1*fHarmonic));
3782  f3pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,1*fHarmonic));
3783  f3pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,2*fHarmonic));
3784  f3pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,1*fHarmonic));
3785  f3pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,2*fHarmonic));
3786  f3pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT3#GT#GT_{%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,1*fHarmonic));
3788  // b3) 4-p correlations (6+15+2+10+8):
3789  TString s4pCorrelationsName = "f4pCorrelations";
3790  s4pCorrelationsName += fAnalysisLabel->Data();
3791  f4pCorrelations = new TProfile(s4pCorrelationsName.Data(),Form("4-particle correlations (n = %d)",fHarmonic),45,0,45,"s");
3792  f4pCorrelations->SetTickLength(-0.01,"Y");
3793  f4pCorrelations->SetMarkerStyle(25);
3794  f4pCorrelations->SetLabelSize(0.03);
3795  f4pCorrelations->SetLabelOffset(0.02,"Y");
3796  f4pCorrelations->SetStats(kFALSE);
3797  f4pCorrelations->Sumw2();
3798  // "same harmonic" (6):
3799  f4pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3800  f4pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3801  f4pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3802  f4pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3803  f4pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic));
3804  f4pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,6*fHarmonic));
3805  f4pCorrelations->GetXaxis()->SetBinLabel(7,""); // empty
3806  // "standard candles" (15):
3807  f4pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",2*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic));
3808  f4pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic));
3809  f4pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic));
3810  f4pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic));
3811  f4pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic));
3812  f4pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic));
3813  f4pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic));
3814  f4pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic));
3815  f4pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic));
3816  f4pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic));
3817  f4pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,6*fHarmonic,1*fHarmonic));
3818  f4pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,2*fHarmonic));
3819  f4pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,3*fHarmonic));
3820  f4pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,4*fHarmonic));
3821  f4pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,5*fHarmonic));
3822  f4pCorrelations->GetXaxis()->SetBinLabel(23,""); // empty
3823  // 4-p correlations sensitive to two distinct harmonics (2):
3824  f4pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3825  f4pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3826  f4pCorrelations->GetXaxis()->SetBinLabel(26,""); // empty
3827  // 4-p correlations sensitive to three distinct harmonics (10):
3828  f4pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic));
3829  f4pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3830  f4pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic));
3831  f4pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3832  f4pCorrelations->GetXaxis()->SetBinLabel(31,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3833  f4pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3834  f4pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic));
3835  f4pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3836  f4pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,4*fHarmonic));
3837  f4pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,5*fHarmonic));
3838  f4pCorrelations->GetXaxis()->SetBinLabel(37,""); // empty
3839  // 4-p correlations sensitive to four distinct harmonics (8):
3840  f4pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic));
3841  f4pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic));
3842  f4pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic));
3843  f4pCorrelations->GetXaxis()->SetBinLabel(41,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3844  f4pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,2*fHarmonic));
3845  f4pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT4#GT#GT_{%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3846  f4pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,3*fHarmonic));
3847  f4pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT4#GT#GT_{%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,4*fHarmonic));
3849  // b3) 5-p correlations (30+9+30+11+3):
3850  TString s5pCorrelationsName = "f5pCorrelations";
3851  s5pCorrelationsName += fAnalysisLabel->Data();
3852  f5pCorrelations = new TProfile(s5pCorrelationsName.Data(),Form("5-particle correlations (n = %d)",fHarmonic),87,0,87,"s");
3853  f5pCorrelations->SetTickLength(-0.01,"Y");
3854  f5pCorrelations->SetMarkerStyle(25);
3855  f5pCorrelations->SetLabelSize(0.02);
3856  f5pCorrelations->SetLabelOffset(0.02,"Y");
3857  f5pCorrelations->SetStats(kFALSE);
3858  f5pCorrelations->Sumw2();
3859  // "standard candles" (30):
3860  f5pCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3861  f5pCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3862  f5pCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3863  f5pCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3864  f5pCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3865  f5pCorrelations->GetXaxis()->SetBinLabel(6,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3866  f5pCorrelations->GetXaxis()->SetBinLabel(7,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3867  f5pCorrelations->GetXaxis()->SetBinLabel(8,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3868  f5pCorrelations->GetXaxis()->SetBinLabel(9,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3869  f5pCorrelations->GetXaxis()->SetBinLabel(10,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3870  f5pCorrelations->GetXaxis()->SetBinLabel(11,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3871  f5pCorrelations->GetXaxis()->SetBinLabel(12,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3872  f5pCorrelations->GetXaxis()->SetBinLabel(13,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3873  f5pCorrelations->GetXaxis()->SetBinLabel(14,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3874  f5pCorrelations->GetXaxis()->SetBinLabel(15,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3875  f5pCorrelations->GetXaxis()->SetBinLabel(16,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3876  f5pCorrelations->GetXaxis()->SetBinLabel(17,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,4*fHarmonic,2*fHarmonic,1*fHarmonic));
3877  f5pCorrelations->GetXaxis()->SetBinLabel(18,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,3*fHarmonic,2*fHarmonic));
3878  f5pCorrelations->GetXaxis()->SetBinLabel(19,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3879  f5pCorrelations->GetXaxis()->SetBinLabel(20,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,5*fHarmonic,2*fHarmonic,1*fHarmonic));
3880  f5pCorrelations->GetXaxis()->SetBinLabel(21,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,3*fHarmonic,1*fHarmonic));
3881  f5pCorrelations->GetXaxis()->SetBinLabel(22,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3882  f5pCorrelations->GetXaxis()->SetBinLabel(23,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,3*fHarmonic));
3883  f5pCorrelations->GetXaxis()->SetBinLabel(24,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,6*fHarmonic,1*fHarmonic,1*fHarmonic));
3884  f5pCorrelations->GetXaxis()->SetBinLabel(25,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,6*fHarmonic,2*fHarmonic,1*fHarmonic));
3885  f5pCorrelations->GetXaxis()->SetBinLabel(26,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,2*fHarmonic,2*fHarmonic));
3886  f5pCorrelations->GetXaxis()->SetBinLabel(27,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,6*fHarmonic,3*fHarmonic,1*fHarmonic));
3887  f5pCorrelations->GetXaxis()->SetBinLabel(28,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,2*fHarmonic));
3888  f5pCorrelations->GetXaxis()->SetBinLabel(29,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,3*fHarmonic,2*fHarmonic));
3889  f5pCorrelations->GetXaxis()->SetBinLabel(30,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,6*fHarmonic,4*fHarmonic,1*fHarmonic));
3890  f5pCorrelations->GetXaxis()->SetBinLabel(31,""); // empty
3891  // 5-p correlations sensitive to two distinct harmonics (9):
3892  f5pCorrelations->GetXaxis()->SetBinLabel(32,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3893  f5pCorrelations->GetXaxis()->SetBinLabel(33,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3894  f5pCorrelations->GetXaxis()->SetBinLabel(34,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3895  f5pCorrelations->GetXaxis()->SetBinLabel(35,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3896  f5pCorrelations->GetXaxis()->SetBinLabel(36,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3897  f5pCorrelations->GetXaxis()->SetBinLabel(37,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3898  f5pCorrelations->GetXaxis()->SetBinLabel(38,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3899  f5pCorrelations->GetXaxis()->SetBinLabel(39,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic));
3900  f5pCorrelations->GetXaxis()->SetBinLabel(40,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,3*fHarmonic,3*fHarmonic));
3901  f5pCorrelations->GetXaxis()->SetBinLabel(41,""); // empty
3902  // 5-p correlations sensitive to three distinct harmonics (30):
3903  f5pCorrelations->GetXaxis()->SetBinLabel(42,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,1*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3904  f5pCorrelations->GetXaxis()->SetBinLabel(43,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic));
3905  f5pCorrelations->GetXaxis()->SetBinLabel(44,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic,1*fHarmonic));
3906  f5pCorrelations->GetXaxis()->SetBinLabel(45,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,1*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic));
3907  f5pCorrelations->GetXaxis()->SetBinLabel(46,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",4*fHarmonic,1*fHarmonic,1*fHarmonic,3*fHarmonic,3*fHarmonic));
3908  f5pCorrelations->GetXaxis()->SetBinLabel(47,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3909  f5pCorrelations->GetXaxis()->SetBinLabel(48,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3910  f5pCorrelations->GetXaxis()->SetBinLabel(49,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",4*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3911  f5pCorrelations->GetXaxis()->SetBinLabel(50,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3912  f5pCorrelations->GetXaxis()->SetBinLabel(51,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,2*fHarmonic,2*fHarmonic,2*fHarmonic));
3913  f5pCorrelations->GetXaxis()->SetBinLabel(52,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3914  f5pCorrelations->GetXaxis()->SetBinLabel(53,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic,2*fHarmonic));
3915  f5pCorrelations->GetXaxis()->SetBinLabel(54,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,1*fHarmonic,4*fHarmonic,1*fHarmonic,1*fHarmonic));
3916  f5pCorrelations->GetXaxis()->SetBinLabel(55,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic,3*fHarmonic));
3917  f5pCorrelations->GetXaxis()->SetBinLabel(56,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3918  f5pCorrelations->GetXaxis()->SetBinLabel(57,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic,3*fHarmonic));
3919  f5pCorrelations->GetXaxis()->SetBinLabel(58,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3920  f5pCorrelations->GetXaxis()->SetBinLabel(59,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3921  f5pCorrelations->GetXaxis()->SetBinLabel(60,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,5*fHarmonic,5*fHarmonic,4*fHarmonic,1*fHarmonic));
3922  f5pCorrelations->GetXaxis()->SetBinLabel(61,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,1*fHarmonic,1*fHarmonic));
3923  f5pCorrelations->GetXaxis()->SetBinLabel(62,Form("#LT#LT5#GT#GT_{%dn|%dn,%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,1*fHarmonic,1*fHarmonic));
3924  f5pCorrelations->GetXaxis()->SetBinLabel(63,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3925  f5pCorrelations->GetXaxis()->SetBinLabel(64,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,5*fHarmonic,1*fHarmonic,1*fHarmonic));
3926  f5pCorrelations->GetXaxis()->SetBinLabel(65,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3927  f5pCorrelations->GetXaxis()->SetBinLabel(66,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,4*fHarmonic,4*fHarmonic,2*fHarmonic));
3928  f5pCorrelations->GetXaxis()->SetBinLabel(67,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,2*fHarmonic,5*fHarmonic,5*fHarmonic));
3929  f5pCorrelations->GetXaxis()->SetBinLabel(68,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,5*fHarmonic,5*fHarmonic,1*fHarmonic));
3930  f5pCorrelations->GetXaxis()->SetBinLabel(69,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,5*fHarmonic,2*fHarmonic));
3931  f5pCorrelations->GetXaxis()->SetBinLabel(70,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,4*fHarmonic,2*fHarmonic));
3932  f5pCorrelations->GetXaxis()->SetBinLabel(71,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,6*fHarmonic,5*fHarmonic,1*fHarmonic));
3933  f5pCorrelations->GetXaxis()->SetBinLabel(72,""); // empty
3934  // 5-p correlations sensitive to four distinct harmonics (11):
3935  f5pCorrelations->GetXaxis()->SetBinLabel(73,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,2*fHarmonic,3*fHarmonic,3*fHarmonic,1*fHarmonic));
3936  f5pCorrelations->GetXaxis()->SetBinLabel(74,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,1*fHarmonic,1*fHarmonic,4*fHarmonic,3*fHarmonic));
3937  f5pCorrelations->GetXaxis()->SetBinLabel(75,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",5*fHarmonic,3*fHarmonic,4*fHarmonic,2*fHarmonic,2*fHarmonic));
3938  f5pCorrelations->GetXaxis()->SetBinLabel(76,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",5*fHarmonic,2*fHarmonic,1*fHarmonic,4*fHarmonic,4*fHarmonic));
3939  f5pCorrelations->GetXaxis()->SetBinLabel(77,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,1*fHarmonic,3*fHarmonic,2*fHarmonic,2*fHarmonic));
3940  f5pCorrelations->GetXaxis()->SetBinLabel(78,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,4*fHarmonic,4*fHarmonic,1*fHarmonic));
3941  f5pCorrelations->GetXaxis()->SetBinLabel(79,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,1*fHarmonic,1*fHarmonic,5*fHarmonic,3*fHarmonic));
3942  f5pCorrelations->GetXaxis()->SetBinLabel(80,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,3*fHarmonic,5*fHarmonic,2*fHarmonic,2*fHarmonic));
3943  f5pCorrelations->GetXaxis()->SetBinLabel(81,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,5*fHarmonic,4*fHarmonic,4*fHarmonic,3*fHarmonic));
3944  f5pCorrelations->GetXaxis()->SetBinLabel(82,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,3*fHarmonic,1*fHarmonic,5*fHarmonic,5*fHarmonic));
3945  f5pCorrelations->GetXaxis()->SetBinLabel(83,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,6*fHarmonic,5*fHarmonic,4*fHarmonic,3*fHarmonic));
3946  f5pCorrelations->GetXaxis()->SetBinLabel(84,""); // empty
3947  // 5-p correlations sensitive to five distinct harmonics (3):
3948  f5pCorrelations->GetXaxis()->SetBinLabel(85,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,2*fHarmonic,4*fHarmonic,3*fHarmonic,1*fHarmonic));
3949  f5pCorrelations->GetXaxis()->SetBinLabel(86,Form("#LT#LT5#GT#GT_{%dn,%dn,%dn|%dn,%dn}",6*fHarmonic,2*fHarmonic,1*fHarmonic,5*fHarmonic,4*fHarmonic));
3950  f5pCorrelations->GetXaxis()->SetBinLabel(87,Form("#LT#LT5#GT#GT_{%dn,%dn|%dn,%dn,%dn}",6*fHarmonic,4*fHarmonic,5*fHarmonic,3*fHarmonic,2*fHarmonic));
3952  // b4) 6-p correlations (??+??+??+??+??):
3953  TString s6pCorrelationsName = "f6pCorrelations";
3954  s6pCorrelationsName += fAnalysisLabel->Data();
3955  f6pCorrelations = new TProfile(s6pCorrelationsName.Data(),Form("6-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3956  f6pCorrelations->SetTickLength(-0.01,"Y");
3957  f6pCorrelations->SetMarkerStyle(25);
3958  f6pCorrelations->SetLabelSize(0.02);
3959  f6pCorrelations->SetLabelOffset(0.02,"Y");
3960  f6pCorrelations->SetStats(kFALSE);
3961  f6pCorrelations->Sumw2();
3962  //fMixedHarmonicsProfiles->Add(f6pCorrelations); // TBI
3963  // b5) 7-p correlations (??+??+??+??+??):
3964  TString s7pCorrelationsName = "f7pCorrelations";
3965  s7pCorrelationsName += fAnalysisLabel->Data();
3966  f7pCorrelations = new TProfile(s7pCorrelationsName.Data(),Form("7-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3967  f7pCorrelations->SetTickLength(-0.01,"Y");
3968  f7pCorrelations->SetMarkerStyle(25);
3969  f7pCorrelations->SetLabelSize(0.02);
3970  f7pCorrelations->SetLabelOffset(0.02,"Y");
3971  f7pCorrelations->SetStats(kFALSE);
3972  f7pCorrelations->Sumw2();
3973  //fMixedHarmonicsProfiles->Add(f7pCorrelations); // TBI
3974  // b6) 8-p correlations (??+??+??+??+??):
3975  TString s8pCorrelationsName = "f8pCorrelations";
3976  s8pCorrelationsName += fAnalysisLabel->Data();
3977  f8pCorrelations = new TProfile(s8pCorrelationsName.Data(),Form("8-particle correlations (n = %d)",fHarmonic),1,0.,1.);
3978  f8pCorrelations->SetTickLength(-0.01,"Y");
3979  f8pCorrelations->SetMarkerStyle(25);
3980  f8pCorrelations->SetLabelSize(0.02);
3981  f8pCorrelations->SetLabelOffset(0.02,"Y");
3982  f8pCorrelations->SetStats(kFALSE);
3983  f8pCorrelations->Sumw2();
3984  //fMixedHarmonicsProfiles->Add(f8pCorrelations); // TBI
3985 
3986  // c) Book all objects in TList fMixedHarmonicsResults:
3987  // QC{2}:
3988  f2pCumulants = f2pCorrelations->ProjectionX("f2pCumulants");
3989  f2pCumulants->SetTitle(Form("2-particle cumulants (n = %d)",fHarmonic));
3990  f2pCumulants->SetStats(kFALSE);
3991  f2pCumulants->SetMarkerStyle(kFullSquare);
3992  f2pCumulants->SetMarkerColor(kBlack);
3993  f2pCumulants->SetLineColor(kBlack);
3995  // QC{3}:
3996  f3pCumulants = f3pCorrelations->ProjectionX("f3pCumulants");
3997  f3pCumulants->SetTitle(Form("3-particle cumulants (n = %d)",fHarmonic));
3998  f3pCumulants->SetStats(kFALSE);
3999  f3pCumulants->SetMarkerStyle(kFullSquare);
4000  f3pCumulants->SetMarkerColor(kGreen+2);
4001  f3pCumulants->SetLineColor(kGreen+2);
4003  // QC{4}:
4004  f4pCumulants = f4pCorrelations->ProjectionX("f4pCumulants");
4005  f4pCumulants->SetTitle(Form("4-particle cumulants (n = %d)",fHarmonic));
4006  f4pCumulants->SetStats(kFALSE);
4007  f4pCumulants->SetMarkerStyle(kFullSquare);
4008  f4pCumulants->SetMarkerColor(kRed);
4009  f4pCumulants->SetLineColor(kRed);
4011  // QC{5}:
4012  f5pCumulants = f5pCorrelations->ProjectionX("f5pCumulants");
4013  f5pCumulants->SetTitle(Form("5-particle cumulants (n = %d)",fHarmonic));
4014  f5pCumulants->SetStats(kFALSE);
4015  f5pCumulants->SetMarkerStyle(kFullSquare);
4016  f5pCumulants->SetMarkerColor(kBlue);
4017  f5pCumulants->SetLineColor(kBlue);
4019 
4020  // d) Book all objects in TList fMixedHarmonicsErrorPropagation:
4021  // Sum of linear and quadratic event weights for mixed harmonics => [0=linear 1,1=quadratic]:
4022  TString mixedHarmonicEventWeightsName = "fMixedHarmonicEventWeights";
4023  mixedHarmonicEventWeightsName += fAnalysisLabel->Data();
4024  TString powerFlag[2] = {"linear","quadratic"};
4025  for(Int_t power=0;power<2;power++)
4026  {
4027  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.);
4028  fMixedHarmonicEventWeights[power]->SetLabelSize(0.04);
4029  fMixedHarmonicEventWeights[power]->SetMarkerStyle(25);
4030  fMixedHarmonicEventWeights[power]->SetStats(kFALSE);
4031  if(power == 0)
4032  {
4033  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}");
4034  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}");
4035  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}");
4036  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}");
4037  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}");
4038  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}");
4039  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}");
4040  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}");
4041  } else if (power == 1)
4042  {
4043  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum w_{#LT1#GT}^{2}");
4044  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum w_{#LT2#GT}^{2}");
4045  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum w_{#LT3#GT}^{2}");
4046  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum w_{#LT4#GT}^{2}");
4047  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(5,"#sum w_{#LT5#GT}^{2}");
4048  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(6,"#sum w_{#LT6#GT}^{2}");
4049  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(7,"#sum w_{#LT7#GT}^{2}");
4050  (fMixedHarmonicEventWeights[power]->GetXaxis())->SetBinLabel(8,"#sum w_{#LT8#GT}^{2}");
4051  }
4053  } // end of for(Int_t power=0;power<2;power++)
4054 
4055  // Sums of products of event weights for mixed harmonics:
4056  TString mixedHarmonicProductOfEventWeightsName = "fMixedHarmonicProductOfEventWeights";
4057  mixedHarmonicProductOfEventWeightsName += fAnalysisLabel->Data();
4058  fMixedHarmonicProductOfEventWeights = new TH2D(mixedHarmonicProductOfEventWeightsName.Data(),"Sums of products of event weights",8,0.,8.,8,0.,8.);
4059  fMixedHarmonicProductOfEventWeights->SetStats(kFALSE);
4060  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetLabelSize(0.05);
4061  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetLabelSize(0.05);
4062  for(Int_t b=1;b<=8;b++)
4063  {
4064  fMixedHarmonicProductOfEventWeights->GetXaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
4065  fMixedHarmonicProductOfEventWeights->GetYaxis()->SetBinLabel(b,Form("w_{#LT%i#GT}",b));
4066  }
4068 
4069  // Averages of products of mixed harmonics correlations:
4070  TString mixedHarmonicProductOfCorrelationsName = "fMixedHarmonicProductOfCorrelations";
4071  mixedHarmonicProductOfCorrelationsName += fAnalysisLabel->Data();
4072  fMixedHarmonicProductOfCorrelations = new TProfile2D(mixedHarmonicProductOfCorrelationsName.Data(),"Averages of products of mixed correlators",139,0.,139.,139,0.,139.);
4074  fMixedHarmonicProductOfCorrelations->SetStats(kFALSE);
4075  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetLabelSize(0.015);
4076  fMixedHarmonicProductOfCorrelations->GetYaxis()->SetLabelSize(0.015);
4077  // x-axis:
4078  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(1,Form("#LT#LT2#GT#GT_{%dn|%dn}",1*fHarmonic,1*fHarmonic));
4079  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(2,Form("#LT#LT2#GT#GT_{%dn|%dn}",2*fHarmonic,2*fHarmonic));
4080  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(3,Form("#LT#LT2#GT#GT_{%dn|%dn}",3*fHarmonic,3*fHarmonic));
4081  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(4,Form("#LT#LT2#GT#GT_{%dn|%dn}",4*fHarmonic,4*fHarmonic));
4082  fMixedHarmonicProductOfCorrelations->GetXaxis()->SetBinLabel(5,Form("#LT#LT2#GT#GT_{%dn|%dn}",5*fHarmonic,5*fHarmonic));
4083