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