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