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