AliPhysics  6f1d526 (6f1d526)
 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 fCentralityEBE(0.),
156 fNewCentralityEBE(0.),
157 fZDCESEclEbE(0),
158 fNewMetricLEBE(0.),
159 fNewMetricDEBE(0.),
160 fNewMetricL2EBE(0.),
161 fNewMetricD2EBE(0.),
162 fCentralityCL1EBE(0.),
163 fNITSCL1EBE(0.),
164 fCentralityTRKEBE(0.),
165 fZNCen(0.),
166 fZNAen(0.),
167 fEnNucl(1.),
168 fAvMultiplicity(NULL),
169 fIntFlowCorrelationsPro(NULL),
170 fIntFlowSquaredCorrelationsPro(NULL),
171 fIntFlowCorrelationsAllPro(NULL),
172 fIntFlowExtraCorrelationsPro(NULL),
173 fIntFlowProductOfCorrelationsPro(NULL),
174 fIntFlowProductOfCorrectionTermsForNUAPro(NULL),
175 fIntFlowCorrelationsHist(NULL),
176 fIntFlowCorrelationsAllHist(NULL),
177 fIntFlowCovariances(NULL),
178 fIntFlowSumOfProductOfEventWeights(NULL),
179 fIntFlowCovariancesNUA(NULL),
180 fIntFlowSumOfProductOfEventWeightsNUA(NULL),
181 fIntFlowQcumulants(NULL),
182 fIntFlowQcumulantsRebinnedInM(NULL),
183 fIntFlowQcumulantsErrorSquaredRatio(NULL),
184 fIntFlow(NULL),
185 fIntFlowRebinnedInM(NULL),
186 fIntFlowDetectorBias(NULL),
187 // 4.) differential flow:
188 fDiffFlowList(NULL),
189 fDiffFlowProfiles(NULL),
190 fDiffFlowResults(NULL),
191 fDiffFlow2D(NULL),
192 fDiffFlowFlags(NULL),
193 fCalculateDiffFlow(kTRUE),
194 fCalculate2DDiffFlow(kFALSE),
195 fCalculateDiffFlowVsEta(kTRUE),
196 // 5.) other differential correlators:
197 fOtherDiffCorrelatorsList(NULL),
198 // 6.) distributions:
199 fDistributionsList(NULL),
200 fDistributionsFlags(NULL),
201 fStoreDistributions(kFALSE),
202 fnBinsForCorrelations(10000),
203 // 8.) debugging and cross-checking:
204 fNestedLoopsList(NULL),
205 fEvaluateIntFlowNestedLoops(kFALSE),
206 fEvaluateDiffFlowNestedLoops(kFALSE),
207 fMaxAllowedMultiplicity(10),
208 fEvaluateNestedLoops(NULL),
209 fIntFlowDirectCorrelations(NULL),
210 fIntFlowExtraDirectCorrelations(NULL),
211 fCrossCheckInPtBinNo(10),
212 fCrossCheckInEtaBinNo(20),
213 fNoOfParticlesInBin(NULL),
214 fMixedHarmonicsNestedLoops(NULL),
215 // 9.) mixed harmonics:
216 fMixedHarmonicsList(NULL),
217 fMixedHarmonicsProfiles(NULL),
218 fMixedHarmonicsResults(NULL),
219 fMixedHarmonicsErrorPropagation(NULL),
220 fMixedHarmonicsFlags(NULL),
221 fCalculateMixedHarmonics(kFALSE),
222 fCalculateMixedHarmonicsVsM(kFALSE),
223 f2pCorrelations(NULL),
224 f3pCorrelations(NULL),
225 f4pCorrelations(NULL),
226 f5pCorrelations(NULL),
227 f6pCorrelations(NULL),
228 f7pCorrelations(NULL),
229 f8pCorrelations(NULL),
230 f2pCumulants(NULL),
231 f3pCumulants(NULL),
232 f4pCumulants(NULL),
233 f5pCumulants(NULL),
234 f6pCumulants(NULL),
235 f7pCumulants(NULL),
236 f8pCumulants(NULL),
237 fMixedHarmonicProductOfEventWeights(NULL),
238 fMixedHarmonicProductOfCorrelations(NULL),
239 // 10.) Control histograms:
240 fControlHistogramsList(NULL),
241 fControlHistogramsFlags(NULL),
242 fStoreControlHistograms(kFALSE),
243 fCorrelationNoRPsVsRefMult(NULL),
244 fCorrelationNoPOIsVsRefMult(NULL),
245 fCorrelationNoRPsVsNoPOIs(NULL),
246 // 11.) Bootstrap:
247 fBootstrapList(NULL),
248 fBootstrapProfilesList(NULL),
249 fBootstrapResultsList(NULL),
250 fBootstrapFlags(NULL),
251 fUseBootstrap(kFALSE),
252 fUseBootstrapVsM(kFALSE),
253 fnSubsamples(10),
254 fRandom(NULL),
255 fBootstrapCorrelations(NULL),
256 fBootstrapCumulants(NULL),
257 // 12.) Charge-Eta Asymmetry:
258 fCRCList(NULL),
259 fTempList(NULL),
260 fCRCFlags(NULL),
261 fCalculateCRC(kTRUE),
262 fCalculateCRCPt(kFALSE),
263 fCalculateCME(kFALSE),
264 fCalculateCRCInt(kFALSE),
265 fCalculateCRC2(kFALSE),
266 fCalculateCRCVZ(kFALSE),
267 fCalculateCRCZDC(kFALSE),
268 fCalculateFlowQC(kFALSE),
269 fCalculateFlowZDC(kFALSE),
270 fCalculateFlowVZ(kFALSE),
271 fCalculateEbEFlow(kFALSE),
272 fStoreZDCQVecVtxPos(kFALSE),
273 fUsePhiEtaCuts(kFALSE),
274 fUseVZERO(kFALSE),
275 fUseZDC(kFALSE),
276 fRecenterZDC(kFALSE),
277 fNUAforCRC(kFALSE),
278 fUseCRCRecenter(kFALSE),
279 fDivSigma(kTRUE),
280 fInvertZDC(kFALSE),
281 fCRCTestSin(kFALSE),
282 fVtxRbR(kFALSE),
283 fCRCEtaMin(0.),
284 fCRCEtaMax(0.),
285 fRunNum(0),
286 fCachedRunNum(0),
287 fRunBin(0),
288 fCenBin(0),
289 fCorrWeightTPC(kUnit),
290 fCorrWeightVZ(kUnit),
291 fCorrWeightZDC(kUnit),
292 fCRCIntList(NULL),
293 fCRCnCen(nCen),
294 fCRCCenBinWidth(CenWidth),
295 fCRCIntRbRList(NULL),
296 fCRCnRun(211),
297 fDataSet(kAny),
298 fInteractionRate(kAll),
299 fSelectCharge(kAllCh),
300 fPOIExtraWeights(kNone),
301 fCRCQVecList(NULL),
302 fCRCQVecListTPC(NULL),
303 fCRCQVecWeightsList(NULL),
304 fCRCZDCCalibList(NULL),
305 fCRCVZEROCalibList(NULL),
306 fCRCZDCResList(NULL),
307 fZDCESEList(NULL),
308 fCRCVZList(NULL),
309 fCRCZDCList(NULL),
310 fCRCZDCRbRList(NULL),
311 fCRCPtList(NULL),
312 fCMEList(NULL),
313 fCMETPCList(NULL),
314 fCMEZDCList(NULL),
315 fCRC2List(NULL),
316 fCRC2nEtaBins(6),
317 fFlowSPZDCList(NULL),
318 fFlowQCList(NULL),
319 //fFlowQCOrdMagList(NULL),
320 fFlowQCHOList(NULL),
321 fFlowQCCenBin(100),
322 fFlowQCDeltaEta(0.4),
323 fFlowSPVZList(NULL),
324 fVariousList(NULL),
325 fEbEFlowList(NULL),
326 fCenWeightEbE(0.),
327 fQAZDCCuts(kFALSE),
328 fQAZDCCutsFlag(kTRUE),
329 fMinMulZN(0),
330 fMaxDevZN(5.),
331 fZDCGainAlpha(0.395),
332 fbFlagIsPosMagField(kFALSE)
333 {
334  // constructor
335 
336  // base list to hold all output objects:
337  fHistList = new TList();
338  fHistList->SetName("cobjQC");
339  fHistList->SetOwner(kTRUE);
340 
341  // base list to hold all temp objects:
342  fTempList = new TList();
343  fTempList->SetName("temp");
344  fTempList->SetOwner(kTRUE);
345 
346  // multiplicity weight:
347  fMultiplicityWeight = new TString("combinations");
348 
349  // analysis label;
350  fAnalysisLabel = new TString();
351 
352  // initialize all arrays:
353  this->InitializeArraysForIntFlow();
354  this->InitializeArraysForDiffFlow();
355  this->InitializeArraysForDistributions();
356  this->InitializeArraysForVarious();
357  this->InitializeArraysForNestedLoops();
358  this->InitializeArraysForMixedHarmonics();
359  this->InitializeArraysForControlHistograms();
360  this->InitializeArraysForBootstrap();
361 
362  fRunList = TArrayI();
363  fAvVtxPosX = TArrayD();
364  fAvVtxPosY = TArrayD();
365  fAvVtxPosZ = TArrayD();
366 
367  // CRC
368  this->InitializeCostantsForCRC();
369  this->InitializeArraysForParticleWeights();
370  this->InitializeArraysForCRC();
371  this->InitializeArraysForCRCVZ();
372  this->InitializeArraysForCRCZDC();
373  this->InitializeArraysForCRC2();
374  this->InitializeArraysForQVec();
375  this->InitializeArraysForCRCPt();
376  this->InitializeArraysForCME();
377  this->InitializeArraysForFlowEbE();
378  this->InitializeArraysForFlowQC();
379  this->InitializeArraysForFlowQCHighOrders();
380  this->InitializeArraysForFlowSPZDC();
381  this->InitializeArraysForFlowSPVZ();
382  this->InitializeArraysForEbEFlow();
383 
384  // printf("Arrays initialized \n");
385 
386 } // end of constructor
387 
388 //================================================================================================================
389 
391 {
392  // destructor
393  delete fHistList;
394  delete fTempList;
398  if(fCRCZDCResList) delete fCRCZDCResList;
399  if(fZDCESEList) delete fZDCESEList;
400  delete[] fCRCPtvarPtBins;
401  delete[] fCRCPtBins;
402  delete[] fZDCEPweightEbE;
403  delete[] fCorrMap;
404  delete[] fchisqVA;
405  delete[] fchisqVC;
407 } // end of AliFlowAnalysisCRC::~AliFlowAnalysisCRC()
408 
409 //================================================================================================================
410 
412 {
413  // a) Cross check if the settings make sense before starting the QC adventure;
414  // b) Access all common constants;
415  // c) Book all objects;
416  // d) Store flags for integrated and differential flow;
417  // e) Store flags for distributions of corelations;
418  // f) Store harmonic which will be estimated;
419  // g) Store flags for mixed harmonics;
420  // h) Store flags for control histograms;
421  // i) Store bootstrap flags.
422 
423  //save old value and prevent histograms from being added to directory
424  //to avoid name clashes in case multiple analaysis objects are used
425  //in an analysis
426  Bool_t oldHistAddStatus = TH1::AddDirectoryStatus();
427  TH1::AddDirectory(kFALSE);
428  fRandom = new TRandom3(0); // if uiSeed is 0, the seed is determined uniquely in space and time via TUUID
429 
430  // a) Cross check if the settings make sense before starting the QC adventure;
431  this->CrossCheckSettings();
432  // b) Access all common constants and book a profile to hold them:
433  this->CommonConstants("Init");
434  // c) Book all objects:
436  this->BookAndNestAllLists();
437  this->BookCommonHistograms();
446  this->SetRunList();
447  if(fCalculateCRC) {
448  this->BookEverythingForCRC();
449  this->BookEverythingForCRCVZ();
450  this->BookEverythingForCRCZDC();
451  this->BookEverythingForCRCPt();
452  this->BookEverythingForCRC2();
453  this->BookEverythingForQVec();
454  this->BookEverythingForCME();
455  this->BookEverythingForFlowEbE();
456  this->BookEverythingForFlowQC();
460  this->BookEverythingForEbEFlow();
461  }
462  this->BookEverythingForVarious();
463 
464  this->SetCentralityWeights();
465 
466  // d) Store flags for integrated and differential flow:
467  this->StoreIntFlowFlags();
468  this->StoreDiffFlowFlags();
469  // e) Store flags for distributions of corelations:
471  // f) Store harmonic which will be estimated:
472  this->StoreHarmonic();
473  // g) Store flags for mixed harmonics:
474  this->StoreMixedHarmonicsFlags();
475  // h) Store flags for control histograms:
477  // i) Store bootstrap flags:
478  this->StoreBootstrapFlags();
479  if(fCalculateCRC) {
480  // j) Store CRC flags:
481  this->StoreCRCFlags();
482  }
483 
484  TH1::AddDirectory(oldHistAddStatus);
485 
486  // printf("Stuff booked \n");
487 
488 } // end of void AliFlowAnalysisCRC::Init()
489 
490 //================================================================================================================
491 
493 {
494  // Running over data only in this method.
495  // a) Check all pointers used in this method;
496  // b) Define local variables;
497  // c) Fill the common control histograms and call the method to fill fAvMultiplicity;
498  // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k};
499  // d.1) initialize particle weights
500  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!);
501  // f) Call the methods which calculate correlations for reference flow;
502  // g) Call the methods which calculate correlations for differential flow;
503  // h) Call the methods which calculate correlations for 2D differential flow;
504  // i) Call the methods which calculate other differential correlators;
505  // j) Distributions of correlations;
506  // k) Store various;
507  // l) Cross-check with nested loops correlators for reference flow;
508  // m) Cross-check with nested loops correlators for differential flow;
509  // n) Reset all event-by-event quantities (very important !!!!).
510 
511  // a) Check all pointers used in this method:
512  this->CheckPointersUsedInMake();
513 
514  // b) Define local variables:
515  Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
516  Double_t dPt = 0.; // transverse momentum
517  Double_t dEta = 0.; // pseudorapidity
518  Double_t wPhi = 1.; // phi weight
519  Double_t wPt = 1.; // pt weight
520  Double_t wEta = 1.; // eta weight
521  Double_t wTrack = 1.; // track weight
522  Double_t wPhiEta = 1.;
523  Double_t wt = 1.;
524  Double_t wProbCut = 1.;
525  Int_t nCounterNoRPs = 0; // needed only for shuffling
526  fNumberOfRPsEBE = anEvent->GetNumberOfRPs(); // number of RPs (i.e. number of reference particles)
527  fNumberOfPOIsEBE = anEvent->GetNumberOfPOIs(); // number of POIs (i.e. number of particles of interest)
528  fReferenceMultiplicityEBE = anEvent->GetReferenceMultiplicity(); // reference multiplicity for current event
529  fCentralityEBE = anEvent->GetCentrality(); // centrality percentile for current event
530  fCentralityCL1EBE = anEvent->GetCentralityCL1(); // centrality percentile for current event (alternative estimation)
531  fCentralityTRKEBE = anEvent->GetCentralityTRK(); // centrality percentile for current event (alternative estimation)
532  fNITSCL1EBE = anEvent->GetNITSCL1();
533 
534  // printf("debug: NoRPs %e, NoPOIs %e, RunNum %d, Cen %e \n",fNumberOfRPsEBE,fNumberOfPOIsEBE,fRunNum,fCentralityEBE);
535 
536  if(fExactNoRPs > 0 && fNumberOfRPsEBE<fExactNoRPs){return;}
537  if(!fCentralityEBE){return;}
538  if(!fNumberOfRPsEBE || !fNumberOfPOIsEBE){return;}
540  if((fDataSet==k2015 || fDataSet==k2015v6) && !MultCut2015o()){return;}
541 
542  // centrality flattening with weights
543  fCenWeightEbE = 1.;
545 
546  // primary vertex position (x,y,z)
547  anEvent->GetVertexPosition(fVtxPos);
548 
549  Double_t ptEta[2] = {0.,0.}; // 0 = dPt, 1 = dEta
550  Int_t dCharge = 0; // charge
551 
552  // d) Loop over data and calculate e-b-e quantities Q_{n,k}, S_{p,k} and s_{p,k}:
553  Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks
554  AliFlowTrackSimple *aftsTrack = NULL;
555  Int_t n = fHarmonic; // shortcut for the harmonic
556 
557  // d.1) Initialize particle weights
558  Int_t cw = 0;
559 
560  if (fDataSet==kAny) {fRunBin = 0;}
561  else {fRunBin = GetCRCRunBin(fRunNum);}
562  if(fRunBin<0 || fRunBin>=fCRCnRun) {return;}
564  if(fCenBin<0 || fCenBin>=fCRCnCen) {return;}
565 
569 
570  // VZERO *********************************************************************************************************
571 
572  if(fUseVZERO) {
573  for(Int_t h=0; h<fCRCnHar; h++) {
574  // Get Q vectors for the subevents
575  AliFlowVector vQarray[2];
576  anEvent->GetV02Qsub(vQarray,h+1);
577  fVZFlowVect[0][h] = vQarray[0];
578  fVZFlowVect[1][h] = vQarray[1];
579  // re-center VZERO Q-vectors
581 
582  // fill Q-vector RbR
583 // if(fCRCVZEROQVec[fRunBin][h]) {
584 // fCRCVZEROQVec[fRunBin][h]->Fill(0.5,fCentralityEBE,fVZFlowVect[0][h].X());
585 // fCRCVZEROQVec[fRunBin][h]->Fill(1.5,fCentralityEBE,fVZFlowVect[0][h].Y());
586 // fCRCVZEROQVec[fRunBin][h]->Fill(2.5,fCentralityEBE,fVZFlowVect[1][h].X());
587 // fCRCVZEROQVec[fRunBin][h]->Fill(3.5,fCentralityEBE,fVZFlowVect[1][h].Y());
588 // fCRCVZEROQVec[fRunBin][h]->Fill(4.5,fCentralityEBE,fVZFlowVect[0][h].X()*fVZFlowVect[1][h].X());
589 // fCRCVZEROQVec[fRunBin][h]->Fill(5.5,fCentralityEBE,fVZFlowVect[0][h].Y()*fVZFlowVect[1][h].Y());
590 // fCRCVZEROQVec[fRunBin][h]->Fill(6.5,fCentralityEBE,fVZFlowVect[0][h].X()*fVZFlowVect[1][h].Y());
591 // fCRCVZEROQVec[fRunBin][h]->Fill(7.5,fCentralityEBE,fVZFlowVect[0][h].Y()*fVZFlowVect[1][h].X());
592 // }
593  } // end of for(Int_t h=0; h<fCRCnHar; h++)
594  } // end of if(fUseVZERO)
595 
596  // ZDC *********************************************************************************************************
597 
598  if(fUseZDC) {
599  // Get Q vectors for the subevents
600  AliFlowVector vQarray[2];
601  anEvent->GetZDC2Qsub(vQarray);
602  fZDCFlowVect[0] = vQarray[0];
603  fZDCFlowVect[1] = vQarray[1];
604  fZNCen = anEvent->GetZNCEnergy()/fEnNucl;
605  fZNAen = anEvent->GetZNAEnergy()/fEnNucl;
606  } // end of if(fUseZDC)
607 
608  this->CalculateCRCQVec();
609 
610  if(fUseZDC) {
611  if(fRecenterZDC) {
612  this->RecenterCRCQVecZDC();
613  } else {
614  // ZDCN-C
615  Double_t QCRe = fZDCFlowVect[0].X();
616  Double_t QCIm = fZDCFlowVect[0].Y();
617  Double_t QMC = fZDCFlowVect[0].GetMult();
618  // ZDCN-A
619  Double_t QARe = fZDCFlowVect[1].X();
620  Double_t QAIm = fZDCFlowVect[1].Y();
621  Double_t QMA = fZDCFlowVect[1].GetMult();
622 
624 
625  // if(fCentralityEBE>5. && fCentralityEBE<60.) {
626  // if(QMC>0. && sqrt(QCRe*QCRe+QCIm*QCIm)>1.E-6) {
627  // fCRCZDCQVecVtxPos[fRunBin][0]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QCRe);
628  // fCRCZDCQVecVtxPos[fRunBin][1]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QCIm);
629  // }
630  // if(QMA>0. && sqrt(QARe*QARe+QAIm*QAIm)>1.E-6) {
631  // fCRCZDCQVecVtxPos[fRunBin][2]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QARe);
632  // fCRCZDCQVecVtxPos[fRunBin][3]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QAIm);
633  // }
634  // }
635  if(fStoreZDCQVecVtxPos) {
636 // if(QMC>0. && sqrt(QCRe*QCRe+QCIm*QCIm)>1.E-6) {
637 // fCRCZDCQVecVtxPosCen[fCenBin][0]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QCRe);
638 // fCRCZDCQVecVtxPosCen[fCenBin][1]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QCIm);
639 // }
640 // if(QMA>0. && sqrt(QARe*QARe+QAIm*QAIm)>1.E-6) {
641 // fCRCZDCQVecVtxPosCen[fCenBin][2]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QARe);
642 // fCRCZDCQVecVtxPosCen[fCenBin][3]->Fill(fVtxPosCor[0],fVtxPosCor[1],fVtxPosCor[2],QAIm);
643 // }
644  }
645  if(QMC>0. && sqrt(QCRe*QCRe+QCIm*QCIm)>1.E-6 && fCentralityEBE>50. && fCentralityEBE<60.) {
646  fCRCZDCQVecCov[fRunBin][0]->Fill(fVtxPosCor[0],QCRe);
647  fCRCZDCQVecCov[fRunBin][1]->Fill(fVtxPosCor[1],QCRe);
648  fCRCZDCQVecCov[fRunBin][2]->Fill(fVtxPosCor[2],QCRe);
649  fCRCZDCQVecCov[fRunBin][3]->Fill(fVtxPosCor[0],QCIm);
650  fCRCZDCQVecCov[fRunBin][4]->Fill(fVtxPosCor[1],QCIm);
651  fCRCZDCQVecCov[fRunBin][5]->Fill(fVtxPosCor[2],QCIm);
652  }
653  if(QMA>0. && sqrt(QARe*QARe+QAIm*QAIm)>1.E-6 && fCentralityEBE>50. && fCentralityEBE<60.) {
654  fCRCZDCQVecCov[fRunBin][6]->Fill(fVtxPosCor[0],QARe);
655  fCRCZDCQVecCov[fRunBin][7]->Fill(fVtxPosCor[1],QARe);
656  fCRCZDCQVecCov[fRunBin][8]->Fill(fVtxPosCor[2],QARe);
657  fCRCZDCQVecCov[fRunBin][9]->Fill(fVtxPosCor[0],QAIm);
658  fCRCZDCQVecCov[fRunBin][10]->Fill(fVtxPosCor[1],QAIm);
659  fCRCZDCQVecCov[fRunBin][11]->Fill(fVtxPosCor[2],QAIm);
660  }
661  if( fInvertZDC ) QARe = -QARe;
662 // if(QMC>0. && sqrt(QCRe*QCRe+QCIm*QCIm)>1.E-6) {
663 // fhZNCenDis[0]->Fill(fCentralityEBE,QCRe,QCIm);
664 // }
665 // if(QMA>0. && sqrt(QARe*QARe+QAIm*QAIm)>1.E-6) {
666 // fhZNCenDis[1]->Fill(fCentralityEBE,QARe,QAIm);
667 // }
668  if(QMC>0. && QMA>0. && sqrt(QCRe*QCRe+QCIm*QCIm)>1.E-6 && sqrt(QARe*QARe+QAIm*QAIm)>1.E-6) {
669  fCRCZDCQVecRes[fRunBin][0]->Fill(fCentralityEBE,QCRe*QARe);
670  fCRCZDCQVecRes[fRunBin][1]->Fill(fCentralityEBE,QCIm*QAIm);
671  fCRCZDCQVecRes[fRunBin][2]->Fill(fCentralityEBE,QCRe*QAIm);
672  fCRCZDCQVecRes[fRunBin][3]->Fill(fCentralityEBE,QCIm*QARe);
673  if(fCentralityEBE>50. && fCentralityEBE<60.) {
674  fCRCZDCQVecCov[fRunBin][12]->Fill(fVtxPosCor[0],QCRe*QARe);
675  fCRCZDCQVecCov[fRunBin][13]->Fill(fVtxPosCor[1],QCRe*QARe);
676  fCRCZDCQVecCov[fRunBin][14]->Fill(fVtxPosCor[2],QCRe*QARe);
677  fCRCZDCQVecCov[fRunBin][15]->Fill(fVtxPosCor[0],QCIm*QAIm);
678  fCRCZDCQVecCov[fRunBin][16]->Fill(fVtxPosCor[1],QCIm*QAIm);
679  fCRCZDCQVecCov[fRunBin][17]->Fill(fVtxPosCor[2],QCIm*QAIm);
680  }
681  }
682  }
683  }
684  // ZDC-C (eta < -8.8)
685  Double_t ZCRe = fZDCFlowVect[0].X();
686  Double_t ZCIm = fZDCFlowVect[0].Y();
687  Double_t ZCM = fZDCFlowVect[0].GetMult();
688  // ZDC-A (eta > 8.8)
689  Double_t ZARe = fZDCFlowVect[1].X();
690  Double_t ZAIm = fZDCFlowVect[1].Y();
691  Double_t ZAM = fZDCFlowVect[1].GetMult();
692  if( fInvertZDC ) ZARe = -ZARe;
693 
694  if(fCalculateCRC) {
695  fQAZDCCutsFlag = this->PassQAZDCCuts();
696  }
697  // ZDC QA cuts
698  Bool_t bPassZDCcuts = kTRUE;
699  if( ZCM<=0. || ZAM<=0. || sqrt(ZCRe*ZCRe+ZCIm*ZCIm)<1.E-6 || sqrt(ZARe*ZARe+ZAIm*ZAIm)<1.E-6 ) bPassZDCcuts=kFALSE;
700  if( !std::isfinite(fZDCFlowVect[0].Mod()) || !std::isfinite(fZDCFlowVect[1].Mod())) bPassZDCcuts=kFALSE;
701  if(fQAZDCCuts && !fQAZDCCutsFlag) bPassZDCcuts=kFALSE;
702 
703  // EbE flow *********************************************************************************************************
704 
705  if(fCalculateEbEFlow) {
706  if(fNumberOfPOIsEBE>0 && fNumberOfPOIsEBE<=2500) {
708  } else {
709  fEBEFlowMulBin = -1;
710  }
711  }
712 
713  // run-by-run corrections ********************************************************************************************
714 
715  if(fRunNum!=fCachedRunNum) {
717  if(fWeightsList->FindObject(Form("fCRCQVecPhiHistRbR[%d]",fRunNum))) {
718  fPhiEtaRbRWeights = (TH3D*)(fWeightsList->FindObject(Form("fCRCQVecPhiRbRHist[%d]",fRunNum)));
719  } else {
720  AliWarning("WARNING: POIExtraWeights (kEtaPhiRbR) not found ! \n");
721  }
722  }
724  for (Int_t i=0; i<2; i++) {
725  if(fWeightsList->FindObject(Form("fCRCQVecPhiRbRHistCh[%d][%d]",fRunNum,i))) {
726  fPhiEtaRbRWeightsCh[i] = (TH3D*)(fWeightsList->FindObject(Form("fCRCQVecPhiRbRHistCh[%d][%d]",fRunNum,i)));
727  } else {
728  AliWarning("WARNING: POIExtraWeights (kEtaPhiChRbR) not found ! \n");
729  }
730  }
731  }
732  fbFlagIsPosMagField = kFALSE;
733  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};
734  for (Int_t i=0; i<40; i++) {
735  if(fRunNum==dRun15hPos[i]) fbFlagIsPosMagField = kTRUE;
736  }
737  }
738 
739  // loop over particles **********************************************************************************************
740 
741  for(Int_t i=0;i<nPrim;i++) {
742  if(fExactNoRPs > 0 && nCounterNoRPs>fExactNoRPs){continue;}
743  aftsTrack=anEvent->GetTrack(i);
744  if(aftsTrack) {
745  if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())){continue;} // safety measure: consider only tracks which are RPs or POIs
746 
747  // RPs *********************************************************************************************************
748 
749  if(aftsTrack->InRPSelection()) {
750  nCounterNoRPs++;
751  dPhi = aftsTrack->Phi();
752  dPt = aftsTrack->Pt();
753  dEta = aftsTrack->Eta();
754  dCharge = aftsTrack->Charge();
755 
756  if(fSelectCharge==kPosCh && dCharge<0.) continue;
757  if(fSelectCharge==kNegCh && dCharge>0.) continue;
758 
759  cw = (dCharge > 0. ? 0 : 1);
760  wPhi = 1.;
761  wPt = 1.;
762  wEta = 1.;
763  wTrack = 1.;
764  wPhiEta = 1.;
765  wProbCut = 0.;
766 
767  // pT weights
769  if(dPt>fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin() && dPt<fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax()) wt = fPtWeightsHist[fCenBin]->Interpolate(dPt);
770  else if(dPt<fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin()) wt = fPtWeightsHist[fCenBin]->Interpolate(fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin());
771  else if(dPt>fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax()) wt = fPtWeightsHist[fCenBin]->Interpolate(fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax());
772  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
773  }
774 
775  // extra weights: eta, phi, ch, vtx
776  if(fPOIExtraWeights==kEtaPhi && fPhiEtaWeights) // determine phieta weight for POI:
777  {
778  wt = fPhiEtaWeights->GetBinContent(fPhiEtaWeights->FindBin(fCentralityEBE,dPhi,dEta));
779  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
780  }
781  if(fPOIExtraWeights==kEtaPhiCh && fPhiEtaWeightsCh[cw]) // determine phieta weight for POI, ch dep:
782  {
783  wt = fPhiEtaWeightsCh[cw]->GetBinContent(fPhiEtaWeightsCh[cw]->FindBin(fCentralityEBE,dPhi,dEta));
784  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
785  }
786  if(fPOIExtraWeights==kEtaPhiVtx) // determine phieta weight for POI:
787  {
788  // TBI
789  }
790  Int_t ptbebe = (dPt>1.? 2 : (dPt>0.5 ? 1 : 0)); // hardcoded
791  if(fPOIExtraWeights==kEtaPhiChPt && fPhiEtaWeightsChPt[cw][ptbebe]) // determine phieta weight for POI, ch dep:
792  {
793  wt = fPhiEtaWeightsChPt[cw][ptbebe]->GetBinContent(fPhiEtaWeightsChPt[cw][ptbebe]->FindBin(fCentralityEBE,dPhi,dEta));
794  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
795  }
796  // run-by-run
797  if(fPOIExtraWeights==kEtaPhiRbR && fPhiEtaRbRWeights) // determine phieta weight for POI:
798  {
799  wt = fPhiEtaRbRWeights->GetBinContent(fPhiEtaRbRWeights->FindBin(fCentralityEBE,dPhi,dEta));
800  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
801  }
802  if(fPOIExtraWeights==kEtaPhiChRbR && fPhiEtaRbRWeightsCh[cw]) // determine phieta weight for POI, ch dep:
803  {
804  wt = fPhiEtaRbRWeightsCh[cw]->GetBinContent(fPhiEtaRbRWeightsCh[cw]->FindBin(fCentralityEBE,dPhi,dEta));
805  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
806  }
807 
808  if(fPhiExclZoneHist) {
809  if(fPhiExclZoneHist->GetBinContent(fPhiExclZoneHist->FindBin(dEta,dPhi))<0.5) continue;
810  }
811 
812  // Calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}] for this event (m = 1,2,...,12, k = 0,1,...,8):
813  for(Int_t m=0;m<12;m++) // to be improved - hardwired 6
814  {
815  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
816  {
817  (*fReQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1)*n*dPhi);
818  (*fImQ)(m,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1)*n*dPhi);
819  }
820  }
821  // Calculate S_{p,k} for this event (Remark: final calculation of S_{p,k} follows after the loop over data bellow):
822  for(Int_t p=0;p<8;p++)
823  {
824  for(Int_t k=0;k<9;k++)
825  {
826  (*fSpk)(p,k)+=pow(wPhiEta*wPhi*wPt*wEta*wTrack,k);
827  }
828  }
829  // Differential flow:
831  {
832  ptEta[0] = dPt;
833  ptEta[1] = dEta;
834  // Calculate r_{m*n,k} and s_{p,k} (r_{m,k} is 'p-vector' for RPs):
835  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
836  {
837  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
838  {
840  {
841  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
842  {
843  fReRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
844  fImRPQ1dEBE[0][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
845  if(m==0) // s_{p,k} does not depend on index m
846  {
847  fs1dEBE[0][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
848  } // end of if(m==0) // s_{p,k} does not depend on index m
849  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
850  } // end of if(fCalculateDiffFlow)
852  {
853  fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
854  fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
855  if(m==0) // s_{p,k} does not depend on index m
856  {
857  fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
858  } // end of if(m==0) // s_{p,k} does not depend on index m
859  } // end of if(fCalculate2DDiffFlow)
860  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
861  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
862  // Checking if RP particle is also POI particle:
863  if(aftsTrack->InPOISelection())
864  {
865  // Calculate q_{m*n,k} and s_{p,k} ('q-vector' and 's' for RPs && POIs):
866  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
867  {
868  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
869  {
871  {
872  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
873  {
874  fReRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
875  fImRPQ1dEBE[2][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
876  if(m==0) // s_{p,k} does not depend on index m
877  {
878  fs1dEBE[2][pe][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
879  } // end of if(m==0) // s_{p,k} does not depend on index m
880  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
881  } // end of if(fCalculateDiffFlow)
883  {
884  fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
885  fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
886  if(m==0) // s_{p,k} does not depend on index m
887  {
888  fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k),1.);
889  } // end of if(m==0) // s_{p,k} does not depend on index m
890  } // end of if(fCalculate2DDiffFlow)
891  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
892  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
893  } // end of if(aftsTrack->InPOISelection())
894  } // end of if(fCalculateDiffFlow || fCalculate2DDiffFlow)
895 
896  } // end of if(pTrack->InRPSelection())
897 
898  // POIs ********************************************************************************************************
899 
900  if(aftsTrack->InPOISelection()) {
901  dPhi = aftsTrack->Phi();
902  dPt = aftsTrack->Pt();
903  dEta = aftsTrack->Eta();
904  dCharge = aftsTrack->Charge();
905  Int_t ITStype = aftsTrack->ITStype();
906 
907  if(fSelectCharge==kPosCh && dCharge<0.) continue;
908  if(fSelectCharge==kNegCh && dCharge>0.) continue;
909 
910  if(fCRCTestSin) {
911  if(dCharge > 0.) dPt += 1.E-3;
912  else dPt -= 1.E-3;
913  }
914 
915  cw = (dCharge > 0. ? 0 : 1);
916  wPhi = 1.;
917  wPt = 1.;
918  wEta = 1.;
919  wTrack = 1.;
920  wPhiEta = 1.;
921  wProbCut = 0.;
922 
923  // pT weights
925  if(dPt>fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin() && dPt<fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax()) wt = fPtWeightsHist[fCenBin]->Interpolate(dPt);
926  else if(dPt<fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin()) wt = fPtWeightsHist[fCenBin]->Interpolate(fPtWeightsHist[fCenBin]->GetXaxis()->GetXmin());
927  else if(dPt>fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax()) wt = fPtWeightsHist[fCenBin]->Interpolate(fPtWeightsHist[fCenBin]->GetXaxis()->GetXmax());
928  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
929  }
930 
931  // extra weights: eta, phi, ch, vtx
932  if(fPOIExtraWeights==kEtaPhi && fPhiEtaWeights) // determine phieta weight for POI:
933  {
934  wt = fPhiEtaWeights->GetBinContent(fPhiEtaWeights->FindBin(fCentralityEBE,dPhi,dEta));
935  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
936  }
937  if(fPOIExtraWeights==kEtaPhiCh && fPhiEtaWeightsCh[cw]) // determine phieta weight for POI, ch dep:
938  {
939  wt = fPhiEtaWeightsCh[cw]->GetBinContent(fPhiEtaWeightsCh[cw]->FindBin(fCentralityEBE,dPhi,dEta));
940  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
941  }
942  if(fPOIExtraWeights==kEtaPhiVtx) // determine phieta weight for POI:
943  {
944  // TBI
945  }
946  Int_t ptbebe = (dPt>1.? 2 : (dPt>0.5 ? 1 : 0)); // hardcoded
947  if(fPOIExtraWeights==kEtaPhiChPt && fPhiEtaWeightsChPt[cw][ptbebe]) // determine phieta weight for POI, ch dep:
948  {
949  wt = fPhiEtaWeightsChPt[cw][ptbebe]->GetBinContent(fPhiEtaWeightsChPt[cw][ptbebe]->FindBin(fCentralityEBE,dPhi,dEta));
950  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
951  }
952  // run-by-run
953  if(fPOIExtraWeights==kEtaPhiRbR && fPhiEtaRbRWeights) // determine phieta weight for POI:
954  {
955  wt = fPhiEtaRbRWeights->GetBinContent(fPhiEtaRbRWeights->FindBin(fCentralityEBE,dPhi,dEta));
956  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
957  }
958  if(fPOIExtraWeights==kEtaPhiChRbR && fPhiEtaRbRWeightsCh[cw]) // determine phieta weight for POI, ch dep:
959  {
960  wt = fPhiEtaRbRWeightsCh[cw]->GetBinContent(fPhiEtaRbRWeightsCh[cw]->FindBin(fCentralityEBE,dPhi,dEta));
961  if(std::isfinite(1./wt)) wPhiEta *= 1./wt;
962  }
963 
964  if(fUsePhiEtaCuts)
965  {
966  // test: remove region with low SPD efficiency
967  if(dPhi>2.136283 && dPhi<2.324779) continue;
968  }
969 
970  ptEta[0] = dPt;
971  ptEta[1] = dEta;
972  // Calculate p_{m*n,k} ('p-vector' for POIs):
973  for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
974  {
975  for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
976  {
978  {
979  for(Int_t pe=0;pe<1+(Int_t)fCalculateDiffFlowVsEta;pe++) // pt or eta
980  {
981  fReRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
982  fImRPQ1dEBE[1][pe][m][k]->Fill(ptEta[pe],pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
983  } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta
984  } // end of if(fCalculateDiffFlow)
986  {
987  fReRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Cos((m+1.)*n*dPhi),1.);
988  fImRPQ2dEBE[1][m][k]->Fill(dPt,dEta,pow(wPhiEta*wPhi*wPt*wEta*wTrack,k)*TMath::Sin((m+1.)*n*dPhi),1.);
989  } // end of if(fCalculate2DDiffFlow)
990  } // end of for(Int_t m=0;m<4;m++) // to be improved - hardwired 4
991  } // end of for(Int_t k=0;k<9;k++) // to be improved - hardwired 9
992 
993  // Charge-Rapidity Correlations
994  for (Int_t h=0;h<fCRCnHar;h++) {
995 
996  fCRCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
997  fCRCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
998  fCRCMult[cw][h]->Fill(dEta,wPhiEta);
999 
1000  fCRC2QRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1001  fCRC2QIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1002  fCRC2Mul[cw][h]->Fill(dEta,pow(wPhiEta,h));
1003 
1004  fCRCZDCQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1005  fCRCZDCQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1006  fCRCZDCMult[cw][h]->Fill(dEta,wPhiEta);
1007 
1008  if(fRandom->Integer(2)>0.5) {
1009  fCRC2QRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1010  fCRC2QIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1011  fCRC2Mul[2][h]->Fill(dEta,pow(wPhiEta,h));
1012  }
1013 
1014  if(fRandom->Integer(2)>0.5) {
1015  fCRCZDCQRe[2][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1016  fCRCZDCQIm[2][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1017  fCRCZDCMult[2][h]->Fill(dEta,wPhiEta);
1018  } else {
1019  fCRCZDCQRe[3][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1020  fCRCZDCQIm[3][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1021  fCRCZDCMult[3][h]->Fill(dEta,wPhiEta);
1022  }
1023 
1024  if(fCalculateCME) {
1025  Double_t SpecWeig = 1.;
1026  if(fUseZDCESESpecWeights && fZDCESESpecWeightsHist[fZDCESEclEbE] && dPt>0.2 && dPt<20.2) {
1028  if(weraw > 0.) SpecWeig = 1./weraw;
1029  }
1030  fCMEQRe[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Cos((h+1.)*dPhi));
1031  fCMEQIm[cw][h]->Fill(dEta,SpecWeig*wPhiEta*TMath::Sin((h+1.)*dPhi));
1032  fCMEMult[cw][h]->Fill(dEta,SpecWeig*wPhiEta);
1033  fCMEQRe[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Cos((h+1.)*dPhi));
1034  fCMEQIm[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.)*TMath::Sin((h+1.)*dPhi));
1035  fCMEMult[2+cw][h]->Fill(dEta,pow(SpecWeig*wPhiEta,2.));
1036 
1037  // spectra
1038  fhCenvsSpec[fZDCESEclEbE]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
1039  fhCenvsSpec[fZDCESEnCl]->Fill(fCentralityEBE,dPt,SpecWeig*wPhiEta);
1040  }
1041 
1042  } // end of for (Int_t h=0;h<fCRCnHar;h++)
1043 
1044  // Flow SP ZDC
1045  Bool_t bFillDis=kTRUE;
1046  for (Int_t k=0; k<fQVecPower; k++) {
1047  for (Int_t h=0;h<fFlowNHarmMax;h++) {
1048 
1049  if(fFlowQCDeltaEta>0.) {
1050 
1051  fPOIPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1052  fPOIPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1053  fPOIPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
1054 
1055  fPOIPtDiffQReCh[cw][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1056  fPOIPtDiffQImCh[cw][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1057  fPOIPtDiffMulCh[cw][k][h]->Fill(dPt,pow(wPhiEta,k));
1058 
1059  fPOIPhiDiffQRe[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1060  fPOIPhiDiffQIm[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1061  fPOIPhiDiffMul[k][h]->Fill(dPhi,pow(wPhiEta,k));
1062 
1063  if(fabs(dEta)>fFlowQCDeltaEta/2.) {
1064  Int_t keta = (dEta<0.?0:1);
1065  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1066  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1067  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1068  fPOIPhiDiffQReEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1069  fPOIPhiDiffQImEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1070  fPOIPhiDiffMulEG[keta][k][h]->Fill(dPhi,pow(wPhiEta,k));
1071  }
1072 
1073  } else if(fFlowQCDeltaEta<0. && fFlowQCDeltaEta>-1.) {
1074 
1075  if(dEta>0.) {
1076  fPOIPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1077  fPOIPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1078  fPOIPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
1079 
1080  fPOIPhiDiffQRe[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1081  fPOIPhiDiffQIm[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1082  fPOIPhiDiffMul[k][h]->Fill(dPhi,pow(wPhiEta,k));
1083 
1084  Double_t boundetagap = fabs(fFlowQCDeltaEta);
1085 
1086  if((dEta>0. && dEta<0.4-boundetagap/2.) || (dEta>0.4+boundetagap/2. && dEta<0.8)) {
1087  Int_t keta;
1088  if(dEta>0. && dEta<0.4-boundetagap/2.) keta = 0;
1089  else keta = 1;
1090  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1091  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1092  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1093  }
1094  } else {
1095  bFillDis = kFALSE;
1096  continue;
1097  }
1098 
1099  } else if(fFlowQCDeltaEta<-1. && fFlowQCDeltaEta>-2.) {
1100 
1101  if(dEta<0.) {
1102  fPOIPtDiffQRe[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1103  fPOIPtDiffQIm[k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1104  fPOIPtDiffMul[k][h]->Fill(dPt,pow(wPhiEta,k));
1105 
1106  fPOIPhiDiffQRe[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1107  fPOIPhiDiffQIm[k][h]->Fill(dPhi,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1108  fPOIPhiDiffMul[k][h]->Fill(dPhi,pow(wPhiEta,k));
1109 
1110  Double_t boundetagap = fabs(fFlowQCDeltaEta)-1.;
1111 
1112  if((dEta<0. && dEta>-0.4+boundetagap/2.) || (dEta<-0.4-boundetagap/2. && dEta>-0.8)) {
1113  Int_t keta;
1114  if(dEta<0. && dEta>-0.4+boundetagap/2.) keta = 0;
1115  else keta = 1;
1116  fPOIPtDiffQReEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Cos((h+1.)*dPhi));
1117  fPOIPtDiffQImEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k)*TMath::Sin((h+1.)*dPhi));
1118  fPOIPtDiffMulEG[keta][k][h]->Fill(dPt,pow(wPhiEta,k));
1119  }
1120  } else {
1121  bFillDis = kFALSE;
1122  continue;
1123  }
1124 
1125  }
1126  }
1127  }
1128 
1129  for (Int_t h=0;h<fFlowNHarmMax;h++) {
1130  fEtaDiffQRe[cw][h]->Fill(dEta,wPhiEta*TMath::Cos((h+1.)*dPhi));
1131  fEtaDiffQIm[cw][h]->Fill(dEta,wPhiEta*TMath::Sin((h+1.)*dPhi));
1132  fEtaDiffMul[cw][h]->Fill(dEta,pow(wPhiEta,h+1));
1133  fPOIEtaPtQRe[cw][h]->Fill(dEta,dPt,wPhiEta*TMath::Cos((h+1.)*dPhi));
1134  fPOIEtaPtQIm[cw][h]->Fill(dEta,dPt,wPhiEta*TMath::Sin((h+1.)*dPhi));
1135  fPOIEtaPtMul[cw][h]->Fill(dEta,dPt,wPhiEta);
1136  }
1137 
1138  if(fCalculateEbEFlow) {
1139  if(fEBEFlowMulBin>=0) fEbEFlowAzimDis[fEBEFlowMulBin]->Fill(dPhi,wPhiEta);
1140  }
1141  if(bFillDis && bPassZDCcuts) {
1142 
1143  fFlowSPZDCv1etaPro[fCenBin][0][7]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1144  fFlowSPZDCv1etaPro[fCenBin][0][8]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1145  if(cw==0) {
1146  fFlowSPZDCv1etaPro[fCenBin][0][9]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1147  fFlowSPZDCv1etaPro[fCenBin][0][10]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1148  } else {
1149  fFlowSPZDCv1etaPro[fCenBin][0][11]->Fill(dEta,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1150  fFlowSPZDCv1etaPro[fCenBin][0][12]->Fill(dEta,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1151  }
1152 
1153  if(fCentralityEBE>5. && fCentralityEBE<40.) {
1154  if(fbFlagIsPosMagField) {
1155  fFlowSPZDCv1etaProPhi[0]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1156  fFlowSPZDCv1etaProPhi[1]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1157  if(cw==0) {
1158  fFlowSPZDCv1etaProPhi[2]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1159  fFlowSPZDCv1etaProPhi[3]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1160  } else {
1161  fFlowSPZDCv1etaProPhi[4]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1162  fFlowSPZDCv1etaProPhi[5]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1163  }
1164  } else {
1165  fFlowSPZDCv1etaProPhi[6]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1166  fFlowSPZDCv1etaProPhi[7]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1167  if(cw==0) {
1168  fFlowSPZDCv1etaProPhi[8]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1169  fFlowSPZDCv1etaProPhi[9]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1170  } else {
1171  fFlowSPZDCv1etaProPhi[10]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1172  fFlowSPZDCv1etaProPhi[11]->Fill(dEta,dPhi,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1173  }
1174  }
1175  }
1176  if(fCentralityEBE>5. && fCentralityEBE<40.) {
1177  Double_t dITStype = ITStype+0.5;
1178  if(fbFlagIsPosMagField) {
1179  fFlowSPZDCv1etaProITS[0]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1180  fFlowSPZDCv1etaProITS[1]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1181  if(cw==0) {
1182  fFlowSPZDCv1etaProITS[2]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1183  fFlowSPZDCv1etaProITS[3]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1184  } else {
1185  fFlowSPZDCv1etaProITS[4]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1186  fFlowSPZDCv1etaProITS[5]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1187  }
1188  } else {
1189  fFlowSPZDCv1etaProITS[6]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1190  fFlowSPZDCv1etaProITS[7]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1191  if(cw==0) {
1192  fFlowSPZDCv1etaProITS[8]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1193  fFlowSPZDCv1etaProITS[9]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1194  } else {
1195  fFlowSPZDCv1etaProITS[10]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZARe+TMath::Sin(dPhi)*ZAIm,wPhiEta);
1196  fFlowSPZDCv1etaProITS[11]->Fill(dEta,dITStype,TMath::Cos(dPhi)*ZCRe+TMath::Sin(dPhi)*ZCIm,wPhiEta);
1197  }
1198  }
1199  if(fbFlagIsPosMagField) {
1200  fFlowSPZDCv1etaProITSDis[0][ITStype]->Fill(dEta,dPhi,wPhiEta);
1201  } else {
1202  fFlowSPZDCv1etaProITSDis[1][ITStype]->Fill(dEta,dPhi,wPhiEta);
1203  }
1204  }
1205 
1206  // all runs
1207  fCRCQVecPhiHist->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1208  fCRCQVecPhiHistCh[cw]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1209  Int_t ptbebe = (dPt>1.? 2 : (dPt>0.5 ? 1 : 0)); // hardcoded
1210  fCRCQVecPhiHistChPt[cw][ptbebe]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1211  for (Int_t h=0;h<6;h++) {
1212  fCRCQVecHarCosProCh[cw]->Fill(fCentralityEBE,(Double_t)h+0.5,dEta,TMath::Cos((h+1.)*dPhi),wPhiEta);
1213  fCRCQVecHarSinProCh[cw]->Fill(fCentralityEBE,(Double_t)h+0.5,dEta,TMath::Sin((h+1.)*dPhi),wPhiEta);
1214  }
1215  // run-by-run
1216  fCRCQVecPhiRbRHist[fRunBin]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1217  fCRCQVecPhiRbRHistCh[fRunBin][cw]->Fill(fCentralityEBE,dPhi,dEta,wPhiEta);
1218  }
1219 // fCRCQVecPhiHistVtxDep[fRunBin][fCenBin]->Fill(fVtxPos[2],dPhi,dEta,wPhiEta);
1221  fFlowQCSpectraCharge[cw]->Fill(fCentralityEBE,dPt,wPhiEta*fCenWeightEbE);
1222 
1223  } // end of if(pTrack->InPOISelection())
1224  } else // to if(aftsTrack)
1225  {
1226  printf("\n WARNING (QC): No particle (i.e. aftsTrack is a NULL pointer in AFAWQC::Make())!!!!\n\n");
1227  }
1228  } // end of for(Int_t i=0;i<nPrim;i++)
1229 
1230  // ************************************************************************************************************
1231 
1232  // e) Calculate the final expressions for S_{p,k} and s_{p,k} (important !!!!):
1233  for(Int_t p=0;p<8;p++)
1234  {
1235  for(Int_t k=0;k<9;k++)
1236  {
1237  (*fSpk)(p,k)=pow((*fSpk)(p,k),p+1);
1238  }
1239  }
1240 
1241  // f) Call the methods which calculate correlations for reference flow:
1243  {
1245  {
1246  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelations();} // without using particle weights
1247  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1248  {
1249  if(fNumberOfRPsEBE>1){this->CalculateIntFlowCorrelationsUsingParticleWeights();} // with using particle weights
1250  }
1251  // Whether or not using particle weights the following is calculated in the same way:
1255  // Non-isotropic terms:
1257  {
1260  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1261  {
1264  }
1265  // Whether or not using particle weights the following is calculated in the same way:
1269  // Mixed harmonics:
1271  } // end of if(!fEvaluateIntFlowNestedLoops)
1272 
1273  // g) Call the methods which calculate correlations for differential flow:
1275  {
1277  {
1278  // Without using particle weights:
1279  this->CalculateDiffFlowCorrelations("RP","Pt");
1281  this->CalculateDiffFlowCorrelations("POI","Pt");
1283  // Non-isotropic terms:
1292  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1293  {
1294  // With using particle weights:
1299  // Non-isotropic terms:
1308  }
1309  // Whether or not using particle weights the following is calculated in the same way:
1310  this->CalculateDiffFlowProductOfCorrelations("RP","Pt");
1312  this->CalculateDiffFlowProductOfCorrelations("POI","Pt");
1314  this->CalculateDiffFlowSumOfEventWeights("RP","Pt");
1316  this->CalculateDiffFlowSumOfEventWeights("POI","Pt");
1322  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculateDiffFlow)
1323 
1324  // h) Call the methods which calculate correlations for 2D differential flow:
1326  {
1328  {
1329  // Without using particle weights:
1330  this->Calculate2DDiffFlowCorrelations("RP");
1331  this->Calculate2DDiffFlowCorrelations("POI");
1332  // Non-isotropic terms:
1333  // ... to be ctd ...
1334  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1335  {
1336  // With using particle weights:
1337  // ... to be ctd ...
1338  // Non-isotropic terms:
1339  // ... to be ctd ...
1340  }
1341  // Whether or not using particle weights the following is calculated in the same way:
1342  // ... to be ctd ...
1343  } // end of if(!fEvaluateDiffFlowNestedLoops && fCalculate2DDiffFlow)
1344 
1345  // i) Call the methods which calculate other differential correlators:
1347  {
1349  {
1350  // Without using particle weights:
1351  this->CalculateOtherDiffCorrelators("RP","Pt");
1353  this->CalculateOtherDiffCorrelators("POI","Pt");
1355  } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights||fUseTrackWeights))
1356  {
1357  // With using particle weights:
1358  // ... to be ctd ...
1359  }
1360  // Whether or not using particle weights the following is calculated in the same way:
1361  // ... to be ctd ...
1362  } // end of if(!fEvaluateDiffFlowNestedLoops)
1363 
1364  // i.2) Calculate CRC quantities:
1365  if(fCalculateCRC) {
1366  if(fCalculateCRCInt) this->CalculateCRCCorr();
1367  if(fCalculateCRC2) this->CalculateCRC2Cor();
1369  if(fCalculateCRCZDC && fUseZDC) this->CalculateCRCZDC();
1370  if(fCalculateCRCPt) this->CalculateCRCPtCorr();
1371  // if(fUseVZERO && fUseZDC) this->CalculateVZvsZDC();
1372  if(fCalculateCME && fUseZDC) {
1373  this->CalculateCMETPC();
1374  this->CalculateCMEZDC();
1375  }
1376  }
1377  // WARNING: do not invert order of SPZDC and QC, used in SC
1379  if(fCalculateFlowQC) {
1380  this->CalculateFlowQC();
1381  this->CalculateFlowQCHighOrders();
1382  }
1384  if(fCalculateEbEFlow) this->FitEbEFlow();
1385 
1386  // j) Distributions of correlations:
1388 
1389  // l) Cross-check with nested loops correlators for reference flow:
1391 
1392  // m) Cross-check with nested loops correlators for differential flow:
1394 
1395  // n) Store multiplicity in various:
1396  if(fStoreVarious) this->FillVarious();
1397 
1398  // o) Reset all event-by-event quantities (very important !!!!):
1400 
1401  // p) cache run number
1403 
1404  fQAZDCCutsFlag = kTRUE;
1405  // printf("Make done \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