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