PWG2/FLOW/AliFlowCommon/AliFlowAnalysisWithQCumulants.cxx

   1 /*************************************************************************\r
   2 * Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *\r
   3 *                                                                        *\r
   4 * Author: The ALICE Off-line Project.                                    *\r
   5 * Contributors are mentioned in the code where appropriate.              *\r
   6 *                                                                        *\r
   7 * Permission to use, copy, modify and distribute this software and its   *\r
   8 * documentation strictly for non-commercial purposes is hereby granted   *\r
   9 * without fee, provided that the above copyright notice appears in all   *\r
  10 * copies and that both the copyright notice and this permission notice   *\r
  11 * appear in the supporting documentation. The authors make no claims     *\r
  12 * about the suitability of this software for any purpose. It is          *\r
  13 * provided "as is" without express or implied warranty.                  * \r
  14 **************************************************************************/\r
  15 \r
  16 /********************************** \r
  17  * flow analysis with Q-cumulants * \r
  18  *                                * \r
  19  * author:  Ante Bilandzic        * \r
  20  *           (anteb@nikhef.nl)    *\r
  21  *********************************/ \r
  22 \r
  23 #define AliFlowAnalysisWithQCumulants_cxx\r
  24 \r
  25 #include "Riostream.h"\r
  26 #include "AliFlowCommonConstants.h"\r
  27 #include "AliFlowCommonHist.h"\r
  28 #include "AliFlowCommonHistResults.h"\r
  29 #include "TChain.h"\r
  30 \r
  31 #include "TFile.h"\r
  32 #include "TList.h"\r
  33 #include "TGraph.h"\r
  34 #include "TParticle.h"\r
  35 #include "TRandom3.h"\r
  36 #include "TStyle.h"\r
  37 #include "TProfile.h"\r
  38 #include "TProfile2D.h" \r
  39 #include "TProfile3D.h"\r
  40 #include "TMath.h"\r
  41 #include "TArrow.h"\r
  42 #include "TPaveLabel.h"\r
  43 #include "TCanvas.h"\r
  44 #include "AliFlowEventSimple.h"\r
  45 #include "AliFlowTrackSimple.h"\r
  46 #include "AliFlowAnalysisWithQCumulants.h"\r
  47 #include "TArrayD.h"\r
  48 #include "TRandom.h"\r
  49 #include "TF1.h"\r
  50 \r
  51 class TH1;\r
  52 class TH2;\r
  53 class TGraph;\r
  54 class TPave;\r
  55 class TLatex;\r
  56 class TMarker;\r
  57 class TRandom3;\r
  58 class TObjArray;\r
  59 class TList;\r
  60 class TCanvas;\r
  61 class TSystem;\r
  62 class TROOT;\r
  63 class AliFlowVector;\r
  64 class TVector;\r
  65 \r
  66 \r
  67 //================================================================================================================\r
  68 \r
  69 \r
  70 ClassImp(AliFlowAnalysisWithQCumulants)\r
  71 \r
  72 AliFlowAnalysisWithQCumulants::AliFlowAnalysisWithQCumulants(): \r
  73  // 0.) base:\r
  74  fHistList(NULL),\r
  75  // 1.) common:\r
  76  fCommonHists(NULL),\r
  77  fCommonHists2nd(NULL), \r
  78  fCommonHists4th(NULL),\r
  79  fCommonHists6th(NULL),\r
  80  fCommonHists8th(NULL),\r
  81  fCommonHistsResults2nd(NULL),\r
  82  fCommonHistsResults4th(NULL),\r
  83  fCommonHistsResults6th(NULL),\r
  84  fCommonHistsResults8th(NULL),\r
  85  fnBinsPhi(0),\r
  86  fPhiMin(0),\r
  87  fPhiMax(0),\r
  88  fPhiBinWidth(0),\r
  89  fnBinsPt(0),\r
  90  fPtMin(0),\r
  91  fPtMax(0),\r
  92  fPtBinWidth(0),\r
  93  fnBinsEta(0),\r
  94  fEtaMin(0),\r
  95  fEtaMax(0),\r
  96  fEtaBinWidth(0),\r
  97  fHarmonic(2),\r
  98  fAnalysisLabel(NULL),\r
  99  // 2a.) particle weights:\r
 100  fWeightsList(NULL),\r
 101  fUsePhiWeights(kFALSE),\r
 102  fUsePtWeights(kFALSE),\r
 103  fUseEtaWeights(kFALSE),\r
 104  fUseParticleWeights(NULL),\r
 105  fPhiWeights(NULL),\r
 106  fPtWeights(NULL),\r
 107  fEtaWeights(NULL),\r
 108  // 2b.) event weights:\r
 109  fMultiplicityWeight(NULL),\r
 110  // 3.) integrated flow:\r
 111  fIntFlowList(NULL), \r
 112  fIntFlowProfiles(NULL),\r
 113  fIntFlowResults(NULL),\r
 114  fIntFlowFlags(NULL),\r
 115  fApplyCorrectionForNUA(kTRUE), \r
 116  fReQ(NULL),\r
 117  fImQ(NULL),\r
 118  fSMpk(NULL),\r
 119  fIntFlowCorrelationsEBE(NULL),\r
 120  fIntFlowEventWeightsForCorrelationsEBE(NULL),\r
 121  fIntFlowCorrelationsAllEBE(NULL),\r
 122  fAvMultiplicity(NULL),\r
 123  fIntFlowCorrelationsPro(NULL),\r
 124  fIntFlowCorrelationsAllPro(NULL),\r
 125  fIntFlowExtraCorrelationsPro(NULL),\r
 126  fIntFlowProductOfCorrelationsPro(NULL),\r
 127  fIntFlowCorrelationsHist(NULL),\r
 128  fIntFlowCorrelationsAllHist(NULL),\r
 129  fIntFlowCovariances(NULL),\r
 130  fIntFlowSumOfProductOfEventWeights(NULL),\r
 131  fIntFlowQcumulants(NULL),\r
 132  fIntFlow(NULL),\r
 133  // 4.) differential flow:\r
 134  fDiffFlowList(NULL),\r
 135  fDiffFlowProfiles(NULL),\r
 136  fDiffFlowResults(NULL),\r
 137  fDiffFlowFlags(NULL),\r
 138  fCalculate2DFlow(kFALSE),\r
 139  // 5.) distributions:\r
 140  fDistributionsList(NULL),
 141  fDistributionsFlags(NULL),
 142  fStoreDistributions(kFALSE),\r
 143  // x.) debugging and cross-checking:\r
 144  fNestedLoopsList(NULL),\r
 145  fEvaluateIntFlowNestedLoops(kFALSE),\r
 146  fEvaluateDiffFlowNestedLoops(kFALSE),\r
 147  fMaxAllowedMultiplicity(10),\r
 148  fEvaluateNestedLoops(NULL),\r
 149  fIntFlowDirectCorrelations(NULL),\r
 150  fIntFlowExtraDirectCorrelations(NULL),\r
 151  fCrossCheckInPtBinNo(10),\r
 152  fCrossCheckInEtaBinNo(20)\r
 153  {\r
 154   // constructor  \r
 155   \r
 156   // base list to hold all output objects:\r
 157   fHistList = new TList();\r
 158   fHistList->SetName("cobjQC");\r
 159   fHistList->SetOwner(kTRUE);\r
 160   \r
 161   // list to hold histograms with phi, pt and eta weights:      \r
 162   fWeightsList = new TList();\r
 163   \r
 164   // multiplicity weight:\r
 165   fMultiplicityWeight = new TString("combinations");\r
 166     \r
 167   // analysis label;\r
 168   fAnalysisLabel = new TString();\r
 169       \r
 170   // initialize all arrays:  \r
 171   this->InitializeArraysForIntFlow();\r
 172   this->InitializeArraysForDiffFlow();\r
 173   this->InitializeArraysForDistributions();\r
 174   this->InitializeArraysForNestedLoops();\r
 175   \r
 176  } // end of constructor\r
 177  \r
 178 \r
 179 //================================================================================================================  \r
 180 \r
 181 \r
 182 AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()\r
 183 {\r
 184  // destructor\r
 185  \r
 186  delete fHistList;\r
 187 \r
 188 } // end of AliFlowAnalysisWithQCumulants::~AliFlowAnalysisWithQCumulants()\r
 189 \r
 190 \r
 191 //================================================================================================================\r
 192 \r
 193 \r
 194 void AliFlowAnalysisWithQCumulants::Init()\r
 195 {\r
 196  // a) Access all common constants;\r
 197  // b) Book all objects;\r
 198  // c) Store flags for integrated and differential flow;
 199  // d) Store flags for distributions of corelations;\r
 200  // e) Store harmonic which will be estimated.\r
 201   \r
 202  // a) Access all common constants:\r
 203  this->AccessConstants();\r
 204  \r
 205  // b) Book all objects:\r
 206  this->BookAndFillWeightsHistograms();\r
 207  this->BookAndNestAllLists();\r
 208  this->BookCommonHistograms();\r
 209  this->BookEverythingForIntegratedFlow(); \r
 210  this->BookEverythingForDifferentialFlow(); \r
 211  this->BookEverythingForDistributions();\r
 212  this->BookEverythingForNestedLoops();\r
 213  \r
 214  // c) Store flags for integrated and differential flow:\r
 215  this->StoreIntFlowFlags();\r
 216  this->StoreDiffFlowFlags();\r
 217
 218  // d) Store flags for distributions of corelations:\r
 219  this->StoreFlagsForDistributions();\r
 220 \r
 221  // e) Store harmonic which will be estimated:\r
 222  this->StoreHarmonic();\r
 223  \r
 224 } // end of void AliFlowAnalysisWithQCumulants::Init()\r
 225 \r
 226 \r
 227 //================================================================================================================\r
 228 \r
 229 \r
 230 void AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)\r
 231 {\r
 232  // Running over data only in this method.\r
 233  \r
 234  //  a) Fill the common control histograms and call the method to fill fAvMultiplicity;\r
 235  //  b) Loop over data and calculate e-b-e quantities;\r
 236  //  c) Call all the methods;\r
 237  //  d) Debugging and cross-checking (evaluate nested loops);\r
 238  //  e) Reset all event by event quantities. \r
 239  \r
 240  Double_t dPhi = 0.; // azimuthal angle in the laboratory frame\r
 241  Double_t dPt  = 0.; // transverse momentum\r
 242  Double_t dEta = 0.; // pseudorapidity\r
 243 \r
 244  Double_t wPhi = 1.; // phi weight\r
 245  Double_t wPt  = 1.; // pt weight\r
 246  Double_t wEta = 1.; // eta weight\r
 247  \r
 248  Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)\r
 249  \r
 250  // a) Fill the common control histograms and call the method to fill fAvMultiplicity:\r
 251  this->FillCommonControlHistograms(anEvent);                                                               \r
 252  this->FillAverageMultiplicities(nRP);                                                                  \r
 253                                                                                                                                                                                                                                                                                         \r
 254  // b) Loop over data and calculate e-b-e quantities:\r
 255  Int_t nPrim = anEvent->NumberOfTracks();  // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI + rest, where:\r
 256                                            // nRP   = # of particles used to determine the reaction plane;\r
 257                                            // nPOI  = # of particles of interest for a detailed flow analysis;\r
 258                                            // rest  = # of particles which are not niether RPs nor POIs.  \r
 259  \r
 260  AliFlowTrackSimple *aftsTrack = NULL;\r
 261  \r
 262  for(Int_t i=0;i<nPrim;i++) \r
 263  { \r
 264   aftsTrack=anEvent->GetTrack(i);\r
 265   if(aftsTrack)\r
 266   {\r
 267    if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())) continue; // consider only tracks which are RPs or POIs\r
 268    Int_t n = fHarmonic; // shortcut for the harmonic\r
 269    if(aftsTrack->InRPSelection()) // RP condition:\r
 270    {    \r
 271     dPhi = aftsTrack->Phi();\r
 272     dPt  = aftsTrack->Pt();\r
 273     dEta = aftsTrack->Eta();\r
 274     if(fUsePhiWeights && fPhiWeights && fnBinsPhi) // determine phi weight for this particle:\r
 275     {\r
 276      wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));\r
 277     }\r
 278     if(fUsePtWeights && fPtWeights && fnBinsPt) // determine pt weight for this particle:\r
 279     {\r
 280      wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); \r
 281     }              \r
 282     if(fUseEtaWeights && fEtaWeights && fEtaBinWidth) // determine eta weight for this particle: \r
 283     {\r
 284      wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); \r
 285     } \r
 286       \r
 287     // integrated flow: \r
 288     // calculate Re[Q_{m*n,k}] and Im[Q_{m*n,k}], m = 1,2,3,4, for this event:\r
 289     for(Int_t m=0;m<4;m++)\r
 290     {\r
 291      for(Int_t k=0;k<9;k++)\r
 292      {\r
 293       (*fReQ)(m,k)+=pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1)*n*dPhi); \r
 294       (*fImQ)(m,k)+=pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1)*n*dPhi); \r
 295      } \r
 296     }\r
 297     // calculate S^{M}_{p,k} for this event \r
 298     // Remark: final calculation of S^{M}_{p,k} follows after the loop over data bellow:\r
 299     for(Int_t p=0;p<8;p++)\r
 300     {\r
 301      for(Int_t k=0;k<9;k++)\r
 302      {     \r
 303       (*fSMpk)(p,k)+=pow(wPhi*wPt*wEta,k);\r
 304      }\r
 305     } \r
 306     \r
 307     // differential flow:\r
 308     // 1D (pt):\r
 309     // (r_{m*m,k}(pt)): \r
 310     for(Int_t m=0;m<4;m++)\r
 311     {\r
 312      for(Int_t k=0;k<9;k++)\r
 313      {\r
 314       fReRPQ1dEBE[0][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 315       fImRPQ1dEBE[0][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 316      }\r
 317     }\r
 318            \r
 319     // s_{k}(pt) for RPs // to be improved (clarified)\r
 320     // Remark: final calculation of s_{p,k}(pt) follows after the loop over data bellow:\r
 321     for(Int_t k=0;k<9;k++)\r
 322     {\r
 323      fs1dEBE[0][0][k]->Fill(dPt,pow(wPhi*wPt*wEta,k),1.);\r
 324     }\r
 325     // 1D (eta):\r
 326     // (r_{m*m,k}(eta)): \r
 327     for(Int_t m=0;m<4;m++)\r
 328     {\r
 329      for(Int_t k=0;k<9;k++)\r
 330      {\r
 331       fReRPQ1dEBE[0][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 332       fImRPQ1dEBE[0][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 333      }\r
 334     }   \r
 335     // s_{k}(eta) for RPs // to be improved (clarified)\r
 336     // Remark: final calculation of s_{p,k}(eta) follows after the loop over data bellow:\r
 337     for(Int_t k=0;k<9;k++)\r
 338     {\r
 339      fs1dEBE[0][1][k]->Fill(dEta,pow(wPhi*wPt*wEta,k),1.);\r
 340     }\r
 341     \r
 342     \r
 343     \r
 344     /*\r
 345     // 2D (pt,eta):\r
 346     if(fCalculate2DFlow)\r
 347     {\r
 348      // (r_{m*m,k}(pt,eta)): \r
 349      for(Int_t m=0;m<4;m++)\r
 350      {\r
 351       for(Int_t k=0;k<9;k++)\r
 352       {\r
 353        fReRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 354        fImRPQ2dEBE[0][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 355       }\r
 356      }    \r
 357      // s_{k}(pt,eta) for RPs // to be improved (clarified)\r
 358      // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
 359      for(Int_t k=0;k<9;k++)\r
 360      {\r
 361       fs2dEBE[0][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k),1.);\r
 362      }\r
 363     } // end of if(fCalculate2DFlow)  \r
 364     */ \r
 365     \r
 366       \r
 367      \r
 368     if(aftsTrack->InPOISelection())\r
 369     {\r
 370      // 1D (pt): \r
 371      // (q_{m*m,k}(pt)): \r
 372      for(Int_t m=0;m<4;m++)\r
 373      {\r
 374       for(Int_t k=0;k<9;k++)\r
 375       {\r
 376        fReRPQ1dEBE[2][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 377        fImRPQ1dEBE[2][0][m][k]->Fill(dPt,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 378       }\r
 379      } \r
 380      // s_{k}(pt) for RP&&POIs // to be improved (clarified)\r
 381      // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
 382      for(Int_t k=0;k<9;k++)\r
 383      {\r
 384       fs1dEBE[2][0][k]->Fill(dPt,pow(wPhi*wPt*wEta,k),1.);\r
 385      }\r
 386      // 1D (eta): \r
 387      // (q_{m*m,k}(eta)): \r
 388      for(Int_t m=0;m<4;m++)\r
 389      {\r
 390       for(Int_t k=0;k<9;k++)\r
 391       {\r
 392        fReRPQ1dEBE[2][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 393        fImRPQ1dEBE[2][1][m][k]->Fill(dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 394       }\r
 395      } \r
 396      // s_{k}(eta) for RP&&POIs // to be improved (clarified)\r
 397      // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
 398      for(Int_t k=0;k<9;k++)\r
 399      {\r
 400       fs1dEBE[2][1][k]->Fill(dEta,pow(wPhi*wPt*wEta,k),1.);\r
 401      }\r
 402      \r
 403      /*\r
 404      // 2D (pt,eta) \r
 405      if(fCalculate2DFlow)\r
 406      {\r
 407       // (q_{m*m,k}(pt,eta)): \r
 408       for(Int_t m=0;m<4;m++)\r
 409       {\r
 410        for(Int_t k=0;k<9;k++)\r
 411        {\r
 412         fReRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Cos((m+1.)*n*dPhi),1.);\r
 413         fImRPQ2dEBE[2][m][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k)*TMath::Sin((m+1.)*n*dPhi),1.);\r
 414        }\r
 415       } \r
 416       // s_{k}(pt,eta) for RP&&POIs // to be improved (clarified)\r
 417       // Remark: final calculation of s_{p,k}(pt,eta) follows after the loop over data bellow:\r
 418       for(Int_t k=0;k<9;k++)\r
 419       {\r
 420        fs2dEBE[2][k]->Fill(dPt,dEta,pow(wPhi*wPt*wEta,k),1.);\r
 421       }\r
 422      } // end of if(fCalculate2DFlow) \r
 423      */\r
 424       \r
 425     } // end of if(aftsTrack->InPOISelection())\r
 426     \r
 427 \r
 428      \r
 429    } // end of if(pTrack->InRPSelection())\r
 430 \r
 431   \r
 432   \r
 433    if(aftsTrack->InPOISelection())\r
 434    {\r
 435     dPhi = aftsTrack->Phi();\r
 436     dPt  = aftsTrack->Pt();\r
 437     dEta = aftsTrack->Eta();\r
 438     \r
 439     // 1D (pt)\r
 440     // p_n(m*n,0):   \r
 441     for(Int_t m=0;m<4;m++)\r
 442     {\r
 443      fReRPQ1dEBE[1][0][m][0]->Fill(dPt,TMath::Cos((m+1.)*n*dPhi),1.);\r
 444      fImRPQ1dEBE[1][0][m][0]->Fill(dPt,TMath::Sin((m+1.)*n*dPhi),1.);\r
 445     }\r
 446     // 1D (eta)\r
 447     // p_n(m*n,0):   \r
 448     for(Int_t m=0;m<4;m++)\r
 449     {\r
 450      fReRPQ1dEBE[1][1][m][0]->Fill(dEta,TMath::Cos((m+1.)*n*dPhi),1.);\r
 451      fImRPQ1dEBE[1][1][m][0]->Fill(dEta,TMath::Sin((m+1.)*n*dPhi),1.);\r
 452     }\r
 453     \r
 454     \r
 455     /*\r
 456     // 2D (pt,eta):\r
 457     if(fCalculate2DFlow)\r
 458     {      \r
 459      // p_n(m*n,0):   \r
 460      for(Int_t m=0;m<4;m++)\r
 461      {\r
 462       fReRPQ2dEBE[1][m][0]->Fill(dPt,dEta,TMath::Cos((m+1.)*n*dPhi),1.);\r
 463       fImRPQ2dEBE[1][m][0]->Fill(dPt,dEta,TMath::Sin((m+1.)*n*dPhi),1.);\r
 464      }\r
 465     } // end of if(fCalculate2DFlow)  \r
 466     */\r
 467     \r
 468     \r
 469    } // end of if(pTrack->InPOISelection() )   \r
 470  \r
 471   \r
 472   } else // to if(aftsTrack)\r
 473     {\r
 474      cout<<endl;\r
 475      cout<<" WARNING: no particle! (i.e. aftsTrack is a NULL pointer in AFAWQC::Make().)"<<endl;\r
 476      cout<<endl;       \r
 477     }\r
 478  } // end of for(Int_t i=0;i<nPrim;i++) \r
 479 \r
 480  // calculate the final expressions for S^{M}_{p,k}:\r
 481  for(Int_t p=0;p<8;p++)\r
 482  {\r
 483   for(Int_t k=0;k<9;k++)\r
 484   {\r
 485    (*fSMpk)(p,k)=pow((*fSMpk)(p,k),p+1);\r
 486   }  \r
 487  } \r
 488  \r
 489  // *****************************\r
 490  // **** CALL THE METHODS *******\r
 491  // *****************************\r
 492  // integrated flow:\r
 493  if(!fEvaluateIntFlowNestedLoops)\r
 494  {\r
 495   if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 496   {\r
 497    if(nRP>1) this->CalculateIntFlowCorrelations(); // without using particle weights\r
 498   } else \r
 499     {\r
 500      if(nRP>1) this->CalculateIntFlowCorrelationsUsingParticleWeights(); // with using particle weights   \r
 501     } \r
 502        \r
 503   if(nRP>3) this->CalculateIntFlowProductOfCorrelations();\r
 504   if(nRP>1) this->CalculateIntFlowSumOfEventWeights();\r
 505   if(nRP>1) this->CalculateIntFlowSumOfProductOfEventWeights();\r
 506   if(fApplyCorrectionForNUA)\r
 507   {\r
 508    if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))
 509    {
 510     if(nRP>0) this->CalculateIntFlowCorrectionsForNUASinTerms();\r
 511     if(nRP>0) this->CalculateIntFlowCorrectionsForNUACosTerms();\r
 512    } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))
 513      {
 514       if(nRP>0) this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights();\r
 515       if(nRP>0) this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights();
 516      }
 517   } // end of if(fApplyCorrectionForNUA)\r
 518  } // end of if(!fEvaluateIntFlowNestedLoops)\r
 519 \r
 520  // differential flow:\r
 521  if(!fEvaluateDiffFlowNestedLoops)\r
 522  {\r
 523   if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 524   {\r
 525    // without using particle weights:\r
 526    this->CalculateDiffFlowCorrelations("RP","Pt"); \r
 527    this->CalculateDiffFlowCorrelations("RP","Eta");\r
 528    this->CalculateDiffFlowCorrelations("POI","Pt");\r
 529    this->CalculateDiffFlowCorrelations("POI","Eta");
 530    if(fApplyCorrectionForNUA)
 531    {
 532     this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");\r
 533     this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");\r
 534     this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");\r
 535     this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");\r
 536     this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");\r
 537     this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");\r
 538     this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");\r
 539     this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");
 540    } // end of if(fApplyCorrectionForNUA)  \r
 541   } else // to if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 542     {\r
 543      // with using particle weights:   \r
 544      this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt"); \r
 545      this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta"); \r
 546      this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt"); \r
 547      this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta"); \r
 548      if(fApplyCorrectionForNUA)
 549      {
 550       this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");\r
 551       this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");\r
 552       this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");\r
 553       this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");\r
 554       this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");\r
 555       this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");\r
 556       this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");\r
 557       this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");
 558      } // end of if(fApplyCorrectionForNUA)  \r
 559     } \r
 560
 561   // whether or not using particle weights the following is calculated in the same way:  \r
 562   this->CalculateDiffFlowProductOfCorrelations("RP","Pt");\r
 563   this->CalculateDiffFlowProductOfCorrelations("RP","Eta");\r
 564   this->CalculateDiffFlowProductOfCorrelations("POI","Pt");\r
 565   this->CalculateDiffFlowProductOfCorrelations("POI","Eta");\r
 566   this->CalculateDiffFlowSumOfEventWeights("RP","Pt");\r
 567   this->CalculateDiffFlowSumOfEventWeights("RP","Eta");\r
 568   this->CalculateDiffFlowSumOfEventWeights("POI","Pt");\r
 569   this->CalculateDiffFlowSumOfEventWeights("POI","Eta");\r
 570   this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Pt");\r
 571   this->CalculateDiffFlowSumOfProductOfEventWeights("RP","Eta");\r
 572   this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Pt");\r
 573   this->CalculateDiffFlowSumOfProductOfEventWeights("POI","Eta");   \r
 574  } // end of if(!fEvaluateDiffFlowNestedLoops)\r
 575 \r
 576 \r
 577    \r
 578   // with weights:\r
 579   // ... \r
 580   \r
 581   /*\r
 582   // 2D differential flow\r
 583   if(fCalculate2DFlow)\r
 584   {\r
 585    // without weights:\r
 586    if(nRP>1) this->CalculateCorrelationsForDifferentialFlow2D("RP");\r
 587    if(nRP>1) this->CalculateCorrelationsForDifferentialFlow2D("POI");\r
 588   \r
 589    // with weights:\r
 590    if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
 591    {\r
 592     if(nRP>1) this->CalculateWeightedCorrelationsForDifferentialFlow2D("RP");\r
 593     if(nRP>1) this->CalculateWeightedCorrelationsForDifferentialFlow2D("POI");\r
 594    } \r
 595   } // end of if(fCalculate2DFlow)\r
 596   */\r
 597
 598  // distributions of correlations:
 599  if(fStoreDistributions)
 600  {
 601   this->StoreDistributionsOfCorrelations();
 602  }
 603   \r
 604  // d) Debugging and cross-checking (evaluate nested loops):\r
 605  //  d1) cross-checking results for integrated flow:\r
 606  if(fEvaluateIntFlowNestedLoops)\r
 607  {\r
 608   if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10 \r
 609   {\r
 610    // without using particle weights:\r
 611    if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 612    {\r
 613     // correlations:\r
 614     this->CalculateIntFlowCorrelations(); // from Q-vectors\r
 615     this->EvaluateIntFlowCorrelationsWithNestedLoops(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)\r
 616     // correction for non-uniform acceptance:\r
 617     this->CalculateIntFlowCorrectionsForNUASinTerms(); // from Q-vectors (sin terms)\r
 618     this->CalculateIntFlowCorrectionsForNUACosTerms(); // from Q-vectors (cos terms)\r
 619     this->EvaluateIntFlowCorrectionsForNUAWithNestedLoops(anEvent); // from nested loops (both sin and cos terms)\r
 620    }\r
 621    // using particle weights:\r
 622    if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
 623    {\r
 624     // correlations:\r
 625     this->CalculateIntFlowCorrelationsUsingParticleWeights(); // from Q-vectors\r
 626     this->EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (to be improved: do I have to pass here anEvent or not?)\r
 627     // correction for non-uniform acceptance:\r
 628     this->CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights(); // from Q-vectors (sin terms)\r
 629     this->CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights(); // from Q-vectors (cos terms)\r
 630     this->EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(anEvent); // from nested loops (both sin and cos terms)
 631    }\r
 632   } else if (nPrim>fMaxAllowedMultiplicity) // to if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity)\r
 633     {\r
 634      cout<<endl;\r
 635      cout<<"Skipping the event because multiplicity is "<<nPrim<<". Too high to evaluate nested loops!"<<endl;\r
 636     } else\r
 637       {\r
 638        cout<<endl;\r
 639        cout<<"Skipping the event because multiplicity is "<<nPrim<<"."<<endl;      \r
 640       } \r
 641  } // end of if(fEvaluateIntFlowNestedLoops) \r
 642  \r
 643  //  d2) cross-checking results for differential flow:\r
 644  if(fEvaluateDiffFlowNestedLoops)\r
 645  {\r
 646   if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10\r
 647   {\r
 648    // without using particle weights:\r
 649    if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 650    {\r
 651     // reduced correlations:\r
 652     // Q-vectors:\r
 653     this->CalculateDiffFlowCorrelations("RP","Pt");\r
 654     this->CalculateDiffFlowCorrelations("RP","Eta");\r
 655     this->CalculateDiffFlowCorrelations("POI","Pt");\r
 656     this->CalculateDiffFlowCorrelations("POI","Eta");\r
 657     // nested loops:\r
 658     //this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
 659     //this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
 660     this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
 661     this->EvaluateDiffFlowCorrelationsWithNestedLoops(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
 662     // reduced corrections for non-uniform acceptance:\r
 663     // Q-vectors:\r
 664     this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Pt");\r
 665     this->CalculateDiffFlowCorrectionsForNUASinTerms("RP","Eta");\r
 666     this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Pt");\r
 667     this->CalculateDiffFlowCorrectionsForNUASinTerms("POI","Eta");\r
 668     this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Pt");\r
 669     this->CalculateDiffFlowCorrectionsForNUACosTerms("RP","Eta");\r
 670     this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Pt");\r
 671     this->CalculateDiffFlowCorrectionsForNUACosTerms("POI","Eta");\r
 672     // nested loops:\r
 673     //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
 674     //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
 675     this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
 676     this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
 677    } // end of if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
 678    // using particle weights:\r
 679    if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
 680    {\r
 681     this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Pt"); \r
 682     this->CalculateDiffFlowCorrelationsUsingParticleWeights("RP","Eta"); \r
 683     this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Pt"); \r
 684     this->CalculateDiffFlowCorrelationsUsingParticleWeights("POI","Eta"); \r
 685     this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Pt");\r
 686     this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("RP","Eta");\r
 687     this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Pt");\r
 688     this->CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights("POI","Eta");\r
 689     this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Pt");\r
 690     this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("RP","Eta");\r
 691     this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Pt");\r
 692     this->CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights("POI","Eta");\r
 693     this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
 694     this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
 695     this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
 696     this->EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)
 697     //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Pt"); // to be improved (enabled eventually)\r
 698     //this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"RP","Eta"); // to be improved (enabled eventually)\r
 699     this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Pt"); // to be improved (do I need to pass here anEvent?)\r
 700     this->EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(anEvent,"POI","Eta"); // to be improved (do I need to pass here anEvent?)\r
 701    } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
 702   } // end of if(nPrim>0 && nPrim<=fMaxAllowedMultiplicity) // by default fMaxAllowedMultiplicity = 10\r
 703  } // end of if(fEvaluateDiffFlowNestedLoops) \r
 704  \r
 705  // e) Reset all event by event quantities: \r
 706  this->ResetEventByEventQuantities();\r
 707  \r
 708 } // end of AliFlowAnalysisWithQCumulants::Make(AliFlowEventSimple* anEvent)\r
 709 \r
 710 \r
 711 //================================================================================================================================\r
 712 \r
 713 \r
 714 void AliFlowAnalysisWithQCumulants::Finish()\r
 715 {\r
 716  // Calculate the final results.\r
 717  //  a) acces the constants;\r
 718  //  b) access the flags;\r
 719  //  c) calculate the final results for integrated flow (without and with weights);\r
 720  //  d) store in AliFlowCommonHistResults and print the final results for integrated flow;\r
 721  //  e) calculate the final results for differential flow (without and with weights);\r
 722  //  f) print the final results for integrated flow obtained from differential flow (to be improved (terminology));\r
 723  //  g) cross-check the results: results from Q-vectors vs results from nested loops\r
 724  \r
 725  // ******************************\r
 726  // **** ACCESS THE CONSTANTS ****\r
 727  // ******************************\r
 728  \r
 729  this->AccessConstants();          \r
 730  \r
 731  if(fCommonHists && fCommonHists->GetHarmonic())\r
 732  {\r
 733   fHarmonic = (Int_t)(fCommonHists->GetHarmonic())->GetBinContent(1); // to be improved (moved somewhere else)\r
 734  } \r
 735 \r
 736  // **************************\r
 737  // **** ACCESS THE FLAGS ****\r
 738  // **************************    \r
 739  fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1); \r
 740  fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2); \r
 741  fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3);  \r
 742  fApplyCorrectionForNUA = (Int_t)fIntFlowFlags->GetBinContent(3); \r
 743  fEvaluateIntFlowNestedLoops = (Int_t)fEvaluateNestedLoops->GetBinContent(1);\r
 744  fEvaluateDiffFlowNestedLoops = (Int_t)fEvaluateNestedLoops->GetBinContent(2); \r
 745  fCrossCheckInPtBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(3);\r
 746  fCrossCheckInEtaBinNo = (Int_t)fEvaluateNestedLoops->GetBinContent(4); \r
 747     \r
 748  // *********************************************************\r
 749  // **** CALCULATE THE FINAL RESULTS FOR INTEGRATED FLOW ****\r
 750  // *********************************************************     \r
 751  \r
 752  this->FinalizeCorrelationsIntFlow();\r
 753  this->CalculateCovariancesIntFlow();\r
 754  this->CalculateCumulantsIntFlow();\r
 755  this->CalculateIntFlow(); \r
 756 \r
 757  if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (reorganized, etc)\r
 758  {\r
 759   this->FinalizeCorrectionTermsForNUAIntFlow();\r
 760   this->CalculateQcumulantsCorrectedForNUAIntFlow();   \r
 761   this->CalculateIntFlowCorrectedForNUA(); \r
 762  }\r
 763   \r
 764  // ***************************************************************\r
 765  // **** STORE AND PRINT THE FINAL RESULTS FOR INTEGRATED FLOW ****\r
 766  // ***************************************************************\r
 767  \r
 768  this->FillCommonHistResultsIntFlow();  \r
 769   \r
 770  this->PrintFinalResultsForIntegratedFlow("NONAME"); // to be improved (name)\r
 771  \r
 772  // ***********************************************************\r
 773  // **** CALCULATE THE FINAL RESULTS FOR DIFFERENTIAL FLOW ****\r
 774  // ***********************************************************    \r
 775  \r
 776  this->FinalizeReducedCorrelations("RP","Pt"); \r
 777  this->FinalizeReducedCorrelations("RP","Eta"); \r
 778  this->FinalizeReducedCorrelations("POI","Pt"); \r
 779  this->FinalizeReducedCorrelations("POI","Eta");\r
 780  this->CalculateDiffFlowCovariances("RP","Pt");\r
 781  this->CalculateDiffFlowCovariances("RP","Eta");\r
 782  this->CalculateDiffFlowCovariances("POI","Pt");\r
 783  this->CalculateDiffFlowCovariances("POI","Eta");\r
 784  this->CalculateDiffFlowCumulants("RP","Pt");\r
 785  this->CalculateDiffFlowCumulants("RP","Eta");\r
 786  this->CalculateDiffFlowCumulants("POI","Pt");\r
 787  this->CalculateDiffFlowCumulants("POI","Eta");\r
 788  this->CalculateDiffFlow("RP","Pt");\r
 789  this->CalculateDiffFlow("RP","Eta");\r
 790  this->CalculateDiffFlow("POI","Pt");\r
 791  this->CalculateDiffFlow("POI","Eta");\r
 792  \r
 793  if(fApplyCorrectionForNUA && !(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (reorganized, etc)\r
 794  {\r
 795   this->FinalizeCorrectionTermsForNUADiffFlow("RP","Pt");\r
 796   this->FinalizeCorrectionTermsForNUADiffFlow("RP","Eta");\r
 797   this->FinalizeCorrectionTermsForNUADiffFlow("POI","Pt");\r
 798   this->FinalizeCorrectionTermsForNUADiffFlow("POI","Eta");      \r
 799   this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Pt");   \r
 800   this->CalculateDiffFlowCumulantsCorrectedForNUA("RP","Eta");   \r
 801   this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Pt");   \r
 802   this->CalculateDiffFlowCumulantsCorrectedForNUA("POI","Eta");  \r
 803   this->CalculateDiffFlowCorrectedForNUA("RP","Pt"); \r
 804   this->CalculateDiffFlowCorrectedForNUA("RP","Eta"); \r
 805   this->CalculateDiffFlowCorrectedForNUA("POI","Pt"); \r
 806   this->CalculateDiffFlowCorrectedForNUA("POI","Eta"); \r
 807  }\r
 808  \r
 809  this->CalculateFinalResultsForRPandPOIIntegratedFlow("RP");\r
 810  this->CalculateFinalResultsForRPandPOIIntegratedFlow("POI");\r
 811 \r
 812  // *****************************************************************\r
 813  // **** STORE AND PRINT THE FINAL RESULTS FOR DIFFERENTIAL FLOW ****\r
 814  // *****************************************************************\r
 815  this->FillCommonHistResultsDiffFlow("RP");\r
 816  this->FillCommonHistResultsDiffFlow("POI");\r
 817 \r
 818  this->PrintFinalResultsForIntegratedFlow("RP"); \r
 819  this->PrintFinalResultsForIntegratedFlow("POI"); \r
 820   \r
 821  // g) cross-check the results: results from Q-vectors vs results from nested loops\r
 822
 823  //  g1) integrated flow:\r
 824  if(fEvaluateIntFlowNestedLoops)\r
 825  {\r
 826   this->CrossCheckIntFlowCorrelations();\r
 827   this->CrossCheckIntFlowCorrectionTermsForNUA(); \r
 828   if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) this->CrossCheckIntFlowExtraCorrelations();     \r
 829  } // end of if(fEvaluateIntFlowNestedLoops)  \r
 830
 831  //  g2) differential flow: \r
 832  if(fEvaluateDiffFlowNestedLoops) \r
 833  {\r
 834   // correlations:\r
 835   //this->CrossCheckDiffFlowCorrelations("RP","Pt"); // to be improved (enabled eventually)  \r
 836   //this->CrossCheckDiffFlowCorrelations("RP","Eta"); // to be improved (enabled eventually)  \r
 837   this->CrossCheckDiffFlowCorrelations("POI","Pt");  \r
 838   this->CrossCheckDiffFlowCorrelations("POI","Eta");\r
 839   // correction terms for non-uniform acceptance:\r
 840   //this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Pt"); // to be improved (enabled eventually)      \r
 841   //this->CrossCheckDiffFlowCorrectionTermsForNUA("RP","Eta"); // to be improved (enabled eventually)      \r
 842   if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) \r
 843   {\r
 844    this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Pt");      \r
 845    this->CrossCheckDiffFlowCorrectionTermsForNUA("POI","Eta");      \r
 846   } \r
 847  } // end of if(fEvaluateDiffFlowNestedLoops)\r
 848                                                                                                                                                                                                                                                                                                                                    \r
 849 } // end of AliFlowAnalysisWithQCumulants::Finish()\r
 850 \r
 851 \r
 852 //================================================================================================================================\r
 853 \r
 854 \r
 855 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()\r
 856 {\r
 857  // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (cos terms)\r
 858  \r
 859  // multiplicity:\r
 860  Double_t dMult = (*fSMpk)(0,0);\r
 861  \r
 862  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
 863  Double_t dReQ1n = (*fReQ)(0,0);\r
 864  Double_t dReQ2n = (*fReQ)(1,0);\r
 865  //Double_t dReQ3n = (*fReQ)(2,0);\r
 866  //Double_t dReQ4n = (*fReQ)(3,0);\r
 867  Double_t dImQ1n = (*fImQ)(0,0);\r
 868  Double_t dImQ2n = (*fImQ)(1,0);\r
 869  //Double_t dImQ3n = (*fImQ)(2,0);\r
 870  //Double_t dImQ4n = (*fImQ)(3,0);\r
 871         \r
 872  //                                  *************************************************************\r
 873  //                                  **** corrections for non-uniform acceptance (cos terms): ****\r
 874  //                                  *************************************************************\r
 875  //\r
 876  // Remark 1: corrections for non-uniform acceptance (cos terms) calculated with non-weighted Q-vectors \r
 877  //           are stored in 1D profile fQCorrectionsCos.\r
 878  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:\r
 879  // --------------------------------------------------------------------------------------------------------------------\r
 880  // 1st bin: <<cos(n*(phi1))>> = cosP1n\r
 881  // 2nd bin: <<cos(n*(phi1+phi2))>> = cosP1nP1n\r
 882  // 3rd bin: <<cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1n\r
 883  // ...\r
 884  // --------------------------------------------------------------------------------------------------------------------\r
 885   \r
 886  // 1-particle:\r
 887  Double_t cosP1n = 0.; // <<cos(n*(phi1))>>\r
 888    \r
 889  if(dMult>0)\r
 890  {\r
 891   cosP1n = dReQ1n/dMult; \r
 892   \r
 893   // average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:\r
 894   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1n);\r
 895   \r
 896   // final average non-weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:\r
 897   fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1n,dMult);  \r
 898  } \r
 899  \r
 900  // 2-particle:\r
 901  Double_t cosP1nP1n = 0.; // <<cos(n*(phi1+phi2))>>\r
 902  \r
 903  if(dMult>1)\r
 904  {\r
 905   cosP1nP1n = (pow(dReQ1n,2)-pow(dImQ1n,2)-dReQ2n)/(dMult*(dMult-1)); \r
 906   \r
 907   // average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:\r
 908   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1n);\r
 909   \r
 910   // final average non-weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:\r
 911   fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1n,dMult*(dMult-1));  \r
 912  } \r
 913  \r
 914  // 3-particle:\r
 915  Double_t cosP1nM1nM1n = 0.; // <<cos(n*(phi1-phi2-phi3))>>\r
 916  \r
 917  if(dMult>2)\r
 918  {\r
 919   cosP1nM1nM1n = (dReQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))-dReQ1n*dReQ2n-dImQ1n*dImQ2n-2.*(dMult-1)*dReQ1n)\r
 920                / (dMult*(dMult-1)*(dMult-2)); \r
 921   \r
 922   // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:\r
 923   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1n);\r
 924   \r
 925   // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:\r
 926   fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1n,dMult*(dMult-1)*(dMult-2));  \r
 927  } \r
 928  \r
 929 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTerms()\r
 930 \r
 931 \r
 932 //================================================================================================================================\r
 933 \r
 934 \r
 935 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()\r
 936 {\r
 937  // calculate corrections for non-uniform acceptance of the detector for no-name integrated flow (sin terms)\r
 938  \r
 939  // multiplicity:\r
 940  Double_t dMult = (*fSMpk)(0,0);\r
 941  \r
 942  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
 943  Double_t dReQ1n = (*fReQ)(0,0);\r
 944  Double_t dReQ2n = (*fReQ)(1,0);\r
 945  //Double_t dReQ3n = (*fReQ)(2,0);\r
 946  //Double_t dReQ4n = (*fReQ)(3,0);\r
 947  Double_t dImQ1n = (*fImQ)(0,0);\r
 948  Double_t dImQ2n = (*fImQ)(1,0);\r
 949  //Double_t dImQ3n = (*fImQ)(2,0);\r
 950  //Double_t dImQ4n = (*fImQ)(3,0);\r
 951         \r
 952  //                                  *************************************************************\r
 953  //                                  **** corrections for non-uniform acceptance (sin terms): ****\r
 954  //                                  *************************************************************\r
 955  //\r
 956  // Remark 1: corrections for non-uniform acceptance (sin terms) calculated with non-weighted Q-vectors \r
 957  //           are stored in 1D profile fQCorrectionsSin.\r
 958  // Remark 2: binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:\r
 959  // --------------------------------------------------------------------------------------------------------------------\r
 960  // 1st bin: <<sin(n*(phi1))>> = sinP1n\r
 961  // 2nd bin: <<sin(n*(phi1+phi2))>> = sinP1nP1n\r
 962  // 3rd bin: <<sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1n\r
 963  // ...\r
 964  // --------------------------------------------------------------------------------------------------------------------\r
 965  \r
 966  // 1-particle:\r
 967  Double_t sinP1n = 0.; // <sin(n*(phi1))>\r
 968  \r
 969  if(dMult>0)\r
 970  {\r
 971   sinP1n = dImQ1n/dMult; \r
 972      \r
 973   // average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:\r
 974   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1n);\r
 975   \r
 976   // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:   \r
 977   fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1n,dMult);  \r
 978  } \r
 979  \r
 980  // 2-particle:\r
 981  Double_t sinP1nP1n = 0.; // <<sin(n*(phi1+phi2))>>\r
 982  \r
 983  if(dMult>1)\r
 984  {\r
 985   sinP1nP1n = (2.*dReQ1n*dImQ1n-dImQ2n)/(dMult*(dMult-1)); \r
 986      \r
 987   // average non-weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:\r
 988   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1n);\r
 989   \r
 990   // final average non-weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:      \r
 991   fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1n,dMult*(dMult-1));  \r
 992  } \r
 993  \r
 994  // 3-particle:\r
 995  Double_t sinP1nM1nM1n = 0.; // <<sin(n*(phi1-phi2-phi3))>>\r
 996  \r
 997  if(dMult>2)\r
 998  {\r
 999   sinP1nM1nM1n = (-dImQ1n*(pow(dReQ1n,2)+pow(dImQ1n,2))+dReQ1n*dImQ2n-dImQ1n*dReQ2n+2.*(dMult-1)*dImQ1n)\r
1000                / (dMult*(dMult-1)*(dMult-2)); \r
1001   \r
1002   // average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:\r
1003   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1n);\r
1004   \r
1005   // final average non-weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:  \r
1006   fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1n,dMult*(dMult-1)*(dMult-2));  \r
1007  } \r
1008  \r
1009 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTerms()\r
1010 \r
1011 \r
1012 //================================================================================================================================\r
1013 \r
1014 \r
1015 void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)\r
1016 {\r
1017  // a) Get pointers for common control and common result histograms and profiles.\r
1018  // b) Get pointers for histograms with particle weights.\r
1019  // c) Get pointers for histograms and profiles relevant for integrated flow.\r
1020  // d) Get pointers for histograms and profiles relevant for differental flow.\r
1021  // e) Get pointers for histograms and profiles holding results obtained with nested loops.\r
1022  \r
1023  if(outputListHistos)\r
1024  {      \r
1025   this->GetPointersForCommonHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
1026   this->GetPointersForParticleWeightsHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
1027   this->GetPointersForIntFlowHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
1028   this->GetPointersForDiffFlowHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
1029   this->GetPointersForNestedLoopsHistograms(outputListHistos); // to be improved (no need to pass here argument, use setter for base list instead)\r
1030  }\r
1031    \r
1032 } // end of void AliFlowAnalysisWithQCumulants::GetOutputHistograms(TList *outputListHistos)\r
1033 \r
1034 \r
1035 //================================================================================================================================\r
1036 \r
1037 \r
1038 TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta) const\r
1039 {\r
1040  // project 2D profile onto pt axis to get 1D profile\r
1041  \r
1042  Int_t nBinsPt   = profilePtEta->GetNbinsX();\r
1043  Double_t dPtMin = (profilePtEta->GetXaxis())->GetXmin();\r
1044  Double_t dPtMax = (profilePtEta->GetXaxis())->GetXmax();\r
1045  \r
1046  Int_t nBinsEta   = profilePtEta->GetNbinsY();\r
1047  \r
1048  TProfile *profilePt = new TProfile("","",nBinsPt,dPtMin,dPtMax); \r
1049  \r
1050  for(Int_t p=1;p<=nBinsPt;p++)\r
1051  {\r
1052   Double_t contentPt = 0.;\r
1053   Double_t entryPt = 0.;\r
1054   Double_t spreadPt = 0.;\r
1055   Double_t sum1 = 0.;\r
1056   Double_t sum2 = 0.;\r
1057   Double_t sum3 = 0.;\r
1058   for(Int_t e=1;e<=nBinsEta;e++)\r
1059   {\r
1060    contentPt += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))\r
1061               * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1062    entryPt   += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1063    \r
1064    sum1 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))\r
1065          * (pow(profilePtEta->GetBinError(profilePtEta->GetBin(p,e)),2.)\r
1066             + pow(profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)),2.)); \r
1067    sum2 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1068    sum3 += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)))\r
1069          * (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)));            \r
1070   }\r
1071   if(sum2>0. && sum1/sum2-pow(sum3/sum2,2.) > 0.)\r
1072   {\r
1073    spreadPt = pow(sum1/sum2-pow(sum3/sum2,2.),0.5);\r
1074   }\r
1075   profilePt->SetBinContent(p,contentPt);\r
1076   profilePt->SetBinEntries(p,entryPt);\r
1077   {\r
1078    profilePt->SetBinError(p,spreadPt);\r
1079   }\r
1080   \r
1081  }\r
1082  \r
1083  return profilePt;\r
1084  \r
1085 } // end of TProfile* AliFlowAnalysisWithQCumulants::MakePtProjection(TProfile2D *profilePtEta)\r
1086 \r
1087 \r
1088 //================================================================================================================================\r
1089 \r
1090 \r
1091 TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta) const\r
1092 {\r
1093  // project 2D profile onto eta axis to get 1D profile\r
1094  \r
1095  Int_t nBinsEta   = profilePtEta->GetNbinsY();\r
1096  Double_t dEtaMin = (profilePtEta->GetYaxis())->GetXmin();\r
1097  Double_t dEtaMax = (profilePtEta->GetYaxis())->GetXmax();\r
1098  \r
1099  Int_t nBinsPt = profilePtEta->GetNbinsX();\r
1100  \r
1101  TProfile *profileEta = new TProfile("","",nBinsEta,dEtaMin,dEtaMax); \r
1102  \r
1103  for(Int_t e=1;e<=nBinsEta;e++)\r
1104  {\r
1105   Double_t contentEta = 0.;\r
1106   Double_t entryEta = 0.;\r
1107   for(Int_t p=1;p<=nBinsPt;p++)\r
1108   {\r
1109    contentEta += (profilePtEta->GetBinContent(profilePtEta->GetBin(p,e)))\r
1110               * (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1111    entryEta   += (profilePtEta->GetBinEntries(profilePtEta->GetBin(p,e)));\r
1112   }\r
1113   profileEta->SetBinContent(e,contentEta);\r
1114   profileEta->SetBinEntries(e,entryEta);\r
1115  }\r
1116  \r
1117  return profileEta;\r
1118  \r
1119 } // end of TProfile* AliFlowAnalysisWithQCumulants::MakeEtaProjection(TProfile2D *profilePtEta)\r
1120 \r
1121 \r
1122 //================================================================================================================================\r
1123 \r
1124 \r
1125 void AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type)\r
1126 {\r
1127  // printing on the screen the final results for integrated flow (NONAME, POI and RP) // to be improved (NONAME) \r
1128  \r
1129  Int_t n = fHarmonic; \r
1130  \r
1131  if(type == "NONAME" || type == "RP" || type == "POI")\r
1132  {\r
1133   if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
1134   {\r
1135    cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl;\r
1136    cout<<"         is NULL in AFAWQC::PFRFIF() !!!!"<<endl;\r
1137   }\r
1138  } else\r
1139    {\r
1140     cout<<"WARNING: type in not from {NONAME, RP, POI} in AFAWQC::PFRFIF() !!!!"<<endl;\r
1141     exit(0);\r
1142    }\r
1143  \r
1144  Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}   \r
1145  Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}   \r
1146  \r
1147  if(type == "NONAME")\r
1148  {\r
1149   dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1); \r
1150   dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1); \r
1151   dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1); \r
1152   dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1); \r
1153   dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1); \r
1154   dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1); \r
1155   dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1); \r
1156   dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1); \r
1157  } else if(type == "RP")\r
1158    {\r
1159     dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1); \r
1160     dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1); \r
1161     dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1); \r
1162     dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1); \r
1163     dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1); \r
1164     dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1); \r
1165     dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1); \r
1166     dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1); \r
1167    } else if(type == "POI")\r
1168      {\r
1169       dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1); \r
1170       dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1); \r
1171       dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1); \r
1172       dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1); \r
1173       dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1); \r
1174       dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1); \r
1175       dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1); \r
1176       dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1); \r
1177      }\r
1178  \r
1179  TString title = " flow estimates from Q-cumulants"; \r
1180  TString subtitle = "    ("; \r
1181  \r
1182  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
1183  {\r
1184   subtitle.Append(type);\r
1185   subtitle.Append(", without weights)");\r
1186  } else  \r
1187    {\r
1188     subtitle.Append(type);\r
1189     subtitle.Append(", with weights)");\r
1190    }\r
1191   \r
1192  cout<<endl;\r
1193  cout<<"*************************************"<<endl;\r
1194  cout<<"*************************************"<<endl;\r
1195  cout<<title.Data()<<endl; \r
1196  cout<<subtitle.Data()<<endl; \r
1197  cout<<endl;\r
1198   \r
1199  for(Int_t i=0;i<4;i++)\r
1200  {\r
1201   if(dVn[i]>=0.)\r
1202   {\r
1203    cout<<"  v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;\r
1204   }\r
1205   else\r
1206   {\r
1207    cout<<"  v_"<<n<<"{"<<2*(i+1)<<"} = Im"<<endl;\r
1208   }  \r
1209  }\r
1210 \r
1211  cout<<endl;\r
1212  /*\r
1213  if(type == "NONAME")\r
1214  {\r
1215   cout<<"     nEvts = "<<nEvtsNoName<<", AvM = "<<dMultNoName<<endl; // to be improved\r
1216  }\r
1217  else if (type == "RP")\r
1218  {\r
1219   cout<<"     nEvts = "<<nEvtsRP<<", AvM = "<<dMultRP<<endl; // to be improved  \r
1220  } \r
1221  else if (type == "POI")\r
1222  {\r
1223   cout<<"     nEvts = "<<nEvtsPOI<<", AvM = "<<dMultPOI<<endl; // to be improved  \r
1224  } \r
1225  */\r
1226  cout<<"*************************************"<<endl;\r
1227  cout<<"*************************************"<<endl;\r
1228  cout<<endl; \r
1229   \r
1230 }// end of AliFlowAnalysisWithQCumulants::PrintFinalResultsForIntegratedFlow(TString type="NONAME");\r
1231 \r
1232 \r
1233 //================================================================================================================================\r
1234 \r
1235 \r
1236 void AliFlowAnalysisWithQCumulants::WriteHistograms(TString outputFileName)\r
1237 {\r
1238  //store the final results in output .root file\r
1239  TFile *output = new TFile(outputFileName.Data(),"RECREATE");\r
1240  //output->WriteObject(fHistList, "cobjQC","SingleKey");\r
1241  fHistList->Write(fHistList->GetName(), TObject::kSingleKey);\r
1242  delete output;\r
1243 }\r
1244 \r
1245 \r
1246 //================================================================================================================================\r
1247
1248
1249 void AliFlowAnalysisWithQCumulants::WriteHistograms(TDirectoryFile *outputFileName)
1250 {
1251  //store the final results in output .root file
1252  fHistList->SetName("cobjQC");
1253  fHistList->SetOwner(kTRUE);
1254  outputFileName->Add(fHistList);
1255  outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);
1256 }
1257 \r
1258
1259 //================================================================================================================================\r
1260
1261 \r
1262 void AliFlowAnalysisWithQCumulants::BookCommonHistograms()\r
1263 {\r
1264  // Book common control histograms and common histograms for final results.\r
1265  // common control histogram (ALL events)\r
1266  TString commonHistsName = "AliFlowCommonHistQC";\r
1267  commonHistsName += fAnalysisLabel->Data();\r
1268  fCommonHists = new AliFlowCommonHist(commonHistsName.Data());\r
1269  fHistList->Add(fCommonHists);  \r
1270  // common control histogram (for events with 2 and more particles)\r
1271  TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";\r
1272  commonHists2ndOrderName += fAnalysisLabel->Data();\r
1273  fCommonHists2nd = new AliFlowCommonHist(commonHists2ndOrderName.Data());\r
1274  fHistList->Add(fCommonHists2nd);  \r
1275  // common control histogram (for events with 4 and more particles)\r
1276  TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";\r
1277  commonHists4thOrderName += fAnalysisLabel->Data();\r
1278  fCommonHists4th = new AliFlowCommonHist(commonHists4thOrderName.Data());\r
1279  fHistList->Add(fCommonHists4th);  \r
1280  // common control histogram (for events with 6 and more particles)\r
1281  TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";\r
1282  commonHists6thOrderName += fAnalysisLabel->Data();\r
1283  fCommonHists6th = new AliFlowCommonHist(commonHists6thOrderName.Data());\r
1284  fHistList->Add(fCommonHists6th);  \r
1285  // common control histogram (for events with 8 and more particles)\r
1286  TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";\r
1287  commonHists8thOrderName += fAnalysisLabel->Data();\r
1288  fCommonHists8th = new AliFlowCommonHist(commonHists8thOrderName.Data());\r
1289  fHistList->Add(fCommonHists8th);    \r
1290  // common histograms for final results (calculated for events with 2 and more particles)\r
1291  TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC";\r
1292  commonHistResults2ndOrderName += fAnalysisLabel->Data();\r
1293  fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data());\r
1294  fHistList->Add(fCommonHistsResults2nd);  \r
1295  // common histograms for final results (calculated for events with 4 and more particles)\r
1296  TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";\r
1297  commonHistResults4thOrderName += fAnalysisLabel->Data();\r
1298  fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data());\r
1299  fHistList->Add(fCommonHistsResults4th); \r
1300  // common histograms for final results (calculated for events with 6 and more particles)\r
1301  TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";\r
1302  commonHistResults6thOrderName += fAnalysisLabel->Data();\r
1303  fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data());\r
1304  fHistList->Add(fCommonHistsResults6th);  \r
1305  // common histograms for final results (calculated for events with 8 and more particles)\r
1306  TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";\r
1307  commonHistResults8thOrderName += fAnalysisLabel->Data();\r
1308  fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data());\r
1309  fHistList->Add(fCommonHistsResults8th); \r
1310  \r
1311 } // end of void AliFlowAnalysisWithQCumulants::BookCommonHistograms()\r
1312 \r
1313 \r
1314 //================================================================================================================================\r
1315 \r
1316 \r
1317 void AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()\r
1318 {\r
1319  // book and fill histograms which hold phi, pt and eta weights\r
1320 \r
1321  if(!fWeightsList)\r
1322  {\r
1323   cout<<"WARNING: fWeightsList is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1324   exit(0);  \r
1325  }\r
1326     \r
1327  TString fUseParticleWeightsName = "fUseParticleWeightsQC";\r
1328  fUseParticleWeightsName += fAnalysisLabel->Data();\r
1329  fUseParticleWeights = new TProfile(fUseParticleWeightsName.Data(),"0 = particle weight not used, 1 = particle weight used ",3,0,3);\r
1330  fUseParticleWeights->SetLabelSize(0.06);\r
1331  (fUseParticleWeights->GetXaxis())->SetBinLabel(1,"w_{#phi}");\r
1332  (fUseParticleWeights->GetXaxis())->SetBinLabel(2,"w_{p_{T}}");\r
1333  (fUseParticleWeights->GetXaxis())->SetBinLabel(3,"w_{#eta}");\r
1334  fUseParticleWeights->Fill(0.5,(Int_t)fUsePhiWeights);\r
1335  fUseParticleWeights->Fill(1.5,(Int_t)fUsePtWeights);\r
1336  fUseParticleWeights->Fill(2.5,(Int_t)fUseEtaWeights);\r
1337  fWeightsList->Add(fUseParticleWeights); \r
1338   \r
1339  if(fUsePhiWeights)\r
1340  {\r
1341   if(fWeightsList->FindObject("phi_weights"))\r
1342   {\r
1343    fPhiWeights = dynamic_cast<TH1F*>(fWeightsList->FindObject("phi_weights"));\r
1344    if((fPhiWeights->GetBinWidth(1) > fPhiBinWidth) || (fPhiWeights->GetBinWidth(1) < fPhiBinWidth))\r
1345    {\r
1346     cout<<"WARNING: fPhiWeights->GetBinWidth(1) != fPhiBinWidth in AFAWQC::BAFWH() !!!!        "<<endl;\r
1347     cout<<"         This indicates inconsistent binning in phi histograms throughout the code."<<endl;\r
1348     exit(0);\r
1349    }\r
1350   } else \r
1351     {\r
1352      cout<<"WARNING: fWeightsList->FindObject(\"phi_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1353      exit(0);\r
1354     }\r
1355  } // end of if(fUsePhiWeights)\r
1356  \r
1357  if(fUsePtWeights) \r
1358  {\r
1359   if(fWeightsList->FindObject("pt_weights"))\r
1360   {\r
1361    fPtWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("pt_weights"));\r
1362    if((fPtWeights->GetBinWidth(1) > fPtBinWidth) || (fPtWeights->GetBinWidth(1) < fPtBinWidth))\r
1363    {\r
1364     cout<<"WARNING: fPtWeights->GetBinWidth(1) != fPtBinWidth in AFAWQC::BAFWH() !!!!         "<<endl;\r
1365     cout<<"         This indicates insconsistent binning in pt histograms throughout the code."<<endl;\r
1366     exit(0);\r
1367    }\r
1368   } else \r
1369     {\r
1370      cout<<"WARNING: fWeightsList->FindObject(\"pt_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1371      exit(0);\r
1372     }\r
1373  } // end of if(fUsePtWeights)    \r
1374 \r
1375  if(fUseEtaWeights) \r
1376  {\r
1377   if(fWeightsList->FindObject("eta_weights"))\r
1378   {\r
1379    fEtaWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("eta_weights"));\r
1380    if((fEtaWeights->GetBinWidth(1) > fEtaBinWidth) || (fEtaWeights->GetBinWidth(1) < fEtaBinWidth))\r
1381    {\r
1382     cout<<"WARNING: fEtaWeights->GetBinWidth(1) != fEtaBinWidth in AFAWQC::BAFWH() !!!!        "<<endl;\r
1383     cout<<"         This indicates insconsistent binning in eta histograms throughout the code."<<endl;\r
1384     exit(0);\r
1385    }\r
1386   } else \r
1387     {\r
1388      cout<<"WARNING: fUseEtaWeights && fWeightsList->FindObject(\"eta_weights\") is NULL in AFAWQC::BAFWH() !!!!"<<endl;\r
1389      exit(0);\r
1390     }\r
1391  } // end of if(fUseEtaWeights)\r
1392  \r
1393 } // end of AliFlowAnalysisWithQCumulants::BookAndFillWeightsHistograms()\r
1394 \r
1395 \r
1396 //================================================================================================================================\r
1397 \r
1398 \r
1399 void AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()\r
1400 {\r
1401  // Book all objects for integrated flow:\r
1402  //  a) Book profile to hold all flags for integrated flow.\r
1403  //  b) Book event-by-event quantities.\r
1404  //  c) Book profiles. // to be improved (comment)\r
1405  //  d) Book histograms holding the final results.\r
1406  \r
1407  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
1408  TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data members?)\r
1409  \r
1410  // a) Book profile to hold all flags for integrated flow:\r
1411  TString intFlowFlagsName = "fIntFlowFlags";\r
1412  intFlowFlagsName += fAnalysisLabel->Data();\r
1413  fIntFlowFlags = new TProfile(intFlowFlagsName.Data(),"Flags for Integrated Flow",3,0,3);\r
1414  fIntFlowFlags->SetTickLength(-0.01,"Y");\r
1415  fIntFlowFlags->SetMarkerStyle(25);\r
1416  fIntFlowFlags->SetLabelSize(0.05);\r
1417  fIntFlowFlags->SetLabelOffset(0.02,"Y");\r
1418  (fIntFlowFlags->GetXaxis())->SetBinLabel(1,"Particle Weights");\r
1419  (fIntFlowFlags->GetXaxis())->SetBinLabel(2,"Event Weights");\r
1420  (fIntFlowFlags->GetXaxis())->SetBinLabel(3,"Corrected for NUA?");\r
1421  fIntFlowList->Add(fIntFlowFlags);\r
1422 \r
1423  // b) Book event-by-event quantities:\r
1424  // Re[Q_{m*n,k}], Im[Q_{m*n,k}] and S_{p,k}^M: \r
1425  fReQ  = new TMatrixD(4,9);\r
1426  fImQ  = new TMatrixD(4,9);\r
1427  fSMpk = new TMatrixD(8,9);\r
1428  // average correlations <2>, <4>, <6> and <8> for single event (bining is the same as in fIntFlowCorrelationsPro and fIntFlowCorrelationsHist):\r
1429  TString intFlowCorrelationsEBEName = "fIntFlowCorrelationsEBE";\r
1430  intFlowCorrelationsEBEName += fAnalysisLabel->Data();\r
1431  fIntFlowCorrelationsEBE = new TH1D(intFlowCorrelationsEBEName.Data(),intFlowCorrelationsEBEName.Data(),4,0,4);\r
1432  // weights for average correlations <2>, <4>, <6> and <8> for single event:\r
1433  TString intFlowEventWeightsForCorrelationsEBEName = "fIntFlowEventWeightsForCorrelationsEBE";\r
1434  intFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();\r
1435  fIntFlowEventWeightsForCorrelationsEBE = new TH1D(intFlowEventWeightsForCorrelationsEBEName.Data(),intFlowEventWeightsForCorrelationsEBEName.Data(),4,0,4);\r
1436  // average all correlations for single event (bining is the same as in fIntFlowCorrelationsAllPro and fIntFlowCorrelationsAllHist):\r
1437  TString intFlowCorrelationsAllEBEName = "fIntFlowCorrelationsAllEBE";\r
1438  intFlowCorrelationsAllEBEName += fAnalysisLabel->Data();\r
1439  fIntFlowCorrelationsAllEBE = new TH1D(intFlowCorrelationsAllEBEName.Data(),intFlowCorrelationsAllEBEName.Data(),32,0,32);\r
1440  // average correction terms for non-uniform acceptance for single event \r
1441  // (binning is the same as in fIntFlowCorrectionTermsForNUAPro[2] and fIntFlowCorrectionTermsForNUAHist[2]):\r
1442  TString fIntFlowCorrectionTermsForNUAEBEName = "fIntFlowCorrectionTermsForNUAEBE";\r
1443  fIntFlowCorrectionTermsForNUAEBEName += fAnalysisLabel->Data();\r
1444  for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1445  {\r
1446   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()),10,0,10);  \r
1447  }\r
1448  \r
1449  // c) Book profiles: // to be improved (comment)\r
1450  // profile to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8:\r
1451  TString avMultiplicityName = "fAvMultiplicity";\r
1452  avMultiplicityName += fAnalysisLabel->Data();\r
1453  fAvMultiplicity = new TProfile(avMultiplicityName.Data(),"Average Multiplicities of RPs",9,0,9);\r
1454  fAvMultiplicity->SetTickLength(-0.01,"Y");\r
1455  fAvMultiplicity->SetMarkerStyle(25);\r
1456  fAvMultiplicity->SetLabelSize(0.05);\r
1457  fAvMultiplicity->SetLabelOffset(0.02,"Y");\r
1458  fAvMultiplicity->SetYTitle("Average Multiplicity");\r
1459  (fAvMultiplicity->GetXaxis())->SetBinLabel(1,"all evts");\r
1460  (fAvMultiplicity->GetXaxis())->SetBinLabel(2,"n_{RP} #geq 1");\r
1461  (fAvMultiplicity->GetXaxis())->SetBinLabel(3,"n_{RP} #geq 2");\r
1462  (fAvMultiplicity->GetXaxis())->SetBinLabel(4,"n_{RP} #geq 3");\r
1463  (fAvMultiplicity->GetXaxis())->SetBinLabel(5,"n_{RP} #geq 4");\r
1464  (fAvMultiplicity->GetXaxis())->SetBinLabel(6,"n_{RP} #geq 5");\r
1465  (fAvMultiplicity->GetXaxis())->SetBinLabel(7,"n_{RP} #geq 6");\r
1466  (fAvMultiplicity->GetXaxis())->SetBinLabel(8,"n_{RP} #geq 7");\r
1467  (fAvMultiplicity->GetXaxis())->SetBinLabel(9,"n_{RP} #geq 8");\r
1468  fIntFlowProfiles->Add(fAvMultiplicity);\r
1469  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with wrong errors!):\r
1470  TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";\r
1471  intFlowCorrelationsProName += fAnalysisLabel->Data();\r
1472  fIntFlowCorrelationsPro = new TProfile(intFlowCorrelationsProName.Data(),"Average correlations for all events",4,0,4,"s");\r
1473  fIntFlowCorrelationsPro->SetTickLength(-0.01,"Y");\r
1474  fIntFlowCorrelationsPro->SetMarkerStyle(25);\r
1475  fIntFlowCorrelationsPro->SetLabelSize(0.06);\r
1476  fIntFlowCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1477  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<2>>");\r
1478  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<4>>");\r
1479  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(3,"<<6>>");\r
1480  (fIntFlowCorrelationsPro->GetXaxis())->SetBinLabel(4,"<<8>>");\r
1481  fIntFlowProfiles->Add(fIntFlowCorrelationsPro);\r
1482  // averaged all correlations for all events (with wrong errors!):\r
1483  TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";\r
1484  intFlowCorrelationsAllProName += fAnalysisLabel->Data();\r
1485  fIntFlowCorrelationsAllPro = new TProfile(intFlowCorrelationsAllProName.Data(),"Average correlations for all events",32,0,32,"s");\r
1486  fIntFlowCorrelationsAllPro->SetTickLength(-0.01,"Y");\r
1487  fIntFlowCorrelationsAllPro->SetMarkerStyle(25);\r
1488  fIntFlowCorrelationsAllPro->SetLabelSize(0.03);\r
1489  fIntFlowCorrelationsAllPro->SetLabelOffset(0.01,"Y");\r
1490  // 2-p correlations:\r
1491  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");\r
1492  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");\r
1493  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");\r
1494  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");\r
1495  // 3-p correlations:\r
1496  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");\r
1497  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");\r
1498  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");\r
1499  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");\r
1500  // 4-p correlations:\r
1501  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}"); \r
1502  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");\r
1503  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");\r
1504  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");\r
1505  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");\r
1506  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}"); \r
1507  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");\r
1508  // 5-p correlations:\r
1509  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}"); \r
1510  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");\r
1511  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");\r
1512  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");\r
1513  // 6-p correlations:\r
1514  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");\r
1515  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");\r
1516  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");\r
1517  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");\r
1518  // 7-p correlations:  \r
1519  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");\r
1520  // 8-p correlations:\r
1521  (fIntFlowCorrelationsAllPro->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");\r
1522  fIntFlowProfiles->Add(fIntFlowCorrelationsAllPro);\r
1523  // when particle weights are used some extra correlations appear:\r
1524  if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights) \r
1525  {\r
1526   TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";\r
1527   intFlowExtraCorrelationsProName += fAnalysisLabel->Data();\r
1528   fIntFlowExtraCorrelationsPro = new TProfile(intFlowExtraCorrelationsProName.Data(),"Average extra correlations for all events",100,0,100,"s");\r
1529   fIntFlowExtraCorrelationsPro->SetTickLength(-0.01,"Y");\r
1530   fIntFlowExtraCorrelationsPro->SetMarkerStyle(25);\r
1531   fIntFlowExtraCorrelationsPro->SetLabelSize(0.03);\r
1532   fIntFlowExtraCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1533   // extra 2-p correlations:\r
1534   (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<w1^3 w2 cos(n*(phi1-phi2))>>");\r
1535   (fIntFlowExtraCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<w1 w2 w3^2 cos(n*(phi1-phi2))>>");\r
1536   fIntFlowProfiles->Add(fIntFlowExtraCorrelationsPro);\r
1537  } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1538  // average product of correlations <2>, <4>, <6> and <8>:  \r
1539  TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";\r
1540  intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();\r
1541  fIntFlowProductOfCorrelationsPro = new TProfile(intFlowProductOfCorrelationsProName.Data(),"Average products of correlations",6,0,6);\r
1542  fIntFlowProductOfCorrelationsPro->SetTickLength(-0.01,"Y");\r
1543  fIntFlowProductOfCorrelationsPro->SetMarkerStyle(25); \r
1544  fIntFlowProductOfCorrelationsPro->SetLabelSize(0.05);\r
1545  fIntFlowProductOfCorrelationsPro->SetLabelOffset(0.01,"Y");\r
1546  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(1,"<<2><4>>");\r
1547  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(2,"<<2><6>>");\r
1548  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(3,"<<2><8>>");\r
1549  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(4,"<<4><6>>");\r
1550  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(5,"<<4><8>>");\r
1551  (fIntFlowProductOfCorrelationsPro->GetXaxis())->SetBinLabel(6,"<<6><8>>");\r
1552  fIntFlowProfiles->Add(fIntFlowProductOfCorrelationsPro);\r
1553  // average correction terms for non-uniform acceptance (with wrong errors!):\r
1554  for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1555  {\r
1556   TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";\r
1557   intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
1558   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()),10,0,10,"s");\r
1559   fIntFlowCorrectionTermsForNUAPro[sc]->SetTickLength(-0.01,"Y");\r
1560   fIntFlowCorrectionTermsForNUAPro[sc]->SetMarkerStyle(25);\r
1561   fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelSize(0.03);\r
1562   fIntFlowCorrectionTermsForNUAPro[sc]->SetLabelOffset(0.01,"Y");\r
1563   // 1-particle terms:\r
1564   (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(1,Form("<<%s(n(phi1))>>",sinCosFlag[sc].Data()));\r
1565   // 2-particle terms:\r
1566   (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(2,Form("<<%s(n(phi1+phi2))>>",sinCosFlag[sc].Data()));  \r
1567   // 3-particle terms:\r
1568   (fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->SetBinLabel(3,Form("<<%s(n(phi1-phi2-phi3))>>",sinCosFlag[sc].Data()));  \r
1569   // ... \r
1570   fIntFlowProfiles->Add(fIntFlowCorrectionTermsForNUAPro[sc]);\r
1571  } // end of for(Int_t sc=0;sc<2;sc++) \r
1572  \r
1573  // d) Book histograms holding the final results:\r
1574  // average correlations <<2>>, <<4>>, <<6>> and <<8>> for all events (with correct errors!):\r
1575  TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";\r
1576  intFlowCorrelationsHistName += fAnalysisLabel->Data();\r
1577  fIntFlowCorrelationsHist = new TH1D(intFlowCorrelationsHistName.Data(),"Average correlations for all events",4,0,4);\r
1578  fIntFlowCorrelationsHist->SetTickLength(-0.01,"Y");\r
1579  fIntFlowCorrelationsHist->SetMarkerStyle(25);\r
1580  fIntFlowCorrelationsHist->SetLabelSize(0.06);\r
1581  fIntFlowCorrelationsHist->SetLabelOffset(0.01,"Y");\r
1582  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(1,"<<2>>");\r
1583  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(2,"<<4>>");\r
1584  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(3,"<<6>>");\r
1585  (fIntFlowCorrelationsHist->GetXaxis())->SetBinLabel(4,"<<8>>");\r
1586  fIntFlowResults->Add(fIntFlowCorrelationsHist);\r
1587  // average all correlations for all events (with correct errors!):\r
1588  TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";\r
1589  intFlowCorrelationsAllHistName += fAnalysisLabel->Data();\r
1590  fIntFlowCorrelationsAllHist = new TH1D(intFlowCorrelationsAllHistName.Data(),"Average correlations for all events",32,0,32);\r
1591  fIntFlowCorrelationsAllHist->SetTickLength(-0.01,"Y");\r
1592  fIntFlowCorrelationsAllHist->SetMarkerStyle(25);\r
1593  fIntFlowCorrelationsAllHist->SetLabelSize(0.03);\r
1594  fIntFlowCorrelationsAllHist->SetLabelOffset(0.01,"Y");\r
1595  // 2-p correlations:\r
1596  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(1,"<<2>>_{n|n}");\r
1597  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(2,"<<2>>_{2n|2n}");\r
1598  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(3,"<<2>>_{3n|3n}");\r
1599  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(4,"<<2>>_{4n|4n}");\r
1600  // 3-p correlations:\r
1601  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(6,"<<3>>_{2n|n,n}");\r
1602  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(7,"<<3>>_{3n|2n,n}");\r
1603  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(8,"<<3>>_{4n|2n,2n}");\r
1604  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(9,"<<3>>_{4n|3n,n}");\r
1605  // 4-p correlations:\r
1606  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(11,"<<4>>_{n,n|n,n}"); \r
1607  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(12,"<<4>>_{2n,n|2n,n}");\r
1608  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(13,"<<4>>_{2n,2n|2n,2n}");\r
1609  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(14,"<<4>>_{3n|n,n,n}");\r
1610  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(15,"<<4>>_{3n,n|3n,n}");\r
1611  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(16,"<<4>>_{3n,n|2n,2n}"); \r
1612  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(17,"<<4>>_{4n|2n,n,n}");\r
1613  // 5-p correlations:\r
1614  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(19,"<<5>>_{2n|n,n,n,n}"); \r
1615  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(20,"<<5>>_{2n,2n|2n,n,n}");\r
1616  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(21,"<<5>>_{3n,n|2n,n,n}");\r
1617  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(22,"<<5>>_{4n|n,n,n,n}");\r
1618  // 6-p correlations:\r
1619  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(24,"<<6>>_{n,n,n|n,n,n}");\r
1620  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(25,"<<6>>_{2n,n,n|2n,n,n}");\r
1621  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(26,"<<6>>_{2n,2n|n,n,n,n}");\r
1622  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(27,"<<6>>_{3n,n|n,n,n,n}");\r
1623  // 7-p correlations:  \r
1624  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(29,"<<7>>_{2n,n,n|n,n,n,n}");\r
1625  // 8-p correlations:\r
1626  (fIntFlowCorrelationsAllHist->GetXaxis())->SetBinLabel(31,"<<8>>_{n,n,n,n|n,n,n,n}");\r
1627  fIntFlowResults->Add(fIntFlowCorrelationsAllHist);\r
1628  // average correction terms for non-uniform acceptance (with correct errors!):\r
1629  for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1630  {\r
1631   TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";\r
1632   intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
1633   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()),10,0,10);\r
1634   fIntFlowCorrectionTermsForNUAHist[sc]->SetTickLength(-0.01,"Y");\r
1635   fIntFlowCorrectionTermsForNUAHist[sc]->SetMarkerStyle(25);\r
1636   fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelSize(0.03);\r
1637   fIntFlowCorrectionTermsForNUAHist[sc]->SetLabelOffset(0.01,"Y");\r
1638   // ......................................................................... \r
1639   // 1-p terms:\r
1640   (fIntFlowCorrectionTermsForNUAHist[sc]->GetXaxis())->SetBinLabel(1,Form("%s(n(#phi_{1}))>",sinCosFlag[sc].Data()));\r
1641   // 2-p terms:\r
1642   // 3-p terms:\r
1643   // ...\r
1644   // ......................................................................... \r
1645   fIntFlowResults->Add(fIntFlowCorrectionTermsForNUAHist[sc]);\r
1646  } // end of for(Int_t sc=0;sc<2;sc++) \r
1647  // covariances (multiplied with weight dependent prefactor):\r
1648  TString intFlowCovariancesName = "fIntFlowCovariances";\r
1649  intFlowCovariancesName += fAnalysisLabel->Data();\r
1650  fIntFlowCovariances = new TH1D(intFlowCovariancesName.Data(),"Covariances (multiplied with weight dependent prefactor)",6,0,6);\r
1651  fIntFlowCovariances->SetLabelSize(0.04);\r
1652  fIntFlowCovariances->SetMarkerStyle(25);\r
1653  (fIntFlowCovariances->GetXaxis())->SetBinLabel(1,"Cov(<2>,<4>)");\r
1654  (fIntFlowCovariances->GetXaxis())->SetBinLabel(2,"Cov(<2>,<6>)");\r
1655  (fIntFlowCovariances->GetXaxis())->SetBinLabel(3,"Cov(<2>,<8>)");\r
1656  (fIntFlowCovariances->GetXaxis())->SetBinLabel(4,"Cov(<4>,<6>)");\r
1657  (fIntFlowCovariances->GetXaxis())->SetBinLabel(5,"Cov(<4>,<8>)");\r
1658  (fIntFlowCovariances->GetXaxis())->SetBinLabel(6,"Cov(<6>,<8>)");  \r
1659  fIntFlowResults->Add(fIntFlowCovariances);\r
1660  // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:\r
1661  TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";\r
1662  intFlowSumOfEventWeightsName += fAnalysisLabel->Data();\r
1663  for(Int_t power=0;power<2;power++)\r
1664  {\r
1665   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);\r
1666   fIntFlowSumOfEventWeights[power]->SetLabelSize(0.05);\r
1667   fIntFlowSumOfEventWeights[power]->SetMarkerStyle(25);\r
1668   if(power == 0)\r
1669   {\r
1670    (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>}");\r
1671    (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<4>}");\r
1672    (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<6>}");\r
1673    (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<8>}");\r
1674   } else if (power == 1) \r
1675     {\r
1676      (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>}^{2}");\r
1677      (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<4>}^{2}");\r
1678      (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<6>}^{2}");\r
1679      (fIntFlowSumOfEventWeights[power]->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<8>}^{2}");\r
1680     }\r
1681   fIntFlowResults->Add(fIntFlowSumOfEventWeights[power]);\r
1682  } \r
1683  // sum of products of event weights for correlations <2>, <4>, <6> and <8>:  \r
1684  TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";\r
1685  intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();\r
1686  fIntFlowSumOfProductOfEventWeights = new TH1D(intFlowSumOfProductOfEventWeightsName.Data(),"Sum of product of event weights for correlations",6,0,6);\r
1687  fIntFlowSumOfProductOfEventWeights->SetLabelSize(0.05);\r
1688  fIntFlowSumOfProductOfEventWeights->SetMarkerStyle(25);\r
1689  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(1,"#sum_{i=1}^{N} w_{<2>} w_{<4>}");\r
1690  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(2,"#sum_{i=1}^{N} w_{<2>} w_{<6>}");\r
1691  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(3,"#sum_{i=1}^{N} w_{<2>} w_{<8>}");\r
1692  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(4,"#sum_{i=1}^{N} w_{<4>} w_{<6>}");\r
1693  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(5,"#sum_{i=1}^{N} w_{<4>} w_{<8>}");\r
1694  (fIntFlowSumOfProductOfEventWeights->GetXaxis())->SetBinLabel(6,"#sum_{i=1}^{N} w_{<6>} w_{<8>}");\r
1695  fIntFlowResults->Add(fIntFlowSumOfProductOfEventWeights);\r
1696  // final results for integrated Q-cumulants:\r
1697  TString intFlowQcumulantsName = "fIntFlowQcumulants";\r
1698  intFlowQcumulantsName += fAnalysisLabel->Data();\r
1699  fIntFlowQcumulants = new TH1D(intFlowQcumulantsName.Data(),"Integrated Q-cumulants",4,0,4);\r
1700  fIntFlowQcumulants->SetLabelSize(0.05);\r
1701  fIntFlowQcumulants->SetMarkerStyle(25);\r
1702  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(1,"QC{2}");\r
1703  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(2,"QC{4}");\r
1704  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(3,"QC{6}");\r
1705  (fIntFlowQcumulants->GetXaxis())->SetBinLabel(4,"QC{8}");\r
1706  fIntFlowResults->Add(fIntFlowQcumulants);\r
1707  // final integrated flow estimates from Q-cumulants:\r
1708  TString intFlowName = "fIntFlow";\r
1709  intFlowName += fAnalysisLabel->Data();  \r
1710  // integrated flow from Q-cumulants:\r
1711  fIntFlow = new TH1D(intFlowName.Data(),"Integrated flow estimates from Q-cumulants",4,0,4);\r
1712  fIntFlow->SetLabelSize(0.05);\r
1713  fIntFlow->SetMarkerStyle(25);\r
1714  (fIntFlow->GetXaxis())->SetBinLabel(1,"v_{2}{2,QC}");\r
1715  (fIntFlow->GetXaxis())->SetBinLabel(2,"v_{2}{4,QC}");\r
1716  (fIntFlow->GetXaxis())->SetBinLabel(3,"v_{2}{6,QC}");\r
1717  (fIntFlow->GetXaxis())->SetBinLabel(4,"v_{2}{8,QC}");\r
1718  fIntFlowResults->Add(fIntFlow);\r
1719 \r
1720  /* // to be improved (removed):\r
1721   // final average weighted multi-particle correlations for all events calculated from Q-vectors\r
1722   fQCorrelations[1] = new TProfile("Weighted correlations","final average multi-particle correlations from weighted Q-vectors",200,0,200,"s");\r
1723   fQCorrelations[1]->SetTickLength(-0.01,"Y");\r
1724   fQCorrelations[1]->SetMarkerStyle(25);\r
1725   fQCorrelations[1]->SetLabelSize(0.03);\r
1726   fQCorrelations[1]->SetLabelOffset(0.01,"Y");\r
1727   // 2-particle correlations:\r
1728   (fQCorrelations[1]->GetXaxis())->SetBinLabel(1,"<w_{1}w_{2}cos(n(#phi_{1}-#phi_{2}))>");\r
1729   (fQCorrelations[1]->GetXaxis())->SetBinLabel(2,"<w_{1}^{2}w_{2}^{2}cos(2n(#phi_{1}-#phi_{2}))>");\r
1730   (fQCorrelations[1]->GetXaxis())->SetBinLabel(3,"<w_{1}^{3}w_{2}^{3}cos(3n(#phi_{1}-#phi_{2}))>");\r
1731   (fQCorrelations[1]->GetXaxis())->SetBinLabel(4,"<w_{1}^{4}w_{2}^{4}cos(4n(#phi_{1}-#phi_{2}))>");\r
1732   (fQCorrelations[1]->GetXaxis())->SetBinLabel(5,"<w_{1}^{3}w_{2}cos(n(#phi_{1}-#phi_{2}))>");\r
1733   (fQCorrelations[1]->GetXaxis())->SetBinLabel(6,"<w_{1}^{2}w_{2}w_{3}cos(n(#phi_{1}-#phi_{2}))>");\r
1734   // 3-particle correlations:\r
1735   (fQCorrelations[1]->GetXaxis())->SetBinLabel(21,"<w_{1}w_{2}w_{3}^{2}cos(n(2#phi_{1}-#phi_{2}-#phi_{3}))>");\r
1736   // 4-particle correlations:\r
1737   (fQCorrelations[1]->GetXaxis())->SetBinLabel(41,"<w_{1}w_{2}w_{3}w_{4}cos(n(#phi_{1}+#phi_{2}-#phi_{3}-#phi_{4}))>");\r
1738   // add fQCorrelations[1] to the list fIntFlowList:\r
1739   fIntFlowList->Add(fQCorrelations[1]); \r
1740  */\r
1741   \r
1742 } // end of AliFlowAnalysisWithQCumulants::BookEverythingForIntegratedFlow()\r
1743 \r
1744 \r
1745 //================================================================================================================================\r
1746 \r
1747 \r
1748 void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()\r
1749 {\r
1750  // Initialize arrays of all objects relevant for calculations with nested loops.\r
1751  \r
1752  // integrated flow:\r
1753  for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1754  {\r
1755   fIntFlowDirectCorrectionTermsForNUA[sc] = NULL;\r
1756  } \r
1757 \r
1758  // differential flow:  \r
1759  // correlations:\r
1760  for(Int_t t=0;t<2;t++) // type: RP or POI\r
1761  { \r
1762   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1763   {\r
1764    for(Int_t ci=0;ci<4;ci++) // correlation index\r
1765    {\r
1766     fDiffFlowDirectCorrelations[t][pe][ci] = NULL;\r
1767    } // end of for(Int_t ci=0;ci<4;ci++) // correlation index  \r
1768   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1769  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
1770  // correction terms for non-uniform acceptance:\r
1771  for(Int_t t=0;t<2;t++) // type: RP or POI\r
1772  { \r
1773   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1774   {\r
1775    for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1776    {\r
1777     for(Int_t cti=0;cti<9;cti++) // correction term index\r
1778     {\r
1779      fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = NULL;\r
1780     }   \r
1781    }\r
1782   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1783  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
1784 \r
1785 \r
1786 } // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForNestedLoops()\r
1787 \r
1788 \r
1789 //================================================================================================================================\r
1790 \r
1791 \r
1792 void AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()\r
1793 {\r
1794  // Book all objects relevant for calculations with nested loops.\r
1795  \r
1796  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
1797  TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)\r
1798  TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)\r
1799  TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)\r
1800  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
1801  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
1802 \r
1803  TString evaluateNestedLoopsName = "fEvaluateNestedLoops";\r
1804  evaluateNestedLoopsName += fAnalysisLabel->Data();\r
1805  fEvaluateNestedLoops = new TProfile(evaluateNestedLoopsName.Data(),"Flags for nested loops",4,0,4);\r
1806  fEvaluateNestedLoops->SetLabelSize(0.03);\r
1807  (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(1,"fEvaluateIntFlowNestedLoops");\r
1808  (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(2,"fEvaluateDiffFlowNestedLoops");\r
1809  (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(3,"fCrossCheckInPtBinNo");\r
1810  (fEvaluateNestedLoops->GetXaxis())->SetBinLabel(4,"fCrossCheckInEtaBinNo");\r
1811  fEvaluateNestedLoops->Fill(0.5,(Int_t)fEvaluateIntFlowNestedLoops);\r
1812  fEvaluateNestedLoops->Fill(1.5,(Int_t)fEvaluateDiffFlowNestedLoops);\r
1813  fEvaluateNestedLoops->Fill(2.5,fCrossCheckInPtBinNo);\r
1814  fEvaluateNestedLoops->Fill(3.5,fCrossCheckInEtaBinNo);\r
1815  fNestedLoopsList->Add(fEvaluateNestedLoops);\r
1816  // nested loops for integrated flow:\r
1817  if(fEvaluateIntFlowNestedLoops)\r
1818  {\r
1819   // correlations:\r
1820   TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";\r
1821   intFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
1822   fIntFlowDirectCorrelations = new TProfile(intFlowDirectCorrelationsName.Data(),"Multiparticle correlations calculated with nested loops (for int. flow)",32,0,32,"s");\r
1823   fNestedLoopsList->Add(fIntFlowDirectCorrelations);\r
1824   if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1825   {\r
1826    TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";\r
1827    intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();\r
1828    fIntFlowExtraDirectCorrelations = new TProfile(intFlowExtraDirectCorrelationsName.Data(),"Extra multiparticle correlations calculated with nested loops (for int. flow)",100,0,100,"s");\r
1829    fNestedLoopsList->Add(fIntFlowExtraDirectCorrelations);  \r
1830   } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
1831   // correction terms for non-uniform acceptance:\r
1832   for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
1833   {\r
1834    TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";\r
1835    intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
1836    fIntFlowDirectCorrectionTermsForNUA[sc] = new TProfile(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data()),Form("Correction terms for non-uniform acceptance (%s terms)",sinCosFlag[sc].Data()),10,0,10,"s");\r
1837    fNestedLoopsList->Add(fIntFlowDirectCorrectionTermsForNUA[sc]);\r
1838   } // end of for(Int_t sc=0;sc<2;sc++) \r
1839  } // end of if(fEvaluateIntFlowNestedLoops)\r
1840  \r
1841  // nested loops for differential flow: \r
1842  if(fEvaluateDiffFlowNestedLoops)\r
1843  {\r
1844   // reduced correlations:\r
1845   TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";\r
1846   diffFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
1847   for(Int_t t=0;t<2;t++) // type: RP or POI\r
1848   { \r
1849    for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1850    {\r
1851     for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
1852     {\r
1853      // reduced correlations:\r
1854      fDiffFlowDirectCorrelations[t][pe][rci] = new TProfile(Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),1,lowerPtEtaEdge[pe],upperPtEtaEdge[pe],"s");\r
1855      fDiffFlowDirectCorrelations[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());\r
1856      fNestedLoopsList->Add(fDiffFlowDirectCorrelations[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)\r
1857     } // end of for(Int_t rci=0;rci<4;rci++) // correlation index\r
1858    } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
1859   } // end of for(Int_t t=0;t<2;t++) // type: RP or POI \r
1860   // correction terms for non-uniform acceptance:\r
1861   TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";\r
1862   diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
1863   for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
1864   { \r
1865    for(Int_t pe=0;pe<2;pe++) // pt or eta\r
1866    {\r
1867     for(Int_t sc=0;sc<2;sc++) // sin or cos\r
1868     {\r
1869      for(Int_t cti=0;cti<9;cti++) // correction term index\r
1870      {\r
1871       fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = new TProfile(Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),1,lowerPtEtaEdge[pe],upperPtEtaEdge[pe],"s"); \r
1872       fNestedLoopsList->Add(fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]);\r
1873      }\r
1874     }\r
1875    }\r
1876   } \r
1877  } // end of if(fEvaluateDiffFlowNestedLoops)\r
1878 \r
1879 } // end of AliFlowAnalysisWithQCumulants::BookEverythingForNestedLoops()\r
1880 \r
1881 \r
1882 //================================================================================================================================\r
1883 \r
1884 \r
1885 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()\r
1886 {\r
1887  // calculate all correlations needed for integrated flow\r
1888  \r
1889  // multiplicity:\r
1890  Double_t dMult = (*fSMpk)(0,0);\r
1891  \r
1892  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
1893  Double_t dReQ1n = (*fReQ)(0,0);\r
1894  Double_t dReQ2n = (*fReQ)(1,0);\r
1895  Double_t dReQ3n = (*fReQ)(2,0);\r
1896  Double_t dReQ4n = (*fReQ)(3,0);\r
1897  Double_t dImQ1n = (*fImQ)(0,0);\r
1898  Double_t dImQ2n = (*fImQ)(1,0);\r
1899  Double_t dImQ3n = (*fImQ)(2,0);\r
1900  Double_t dImQ4n = (*fImQ)(3,0);\r
1901   \r
1902  // real and imaginary parts of some expressions involving various combinations of Q-vectors evaluated in harmonics n, 2n, 3n and 4n:\r
1903  // (these expression appear in the Eqs. for the multi-particle correlations bellow)\r
1904  \r
1905  // Re[Q_{2n} Q_{n}^* Q_{n}^*]\r
1906  Double_t reQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dReQ2n + 2.*dReQ1n*dImQ1n*dImQ2n - pow(dImQ1n,2.)*dReQ2n; \r
1907  \r
1908  // Im[Q_{2n} Q_{n}^* Q_{n}^*]\r
1909  //Double_t imQ2nQ1nstarQ1nstar = pow(dReQ1n,2.)*dImQ2n-2.*dReQ1n*dImQ1n*dReQ2n-pow(dImQ1n,2.)*dImQ2n; \r
1910  \r
1911  // Re[Q_{n} Q_{n} Q_{2n}^*] = Re[Q_{2n} Q_{n}^* Q_{n}^*]\r
1912  Double_t reQ1nQ1nQ2nstar = reQ2nQ1nstarQ1nstar; \r
1913  \r
1914  // Re[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*]\r
1915  Double_t reQ3nQ1nQ2nstarQ2nstar = (pow(dReQ2n,2.)-pow(dImQ2n,2.))*(dReQ3n*dReQ1n-dImQ3n*dImQ1n) \r
1916                                  + 2.*dReQ2n*dImQ2n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);\r
1917 \r
1918  // Im[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*]                                                                  \r
1919  //Double_t imQ3nQ1nQ2nstarQ2nstar = calculate and implement this (deleteMe)\r
1920   \r
1921  // Re[Q_{2n} Q_{2n} Q_{3n}^* Q_{1n}^*] = Re[Q_{3n} Q_{n} Q_{2n}^* Q_{2n}^*]\r
1922  Double_t reQ2nQ2nQ3nstarQ1nstar = reQ3nQ1nQ2nstarQ2nstar;\r
1923   \r
1924  // Re[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1925  Double_t reQ4nQ2nstarQ2nstar = pow(dReQ2n,2.)*dReQ4n+2.*dReQ2n*dImQ2n*dImQ4n-pow(dImQ2n,2.)*dReQ4n;\r
1926 \r
1927  // Im[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1928  //Double_t imQ4nQ2nstarQ2nstar = calculate and implement this (deleteMe)\r
1929  \r
1930  // Re[Q_{2n} Q_{2n} Q_{4n}^*] =  Re[Q_{4n} Q_{2n}^* Q_{2n}^*]\r
1931  Double_t reQ2nQ2nQ4nstar = reQ4nQ2nstarQ2nstar;\r
1932  \r
1933  // Re[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1934  Double_t reQ4nQ3nstarQ1nstar = dReQ4n*(dReQ3n*dReQ1n-dImQ3n*dImQ1n)+dImQ4n*(dReQ3n*dImQ1n+dImQ3n*dReQ1n);\r
1935  \r
1936  // Re[Q_{3n} Q_{n} Q_{4n}^*] = Re[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1937  Double_t reQ3nQ1nQ4nstar = reQ4nQ3nstarQ1nstar;\r
1938  \r
1939  // Im[Q_{4n} Q_{3n}^* Q_{n}^*]\r
1940  //Double_t imQ4nQ3nstarQ1nstar = calculate and implement this (deleteMe)\r
1941 \r
1942  // Re[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1943  Double_t reQ3nQ2nstarQ1nstar = dReQ3n*dReQ2n*dReQ1n-dReQ3n*dImQ2n*dImQ1n+dImQ3n*dReQ2n*dImQ1n\r
1944                               + dImQ3n*dImQ2n*dReQ1n;\r
1945                               \r
1946  // Re[Q_{2n} Q_{n} Q_{3n}^*] = Re[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1947  Double_t reQ2nQ1nQ3nstar = reQ3nQ2nstarQ1nstar;\r
1948  \r
1949  // Im[Q_{3n} Q_{2n}^* Q_{n}^*]\r
1950  //Double_t imQ3nQ2nstarQ1nstar; //calculate and implement this (deleteMe)\r
1951  \r
1952  // Re[Q_{3n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1953  Double_t reQ3nQ1nstarQ1nstarQ1nstar = dReQ3n*pow(dReQ1n,3)-3.*dReQ1n*dReQ3n*pow(dImQ1n,2)\r
1954                                      + 3.*dImQ1n*dImQ3n*pow(dReQ1n,2)-dImQ3n*pow(dImQ1n,3);\r
1955 \r
1956  // Im[Q_{3n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1957  //Double_t imQ3nQ1nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1958  \r
1959  // |Q_{2n}|^2 |Q_{n}|^2\r
1960  Double_t dQ2nQ1nQ2nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.));\r
1961  \r
1962  // Re[Q_{4n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1963  Double_t reQ4nQ2nstarQ1nstarQ1nstar = (dReQ4n*dReQ2n+dImQ4n*dImQ2n)*(pow(dReQ1n,2)-pow(dImQ1n,2))\r
1964                                      + 2.*dReQ1n*dImQ1n*(dImQ4n*dReQ2n-dReQ4n*dImQ2n); \r
1965  \r
1966  // Im[Q_{4n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1967  //Double_t imQ4nQ2nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1968  \r
1969  // Re[Q_{2n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^*]\r
1970  Double_t reQ2nQ1nQ1nstarQ1nstarQ1nstar = (dReQ2n*dReQ1n-dImQ2n*dImQ1n)*(pow(dReQ1n,3)-3.*dReQ1n*pow(dImQ1n,2))\r
1971                                         + (dReQ2n*dImQ1n+dReQ1n*dImQ2n)*(3.*dImQ1n*pow(dReQ1n,2)-pow(dImQ1n,3));\r
1972 \r
1973  // Im[Q_{2n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^*] \r
1974  //Double_t imQ2nQ1nQ1nstarQ1nstarQ1nstar; //calculate and implement this (deleteMe)\r
1975  \r
1976  // Re[Q_{2n} Q_{2n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1977  Double_t reQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
1978                                         * (dReQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) + 2.*dImQ2n*dReQ1n*dImQ1n);\r
1979 \r
1980  // Im[Q_{2n} Q_{2n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1981  //Double_t imQ2nQ2nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
1982  //                                       * (dImQ2n*(pow(dReQ1n,2.)-pow(dImQ1n,2.)) - 2.*dReQ2n*dReQ1n*dImQ1n);\r
1983  \r
1984  // Re[Q_{4n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1985  Double_t reQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dReQ4n-6.*pow(dReQ1n,2.)*dReQ4n*pow(dImQ1n,2.)\r
1986                                             + pow(dImQ1n,4.)*dReQ4n+4.*pow(dReQ1n,3.)*dImQ1n*dImQ4n\r
1987                                             - 4.*pow(dImQ1n,3.)*dReQ1n*dImQ4n;\r
1988                                             \r
1989  // Im[Q_{4n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
1990  //Double_t imQ4nQ1nstarQ1nstarQ1nstarQ1nstar = pow(dReQ1n,4.)*dImQ4n-6.*pow(dReQ1n,2.)*dImQ4n*pow(dImQ1n,2.)\r
1991  //                                           + pow(dImQ1n,4.)*dImQ4n+4.*pow(dImQ1n,3.)*dReQ1n*dReQ4n\r
1992  //                                           - 4.*pow(dReQ1n,3.)*dImQ1n*dReQ4n;\r
1993  \r
1994  // Re[Q_{3n} Q_{n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1995  Double_t reQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
1996                                         * (dReQ1n*dReQ2n*dReQ3n-dReQ3n*dImQ1n*dImQ2n+dReQ2n*dImQ1n*dImQ3n+dReQ1n*dImQ2n*dImQ3n);\r
1997  \r
1998  // Im[Q_{3n} Q_{n} Q_{2n}^* Q_{n}^* Q_{n}^*]\r
1999  //Double_t imQ3nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2000  //                                       * (-dReQ2n*dReQ3n*dImQ1n-dReQ1n*dReQ3n*dImQ2n+dReQ1n*dReQ2n*dImQ3n-dImQ1n*dImQ2n*dImQ3n);\r
2001  \r
2002  \r
2003  // Re[Q_{2n} Q_{2n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
2004  Double_t reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)*dReQ2n-2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)\r
2005                                                + dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n-pow(dImQ1n,2.)*dImQ2n)\r
2006                                                * (pow(dReQ1n,2.)*dReQ2n+2.*dReQ1n*dReQ2n*dImQ1n-dReQ2n*pow(dImQ1n,2.)\r
2007                                                - dImQ2n*pow(dReQ1n,2.)+2.*dReQ1n*dImQ1n*dImQ2n+pow(dImQ1n,2.)*dImQ2n);\r
2008  \r
2009  // Im[Q_{2n} Q_{2n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
2010  //Double_t imQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar = 2.*(pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)\r
2011  //                                              + 2.*dReQ1n*dImQ1n*dImQ2n)*(pow(dReQ1n,2.)*dImQ2n\r
2012  //                                              - 2.*dReQ1n*dImQ1n*dReQ2n-pow(dImQ1n,2.)*dImQ2n);\r
2013  \r
2014  // Re[Q_{3n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
2015  Double_t reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2016                                                * (pow(dReQ1n,3.)*dReQ3n-3.*dReQ1n*dReQ3n*pow(dImQ1n,2.)\r
2017                                                + 3.*pow(dReQ1n,2.)*dImQ1n*dImQ3n-pow(dImQ1n,3.)*dImQ3n);\r
2018   \r
2019  // Im[Q_{3n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]                                                                                           \r
2020  //Double_t imQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = (pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2021  //                                              * (pow(dImQ1n,3.)*dReQ3n-3.*dImQ1n*dReQ3n*pow(dReQ1n,2.)\r
2022  //                                              - 3.*pow(dImQ1n,2.)*dReQ1n*dImQ3n+pow(dReQ1n,3.)*dImQ3n);\r
2023  \r
2024  // |Q_{2n}|^2 |Q_{n}|^4\r
2025  Double_t dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar = (pow(dReQ2n,2.)+pow(dImQ2n,2.))*pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.);\r
2026  \r
2027  // Re[Q_{2n} Q_{n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]\r
2028  Double_t reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2029                                                   * (pow(dReQ1n,2.)*dReQ2n-dReQ2n*pow(dImQ1n,2.)\r
2030                                                   + 2.*dReQ1n*dImQ1n*dImQ2n);\r
2031                                                   \r
2032  // Im[Q_{2n} Q_{n} Q_{n} Q_{n}^* Q_{n}^* Q_{n}^* Q_{n}^*]                                                  \r
2033  //Double_t imQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar = pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2034  //                                                 * (pow(dReQ1n,2.)*dImQ2n-dImQ2n*pow(dImQ1n,2.)\r
2035  //                                                 - 2.*dReQ1n*dReQ2n*dImQ1n);\r
2036  \r
2037   \r
2038  \r
2039        \r
2040  //                                        **************************************\r
2041  //                                        **** multi-particle correlations: ****\r
2042  //                                        **************************************\r
2043  //\r
2044  // Remark 1: multi-particle correlations calculated with non-weighted Q-vectors are stored in 1D profile fQCorrelations[0]. // to be improved (wrong profiles)\r
2045  // Remark 2: binning of fQCorrelations[0] is organized as follows: // to be improved (wrong profiles)\r
2046  // --------------------------------------------------------------------------------------------------------------------\r
2047  //  1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>\r
2048  //  2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>\r
2049  //  3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))> \r
2050  //  4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>\r
2051  //  5th bin:           ----  EMPTY ----\r
2052  //  6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>\r
2053  //  7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>\r
2054  //  8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
2055  //  9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>\r
2056  // 10th bin:           ----  EMPTY ----\r
2057  // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>\r
2058  // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
2059  // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>\r
2060  // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
2061  // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>\r
2062  // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>\r
2063  // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))> \r
2064  // 18th bin:           ----  EMPTY ----\r
2065  // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
2066  // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
2067  // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
2068  // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
2069  // 23rd bin:           ----  EMPTY ----\r
2070  // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2071  // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
2072  // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
2073  // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
2074  // 28th bin:           ----  EMPTY ----\r
2075  // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n =  <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
2076  // 30th bin:           ----  EMPTY ----\r
2077  // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2078  // --------------------------------------------------------------------------------------------------------------------\r
2079     \r
2080  // 2-particle:\r
2081  Double_t two1n1n = 0.; // <cos(n*(phi1-phi2))>\r
2082  Double_t two2n2n = 0.; // <cos(2n*(phi1-phi2))>\r
2083  Double_t two3n3n = 0.; // <cos(3n*(phi1-phi2))>\r
2084  Double_t two4n4n = 0.; // <cos(4n*(phi1-phi2))>\r
2085  \r
2086  if(dMult>1)\r
2087  {\r
2088   two1n1n = (pow(dReQ1n,2.)+pow(dImQ1n,2.)-dMult)/(dMult*(dMult-1.)); \r
2089   two2n2n = (pow(dReQ2n,2.)+pow(dImQ2n,2.)-dMult)/(dMult*(dMult-1.)); \r
2090   two3n3n = (pow(dReQ3n,2.)+pow(dImQ3n,2.)-dMult)/(dMult*(dMult-1.)); \r
2091   two4n4n = (pow(dReQ4n,2.)+pow(dImQ4n,2.)-dMult)/(dMult*(dMult-1.)); \r
2092   \r
2093   // average 2-particle correlations for single event: \r
2094   fIntFlowCorrelationsAllEBE->SetBinContent(1,two1n1n);\r
2095   fIntFlowCorrelationsAllEBE->SetBinContent(2,two2n2n);\r
2096   fIntFlowCorrelationsAllEBE->SetBinContent(3,two3n3n);\r
2097   fIntFlowCorrelationsAllEBE->SetBinContent(4,two4n4n);\r
2098           \r
2099   // average 2-particle correlations for all events:      \r
2100   fIntFlowCorrelationsAllPro->Fill(0.5,two1n1n,dMult*(dMult-1.));  \r
2101   fIntFlowCorrelationsAllPro->Fill(1.5,two2n2n,dMult*(dMult-1.)); \r
2102   fIntFlowCorrelationsAllPro->Fill(2.5,two3n3n,dMult*(dMult-1.)); \r
2103   fIntFlowCorrelationsAllPro->Fill(3.5,two4n4n,dMult*(dMult-1.)); \r
2104   \r
2105   // store separetately <2> (to be improved: do I really need this?)\r
2106   fIntFlowCorrelationsEBE->SetBinContent(1,two1n1n); // <2>\r
2107   \r
2108   // to be improved (this can be implemented better):\r
2109   Double_t mWeight2p = 0.;\r
2110   if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2111   {\r
2112    mWeight2p = dMult*(dMult-1.);\r
2113   } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2114     {\r
2115      mWeight2p = 1.;    \r
2116     } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2117       {\r
2118        mWeight2p = dMult;           \r
2119       }\r
2120             \r
2121   fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,mWeight2p); // eW_<2>\r
2122   fIntFlowCorrelationsPro->Fill(0.5,two1n1n,mWeight2p);\r
2123     \r
2124   // distribution of <cos(n*(phi1-phi2))>:\r
2125   //f2pDistribution->Fill(two1n1n,dMult*(dMult-1.)); \r
2126  } // end of if(dMult>1)\r
2127  \r
2128  // 3-particle:\r
2129  Double_t three2n1n1n = 0.; // <cos(n*(2.*phi1-phi2-phi3))>\r
2130  Double_t three3n2n1n = 0.; // <cos(n*(3.*phi1-2.*phi2-phi3))>\r
2131  Double_t three4n2n2n = 0.; // <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
2132  Double_t three4n3n1n = 0.; // <cos(n*(4.*phi1-3.*phi2-phi3))>\r
2133  \r
2134  if(dMult>2)\r
2135  {\r
2136   three2n1n1n = (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2137               - (pow(dReQ2n,2.)+pow(dImQ2n,2.))+2.*dMult)\r
2138               / (dMult*(dMult-1.)*(dMult-2.));              \r
2139   three3n2n1n = (reQ3nQ2nstarQ1nstar-(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2140               - (pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2141               - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)\r
2142               / (dMult*(dMult-1.)*(dMult-2.));\r
2143   three4n2n2n = (reQ4nQ2nstarQ2nstar-2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2144               - (pow(dReQ4n,2.)+pow(dImQ4n,2.))+2.*dMult)\r
2145               / (dMult*(dMult-1.)*(dMult-2.)); \r
2146   three4n3n1n = (reQ4nQ3nstarQ1nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))\r
2147               - (pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2148               - (pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult)\r
2149               / (dMult*(dMult-1.)*(dMult-2.)); \r
2150               \r
2151   // average 3-particle correlations for single event: \r
2152   fIntFlowCorrelationsAllEBE->SetBinContent(6,three2n1n1n);\r
2153   fIntFlowCorrelationsAllEBE->SetBinContent(7,three3n2n1n);\r
2154   fIntFlowCorrelationsAllEBE->SetBinContent(8,three4n2n2n);\r
2155   fIntFlowCorrelationsAllEBE->SetBinContent(9,three4n3n1n);\r
2156         \r
2157   // average 3-particle correlations for all events:                \r
2158   fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1n,dMult*(dMult-1.)*(dMult-2.)); \r
2159   fIntFlowCorrelationsAllPro->Fill(6.5,three3n2n1n,dMult*(dMult-1.)*(dMult-2.));\r
2160   fIntFlowCorrelationsAllPro->Fill(7.5,three4n2n2n,dMult*(dMult-1.)*(dMult-2.)); \r
2161   fIntFlowCorrelationsAllPro->Fill(8.5,three4n3n1n,dMult*(dMult-1.)*(dMult-2.));    \r
2162  } // end of if(dMult>2)\r
2163  \r
2164  // 4-particle:\r
2165  Double_t four1n1n1n1n = 0.; // <cos(n*(phi1+phi2-phi3-phi4))>\r
2166  Double_t four2n2n2n2n = 0.; // <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
2167  Double_t four2n1n2n1n = 0.; // <cos(n*(2.*phi1+phi2-2.*phi3-phi4))> \r
2168  Double_t four3n1n1n1n = 0.; // <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
2169  Double_t four4n2n1n1n = 0.; // <cos(n*(4.*phi1-2.*phi2-phi3-phi4))> \r
2170  Double_t four3n1n2n2n = 0.; // <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))> \r
2171  Double_t four3n1n3n1n = 0.; // <cos(n*(3.*phi1+phi2-3.*phi3-phi4))>   \r
2172  \r
2173  if(dMult>3)\r
2174  {\r
2175   four1n1n1n1n = (2.*dMult*(dMult-3.)+pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ1n,2.)\r
2176                + pow(dImQ1n,2.))-2.*reQ2nQ1nstarQ1nstar+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2177                / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));     \r
2178   four2n2n2n2n = (2.*dMult*(dMult-3.)+pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)-4.*(dMult-2.)*(pow(dReQ2n,2.)\r
2179                + pow(dImQ2n,2.))-2.*reQ4nQ2nstarQ2nstar+(pow(dReQ4n,2.)+pow(dImQ4n,2.)))\r
2180                / (dMult*(dMult-1)*(dMult-2.)*(dMult-3.));\r
2181   four2n1n2n1n = (dQ2nQ1nQ2nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar-2.*reQ2nQ1nstarQ1nstar)\r
2182                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2183                - ((dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2184                + (dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-(pow(dReQ3n,2.)+pow(dImQ3n,2.)))\r
2185                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2186                + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2187   four3n1n1n1n = (reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar-3.*reQ2nQ1nstarQ1nstar)\r
2188                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2189                + (2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2190                + 6.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-6.*dMult)\r
2191                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2192   four4n2n1n1n = (reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar-2.*reQ3nQ2nstarQ1nstar)\r
2193                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2194                - (reQ2nQ1nstarQ1nstar-2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2195                - 3.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2196                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2197                - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2198   four3n1n2n2n = (reQ3nQ1nQ2nstarQ2nstar-reQ4nQ2nstarQ2nstar-reQ3nQ1nQ4nstar-2.*reQ3nQ2nstarQ1nstar)\r
2199                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2200                - (2.*reQ1nQ1nQ2nstar-(pow(dReQ4n,2.)+pow(dImQ4n,2.))-2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2201                - 4.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))-4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2202                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2203                - 6./((dMult-1.)*(dMult-2.)*(dMult-3.)); \r
2204   four3n1n3n1n = ((pow(dReQ3n,2.)+pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2205                - 2.*reQ4nQ3nstarQ1nstar-2.*reQ3nQ2nstarQ1nstar)\r
2206                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2207                + ((pow(dReQ4n,2.)+pow(dImQ4n,2.))-(dMult-4.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2208                + (pow(dReQ2n,2.)+pow(dImQ2n,2.))-(dMult-4.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2209                / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
2210                + (dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2211                \r
2212   // average 4-particle correlations for single event: \r
2213   fIntFlowCorrelationsAllEBE->SetBinContent(11,four1n1n1n1n);\r
2214   fIntFlowCorrelationsAllEBE->SetBinContent(12,four2n1n2n1n);\r
2215   fIntFlowCorrelationsAllEBE->SetBinContent(13,four2n2n2n2n);\r
2216   fIntFlowCorrelationsAllEBE->SetBinContent(14,four3n1n1n1n);\r
2217   fIntFlowCorrelationsAllEBE->SetBinContent(15,four3n1n3n1n);\r
2218   fIntFlowCorrelationsAllEBE->SetBinContent(16,four3n1n2n2n);\r
2219   fIntFlowCorrelationsAllEBE->SetBinContent(17,four4n2n1n1n);\r
2220         \r
2221   // average 4-particle correlations for all events:                \r
2222   fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2223   fIntFlowCorrelationsAllPro->Fill(11.5,four2n1n2n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2224   fIntFlowCorrelationsAllPro->Fill(12.5,four2n2n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2225   fIntFlowCorrelationsAllPro->Fill(13.5,four3n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2226   fIntFlowCorrelationsAllPro->Fill(14.5,four3n1n3n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2227   fIntFlowCorrelationsAllPro->Fill(15.5,four3n1n2n2n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));  \r
2228   fIntFlowCorrelationsAllPro->Fill(16.5,four4n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
2229   \r
2230   // store separetately <4> (to be improved: do I really need this?)\r
2231   fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1n); // <4>\r
2232   \r
2233   // to be improved (this can be implemented better):\r
2234   Double_t mWeight4p = 0.;\r
2235   if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2236   {\r
2237    mWeight4p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.);\r
2238   } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2239     {\r
2240      mWeight4p = 1.;    \r
2241     } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2242       {\r
2243        mWeight4p = dMult;           \r
2244       }\r
2245       \r
2246   fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,mWeight4p); // eW_<4>\r
2247   fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1n,mWeight4p);\r
2248   \r
2249   // distribution of <cos(n*(phi1+phi2-phi3-phi4))>\r
2250   //f4pDistribution->Fill(four1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
2251   \r
2252  } // end of if(dMult>3)\r
2253 \r
2254  // 5-particle:\r
2255  Double_t five2n1n1n1n1n = 0.; // <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
2256  Double_t five2n2n2n1n1n = 0.; // <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
2257  Double_t five3n1n2n1n1n = 0.; // <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
2258  Double_t five4n1n1n1n1n = 0.; // <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
2259  \r
2260  if(dMult>4)\r
2261  {\r
2262   five2n1n1n1n1n = (reQ2nQ1nQ1nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar+6.*reQ3nQ2nstarQ1nstar)\r
2263                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2264                  - (reQ2nQ1nQ3nstar+3.*(dMult-6.)*reQ2nQ1nstarQ1nstar+3.*reQ1nQ1nQ2nstar)\r
2265                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2266                  - (2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2267                  + 3.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))     \r
2268                  - 3.*(dMult-4.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2269                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2270                  - 3.*(pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2271                  - 2.*(2*dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+2.*dMult*(dMult-4.))\r
2272                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2273                  \r
2274   five2n2n2n1n1n = (reQ2nQ2nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-2.*reQ2nQ2nQ3nstarQ1nstar)\r
2275                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2276                  + 2.*(reQ4nQ2nstarQ2nstar+4.*reQ3nQ2nstarQ1nstar+reQ3nQ1nQ4nstar)\r
2277                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2278                  + (reQ2nQ2nQ4nstar-2.*(dMult-5.)*reQ2nQ1nstarQ1nstar+2.*reQ1nQ1nQ2nstar)\r
2279                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2280                  - (2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+4.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2281                  + 1.*pow((pow(dReQ2n,2.)+pow(dImQ2n,2.)),2.)\r
2282                  - 2.*(3.*dMult-10.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2283                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2284                  - (4.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2285                  - 4.*(dMult-5.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.))+4.*dMult*(dMult-6.))\r
2286                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)); \r
2287 \r
2288   five4n1n1n1n1n = (reQ4nQ1nstarQ1nstarQ1nstarQ1nstar-6.*reQ4nQ2nstarQ1nstarQ1nstar-4.*reQ3nQ1nstarQ1nstarQ1nstar)\r
2289                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2290                  + (8.*reQ4nQ3nstarQ1nstar+3.*reQ4nQ2nstarQ2nstar+12.*reQ3nQ2nstarQ1nstar+12.*reQ2nQ1nstarQ1nstar)\r
2291                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2292                  - (6.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))+8.*(pow(dReQ3n,2.)+pow(dImQ3n,2.))\r
2293                  + 12.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))+24.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))-24.*dMult)\r
2294                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2295   \r
2296   five3n1n2n1n1n = (reQ3nQ1nQ2nstarQ1nstarQ1nstar-reQ4nQ2nstarQ1nstarQ1nstar-reQ3nQ1nstarQ1nstarQ1nstar)\r
2297                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2298                  - (reQ3nQ1nQ2nstarQ2nstar-3.*reQ4nQ3nstarQ1nstar-reQ4nQ2nstarQ2nstar)\r
2299                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2300                  - ((2.*dMult-13.)*reQ3nQ2nstarQ1nstar-reQ3nQ1nQ4nstar-9.*reQ2nQ1nstarQ1nstar)\r
2301                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2302                  - (2.*reQ1nQ1nQ2nstar+2.*(pow(dReQ4n,2.)+pow(dImQ4n,2.))\r
2303                  - 2.*(dMult-5.)*(pow(dReQ3n,2.)+pow(dImQ3n,2.))+2.*(pow(dReQ3n,2.)\r
2304                  + pow(dImQ3n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2305                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2306                  + (2.*(dMult-6.)*(pow(dReQ2n,2.)+pow(dImQ2n,2.))\r
2307                  - 2.*(pow(dReQ2n,2.)+pow(dImQ2n,2.))*(pow(dReQ1n,2.)+pow(dImQ1n,2.))\r
2308                  - pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)\r
2309                  + 2.*(3.*dMult-11.)*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2310                  / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.))\r
2311                  - 4.*(dMult-6.)/((dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2312                  \r
2313   // average 5-particle correlations for single event: \r
2314   fIntFlowCorrelationsAllEBE->SetBinContent(19,five2n1n1n1n1n);\r
2315   fIntFlowCorrelationsAllEBE->SetBinContent(20,five2n2n2n1n1n);\r
2316   fIntFlowCorrelationsAllEBE->SetBinContent(21,five3n1n2n1n1n);\r
2317   fIntFlowCorrelationsAllEBE->SetBinContent(22,five4n1n1n1n1n);\r
2318         \r
2319   // average 5-particle correlations for all events:                         \r
2320   fIntFlowCorrelationsAllPro->Fill(18.5,five2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)); \r
2321   fIntFlowCorrelationsAllPro->Fill(19.5,five2n2n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2322   fIntFlowCorrelationsAllPro->Fill(20.5,five3n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2323   fIntFlowCorrelationsAllPro->Fill(21.5,five4n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.));\r
2324  } // end of if(dMult>4)\r
2325     \r
2326  // 6-particle:\r
2327  Double_t six1n1n1n1n1n1n = 0.; // <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2328  Double_t six2n2n1n1n1n1n = 0.; // <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
2329  Double_t six3n1n1n1n1n1n = 0.; // <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
2330  Double_t six2n1n1n2n1n1n = 0.; // <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
2331  \r
2332  if(dMult>5)\r
2333  {\r
2334   six1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),3.)+9.*dQ2nQ1nQ2nstarQ1nstar-6.*reQ2nQ1nQ1nstarQ1nstarQ1nstar)\r
2335                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2336                   + 4.*(reQ3nQ1nstarQ1nstarQ1nstar-3.*reQ3nQ2nstarQ1nstar)\r
2337                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2338                   + 2.*(9.*(dMult-4.)*reQ2nQ1nstarQ1nstar+2.*(pow(dReQ3n,2.)+pow(dImQ3n,2.)))\r
2339                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.))\r
2340                   - 9.*(pow((pow(dReQ1n,2.)+pow(dImQ1n,2.)),2.)+(pow(dReQ2n,2.)+pow(dImQ2n,2.)))\r
2341                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-5.))\r
2342                   + (18.*(pow(dReQ1n,2.)+pow(dImQ1n,2.)))\r
2343                   / (dMult*(dMult-1)*(dMult-3)*(dMult-4))\r
2344                   - 6./((dMult-1.)*(dMult-2.)*(dMult-3.));\r
2345                   \r
2346   six2n1n1n2n1n1n = (dQ2nQ1nQ1nQ2nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2347                   * (2.*five2n2n2n1n1n+4.*five2n1n1n1n1n+4.*five3n1n2n1n1n+4.*four2n1n2n1n+1.*four1n1n1n1n)\r
2348                   - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four1n1n1n1n+4.*two1n1n\r
2349                   + 2.*three2n1n1n+2.*three2n1n1n+4.*four3n1n1n1n+8.*three2n1n1n+2.*four4n2n1n1n\r
2350                   + 4.*four2n1n2n1n+2.*two2n2n+8.*four2n1n2n1n+4.*four3n1n3n1n+8.*three3n2n1n\r
2351                   + 4.*four3n1n2n2n+4.*four1n1n1n1n+4.*four2n1n2n1n+1.*four2n2n2n2n)\r
2352                   - dMult*(dMult-1.)*(dMult-2.)*(2.*three2n1n1n+8.*two1n1n+4.*two1n1n+2.\r
2353                   + 4.*two1n1n+4.*three2n1n1n+2.*two2n2n+4.*three2n1n1n+8.*three3n2n1n\r
2354                   + 8.*two2n2n+4.*three4n3n1n+4.*two3n3n+4.*three3n2n1n+4.*two1n1n\r
2355                   + 8.*three2n1n1n+4.*two1n1n+4.*three3n2n1n+4.*three2n1n1n+2.*two2n2n\r
2356                   + 4.*three3n2n1n+2.*three4n2n2n)-dMult*(dMult-1.)\r
2357                   * (4.*two1n1n+4.+4.*two1n1n+2.*two2n2n+1.+4.*two1n1n+4.*two2n2n+4.*two3n3n\r
2358                   + 1.+2.*two2n2n+1.*two4n4n)-dMult)\r
2359                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2360  \r
2361   six2n2n1n1n1n1n = (reQ2nQ2nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2362                   * (five4n1n1n1n1n+8.*five2n1n1n1n1n+6.*five2n2n2n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)\r
2363                   * (4.*four3n1n1n1n+6.*four4n2n1n1n+12.*three2n1n1n+12.*four1n1n1n1n+24.*four2n1n2n1n\r
2364                   + 4.*four3n1n2n2n+3.*four2n2n2n2n)-dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+12.*three3n2n1n\r
2365                   + 4.*three4n3n1n+3.*three4n2n2n+8.*three2n1n1n+24.*two1n1n+12.*two2n2n+12.*three2n1n1n+8.*three3n2n1n\r
2366                   + 1.*three4n2n2n)-dMult*(dMult-1.)*(4.*two1n1n+6.*two2n2n+4.*two3n3n+1.*two4n4n+2.*two2n2n+8.*two1n1n+6.)-dMult)\r
2367                   / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2368    \r
2369   six3n1n1n1n1n1n = (reQ3nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)\r
2370                   * (five4n1n1n1n1n+4.*five2n1n1n1n1n+6.*five3n1n2n1n1n+4.*four3n1n1n1n)\r
2371                   - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four3n1n1n1n+6.*four4n2n1n1n+6.*four1n1n1n1n\r
2372                   + 12.*three2n1n1n+12.*four2n1n2n1n+6.*four3n1n1n1n+12.*three3n2n1n+4.*four3n1n3n1n+3.*four3n1n2n2n)\r
2373                   - dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+12.*three3n2n1n+4.*three4n3n1n+3.*three4n2n2n+4.*two1n1n\r
2374                   + 12.*two1n1n+6.*three2n1n1n+12.*three2n1n1n+4.*three3n2n1n+12.*two2n2n+4.*three3n2n1n+4.*two3n3n+1.*three4n3n1n\r
2375                   + 6.*three3n2n1n)-dMult*(dMult-1.)*(4.*two1n1n+6.*two2n2n+4.*two3n3n+1.*two4n4n+1.*two1n1n+4.+6.*two1n1n+4.*two2n2n\r
2376                   + 1.*two3n3n)-dMult)/(dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); // to be improved (direct formula needed)\r
2377                                  \r
2378   // average 6-particle correlations for single event: \r
2379   fIntFlowCorrelationsAllEBE->SetBinContent(24,six1n1n1n1n1n1n);\r
2380   fIntFlowCorrelationsAllEBE->SetBinContent(25,six2n1n1n2n1n1n);\r
2381   fIntFlowCorrelationsAllEBE->SetBinContent(26,six2n2n1n1n1n1n);\r
2382   fIntFlowCorrelationsAllEBE->SetBinContent(27,six3n1n1n1n1n1n);\r
2383         \r
2384   // average 6-particle correlations for all events:         \r
2385   fIntFlowCorrelationsAllPro->Fill(23.5,six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2386   fIntFlowCorrelationsAllPro->Fill(24.5,six2n1n1n2n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2387   fIntFlowCorrelationsAllPro->Fill(25.5,six2n2n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.));\r
2388   fIntFlowCorrelationsAllPro->Fill(26.5,six3n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2389 \r
2390   // store separetately <6> (to be improved: do I really need this?)\r
2391   fIntFlowCorrelationsEBE->SetBinContent(3,six1n1n1n1n1n1n); // <6>\r
2392   \r
2393   // to be improved (this can be implemented better):\r
2394   Double_t mWeight6p = 0.;\r
2395   if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2396   {\r
2397    mWeight6p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.);\r
2398   } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2399     {\r
2400      mWeight6p = 1.;    \r
2401     } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2402       {\r
2403        mWeight6p = dMult;           \r
2404       }\r
2405       \r
2406   fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(3,mWeight6p); // eW_<6>\r
2407   fIntFlowCorrelationsPro->Fill(2.5,six1n1n1n1n1n1n,mWeight6p);\r
2408  \r
2409   // distribution of <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
2410   //f6pDistribution->Fill(six1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)); \r
2411  } // end of if(dMult>5)\r
2412  \r
2413  // 7-particle:\r
2414  Double_t seven2n1n1n1n1n1n1n = 0.; // <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
2415  \r
2416  if(dMult>6)\r
2417  {\r
2418   seven2n1n1n1n1n1n1n = (reQ2nQ1nQ1nQ1nstarQ1nstarQ1nstarQ1nstar-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)\r
2419                       * (2.*six3n1n1n1n1n1n+4.*six1n1n1n1n1n1n+1.*six2n2n1n1n1n1n+6.*six2n1n1n2n1n1n+8.*five2n1n1n1n1n)\r
2420                       - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(1.*five4n1n1n1n1n +8.*five2n1n1n1n1n+8.*four3n1n1n1n\r
2421                       + 12.*five3n1n2n1n1n+4.*five2n1n1n1n1n+3.*five2n2n2n1n1n+6.*five2n2n2n1n1n+6.*four1n1n1n1n+24.*four1n1n1n1n\r
2422                       + 12.*five2n1n1n1n1n+12.*five2n1n1n1n1n+12.*three2n1n1n+24.*four2n1n2n1n+4.*five3n1n2n1n1n+4.*five2n1n1n1n1n)\r
2423                       - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(4.*four3n1n1n1n+6.*four4n2n1n1n+12.*four1n1n1n1n+24.*three2n1n1n\r
2424                       + 24.*four2n1n2n1n+12.*four3n1n1n1n+24.*three3n2n1n+8.*four3n1n3n1n+6.*four3n1n2n2n+6.*three2n1n1n+12.*four1n1n1n1n\r
2425                       + 12.*four2n1n2n1n+6.*three2n1n1n+12.*four2n1n2n1n+4.*four3n1n2n2n+3.*four2n2n2n2n+4.*four1n1n1n1n+6.*three2n1n1n\r
2426                       + 24.*two1n1n+24.*four1n1n1n1n+4.*four3n1n1n1n+24.*two1n1n+24.*three2n1n1n+12.*two2n2n+24.*three2n1n1n+12.*four2n1n2n1n\r
2427                       + 8.*three3n2n1n+8.*four2n1n2n1n+1.*four4n2n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(6.*three2n1n1n+1.*three2n1n1n+8.*two1n1n\r
2428                       + 12.*three3n2n1n+24.*two1n1n+12.*three2n1n1n+4.*three2n1n1n+8.*two1n1n+4.*three4n3n1n+24.*three2n1n1n+8.*three3n2n1n\r
2429                       + 12.*two1n1n+12.*two1n1n+3.*three4n2n2n+24.*two2n2n+6.*two2n2n+12.+12.*three3n2n1n+8.*two3n3n+12.*three2n1n1n+24.*two1n1n\r
2430                       + 4.*three3n2n1n+8.*three3n2n1n+2.*three4n3n1n+12.*two1n1n+8.*three2n1n1n+4.*three2n1n1n+2.*three3n2n1n+6.*two2n2n+8.*two2n2n\r
2431                       + 1.*three4n2n2n+4.*three3n2n1n+6.*three2n1n1n)-dMult*(dMult-1.)*(4.*two1n1n+2.*two1n1n+6.*two2n2n+8.+1.*two2n2n+4.*two3n3n\r
2432                       + 12.*two1n1n+4.*two1n1n+1.*two4n4n+8.*two2n2n+6.+2.*two3n3n+4.*two1n1n+1.*two2n2n)-dMult)\r
2433                       / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)); // to be improved (direct formula needed)\r
2434         \r
2435   // average 7-particle correlations for single event: \r
2436   fIntFlowCorrelationsAllEBE->SetBinContent(29,seven2n1n1n1n1n1n1n);\r
2437        \r
2438   // average 7-particle correlations for all events:                      \r
2439   fIntFlowCorrelationsAllPro->Fill(28.5,seven2n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.));\r
2440  } // end of if(dMult>6)\r
2441  \r
2442  // 8-particle:\r
2443  Double_t eight1n1n1n1n1n1n1n1n = 0.; // <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2444  if(dMult>7)\r
2445  {\r
2446   eight1n1n1n1n1n1n1n1n = (pow(pow(dReQ1n,2.)+pow(dImQ1n,2.),4.)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)\r
2447                         * (12.*seven2n1n1n1n1n1n1n+16.*six1n1n1n1n1n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)\r
2448                         * (8.*six3n1n1n1n1n1n+48.*six1n1n1n1n1n1n+6.*six2n2n1n1n1n1n+96.*five2n1n1n1n1n+72.*four1n1n1n1n+36.*six2n1n1n2n1n1n)\r
2449                         - dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(2.*five4n1n1n1n1n+32.*five2n1n1n1n1n+36.*four1n1n1n1n\r
2450                         + 32.*four3n1n1n1n+48.*five2n1n1n1n1n+48.*five3n1n2n1n1n+144.*five2n1n1n1n1n+288.*four1n1n1n1n+36.*five2n2n2n1n1n\r
2451                         + 144.*three2n1n1n+96.*two1n1n+144.*four2n1n2n1n)-dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)\r
2452                         * (8.*four3n1n1n1n+48.*four1n1n1n1n+12.*four4n2n1n1n+96.*four2n1n2n1n+96.*three2n1n1n+72.*three2n1n1n+144.*two1n1n\r
2453                         + 16.*four3n1n3n1n+48.*four3n1n1n1n+144.*four1n1n1n1n+72.*four1n1n1n1n+96.*three3n2n1n+24.*four3n1n2n2n+144.*four2n1n2n1n\r
2454                         + 288.*two1n1n+288.*three2n1n1n+9.*four2n2n2n2n+72.*two2n2n+24.)-dMult*(dMult-1.)*(dMult-2.)*(12.*three2n1n1n+16.*two1n1n\r
2455                         + 24.*three3n2n1n+48.*three2n1n1n+96.*two1n1n+8.*three4n3n1n+32.*three3n2n1n+96.*three2n1n1n+144.*two1n1n+6.*three4n2n2n\r
2456                         + 96.*two2n2n+36.*two2n2n+72.+48.*three3n2n1n+16.*two3n3n+72.*three2n1n1n+144.*two1n1n)-dMult*(dMult-1.)*(8.*two1n1n\r
2457                         + 12.*two2n2n+16.+8.*two3n3n+48.*two1n1n+1.*two4n4n+16.*two2n2n+18.)-dMult)\r
2458                         / (dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.)); // to be improved (direct formula needed)\r
2459   \r
2460   // average 8-particle correlations for single event: \r
2461   fIntFlowCorrelationsAllEBE->SetBinContent(31,eight1n1n1n1n1n1n1n1n);\r
2462        \r
2463   // average 8-particle correlations for all events:                       \r
2464   fIntFlowCorrelationsAllPro->Fill(30.5,eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));\r
2465  \r
2466   // store separetately <8> (to be improved: do I really need this?)\r
2467   fIntFlowCorrelationsEBE->SetBinContent(4,eight1n1n1n1n1n1n1n1n); // <8>\r
2468   \r
2469   // to be improved (this can be implemented better):\r
2470   Double_t mWeight8p = 0.;\r
2471   if(!strcmp(fMultiplicityWeight->Data(),"combinations"))\r
2472   {\r
2473    mWeight8p = dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.);\r
2474   } else if(!strcmp(fMultiplicityWeight->Data(),"unit"))\r
2475     {\r
2476      mWeight8p = 1.;    \r
2477     } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))\r
2478       {\r
2479        mWeight8p = dMult;           \r
2480       }\r
2481         \r
2482   fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(4,mWeight8p); // eW_<8>\r
2483   fIntFlowCorrelationsPro->Fill(3.5,eight1n1n1n1n1n1n1n1n,mWeight8p);  \r
2484   \r
2485   // distribution of <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
2486   //f8pDistribution->Fill(eight1n1n1n1n1n1n1n1n,dMult*(dMult-1.)*(dMult-2.)*(dMult-3.)*(dMult-4.)*(dMult-5.)*(dMult-6.)*(dMult-7.));\r
2487  } // end of if(dMult>7) \r
2488  \r
2489 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelations()\r
2490 \r
2491 \r
2492 //================================================================================================================================\r
2493 \r
2494 \r
2495 void AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()\r
2496 {\r
2497  // Calculate averages of products of correlations for integrated flow  // to be improved (this method can be implemented better)\r
2498  \r
2499  // a) Binning of fIntFlowProductOfCorrelationsPro is organized as follows:\r
2500  //     1st bin: <<2><4>> \r
2501  //     2nd bin: <<2><6>>\r
2502  //     3rd bin: <<2><8>>\r
2503  //     4th bin: <<4><6>>\r
2504  //     5th bin: <<4><8>>\r
2505  //     6th bin: <<6><8>>\r
2506 \r
2507  /*\r
2508  Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
2509 \r
2510  Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>\r
2511  Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>\r
2512  Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>\r
2513  Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>\r
2514  \r
2515  Double_t eW2 = 0.; // event weight for <2>\r
2516  Double_t eW4 = 0.; // event weight for <4>\r
2517  Double_t eW6 = 0.; // event weight for <6>\r
2518  Double_t eW8 = 0.; // event weight for <8>\r
2519  \r
2520  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
2521  {\r
2522   eW2 = dMult*(dMult-1);\r
2523   eW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3);\r
2524   eW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5);\r
2525   eW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7);\r
2526  } else \r
2527    {\r
2528     eW2 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
2529     eW4 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1)  \r
2530         + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
2531         + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
2532    }\r
2533   \r
2534  fIntFlowProductOfCorrelationsPro->Fill(0.5,twoEBE*fourEBE,eW2*eW4); // <<2><4>> \r
2535  fIntFlowProductOfCorrelationsPro->Fill(1.5,twoEBE*sixEBE,eW2*eW6); // <<2><6>>\r
2536  fIntFlowProductOfCorrelationsPro->Fill(2.5,twoEBE*eightEBE,eW2*eW8); // <<2><8>>\r
2537  fIntFlowProductOfCorrelationsPro->Fill(3.5,fourEBE*sixEBE,eW4*eW6); // <<4><6>>\r
2538  fIntFlowProductOfCorrelationsPro->Fill(4.5,fourEBE*eightEBE,eW4*eW8); // <<4><8>>\r
2539  fIntFlowProductOfCorrelationsPro->Fill(5.5,sixEBE*eightEBE,eW6*eW8); // <<6><8>>\r
2540  */\r
2541  \r
2542  \r
2543  Int_t counter = 0;\r
2544  \r
2545  for(Int_t ci1=1;ci1<4;ci1++)\r
2546  {\r
2547   for(Int_t ci2=ci1+1;ci2<=4;ci2++)\r
2548   {\r
2549    fIntFlowProductOfCorrelationsPro->Fill(0.5+counter++,\r
2550                                           fIntFlowCorrelationsEBE->GetBinContent(ci1)*fIntFlowCorrelationsEBE->GetBinContent(ci2),\r
2551                                           fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));\r
2552   }\r
2553  }\r
2554  \r
2555 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowProductOfCorrelations()\r
2556 \r
2557 \r
2558 //================================================================================================================================\r
2559 \r
2560 \r
2561 void AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()\r
2562 {\r
2563  // a) Calculate unbiased estimators Cov(<2>,<4>), Cov(<2>,<6>), Cov(<2>,<8>), Cov(<4>,<6>), Cov(<4>,<8>) and Cov(<6>,<8>)\r
2564  //    for covariances V_(<2>,<4>), V_(<2>,<6>), V_(<2>,<8>), V_(<4>,<6>), V_(<4>,<8>) and V_(<6>,<8>).\r
2565  // b) Store in histogram fIntFlowCovariances for instance the following: \r
2566  //\r
2567  //             Cov(<2>,<4>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4>}_j)]\r
2568  // \r
2569  //    where N is the number of events, w_{<2>} is event weight for <2> and w_{<4>} is event weight for <4>.\r
2570  // c) Binning of fIntFlowCovariances is organized as follows:\r
2571  // \r
2572  //     1st bin: Cov(<2>,<4>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4>}_j)] \r
2573  //     2nd bin: Cov(<2>,<6>) * (sum_{i=1}^{N} w_{<2>}_i w_{<6>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<6>}_j)]\r
2574  //     3rd bin: Cov(<2>,<8>) * (sum_{i=1}^{N} w_{<2>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2575  //     4th bin: Cov(<4>,<6>) * (sum_{i=1}^{N} w_{<4>}_i w_{<6>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<6>}_j)]\r
2576  //     5th bin: Cov(<4>,<8>) * (sum_{i=1}^{N} w_{<4>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2577  //     6th bin: Cov(<6>,<8>) * (sum_{i=1}^{N} w_{<6>}_i w_{<8>}_i )/[(sum_{i=1}^{N} w_{<6>}_i) * (sum_{j=1}^{N} w_{<8>}_j)]\r
2578     \r
2579  for(Int_t power=0;power<2;power++)\r
2580  { \r
2581   if(!(fIntFlowCorrelationsPro && fIntFlowProductOfCorrelationsPro \r
2582        && fIntFlowSumOfEventWeights[power] && fIntFlowSumOfProductOfEventWeights\r
2583        && fIntFlowCovariances)) \r
2584   {\r
2585    cout<<"WARNING: fIntFlowCorrelationsPro && fIntFlowProductOfCorrelationsPro "<<endl;\r
2586    cout<<"         && fIntFlowSumOfEventWeights[power] && fIntFlowSumOfProductOfEventWeights"<<endl;\r
2587    cout<<"         && fIntFlowCovariances is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
2588    cout<<"power = "<<power<<endl;\r
2589    exit(0);\r
2590   }\r
2591  }\r
2592    \r
2593  // average 2-, 4-, 6- and 8-particle correlations for all events:\r
2594  Double_t correlation[4] = {0.};\r
2595  for(Int_t ci=0;ci<4;ci++)\r
2596  {\r
2597   correlation[ci] = fIntFlowCorrelationsPro->GetBinContent(ci+1);\r
2598  } \r
2599  // average products of 2-, 4-, 6- and 8-particle correlations: \r
2600  Double_t productOfCorrelations[4][4] = {{0.}};\r
2601  Int_t productOfCorrelationsLabel = 1;\r
2602  // denominators in the expressions for the unbiased estimator for covariance:\r
2603  Double_t denominator[4][4] = {{0.}};\r
2604  Int_t sumOfProductOfEventWeightsLabel1 = 1;\r
2605  // weight dependent prefactor which multiply unbiased estimators for covariances:\r
2606  Double_t wPrefactor[4][4] = {{0.}}; \r
2607  Int_t sumOfProductOfEventWeightsLabel2 = 1;\r
2608  for(Int_t c1=0;c1<4;c1++)\r
2609  {\r
2610   for(Int_t c2=c1+1;c2<4;c2++)\r
2611   {\r
2612    productOfCorrelations[c1][c2] = fIntFlowProductOfCorrelationsPro->GetBinContent(productOfCorrelationsLabel);\r
2613    if(fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1) && fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1))\r
2614    {\r
2615     denominator[c1][c2] = 1.-(fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel1))/\r
2616                              (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1) \r
2617                               * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));\r
2618                               \r
2619     wPrefactor[c1][c2] =  fIntFlowSumOfProductOfEventWeights->GetBinContent(sumOfProductOfEventWeightsLabel2)/ \r
2620                           (fIntFlowSumOfEventWeights[0]->GetBinContent(c1+1)\r
2621                             * fIntFlowSumOfEventWeights[0]->GetBinContent(c2+1));\r
2622                           \r
2623                               \r
2624    }\r
2625    productOfCorrelationsLabel++;\r
2626    sumOfProductOfEventWeightsLabel1++;\r
2627    sumOfProductOfEventWeightsLabel2++;  \r
2628   }\r
2629  }\r
2630  \r
2631  // covariance label:\r
2632  Int_t covarianceLabel = 1;\r
2633  for(Int_t c1=0;c1<4;c1++)\r
2634  {\r
2635   for(Int_t c2=c1+1;c2<4;c2++)\r
2636   {\r
2637    if(denominator[c1][c2])\r
2638    {\r
2639     // covariances:\r
2640     Double_t cov = (productOfCorrelations[c1][c2]-correlation[c1]*correlation[c2])/denominator[c1][c2]; \r
2641     // covarianced multiplied with weight dependent prefactor:\r
2642     Double_t wCov = cov * wPrefactor[c1][c2];\r
2643     fIntFlowCovariances->SetBinContent(covarianceLabel,wCov);\r
2644    }\r
2645    covarianceLabel++;\r
2646   }\r
2647  }\r
2648  \r
2649 } // end of AliFlowAnalysisWithQCumulants::CalculateCovariancesIntFlow()\r
2650 \r
2651 \r
2652 //================================================================================================================================\r
2653 \r
2654 \r
2655 void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow() \r
2656 {\r
2657  // From profile fIntFlowCorrelationsPro access measured correlations and spread, \r
2658  // correctly calculate the statistical errors and store the final results and \r
2659  // statistical errors for correlations in histogram fIntFlowCorrelationsHist.\r
2660  //\r
2661  // Remark: Statistical error of correlation is calculated as:\r
2662  //\r
2663  //          statistical error = termA * spread * termB:\r
2664  //          termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)\r
2665  //          termB = 1/sqrt(1-termA^2)   \r
2666  \r
2667  for(Int_t power=0;power<2;power++)\r
2668  { \r
2669   if(!(fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power])) \r
2670   {\r
2671    cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power] is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
2672    cout<<"power = "<<power<<endl;\r
2673    exit(0);\r
2674   }\r
2675  }\r
2676   \r
2677  for(Int_t ci=1;ci<=4;ci++) // correlation index\r
2678  {\r
2679   Double_t correlation = fIntFlowCorrelationsPro->GetBinContent(ci);\r
2680   Double_t spread = fIntFlowCorrelationsPro->GetBinError(ci);\r
2681   Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);\r
2682   Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);\r
2683   Double_t termA = 0.;\r
2684   Double_t termB = 0.;\r
2685   if(sumOfLinearEventWeights)\r
2686   {\r
2687    termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;\r
2688   } else\r
2689     {\r
2690      cout<<"WARNING: sumOfLinearEventWeights == 0 in AFAWQC::FCIF() !!!!"<<endl;\r
2691      cout<<"         (for "<<2*ci<<"-particle correlation)"<<endl;\r
2692     }\r
2693   if(1.-pow(termA,2.) > 0.)\r
2694   {\r
2695    termB = 1./pow(1-pow(termA,2.),0.5);\r
2696   } else\r
2697     {\r
2698      cout<<"WARNING: 1.-pow(termA,2.) <= 0 in AFAWQC::FCIF() !!!!"<<endl;   \r
2699      cout<<"         (for "<<2*ci<<"-particle correlation)"<<endl;\r
2700     }     \r
2701   Double_t statisticalError = termA * spread * termB;\r
2702   fIntFlowCorrelationsHist->SetBinContent(ci,correlation);\r
2703   fIntFlowCorrelationsHist->SetBinError(ci,statisticalError);\r
2704  } // end of for(Int_t ci=1;ci<=4;ci++) // correlation index                                                                \r
2705                                                                                                                               \r
2706 } // end of AliFlowAnalysisWithQCumulants::FinalizeCorrelationsIntFlow()\r
2707 \r
2708 \r
2709 //================================================================================================================================\r
2710 \r
2711 \r
2712 void AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(Int_t nRP)\r
2713 {\r
2714  // Fill profile fAverageMultiplicity to hold average multiplicities and number of events for events with nRP>=0, nRP>=1, ... , and nRP>=8\r
2715  \r
2716  // Binning of fAverageMultiplicity is organized as follows:\r
2717  //  1st bin: all events (including the empty ones)\r
2718  //  2nd bin: event with # of RPs greater or equal to 1\r
2719  //  3rd bin: event with # of RPs greater or equal to 2\r
2720  //  4th bin: event with # of RPs greater or equal to 3\r
2721  //  5th bin: event with # of RPs greater or equal to 4\r
2722  //  6th bin: event with # of RPs greater or equal to 5\r
2723  //  7th bin: event with # of RPs greater or equal to 6\r
2724  //  8th bin: event with # of RPs greater or equal to 7\r
2725  //  9th bin: event with # of RPs greater or equal to 8\r
2726  \r
2727  if(!fAvMultiplicity)\r
2728  {\r
2729   cout<<"WARNING: fAvMultiplicity is NULL in AFAWQC::FAM() !!!!"<<endl;\r
2730   exit(0);\r
2731  }\r
2732  \r
2733  if(nRP<0)\r
2734  {\r
2735   cout<<"WARNING: nRP<0 in in AFAWQC::FAM() !!!!"<<endl;\r
2736   exit(0);\r
2737  }\r
2738  \r
2739  for(Int_t i=0;i<9;i++)\r
2740  {\r
2741   if(nRP>=i) fAvMultiplicity->Fill(i+0.5,nRP,1);\r
2742  }\r
2743  \r
2744 } // end of AliFlowAnalysisWithQCumulants::FillAverageMultiplicities(nRP)\r
2745 \r
2746 \r
2747 //================================================================================================================================\r
2748 \r
2749 \r
2750 void AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()\r
2751 {\r
2752  // a) Calculate Q-cumulants from the measured multiparticle correlations.\r
2753  // b) Propagate the statistical errors of measured multiparticle correlations to statistical errors of Q-cumulants.  \r
2754  // c) REMARK: Q-cumulants calculated in this method are biased by non-uniform acceptance of detector !!!! \r
2755  //            Method ApplyCorrectionForNonUniformAcceptance* (to be improved: finalize the name here)\r
2756  //            is called afterwards to correct for this bias.   \r
2757  // d) Store the results and statistical error of Q-cumulants in histogram fCumulants.\r
2758  //    Binning of fCumulants is organized as follows:\r
2759  //\r
2760  //     1st bin: QC{2}\r
2761  //     2nd bin: QC{4}\r
2762  //     3rd bin: QC{6}\r
2763  //     4th bin: QC{8}\r
2764  \r
2765  if(!(fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants))\r
2766  {\r
2767   cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants is NULL in AFAWQC::CCIF() !!!!"<<endl;\r
2768   exit(0);\r
2769  }\r
2770  \r
2771  // correlations:\r
2772  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>> \r
2773  Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>  \r
2774  Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>> \r
2775  Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>  \r
2776  \r
2777  // statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:\r
2778  Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2>  \r
2779  Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4>   \r
2780  Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6> \r
2781  Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8> \r
2782  \r
2783  // covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):\r
2784  Double_t wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)\r
2785  Double_t wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)\r
2786  Double_t wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)\r
2787  Double_t wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)\r
2788  Double_t wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)\r
2789  Double_t wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)\r
2790  \r
2791  // Q-cumulants: \r
2792  Double_t qc2 = 0.; // QC{2}\r
2793  Double_t qc4 = 0.; // QC{4}\r
2794  Double_t qc6 = 0.; // QC{6}\r
2795  Double_t qc8 = 0.; // QC{8}\r
2796  if(two) qc2 = two; \r
2797  if(four) qc4 = four-2.*pow(two,2.); \r
2798  if(six) qc6 = six-9.*two*four+12.*pow(two,3.); \r
2799  if(eight) qc8 = eight-16.*two*six-18.*pow(four,2.)+144.*pow(two,2.)*four-144.*pow(two,4.); \r
2800  \r
2801  // statistical errors of Q-cumulants:       \r
2802  Double_t qc2Error = 0.;\r
2803  Double_t qc4Error = 0.;\r
2804  Double_t qc6Error = 0.;\r
2805  Double_t qc8Error = 0.;\r
2806  \r
2807  // squared statistical errors of Q-cumulants:       \r
2808  //Double_t qc2ErrorSquared = 0.;\r
2809  Double_t qc4ErrorSquared = 0.;\r
2810  Double_t qc6ErrorSquared = 0.;\r
2811  Double_t qc8ErrorSquared = 0.;\r
2812         \r
2813  // statistical error of QC{2}:              \r
2814  qc2Error = twoError;                     \r
2815                              \r
2816  // statistical error of QC{4}:              \r
2817  qc4ErrorSquared = 16.*pow(two,2.)*pow(twoError,2)+pow(fourError,2.)\r
2818                  - 8.*two*wCov24;                     \r
2819  if(qc4ErrorSquared>0.)\r
2820  {\r
2821   qc4Error = pow(qc4ErrorSquared,0.5);\r
2822  } else \r
2823    {\r
2824     cout<<"WARNING: Statistical error of QC{4} is imaginary !!!!"<<endl;\r
2825    }\r
2826                                            \r
2827  // statistical error of QC{6}:              \r
2828  qc6ErrorSquared = 81.*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.)\r
2829                  + 81.*pow(two,2.)*pow(fourError,2.)\r
2830                  + pow(sixError,2.)\r
2831                  - 162.*two*(4.*pow(two,2.)-four)*wCov24\r
2832                  + 18.*(4.*pow(two,2.)-four)*wCov26\r
2833                  - 18.*two*wCov46; \r
2834                     \r
2835  if(qc6ErrorSquared>0.)\r
2836  {\r
2837   qc6Error = pow(qc6ErrorSquared,0.5);\r
2838  } else \r
2839    {\r
2840     cout<<"WARNING: Statistical error of QC{6} is imaginary !!!!"<<endl;\r
2841    }\r
2842                             \r
2843  // statistical error of QC{8}:              \r
2844  qc8ErrorSquared = 256.*pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)\r
2845                  + 1296.*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)\r
2846                  + 256.*pow(two,2.)*pow(sixError,2.)\r
2847                  + pow(eightError,2.)\r
2848                  - 1152.*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24\r
2849                  + 512.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26\r
2850                  - 32.*(36.*pow(two,3.)-18.*four*two+six)*wCov28\r
2851                  - 1152.*two*(4.*pow(two,2.)-four)*wCov46\r
2852                  + 72.*(4.*pow(two,2.)-four)*wCov48\r
2853                  - 32.*two*wCov68;      \r
2854  if(qc8ErrorSquared>0.)\r
2855  {\r
2856   qc8Error = pow(qc8ErrorSquared,0.5);\r
2857  } else \r
2858    {\r
2859     cout<<"WARNING: Statistical error of QC{8} is imaginary !!!!"<<endl;\r
2860    }\r
2861 \r
2862  // store the results and statistical errors for Q-cumulants:\r
2863  fIntFlowQcumulants->SetBinContent(1,qc2);\r
2864  fIntFlowQcumulants->SetBinError(1,qc2Error);\r
2865  fIntFlowQcumulants->SetBinContent(2,qc4);\r
2866  fIntFlowQcumulants->SetBinError(2,qc4Error);\r
2867  fIntFlowQcumulants->SetBinContent(3,qc6);\r
2868  fIntFlowQcumulants->SetBinError(3,qc6Error);\r
2869  fIntFlowQcumulants->SetBinContent(4,qc8); \r
2870  fIntFlowQcumulants->SetBinError(4,qc8Error); \r
2871   \r
2872 } // end of AliFlowAnalysisWithQCumulants::CalculateCumulantsIntFlow()\r
2873 \r
2874 \r
2875 //================================================================================================================================ \r
2876 \r
2877 \r
2878 void AliFlowAnalysisWithQCumulants::CalculateIntFlow()\r
2879 {\r
2880  // a) Calculate the final results for integrated flow estimates from Q-cumulants.\r
2881  // b) Propagate the statistical errors of measured multiparticle correlations to statistical errors of integrated flow estimates.  \r
2882  // c) Store the results and statistical errors of integrated flow estimates in histogram fIntFlow.\r
2883  //    Binning of fIntFlow is organized as follows:\r
2884  //\r
2885  //     1st bin: v{2,QC}\r
2886  //     2nd bin: v{4,QC}\r
2887  //     3rd bin: v{6,QC}\r
2888  //     4th bin: v{8,QC}\r
2889  \r
2890  if(!(fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants && fIntFlow))\r
2891  {\r
2892   cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCovariances && fIntFlowQcumulants && fIntFlow is NULL in AFAWQC::CCIF() !!!!"<<endl;\r
2893   exit(0);\r
2894  }\r
2895    \r
2896  // Q-cumulants:\r
2897  Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}  \r
2898  Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}  \r
2899  Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6}  \r
2900  Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}\r
2901   \r
2902  // correlations:\r
2903  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>> \r
2904  Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>  \r
2905  Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>> \r
2906  Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>  \r
2907  \r
2908  // statistical errors of average 2-, 4-, 6- and 8-particle azimuthal correlations:\r
2909  Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <2>  \r
2910  Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <4>   \r
2911  Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <6> \r
2912  Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <8> \r
2913  \r
2914  // covariances (multiplied by prefactor depending on weights - see comments in CalculateCovariancesIntFlow()):\r
2915  Double_t wCov24 = fIntFlowCovariances->GetBinContent(1); // Cov(<2>,<4>) * prefactor(w_<2>,w_<4>)\r
2916  Double_t wCov26 = fIntFlowCovariances->GetBinContent(2); // Cov(<2>,<6>) * prefactor(w_<2>,w_<6>)\r
2917  Double_t wCov28 = fIntFlowCovariances->GetBinContent(3); // Cov(<2>,<8>) * prefactor(w_<2>,w_<8>)\r
2918  Double_t wCov46 = fIntFlowCovariances->GetBinContent(4); // Cov(<4>,<6>) * prefactor(w_<4>,w_<6>)\r
2919  Double_t wCov48 = fIntFlowCovariances->GetBinContent(5); // Cov(<4>,<8>) * prefactor(w_<4>,w_<8>)\r
2920  Double_t wCov68 = fIntFlowCovariances->GetBinContent(6); // Cov(<6>,<8>) * prefactor(w_<6>,w_<8>)\r
2921   \r
2922  // integrated flow estimates:\r
2923  Double_t v2 = 0.; // v{2,QC}  \r
2924  Double_t v4 = 0.; // v{4,QC}  \r
2925  Double_t v6 = 0.; // v{6,QC}  \r
2926  Double_t v8 = 0.; // v{8,QC}\r
2927  \r
2928  // calculate integrated flow estimates from Q-cumulants: \r
2929  if(qc2>=0.) v2 = pow(qc2,1./2.); \r
2930  if(qc4<=0.) v4 = pow(-1.*qc4,1./4.); \r
2931  if(qc6>=0.) v6 = pow((1./4.)*qc6,1./6.); \r
2932  if(qc8<=0.) v8 = pow((-1./33.)*qc8,1./8.); \r
2933    \r
2934  // statistical errors of integrated flow estimates:\r
2935  Double_t v2Error = 0.; // statistical error of v{2,QC}  \r
2936  Double_t v4Error = 0.; // statistical error of v{4,QC}  \r
2937  Double_t v6Error = 0.; // statistical error of v{6,QC}  \r
2938  Double_t v8Error = 0.; // statistical error of v{8,QC}\r
2939    \r
2940  // squares of statistical errors of integrated flow estimates:\r
2941  Double_t v2ErrorSquared = 0.; // squared statistical error of v{2,QC} \r
2942  Double_t v4ErrorSquared = 0.; // squared statistical error of v{4,QC}   \r
2943  Double_t v6ErrorSquared = 0.; // squared statistical error of v{6,QC}   \r
2944  Double_t v8ErrorSquared = 0.; // squared statistical error of v{8,QC} \r
2945  \r
2946  // calculate squared statistical errors of integrated flow estimates:\r
2947  if(two > 0.) \r
2948  { \r
2949   v2ErrorSquared = (1./(4.*two))*pow(twoError,2.);\r
2950  } \r
2951  if(2.*pow(two,2.)-four > 0.)\r
2952  {\r
2953   v4ErrorSquared = (1./pow(2.*pow(two,2.)-four,3./2.))*\r
2954                    (pow(two,2.)*pow(twoError,2.)+(1./16.)*pow(fourError,2.)-(1./2.)*two*wCov24);\r
2955  }\r
2956  if(six-9.*four*two+12.*pow(two,3.) > 0.) \r
2957  {\r
2958   v6ErrorSquared = ((1./2.)*(1./pow(2.,2./3.))*(1./pow(six-9.*four*two+12.*pow(two,3.),5./3.)))*\r
2959                    ((9./2.)*pow(4.*pow(two,2.)-four,2.)*pow(twoError,2.) \r
2960                     + (9./2.)*pow(two,2.)*pow(fourError,2.)+(1./18.)*pow(sixError,2.)\r
2961                     - 9.*two*(4.*pow(two,2.)-four)*wCov24+(4.*pow(two,2.)-four)*wCov26-two*wCov46); \r
2962  }\r
2963  if(-1.*eight+16.*six*two+18.*pow(four,2.)-144.*four*pow(two,2.)+144.*pow(two,4.) > 0.) \r
2964  {\r
2965   v8ErrorSquared = (4./pow(33,1./4.))*(1./pow(-1.*eight+16.*six*two+18.*pow(four,2.)-144.*four*pow(two,2.)+144.*pow(two,4.),7./4.))*\r
2966                    (pow(36.*pow(two,3.)-18.*four*two+six,2.)*pow(twoError,2.)\r
2967                     + (81./16.)*pow(4.*pow(two,2.)-four,2.)*pow(fourError,2.)\r
2968                     + pow(two,2.)*pow(sixError,2.)\r
2969                     + (1./256.)*pow(eightError,2.)\r
2970                     - (9./2.)*(36.*pow(two,3.)-18.*four*two+six)*(4.*pow(two,2.)-four)*wCov24\r
2971                     + 2.*two*(36.*pow(two,3.)-18.*four*two+six)*wCov26\r
2972                     - (1./8.)*(36.*pow(two,3.)-18.*four*two+six)*wCov28                    \r
2973                     - (9./2.)*two*(4.*pow(two,2.)-four)*wCov46                   \r
2974                     + (9./32.)*(4.*pow(two,2.)-four)*wCov48                    \r
2975                     - (1./8.)*two*wCov68);\r
2976  } \r
2977 \r
2978  // calculate statistical errors of integrated flow estimates: \r
2979  if(v2ErrorSquared > 0.)\r
2980  {\r
2981   v2Error = pow(v2ErrorSquared,0.5);\r
2982  } else\r
2983    {\r
2984     cout<<"WARNING: Statistical error of v{2,QC} is imaginary !!!!"<<endl;\r
2985    }    \r
2986  if(v4ErrorSquared > 0.)\r
2987  {\r
2988   v4Error = pow(v4ErrorSquared,0.5);\r
2989  } else\r
2990    {\r
2991     cout<<"WARNING: Statistical error of v{4,QC} is imaginary !!!!"<<endl;\r
2992    }     \r
2993  if(v6ErrorSquared > 0.)\r
2994  {\r
2995   v6Error = pow(v6ErrorSquared,0.5);\r
2996  } else\r
2997    {\r
2998     cout<<"WARNING: Statistical error of v{6,QC} is imaginary !!!!"<<endl;\r
2999    }     \r
3000  if(v8ErrorSquared > 0.)\r
3001  {\r
3002   v8Error = pow(v8ErrorSquared,0.5);\r
3003  } else\r
3004    {\r
3005     cout<<"WARNING: Statistical error of v{8,QC} is imaginary !!!!"<<endl;\r
3006    }    \r
3007                      \r
3008  // store the results and statistical errors of integrated flow estimates:\r
3009  fIntFlow->SetBinContent(1,v2);\r
3010  fIntFlow->SetBinError(1,v2Error);\r
3011  fIntFlow->SetBinContent(2,v4);\r
3012  fIntFlow->SetBinError(2,v4Error);\r
3013  fIntFlow->SetBinContent(3,v6);\r
3014  fIntFlow->SetBinError(3,v6Error);\r
3015  fIntFlow->SetBinContent(4,v8);\r
3016  fIntFlow->SetBinError(4,v8Error);\r
3017        \r
3018 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlow()\r
3019 \r
3020 \r
3021 //================================================================================================================================ \r
3022 \r
3023 \r
3024 void AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()\r
3025 {\r
3026  // Fill in AliFlowCommonHistResults histograms relevant for 'NONAME' integrated flow (to be improved (name))\r
3027  \r
3028  if(!fIntFlow)\r
3029  {\r
3030   cout<<"WARNING: fIntFlow is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
3031   exit(0); \r
3032  }  \r
3033     \r
3034  if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
3035  {\r
3036   cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl; \r
3037   cout<<"         is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
3038   exit(0);\r
3039  }\r
3040  \r
3041  Double_t v2 = fIntFlow->GetBinContent(1);\r
3042  Double_t v4 = fIntFlow->GetBinContent(2);\r
3043  Double_t v6 = fIntFlow->GetBinContent(3);\r
3044  Double_t v8 = fIntFlow->GetBinContent(4);\r
3045   \r
3046  Double_t v2Error = fIntFlow->GetBinError(1);\r
3047  Double_t v4Error = fIntFlow->GetBinError(2);\r
3048  Double_t v6Error = fIntFlow->GetBinError(3);\r
3049  Double_t v8Error = fIntFlow->GetBinError(4);\r
3050  \r
3051  fCommonHistsResults2nd->FillIntegratedFlow(v2,v2Error); // to be improved (hardwired 2nd in the name)  \r
3052  fCommonHistsResults4th->FillIntegratedFlow(v4,v4Error); // to be improved (hardwired 4th in the name)\r
3053  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)) // to be improved (calculate also 6th and 8th order)\r
3054  {\r
3055   fCommonHistsResults6th->FillIntegratedFlow(v6,v6Error); // to be improved (hardwired 6th in the name)\r
3056   fCommonHistsResults8th->FillIntegratedFlow(v8,v8Error); // to be improved (hardwired 8th in the name) \r
3057  }\r
3058  \r
3059 } // end of AliFlowAnalysisWithQCumulants::FillCommonHistResultsIntFlow()\r
3060 \r
3061 \r
3062 //================================================================================================================================ \r
3063 \r
3064 \r
3065 /*\r
3066 void AliFlowAnalysisWithQCumulants::ApplyCorrectionForNonUniformAcceptanceToCumulantsForIntFlow(Bool_t useParticleWeights, TString eventWeights)\r
3067 {\r
3068  // apply correction for non-uniform acceptance to cumulants for integrated flow \r
3069  // (Remark: non-corrected cumulants are accessed from fCumulants[pW][0], corrected cumulants are stored in fCumulants[pW][1])\r
3070  \r
3071  // shortcuts for the flags:\r
3072  Int_t pW = (Int_t)(useParticleWeights); // 0=pWeights not used, 1=pWeights used\r
3073  Int_t eW = -1;\r
3074  \r
3075  if(eventWeights == "exact")\r
3076  {\r
3077   eW = 0;\r
3078  }\r
3079  \r
3080  if(!(fCumulants[pW][eW][0] && fCumulants[pW][eW][1] && fCorrections[pW][eW]))\r
3081  {\r
3082   cout<<"WARNING: fCumulants[pW][eW][0] && fCumulants[pW][eW][1] && fCorrections[pW][eW] is NULL in AFAWQC::ACFNUATCFIF() !!!!"<<endl;\r
3083   cout<<"pW = "<<pW<<endl;\r
3084   cout<<"eW = "<<eW<<endl;\r
3085   exit(0);\r
3086  } \r
3087   \r
3088  // non-corrected cumulants:\r
3089  Double_t qc2 = fCumulants[pW][eW][0]->GetBinContent(1); \r
3090  Double_t qc4 = fCumulants[pW][eW][0]->GetBinContent(2); \r
3091  Double_t qc6 = fCumulants[pW][eW][0]->GetBinContent(3); \r
3092  Double_t qc8 = fCumulants[pW][eW][0]->GetBinContent(4); \r
3093  // statistical error of non-corrected cumulants:  \r
3094  Double_t qc2Error = fCumulants[pW][eW][0]->GetBinError(1); \r
3095  Double_t qc4Error = fCumulants[pW][eW][0]->GetBinError(2); \r
3096  Double_t qc6Error = fCumulants[pW][eW][0]->GetBinError(3); \r
3097  Double_t qc8Error = fCumulants[pW][eW][0]->GetBinError(4); \r
3098  // corrections for non-uniform acceptance:\r
3099  Double_t qc2Correction = fCorrections[pW][eW]->GetBinContent(1); \r
3100  Double_t qc4Correction = fCorrections[pW][eW]->GetBinContent(2); \r
3101  Double_t qc6Correction = fCorrections[pW][eW]->GetBinContent(3); \r
3102  Double_t qc8Correction = fCorrections[pW][eW]->GetBinContent(4); \r
3103  // corrected cumulants:\r
3104  Double_t qc2Corrected = qc2 + qc2Correction;\r
3105  Double_t qc4Corrected = qc4 + qc4Correction;\r
3106  Double_t qc6Corrected = qc6 + qc6Correction;\r
3107  Double_t qc8Corrected = qc8 + qc8Correction;\r
3108   \r
3109  // ... to be improved (I need here also to correct error of QCs for NUA. \r
3110  // For simplicity sake I assume at the moment that this correction is negliglible, but it will be added eventually...)\r
3111  \r
3112  // store corrected results and statistical errors for cumulants:   \r
3113  fCumulants[pW][eW][1]->SetBinContent(1,qc2Corrected);\r
3114  fCumulants[pW][eW][1]->SetBinContent(2,qc4Corrected);\r
3115  fCumulants[pW][eW][1]->SetBinContent(3,qc6Corrected);\r
3116  fCumulants[pW][eW][1]->SetBinContent(4,qc8Corrected);\r
3117  fCumulants[pW][eW][1]->SetBinError(1,qc2Error); // to be improved (correct also qc2Error for NUA)\r
3118  fCumulants[pW][eW][1]->SetBinError(2,qc4Error); // to be improved (correct also qc4Error for NUA)\r
3119  fCumulants[pW][eW][1]->SetBinError(3,qc6Error); // to be improved (correct also qc6Error for NUA)\r
3120  fCumulants[pW][eW][1]->SetBinError(4,qc8Error); // to be improved (correct also qc8Error for NUA)  \r
3121   \r
3122 } // end of AliFlowAnalysisWithQCumulants::ApplyCorrectionForNonUniformAcceptanceToCumulantsForIntFlow(Bool_t useParticleWeights, TString eventWeights)\r
3123 */\r
3124 \r
3125 \r
3126 //================================================================================================================================\r
3127 \r
3128 \r
3129 /*  \r
3130 void AliFlowAnalysisWithQCumulants::PrintQuantifyingCorrectionsForNonUniformAcceptance(Bool_t useParticleWeights, TString eventWeights)\r
3131 {\r
3132  // print on the screen QC{n,biased}/QC{n,corrected}\r
3133  \r
3134  // shortcuts for the flags:\r
3135  Int_t pW = (Int_t)(useParticleWeights); // 0=pWeights not used, 1=pWeights used\r
3136  \r
3137  Int_t eW = -1;\r
3138  \r
3139  if(eventWeights == "exact")\r
3140  {\r
3141   eW = 0;\r
3142  } \r
3143  \r
3144  if(!(fCumulants[pW][eW][0] && fCumulants[pW][eW][1]))\r
3145  {\r
3146   cout<<"WARNING: fCumulants[pW][eW][0] && fCumulants[pW][eW][1] is NULL in AFAWQC::PQCFNUA() !!!!"<<endl;\r
3147   cout<<"pW = "<<pW<<endl;\r
3148   cout<<"eW = "<<eW<<endl;\r
3149   exit(0);\r
3150  }\r
3151    \r
3152  cout<<endl;\r
3153  cout<<" Quantifying the bias to Q-cumulants from"<<endl;\r
3154  cout<<"  non-uniform acceptance of the detector:"<<endl;\r
3155  cout<<endl;\r
3156   \r
3157  if(fCumulants[pW][eW][1]->GetBinContent(1)) \r
3158  { \r
3159   cout<<"  QC{2,biased}/QC{2,corrected} = "<<(fCumulants[pW][eW][0]->GetBinContent(1))/(fCumulants[pW][eW][1]->GetBinContent(1))<<endl;   \r
3160  }\r
3161  if(fCumulants[pW][eW][1]->GetBinContent(2)) \r
3162  { \r
3163   cout<<"  QC{4,biased}/QC{4,corrected} = "<<fCumulants[pW][eW][0]->GetBinContent(2)/fCumulants[pW][eW][1]->GetBinContent(2)<<endl;   \r
3164  }\r
3165  \r
3166  cout<<endl;\r
3167             \r
3168 } // end of AliFlowAnalysisWithQCumulants::PrintQuantifyingCorrectionsForNonUniformAcceptance(Bool_t useParticleWeights, TString eventWeights)\r
3169 */\r
3170 \r
3171 \r
3172 //================================================================================================================================\r
3173 \r
3174 \r
3175 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()\r
3176 {\r
3177  // Calculate all correlations needed for integrated flow using particle weights.\r
3178   \r
3179  // Remark 1: When particle weights are used the binning of fIntFlowCorrelationAllPro is organized as follows:\r
3180  //\r
3181  //  1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>\r
3182  //  2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
3183  //  3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))> \r
3184  //  4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
3185  //  5th bin:           ----  EMPTY ----\r
3186  //  6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
3187  //  7th bin: <3>_{3n|2n,1n} = ...\r
3188  //  8th bin: <3>_{4n|2n,2n} = ...\r
3189  //  9th bin: <3>_{4n|3n,1n} = ...\r
3190  // 10th bin:           ----  EMPTY ----\r
3191  // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
3192  // 12th bin: <4>_{2n,1n|2n,1n} = ...\r
3193  // 13th bin: <4>_{2n,2n|2n,2n} = ...\r
3194  // 14th bin: <4>_{3n|1n,1n,1n} = ... \r
3195  // 15th bin: <4>_{3n,1n|3n,1n} = ...\r
3196  // 16th bin: <4>_{3n,1n|2n,2n} = ...\r
3197  // 17th bin: <4>_{4n|2n,1n,1n} = ... \r
3198  // 18th bin:           ----  EMPTY ----\r
3199  // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...\r
3200  // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...\r
3201  // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...\r
3202  // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...\r
3203  // 23rd bin:           ----  EMPTY ----\r
3204  // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...\r
3205  // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...\r
3206  // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...\r
3207  // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...\r
3208  // 28th bin:           ----  EMPTY ----\r
3209  // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...\r
3210  // 30th bin:           ----  EMPTY ----\r
3211  // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...\r
3212  \r
3213  // Remark 2: When particle weights are used there are some extra correlations. They are stored in \r
3214  // fIntFlowExtraCorrelationsPro binning of which is organized as follows:\r
3215  \r
3216  // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>\r
3217  // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>  \r
3218
3219  // multiplicity (number of particles used to determine the reaction plane)\r
3220  Double_t dMult = (*fSMpk)(0,0);\r
3221  \r
3222  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3223  Double_t dReQ1n1k = (*fReQ)(0,1);\r
3224  Double_t dReQ2n2k = (*fReQ)(1,2);\r
3225  Double_t dReQ3n3k = (*fReQ)(2,3);\r
3226  Double_t dReQ4n4k = (*fReQ)(3,4);\r
3227  Double_t dReQ1n3k = (*fReQ)(0,3);\r
3228  Double_t dImQ1n1k = (*fImQ)(0,1);\r
3229  Double_t dImQ2n2k = (*fImQ)(1,2);\r
3230  Double_t dImQ3n3k = (*fImQ)(2,3);\r
3231  Double_t dImQ4n4k = (*fImQ)(3,4);\r
3232  Double_t dImQ1n3k = (*fImQ)(0,3);\r
3233 \r
3234  // dMs are variables introduced in order to simplify some Eqs. bellow:\r
3235  //..............................................................................................\r
3236  Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
3237  Double_t dM22 = (*fSMpk)(1,2)-(*fSMpk)(0,4); // dM22 = sum_{i,j=1,i!=j}^M w_i^2 w_j^2\r
3238  Double_t dM33 = (*fSMpk)(1,3)-(*fSMpk)(0,6); // dM33 = sum_{i,j=1,i!=j}^M w_i^3 w_j^3\r
3239  Double_t dM44 = (*fSMpk)(1,4)-(*fSMpk)(0,8); // dM44 = sum_{i,j=1,i!=j}^M w_i^4 w_j^4\r
3240  Double_t dM31 = (*fSMpk)(0,3)*(*fSMpk)(0,1)-(*fSMpk)(0,4); // dM31 = sum_{i,j=1,i!=j}^M w_i^3 w_j\r
3241  Double_t dM211 = (*fSMpk)(0,2)*(*fSMpk)(1,1)-2.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3242                 - (*fSMpk)(1,2)+2.*(*fSMpk)(0,4); // dM211 = sum_{i,j,k=1,i!=j!=k}^M w_i^2 w_j w_k\r
3243  Double_t dM1111 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1)  \r
3244                  + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3245                  + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
3246  //..............................................................................................\r
3247 \r
3248  // 2-particle correlations:\r
3249  Double_t two1n1nW1W1 = 0.; // <w1 w2 cos(n*(phi1-phi2))>\r
3250  Double_t two2n2nW2W2 = 0.; // <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
3251  Double_t two3n3nW3W3 = 0.; // <w1^3 w2^3 cos(3n*(phi1-phi2))>\r
3252  Double_t two4n4nW4W4 = 0.; // <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
3253  if(dMult>1) \r
3254  { \r
3255   if(dM11)\r
3256   {\r
3257    two1n1nW1W1 = (pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSMpk)(0,2))/dM11;    \r
3258    // average correlation <w1 w2 cos(n*(phi1-phi2))> for single event: \r
3259    fIntFlowCorrelationsEBE->SetBinContent(1,two1n1nW1W1);\r
3260    fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(1,dM11);\r
3261    // average correlation <w1 w2 cos(n*(phi1-phi2))> for all events:\r
3262    fIntFlowCorrelationsPro->Fill(0.5,two1n1nW1W1,dM11);   \r
3263    fIntFlowCorrelationsAllPro->Fill(0.5,two1n1nW1W1,dM11);   \r
3264   }\r
3265   if(dM22)\r
3266   {\r
3267    two2n2nW2W2 = (pow(dReQ2n2k,2)+pow(dImQ2n2k,2)-(*fSMpk)(0,4))/dM22; \r
3268    // ...\r
3269    // average correlation <w1^2 w2^2 cos(2n*(phi1-phi2))> for all events:\r
3270    fIntFlowCorrelationsAllPro->Fill(1.5,two2n2nW2W2,dM22);   \r
3271   }\r
3272   if(dM33)\r
3273   {\r
3274    two3n3nW3W3 = (pow(dReQ3n3k,2)+pow(dImQ3n3k,2)-(*fSMpk)(0,6))/dM33;\r
3275    // ...\r
3276    // average correlation <w1^3 w2^3 cos(3n*(phi1-phi2))> for all events:\r
3277    fIntFlowCorrelationsAllPro->Fill(2.5,two3n3nW3W3,dM33);   \r
3278   }\r
3279   if(dM44)\r
3280   {\r
3281    two4n4nW4W4 = (pow(dReQ4n4k,2)+pow(dImQ4n4k,2)-(*fSMpk)(0,8))/dM44; \r
3282    // ...\r
3283    // average correlation <w1^4 w2^4 cos(4n*(phi1-phi2))> for all events:\r
3284    fIntFlowCorrelationsAllPro->Fill(3.5,two4n4nW4W4,dM44);      \r
3285   }\r
3286  } // end of if(dMult>1) \r
3287 \r
3288  // extra 2-particle correlations:\r
3289  Double_t two1n1nW3W1 = 0.; // <w1^3 w2 cos(n*(phi1-phi2))>\r
3290  Double_t two1n1nW1W1W2 = 0.; // <w1 w2 w3^2 cos(n*(phi1-phi2))> \r
3291  if(dMult>1) \r
3292  {    \r
3293   if(dM31)\r
3294   {\r
3295    two1n1nW3W1 = (dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k-(*fSMpk)(0,4))/dM31; \r
3296    fIntFlowExtraCorrelationsPro->Fill(0.5,two1n1nW3W1,dM31);  \r
3297   } \r
3298   if(dM211)\r
3299   {\r
3300    two1n1nW1W1W2 = ((*fSMpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2)-(*fSMpk)(0,2))\r
3301                  - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k\r
3302                  - (*fSMpk)(0,4)))/dM211;\r
3303    fIntFlowExtraCorrelationsPro->Fill(1.5,two1n1nW1W1W2,dM211);  \r
3304   }  \r
3305  } // end of if(dMult>1)\r
3306  //..............................................................................................\r
3307  \r
3308  //..............................................................................................\r
3309  // 3-particle correlations:\r
3310  Double_t three2n1n1nW2W1W1 = 0.; // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
3311  \r
3312  if(dMult>2) \r
3313  { \r
3314   if(dM211)\r
3315   {                                                       \r
3316    three2n1n1nW2W1W1 = (pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k\r
3317                      - 2.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)\r
3318                      - pow(dReQ2n2k,2)-pow(dImQ2n2k,2)\r
3319                      + 2.*(*fSMpk)(0,4))/dM211;                                                                               \r
3320    fIntFlowCorrelationsAllPro->Fill(5.5,three2n1n1nW2W1W1,dM211);\r
3321   } \r
3322  } // end of if(dMult>2) \r
3323  //..............................................................................................\r
3324  \r
3325  //..............................................................................................\r
3326  // 4-particle correlations:\r
3327  Double_t four1n1n1n1nW1W1W1W1 = 0.; // <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
3328  if(dMult>3) \r
3329  { \r
3330   if(dM1111)\r
3331   {      \r
3332    four1n1n1n1nW1W1W1W1 = (pow(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.),2)\r
3333                         - 2.*(pow(dReQ1n1k,2.)*dReQ2n2k+2.*dReQ1n1k*dImQ1n1k*dImQ2n2k-pow(dImQ1n1k,2.)*dReQ2n2k)\r
3334                         + 8.*(dReQ1n3k*dReQ1n1k+dImQ1n3k*dImQ1n1k)\r
3335                         + (pow(dReQ2n2k,2)+pow(dImQ2n2k,2))\r
3336                         - 4.*(*fSMpk)(0,2)*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))\r
3337                         - 6.*(*fSMpk)(0,4)+2.*(*fSMpk)(1,2))/dM1111;  \r
3338                           \r
3339    // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for single event: \r
3340    fIntFlowCorrelationsEBE->SetBinContent(2,four1n1n1n1nW1W1W1W1);\r
3341    fIntFlowEventWeightsForCorrelationsEBE->SetBinContent(2,dM1111);\r
3342    // average correlation <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))> for all events:\r
3343    fIntFlowCorrelationsPro->Fill(1.5,four1n1n1n1nW1W1W1W1,dM1111);   \r
3344    fIntFlowCorrelationsAllPro->Fill(10.5,four1n1n1n1nW1W1W1W1,dM1111);   \r
3345   } \r
3346  } // end of if(dMult>3) \r
3347  //..............................................................................................\r
3348  \r
3349 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrelationsUsingParticleWeights()\r
3350 \r
3351 \r
3352 //================================================================================================================================\r
3353 \r
3354 \r
3355 void AliFlowAnalysisWithQCumulants::CalculateWeightedQProductsForIntFlow() // to be improved (completed)\r
3356 {\r
3357  // calculate averages like <<2><4>>, <<2><6>>, <<4><6>>, etc. which are needed to calculate covariances \r
3358  // Remark: here we take weighted correlations!\r
3359  \r
3360  /*\r
3361  \r
3362  // binning of fQProductsW is organized as follows:\r
3363  // \r
3364  // 1st bin: <2><4> \r
3365  // 2nd bin: <2><6>\r
3366  // 3rd bin: <2><8>\r
3367  // 4th bin: <4><6>\r
3368  // 5th bin: <4><8>\r
3369  // 6th bin: <6><8>\r
3370  \r
3371  Double_t dMult = (*fSMpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)\r
3372 \r
3373  Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
3374  Double_t dM1111 = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1)  \r
3375                  + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
3376                  + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
3377 \r
3378  Double_t twoEBEW = 0.; // <2>\r
3379  Double_t fourEBEW = 0.; // <4>\r
3380  \r
3381  twoEBEW = fQCorrelationsEBE[1]->GetBinContent(1);\r
3382  fourEBEW = fQCorrelationsEBE[1]->GetBinContent(11);\r
3383  \r
3384  // <2><4>\r
3385  if(dMult>3)\r
3386  {\r
3387   fQProducts[1][0]->Fill(0.5,twoEBEW*fourEBEW,dM11*dM1111);\r
3388  }\r
3389  \r
3390  */\r
3391  \r
3392 } // end of AliFlowAnalysisWithQCumulants::CalculateWeightedQProductsForIntFlow()  \r
3393 \r
3394 \r
3395 //================================================================================================================================\r
3396 \r
3397 \r
3398 void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()\r
3399 {\r
3400  // Initialize all arrays used to calculate integrated flow.\r
3401  \r
3402  for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3403  {\r
3404   fIntFlowCorrectionTermsForNUAEBE[sc] = NULL;\r
3405   fIntFlowCorrectionTermsForNUAPro[sc] = NULL;\r
3406   fIntFlowCorrectionTermsForNUAHist[sc] = NULL;\r
3407  }\r
3408    \r
3409  for(Int_t power=0;power<2;power++) // linear or quadratic \r
3410  {\r
3411   fIntFlowSumOfEventWeights[power] = NULL;    \r
3412  }\r
3413  \r
3414 } // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForIntFlow()\r
3415 \r
3416 \r
3417 //================================================================================================================================\r
3418 \r
3419 \r
3420 void AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()\r
3421 {\r
3422  // Initialize all arrays needed to calculate differential flow.\r
3423  //  a) Initialize lists holding profiles;\r
3424  //  b) Initialize lists holding histograms;\r
3425  //  c) Initialize event-by-event quantities;\r
3426  //  d) Initialize profiles;\r
3427  //  e) Initialize histograms holding final results.\r
3428  \r
3429  // a) Initialize lists holding profiles;\r
3430  for(Int_t t=0;t<2;t++) // type (RP, POI)\r
3431  {\r
3432   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3433   {\r
3434    fDiffFlowCorrelationsProList[t][pe] = NULL;\r
3435    fDiffFlowProductOfCorrelationsProList[t][pe] = NULL;\r
3436    fDiffFlowCorrectionsProList[t][pe] = NULL;\r
3437   }\r
3438  }  \r
3439  \r
3440  // b) Initialize lists holding histograms;\r
3441  for(Int_t t=0;t<2;t++) // type (RP, POI)\r
3442  {\r
3443   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3444   {\r
3445    fDiffFlowCorrelationsHistList[t][pe] = NULL;\r
3446    for(Int_t power=0;power<2;power++)\r
3447    {\r
3448     fDiffFlowSumOfEventWeightsHistList[t][pe][power] = NULL;\r
3449    } // end of for(Int_t power=0;power<2;power++)  \r
3450    fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = NULL;\r
3451    fDiffFlowCorrectionsHistList[t][pe] = NULL;\r
3452    fDiffFlowCovariancesHistList[t][pe] = NULL;\r
3453    fDiffFlowCumulantsHistList[t][pe] = NULL;\r
3454    fDiffFlowHistList[t][pe] = NULL;\r
3455   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3456  } // enf of for(Int_t t=0;t<2;t++) // type (RP, POI) \r
3457  \r
3458  // c) Initialize event-by-event quantities:\r
3459  // 1D:\r
3460  for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
3461  {\r
3462   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3463   { \r
3464    for(Int_t m=0;m<4;m++) // multiple of harmonic\r
3465    {\r
3466     for(Int_t k=0;k<9;k++) // power of weight\r
3467     {\r
3468      fReRPQ1dEBE[t][pe][m][k] = NULL;\r
3469      fImRPQ1dEBE[t][pe][m][k] = NULL;\r
3470      fs1dEBE[t][pe][k] = NULL; // to be improved (this doesn't need to be within loop over m)\r
3471     }   \r
3472    }\r
3473   }\r
3474  }\r
3475  // 1D:\r
3476  for(Int_t t=0;t<2;t++) // type (RP or POI)\r
3477  {\r
3478   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3479   { \r
3480    for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3481    {\r
3482     for(Int_t cti=0;cti<9;cti++) // correction term index\r
3483     {\r
3484      fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = NULL;\r
3485     }   \r
3486    }\r
3487   }\r
3488  }\r
3489  // 2D:  \r
3490  for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
3491  {\r
3492   for(Int_t m=0;m<4;m++) // multiple of harmonic\r
3493   {\r
3494    for(Int_t k=0;k<9;k++) // power of weight\r
3495    {\r
3496     fReRPQ2dEBE[t][m][k] = NULL;\r
3497     fImRPQ2dEBE[t][m][k] = NULL;\r
3498     fs2dEBE[t][k] = NULL; // to be improved (this doesn't need to be within loop over m)\r
3499    }   \r
3500   }\r
3501  }\r
3502  \r
3503  // d) Initialize profiles:\r
3504  for(Int_t t=0;t<2;t++) // type: RP or POI\r
3505  { \r
3506   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3507   {\r
3508    for(Int_t ci=0;ci<4;ci++) // correlation index\r
3509    {\r
3510     fDiffFlowCorrelationsPro[t][pe][ci] = NULL;\r
3511    } // end of for(Int_t ci=0;ci<4;ci++)   \r
3512    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
3513    {\r
3514     for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3515     {\r
3516      fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = NULL;\r
3517     } // end of for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3518    } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index  \r
3519    // correction terms for nua:\r
3520    for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3521    {\r
3522     for(Int_t cti=0;cti<9;cti++) // correction term index\r
3523     {\r
3524      fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = NULL;\r
3525     }   \r
3526    }\r
3527   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3528  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
3529   \r
3530  // e) Initialize histograms holding final results.\r
3531  for(Int_t t=0;t<2;t++) // type: RP or POI\r
3532  { \r
3533   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3534   {\r
3535    for(Int_t ci=0;ci<4;ci++) // correlation index\r
3536    {\r
3537     fDiffFlowCorrelationsHist[t][pe][ci] = NULL;\r
3538     fDiffFlowCumulants[t][pe][ci] = NULL;\r
3539     fDiffFlow[t][pe][ci] = NULL;\r
3540    } // end of for(Int_t ci=0;ci<4;ci++)    \r
3541    for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++) \r
3542    {\r
3543     fDiffFlowCovariances[t][pe][covarianceIndex] = NULL;     \r
3544    } // end of for(Int_t covarianceIndex=0;covarianceIndex<5;covarianceIndex++) \r
3545    // correction terms for nua:\r
3546    for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
3547    {\r
3548     for(Int_t cti=0;cti<9;cti++) // correction term index\r
3549     {\r
3550      fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = NULL;\r
3551     }   \r
3552    }\r
3553   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3554  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
3555  \r
3556  // sum of event weights for reduced correlations:\r
3557  for(Int_t t=0;t<2;t++) // type = RP or POI\r
3558  {\r
3559   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3560   {\r
3561    for(Int_t p=0;p<2;p++) // power of weight is 1 or 2\r
3562    {\r
3563     for(Int_t ew=0;ew<4;ew++) // event weight index for reduced correlations\r
3564     {\r
3565      fDiffFlowSumOfEventWeights[t][pe][p][ew] = NULL;\r
3566     } \r
3567    }   \r
3568   }\r
3569  }\r
3570  // product of event weights for both types of correlations:\r
3571  for(Int_t t=0;t<2;t++) // type = RP or POI\r
3572  {\r
3573   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
3574   {\r
3575    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
3576    {\r
3577     for(Int_t mci2=0;mci2<8;mci2++) // mixed correlation index\r
3578     {\r
3579      fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = NULL;\r
3580     } \r
3581    }   \r
3582   }\r
3583  }\r
3584 \r
3585  \r
3586  \r
3587  \r
3588  /*\r
3589  \r
3590  // nested lists in fDiffFlowProfiles:\r
3591  for(Int_t t=0;t<2;t++)\r
3592  {\r
3593   fDFPType[t] = NULL;\r
3594   for(Int_t pW=0;pW<2;pW++) // particle weights not used (0) or used (1)\r
3595   {\r
3596    fDFPParticleWeights[t][pW] = NULL;\r
3597    for(Int_t eW=0;eW<2;eW++)\r
3598    {   \r
3599     fDFPEventWeights[t][pW][eW] = NULL;\r
3600     fDiffFlowCorrelations[t][pW][eW] = NULL;\r
3601     fDiffFlowProductsOfCorrelations[t][pW][eW] = NULL;\r
3602     for(Int_t sc=0;sc<2;sc++)\r
3603     {\r
3604      fDiffFlowCorrectionTerms[t][pW][eW][sc] = NULL;\r
3605     }\r
3606    } \r
3607   }\r
3608  }  \r
3609  \r
3610  \r
3611  */\r
3612  \r
3613   \r
3614   \r
3615   /*\r
3616   for(Int_t pW=0;pW<2;pW++) // particle weights not used (0) or used (1)\r
3617   {\r
3618    for(Int_t eW=0;eW<2;eW++)\r
3619    {\r
3620     // correlations:\r
3621     for(Int_t correlationIndex=0;correlationIndex<4;correlationIndex++)\r
3622     {\r
3623      fCorrelationsPro[t][pW][eW][correlationIndex] = NULL;\r
3624     }\r
3625     // products of correlations:\r
3626     for(Int_t productOfCorrelationsIndex=0;productOfCorrelationsIndex<6;productOfCorrelationsIndex++)\r
3627     {\r
3628      fProductsOfCorrelationsPro[t][pW][eW][productOfCorrelationsIndex] = NULL;\r
3629     }\r
3630     // correction terms:\r
3631     for(Int_t sc=0;sc<2;sc++)\r
3632     {\r
3633      for(Int_t correctionsIndex=0;correctionsIndex<2;correctionsIndex++)\r
3634      {\r
3635       fCorrectionTermsPro[t][pW][eW][sc][correctionsIndex] = NULL;\r
3636      } \r
3637     } \r
3638    }\r
3639   } \r
3640   */\r
3641     \r
3642 } // end of AliFlowAnalysisWithQCumulants::InitializeArraysForDiffFlow()\r
3643 \r
3644 \r
3645 //================================================================================================================================\r
3646  /*\r
3647 \r
3648 \r
3649 void AliFlowAnalysisWithQCumulants::CalculateCorrelationsForDifferentialFlow2D(TString type)\r
3650 {\r
3651  // calculate all reduced correlations needed for differential flow for each (pt,eta) bin: \r
3652  \r
3653  if(type == "RP") // to be improved (removed)\r
3654  {\r
3655   cout<<endl;\r
3656  }\r
3657  // ... \r
3658  \r
3659  \r
3660  Int_t typeFlag = -1; \r
3661   \r
3662  // reduced correlations ares stored in fCorrelationsPro[t][pW][index] and are indexed as follows:\r
3663  // index:\r
3664  // 0: <2'>\r
3665  // 1: <4'>\r
3666 \r
3667  // multiplicity:\r
3668  Double_t dMult = (*fSMpk)(0,0);\r
3669  \r
3670  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3671  Double_t dReQ1n = (*fReQ)(0,0);\r
3672  Double_t dReQ2n = (*fReQ)(1,0);\r
3673  //Double_t dReQ3n = (*fReQ)(2,0);\r
3674  //Double_t dReQ4n = (*fReQ)(3,0);\r
3675  Double_t dImQ1n = (*fImQ)(0,0);\r
3676  Double_t dImQ2n = (*fImQ)(1,0);\r
3677  //Double_t dImQ3n = (*fImQ)(2,0);\r
3678  //Double_t dImQ4n = (*fImQ)(3,0);\r
3679 \r
3680  // looping over all (pt,eta) bins and calculating correlations needed for differential flow: \r
3681  for(Int_t p=1;p<=fnBinsPt;p++)\r
3682  {\r
3683   for(Int_t e=1;e<=fnBinsEta;e++)\r
3684   {\r
3685    // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin): \r
3686    Double_t p1n0kRe = 0.;\r
3687    Double_t p1n0kIm = 0.;\r
3688 \r
3689    // number of POIs in particular (pt,eta) bin:\r
3690    Double_t mp = 0.;\r
3691 \r
3692    // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin):\r
3693    Double_t q1n0kRe = 0.;\r
3694    Double_t q1n0kIm = 0.;\r
3695    Double_t q2n0kRe = 0.;\r
3696    Double_t q2n0kIm = 0.;\r
3697 \r
3698    // number of particles which are both RPs and POIs in particular (pt,eta) bin:\r
3699    Double_t mq = 0.;\r
3700    \r
3701    // q_{m*n,0}:\r
3702    q1n0kRe = fReEBE2D[2][0][0]->GetBinContent(fReEBE2D[2][0][0]->GetBin(p,e))\r
3703            * fReEBE2D[2][0][0]->GetBinEntries(fReEBE2D[2][0][0]->GetBin(p,e));\r
3704    q1n0kIm = fImEBE2D[2][0][0]->GetBinContent(fImEBE2D[2][0][0]->GetBin(p,e))\r
3705            * fImEBE2D[2][0][0]->GetBinEntries(fImEBE2D[2][0][0]->GetBin(p,e));\r
3706    q2n0kRe = fReEBE2D[2][1][0]->GetBinContent(fReEBE2D[2][1][0]->GetBin(p,e))\r
3707            * fReEBE2D[2][1][0]->GetBinEntries(fReEBE2D[2][1][0]->GetBin(p,e));\r
3708    q2n0kIm = fImEBE2D[2][1][0]->GetBinContent(fImEBE2D[2][1][0]->GetBin(p,e))\r
3709            * fImEBE2D[2][1][0]->GetBinEntries(fImEBE2D[2][1][0]->GetBin(p,e));\r
3710            \r
3711    mq = fReEBE2D[2][0][0]->GetBinEntries(fReEBE2D[2][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)\r
3712    \r
3713    if(type == "POI")\r
3714    {\r
3715     // p_{m*n,0}:\r
3716     p1n0kRe = fReEBE2D[1][0][0]->GetBinContent(fReEBE2D[1][0][0]->GetBin(p,e))\r
3717             * fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3718     p1n0kIm = fImEBE2D[1][0][0]->GetBinContent(fImEBE2D[1][0][0]->GetBin(p,e))  \r
3719             * fImEBE2D[1][0][0]->GetBinEntries(fImEBE2D[1][0][0]->GetBin(p,e));\r
3720             \r
3721     mp = fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e)); // to be improved (cross-checked by accessing other profiles here)\r
3722     \r
3723     typeFlag = 1;\r
3724    }\r
3725    else if(type == "RP")\r
3726    {\r
3727     // p_{m*n,0} = q_{m*n,0}:\r
3728     p1n0kRe = q1n0kRe; \r
3729     p1n0kIm = q1n0kIm; \r
3730     mp = mq; \r
3731     \r
3732     typeFlag = 0;\r
3733    }\r
3734    \r
3735    // count events with non-empty (pt,eta) bin:\r
3736    if(mp>0)\r
3737    {\r
3738     fNonEmptyBins2D[typeFlag]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,1);\r
3739    }\r
3740    \r
3741    // 2'-particle correlation for particular (pt,eta) bin:\r
3742    Double_t two1n1nPtEta = 0.;\r
3743    if(mp*dMult-mq)\r
3744    {\r
3745     two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)\r
3746                  / (mp*dMult-mq);\r
3747    \r
3748     // fill the 2D profile to get the average correlation for each (pt,eta) bin:\r
3749     if(type == "POI")\r
3750     { \r
3751      //f2pPtEtaPOI->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3752      \r
3753      fCorrelationsPro[1][0][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3754     }\r
3755     else if(type == "RP")\r
3756     {\r
3757      //f2pPtEtaRP->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);   \r
3758      fCorrelationsPro[0][0][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nPtEta,mp*dMult-mq);\r
3759     }\r
3760    } // end of if(mp*dMult-mq)\r
3761   \r
3762    // 4'-particle correlation:\r
3763    Double_t four1n1n1n1nPtEta = 0.;\r
3764    if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3765        + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)\r
3766    {\r
3767     four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
3768                       - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))\r
3769                       - 2.*q2n0kIm*dReQ1n*dImQ1n\r
3770                       - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)\r
3771                       + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)\r
3772                       - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
3773                       - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq                      \r
3774                       + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)                                            \r
3775                       + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)                      \r
3776                       + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)                       \r
3777                       + 2.*mq*dMult                      \r
3778                       - 6.*mq)        \r
3779                       / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3780                           + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
3781     \r
3782     // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3783     if(type == "POI")\r
3784     {\r
3785      //f4pPtEtaPOI->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3786      //                  (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3787      //                   + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
3788      \r
3789      fCorrelationsPro[1][0][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3790                                      (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3791                                      + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));\r
3792     }\r
3793     else if(type == "RP")\r
3794     {\r
3795      //f4pPtEtaRP->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3796      //                 (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3797      //                  + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));   \r
3798                        \r
3799      fCorrelationsPro[0][0][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nPtEta,\r
3800                                        (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3801                                        + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));                   \r
3802     }\r
3803    } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
3804      //            +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
3805    \r
3806   } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
3807  } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
3808 \r
3809  \r
3810    \r
3811     \r
3812       \r
3813 } // end of AliFlowAnalysisWithQCumulants::CalculateCorrelationsForDifferentialFlow2D()\r
3814 \r
3815 \r
3816 \r
3817  \r
3818  \r
3819 \r
3820 //================================================================================================================================\r
3821 \r
3822 \r
3823 void AliFlowAnalysisWithQCumulants::CalculateWeightedCorrelationsForDifferentialFlow2D(TString type)\r
3824 {\r
3825  // calculate all weighted correlations needed for differential flow \r
3826  \r
3827   if(type == "RP") // to be improved (removed)\r
3828  {\r
3829   cout<<endl;\r
3830  }\r
3831  // ... \r
3832  \r
3833  \r
3834  \r
3835  \r
3836  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
3837  Double_t dReQ1n1k = (*fReQ)(0,1);\r
3838  Double_t dReQ2n2k = (*fReQ)(1,2);\r
3839  Double_t dReQ1n3k = (*fReQ)(0,3);\r
3840  //Double_t dReQ4n4k = (*fReQ)(3,4);\r
3841  Double_t dImQ1n1k = (*fImQ)(0,1);\r
3842  Double_t dImQ2n2k = (*fImQ)(1,2);\r
3843  Double_t dImQ1n3k = (*fImQ)(0,3);\r
3844  //Double_t dImQ4n4k = (*fImQ)(3,4);\r
3845  \r
3846  // S^M_{p,k} (see .h file for the definition of fSMpk):\r
3847  Double_t dSM1p1k = (*fSMpk)(0,1);\r
3848  Double_t dSM1p2k = (*fSMpk)(0,2);\r
3849  Double_t dSM1p3k = (*fSMpk)(0,3);\r
3850  Double_t dSM2p1k = (*fSMpk)(1,1);\r
3851  Double_t dSM3p1k = (*fSMpk)(2,1);\r
3852  \r
3853  // looping over all (pt,eta) bins and calculating weighted correlations needed for differential flow: \r
3854  for(Int_t p=1;p<=fnBinsPt;p++)\r
3855  {\r
3856   for(Int_t e=1;e<=fnBinsEta;e++)\r
3857   {\r
3858    // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):  \r
3859    Double_t p1n0kRe = 0.;\r
3860    Double_t p1n0kIm = 0.;\r
3861 \r
3862    // number of POIs in particular (pt,eta) bin):\r
3863    Double_t mp = 0.;\r
3864 \r
3865    // real and imaginary parts of q_{m*n,k}: \r
3866    // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)\r
3867    Double_t q1n2kRe = 0.;\r
3868    Double_t q1n2kIm = 0.;\r
3869    Double_t q2n1kRe = 0.;\r
3870    Double_t q2n1kIm = 0.;\r
3871 \r
3872    // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
3873    Double_t s1p1k = 0.; \r
3874    Double_t s1p2k = 0.; \r
3875    Double_t s1p3k = 0.; \r
3876    \r
3877    // M0111 from Eq. (118) in QC2c (to be improved (notation))\r
3878    Double_t dM0111 = 0.;\r
3879  \r
3880    if(type == "POI")\r
3881    {\r
3882     // p_{m*n,0}:\r
3883     p1n0kRe = fReEBE2D[1][0][0]->GetBinContent(fReEBE2D[1][0][0]->GetBin(p,e))\r
3884             * fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3885     p1n0kIm = fImEBE2D[1][0][0]->GetBinContent(fImEBE2D[1][0][0]->GetBin(p,e))\r
3886             * fImEBE2D[1][0][0]->GetBinEntries(fImEBE2D[1][0][0]->GetBin(p,e)); \r
3887             \r
3888     mp = fReEBE2D[1][0][0]->GetBinEntries(fReEBE2D[1][0][0]->GetBin(p,e));\r
3889     \r
3890     // q_{m*n,k}: \r
3891     q1n2kRe = fReEBE2D[2][0][2]->GetBinContent(fReEBE2D[2][0][2]->GetBin(p,e))\r
3892             * fReEBE2D[2][0][2]->GetBinEntries(fReEBE2D[2][0][2]->GetBin(p,e));\r
3893     q1n2kIm = fImEBE2D[2][0][2]->GetBinContent(fImEBE2D[2][0][2]->GetBin(p,e))\r
3894             * fImEBE2D[2][0][2]->GetBinEntries(fImEBE2D[2][0][2]->GetBin(p,e));\r
3895     q2n1kRe = fReEBE2D[2][1][1]->GetBinContent(fReEBE2D[2][1][1]->GetBin(p,e))\r
3896             * fReEBE2D[2][1][1]->GetBinEntries(fReEBE2D[2][1][1]->GetBin(p,e)); \r
3897     q2n1kIm = fImEBE2D[2][1][1]->GetBinContent(fImEBE2D[2][1][1]->GetBin(p,e))\r
3898             * fImEBE2D[2][1][1]->GetBinEntries(fImEBE2D[2][1][1]->GetBin(p,e));\r
3899        \r
3900     // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
3901     s1p1k = pow(fs2D[2][1]->GetBinContent(fs2D[2][1]->GetBin(p,e)),1.); \r
3902     s1p2k = pow(fs2D[2][2]->GetBinContent(fs2D[2][2]->GetBin(p,e)),1.); \r
3903     s1p3k = pow(fs2D[2][3]->GetBinContent(fs2D[2][3]->GetBin(p,e)),1.); \r
3904    \r
3905     // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
3906     dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
3907            - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
3908            + 2.*(s1p3k-s1p2k*dSM1p1k));\r
3909    }\r
3910    else if(type == "RP")\r
3911    {\r
3912     p1n0kRe = fReEBE2D[0][0][0]->GetBinContent(fReEBE2D[0][0][0]->GetBin(p,e))\r
3913             * fReEBE2D[0][0][0]->GetBinEntries(fReEBE2D[0][0][0]->GetBin(p,e));\r
3914     p1n0kIm = fImEBE2D[0][0][0]->GetBinContent(fImEBE2D[0][0][0]->GetBin(p,e))\r
3915             * fImEBE2D[0][0][0]->GetBinEntries(fImEBE2D[0][0][0]->GetBin(p,e));\r
3916             \r
3917     mp = fReEBE2D[0][0][0]->GetBinEntries(fReEBE2D[0][0][0]->GetBin(p,e));\r
3918     \r
3919     // q_{m*n,k}: \r
3920     q1n2kRe = fReEBE2D[0][0][2]->GetBinContent(fReEBE2D[0][0][2]->GetBin(p,e))\r
3921             * fReEBE2D[0][0][2]->GetBinEntries(fReEBE2D[0][0][2]->GetBin(p,e));\r
3922     q1n2kIm = fImEBE2D[0][0][2]->GetBinContent(fImEBE2D[0][0][2]->GetBin(p,e))\r
3923             * fImEBE2D[0][0][2]->GetBinEntries(fImEBE2D[0][0][2]->GetBin(p,e));\r
3924     q2n1kRe = fReEBE2D[0][1][1]->GetBinContent(fReEBE2D[0][1][1]->GetBin(p,e))\r
3925             * fReEBE2D[0][1][1]->GetBinEntries(fReEBE2D[0][1][1]->GetBin(p,e));\r
3926     q2n1kIm = fImEBE2D[0][1][1]->GetBinContent(fImEBE2D[0][1][1]->GetBin(p,e))\r
3927             * fImEBE2D[0][1][1]->GetBinEntries(fImEBE2D[0][1][1]->GetBin(p,e));\r
3928    \r
3929     // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
3930     s1p1k = pow(fs2D[0][1]->GetBinContent(fs2D[0][1]->GetBin(p,e)),1.); \r
3931     s1p2k = pow(fs2D[0][2]->GetBinContent(fs2D[0][2]->GetBin(p,e)),1.); \r
3932     s1p3k = pow(fs2D[0][3]->GetBinContent(fs2D[0][3]->GetBin(p,e)),1.); \r
3933    \r
3934     // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
3935     dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
3936            - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
3937            + 2.*(s1p3k-s1p2k*dSM1p1k));\r
3938     //...............................................................................................   \r
3939    }\r
3940    \r
3941    // 2'-particle correlation:\r
3942    Double_t two1n1nW0W1PtEta = 0.;\r
3943    if(mp*dSM1p1k-s1p1k)\r
3944    {\r
3945     two1n1nW0W1PtEta = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)\r
3946                  / (mp*dSM1p1k-s1p1k);\r
3947    \r
3948     // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3949     if(type == "POI")\r
3950     {\r
3951      //f2pPtEtaPOIW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,\r
3952      //                   mp*dSM1p1k-s1p1k);\r
3953      fCorrelationsPro[1][1][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,mp*dSM1p1k-s1p1k);\r
3954     }\r
3955     else if(type == "RP")\r
3956     {\r
3957      //f2pPtEtaRPW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,\r
3958      //                  mp*dSM1p1k-s1p1k); \r
3959      fCorrelationsPro[0][1][0][0]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,two1n1nW0W1PtEta,mp*dSM1p1k-s1p1k);  \r
3960     }\r
3961    } // end of if(mp*dMult-dmPrimePrimePtEta)\r
3962    \r
3963    // 4'-particle correlation:\r
3964    Double_t four1n1n1n1nW0W1W1W1PtEta = 0.;\r
3965    if(dM0111)\r
3966    {\r
3967     four1n1n1n1nW0W1W1W1PtEta = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
3968                       - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))\r
3969                       - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k\r
3970                       - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)\r
3971                       + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)\r
3972                       - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
3973                       - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k                                            \r
3974                       + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k)                                           \r
3975                       + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k)                         \r
3976                       + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k)                      \r
3977                       + 2.*s1p1k*dSM1p2k                                      \r
3978                       - 6.*s1p3k)        \r
3979                       / dM0111; // to be imropoved (notation of dM0111)\r
3980    \r
3981     // fill the 2D profile to get the average correlation for each (pt, eta) bin:\r
3982     if(type == "POI")\r
3983     {\r
3984      //f4pPtEtaPOIW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111);\r
3985      fCorrelationsPro[1][1][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111);\r
3986     }\r
3987     else if(type == "RP")\r
3988     {\r
3989      //f4pPtEtaRPW->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111); \r
3990      fCorrelationsPro[0][1][0][1]->Fill(fPtMin+(p-1)*fPtBinWidth,fEtaMin+(e-1)*fEtaBinWidth,four1n1n1n1nW0W1W1W1PtEta,dM0111); \r
3991     }\r
3992    } // end of if(dM0111)\r
3993   \r
3994   } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
3995  } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
3996  \r
3997   \r
3998     \r
3999       \r
4000 } // end of AliFlowAnalysisWithQCumulants::CalculateWeightedCorrelationsForDifferentialFlow2D(TString type)\r
4001 \r
4002 \r
4003 //================================================================================================================================\r
4004 \r
4005  */  \r
4006 \r
4007 /*\r
4008 void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsForDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights)\r
4009 {\r
4010  // 1.) Access average for 2D correlations from profiles and store them in 2D final results histograms;\r
4011  // 2.) Access spread for 2D correlations from profiles, calculate error and store it in 2D final results histograms;\r
4012  // 3.) Make projections along pt and eta axis and store results and errors in 1D final results histograms. \r
4013  \r
4014  Int_t typeFlag = -1;\r
4015  Int_t pWeightsFlag = -1;\r
4016  Int_t eWeightsFlag = -1;\r
4017 \r
4018  if(type == "RP")\r
4019  {\r
4020   typeFlag = 0;\r
4021  } else if(type == "POI")\r
4022    {\r
4023     typeFlag = 1;\r
4024    } else \r
4025      {\r
4026       cout<<"WARNING: type must be either RP or POI in AFAWQC::FCFDF() !!!!"<<endl;\r
4027       exit(0);\r
4028      }\r
4029      \r
4030  if(!useParticleWeights)\r
4031  {\r
4032   pWeightsFlag = 0;\r
4033  } else \r
4034    {\r
4035     pWeightsFlag = 1;   \r
4036    }   \r
4037    \r
4038  if(eventWeights == "exact")\r
4039  {\r
4040   eWeightsFlag = 0;\r
4041  }          \r
4042   \r
4043  // shortcuts:\r
4044  Int_t t = typeFlag;\r
4045  Int_t pW = pWeightsFlag;\r
4046  Int_t eW = eWeightsFlag;\r
4047  \r
4048  // from 2D histogram fNonEmptyBins2D make two 1D histograms fNonEmptyBins1D in pt and eta (to be improved (i.e. moved somewhere else))  \r
4049  // pt:\r
4050  for(Int_t p=1;p<fnBinsPt;p++)\r
4051  {\r
4052   Double_t contentPt = 0.;\r
4053   for(Int_t e=1;e<=fnBinsEta;e++)\r
4054   {\r
4055    contentPt += (fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e)));          \r
4056   }\r
4057   fNonEmptyBins1D[t][0]->SetBinContent(p,contentPt);\r
4058  }\r
4059  // eta:\r
4060  for(Int_t e=1;e<fnBinsEta;e++)\r
4061  {\r
4062   Double_t contentEta = 0.;\r
4063   for(Int_t p=1;p<=fnBinsPt;p++)\r
4064   {\r
4065    contentEta += (fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e)));          \r
4066   }\r
4067   fNonEmptyBins1D[t][1]->SetBinContent(e,contentEta);\r
4068  }\r
4069  \r
4070  // from 2D profile in (pt,eta) make two 1D profiles in (pt) and (eta):\r
4071  TProfile *profile[2][4]; // [0=pt,1=eta][correlation index] // to be improved (do not hardwire the correlation index)\r
4072  \r
4073  for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4074  {\r
4075   for(Int_t ci=0;ci<4;ci++) // correlation index\r
4076   {\r
4077    if(pe==0) profile[pe][ci] = this->MakePtProjection(fCorrelationsPro[t][pW][eW][ci]);\r
4078    if(pe==1) profile[pe][ci] = this->MakeEtaProjection(fCorrelationsPro[t][pW][eW][ci]);\r
4079   }\r
4080  }\r
4081   \r
4082  // transfer 2D profile into 2D histogram:\r
4083  // to be improved (see in documentation if there is a method to transfer values from 2D profile into 2D histogram)    \r
4084  for(Int_t ci=0;ci<4;ci++)\r
4085  {\r
4086   for(Int_t p=1;p<=fnBinsPt;p++)\r
4087   {\r
4088    for(Int_t e=1;e<=fnBinsEta;e++)\r
4089    {\r
4090     Double_t correlation = fCorrelationsPro[t][pW][eW][ci]->GetBinContent(fCorrelationsPro[t][pW][eW][ci]->GetBin(p,e)); \r
4091     Double_t spread = fCorrelationsPro[t][pW][eW][ci]->GetBinError(fCorrelationsPro[t][pW][eW][ci]->GetBin(p,e));\r
4092     Double_t nEvts = fNonEmptyBins2D[t]->GetBinContent(fNonEmptyBins2D[t]->GetBin(p,e));\r
4093     Double_t error = 0.;\r
4094     fFinalCorrelations2D[t][pW][eW][ci]->SetBinContent(fFinalCorrelations2D[t][pW][eW][ci]->GetBin(p,e),correlation);          \r
4095     if(nEvts>0)\r
4096     {\r
4097      error = spread/pow(nEvts,0.5);\r
4098      fFinalCorrelations2D[t][pW][eW][ci]->SetBinError(fFinalCorrelations2D[t][pW][eW][ci]->GetBin(p,e),error);\r
4099     }\r
4100    } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4101   } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4102  } // end of for(Int_t ci=0;ci<4;ci++)\r
4103  \r
4104  // transfer 1D profile into 1D histogram (pt):\r
4105  // to be improved (see in documentation if there is a method to transfer values from 1D profile into 1D histogram)    \r
4106  for(Int_t ci=0;ci<4;ci++)\r
4107  {\r
4108   for(Int_t p=1;p<=fnBinsPt;p++)\r
4109   {\r
4110    if(profile[0][ci])\r
4111    {\r
4112     Double_t correlation = profile[0][ci]->GetBinContent(p); \r
4113     Double_t spread = profile[0][ci]->GetBinError(p);\r
4114     Double_t nEvts = fNonEmptyBins1D[t][0]->GetBinContent(p);\r
4115     Double_t error = 0.;\r
4116     fFinalCorrelations1D[t][pW][eW][0][ci]->SetBinContent(p,correlation); \r
4117     if(nEvts>0)\r
4118     {\r
4119      error = spread/pow(nEvts,0.5);\r
4120      fFinalCorrelations1D[t][pW][eW][0][ci]->SetBinError(p,error);\r
4121     }  \r
4122    }   \r
4123   } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4124  } // end of for(Int_t ci=0;ci<4;ci++)\r
4125  \r
4126  // transfer 1D profile into 1D histogram (eta):\r
4127  // to be improved (see in documentation if there is a method to transfer values from 1D profile into 1D histogram)    \r
4128  for(Int_t ci=0;ci<4;ci++)\r
4129  {\r
4130   for(Int_t e=1;e<=fnBinsEta;e++)\r
4131   {\r
4132    if(profile[1][ci])\r
4133    {\r
4134     Double_t correlation = profile[1][ci]->GetBinContent(e); \r
4135     fFinalCorrelations1D[t][pW][eW][1][ci]->SetBinContent(e,correlation);      \r
4136    }    \r
4137   } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4138  } // end of for(Int_t ci=0;ci<4;ci++)\r
4139         \r
4140 } // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrelationsForDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights)\r
4141 */\r
4142 \r
4143 \r
4144 //================================================================================================================================\r
4145 \r
4146 \r
4147 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, TString ptOrEta)\r
4148 {\r
4149  // calcualate cumulants for differential flow from measured correlations\r
4150  // Remark: cumulants calculated here are NOT corrected for non-uniform acceptance. This correction is applied in the method ...\r
4151  // to be improved (description) \r
4152  \r
4153  Int_t typeFlag = -1;\r
4154  Int_t ptEtaFlag = -1;\r
4155 \r
4156  if(type == "RP")\r
4157  {\r
4158   typeFlag = 0;\r
4159  } else if(type == "POI")\r
4160    {\r
4161     typeFlag = 1;\r
4162    } \r
4163      \r
4164  if(ptOrEta == "Pt")\r
4165  {\r
4166   ptEtaFlag = 0;\r
4167  } else if(ptOrEta == "Eta")\r
4168    {\r
4169     ptEtaFlag = 1;\r
4170    } \r
4171   \r
4172  // shortcuts:\r
4173  Int_t t = typeFlag;\r
4174  Int_t pe = ptEtaFlag;\r
4175      \r
4176  // common:\r
4177  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
4178  \r
4179  // correlation <<2>>: \r
4180  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1);\r
4181  \r
4182  // 1D:\r
4183  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4184  {\r
4185   // reduced correlations:   \r
4186   Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>(pt)\r
4187   Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>(pt)\r
4188   // final statistical error of reduced correlations:\r
4189   //Double_t twoPrimeError = fFinalCorrelations1D[t][pW][eW][0][0]->GetBinError(p); \r
4190   // QC{2'}:\r
4191   Double_t qc2Prime = twoPrime; // QC{2'}\r
4192   //Double_t qc2PrimeError = twoPrimeError; // final stat. error of QC{2'}\r
4193   fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime); \r
4194   //fFinalCumulantsPt[t][pW][eW][nua][0]->SetBinError(p,qc2PrimeError);   \r
4195   // QC{4'}:\r
4196   Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>\r
4197   fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime); \r
4198  } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4199  \r
4200     \r
4201  /* \r
4202  // 2D (pt,eta):\r
4203  // to be improved (see documentation if I can do all this without looping)\r
4204  for(Int_t p=1;p<=fnBinsPt;p++)\r
4205  {\r
4206   for(Int_t e=1;e<=fnBinsEta;e++) \r
4207   {  \r
4208    // reduced correlations:   \r
4209    Double_t twoPrime = fFinalCorrelations2D[t][pW][eW][0]->GetBinContent(fFinalCorrelations2D[t][pW][eW][0]->GetBin(p,e)); // <<2'>>(pt,eta)\r
4210    Double_t fourPrime = fFinalCorrelations2D[t][pW][eW][1]->GetBinContent(fFinalCorrelations2D[t][pW][eW][1]->GetBin(p,e)); // <<4'>>(pt,eta)\r
4211    for(Int_t nua=0;nua<2;nua++)\r
4212    {\r
4213     // QC{2'}:\r
4214     Double_t qc2Prime = twoPrime; // QC{2'} = <<2'>>\r
4215     fFinalCumulants2D[t][pW][eW][nua][0]->SetBinContent(fFinalCumulants2D[t][pW][eW][nua][0]->GetBin(p,e),qc2Prime);    \r
4216     // QC{4'}:\r
4217     Double_t qc4Prime = fourPrime - 2.*twoPrime*two; // QC{4'} = <<4'>> - 2*<<2'>><<2>>\r
4218     fFinalCumulants2D[t][pW][eW][nua][1]->SetBinContent(fFinalCumulants2D[t][pW][eW][nua][1]->GetBin(p,e),qc4Prime);   \r
4219    } // end of for(Int_t nua=0;nua<2;nua++)   \r
4220   } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
4221  } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
4222  */\r
4223    \r
4224 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulants(TString type, Bool_t useParticleWeights, TString eventWeights); \r
4225 \r
4226 \r
4227 //================================================================================================================================\r
4228 \r
4229 \r
4230 void AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)\r
4231 {\r
4232  // calculate final results for integrated flow of RPs and POIs \r
4233   \r
4234  Int_t typeFlag = -1;\r
4235 \r
4236  if(type == "RP")\r
4237  {\r
4238   typeFlag = 0;\r
4239  } else if(type == "POI")\r
4240    {\r
4241     typeFlag = 1;\r
4242    } else \r
4243      {\r
4244       cout<<"WARNING: type must be either RP or POI in AFAWQC::CDF() !!!!"<<endl;\r
4245       exit(0);\r
4246      }\r
4247      \r
4248  // shortcuts:\r
4249  Int_t t = typeFlag;\r
4250   \r
4251  // pt yield:    \r
4252  TH1F *yield2ndPt = NULL;\r
4253  TH1F *yield4thPt = NULL;\r
4254  TH1F *yield6thPt = NULL;\r
4255  TH1F *yield8thPt = NULL;\r
4256  \r
4257  if(type == "POI")\r
4258  {\r
4259   yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtPOI())->Clone();\r
4260   yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtPOI())->Clone();\r
4261   yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtPOI())->Clone();\r
4262   yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtPOI())->Clone();  \r
4263  } \r
4264  else if(type == "RP")\r
4265  {\r
4266   yield2ndPt = (TH1F*)(fCommonHists2nd->GetHistPtRP())->Clone();\r
4267   yield4thPt = (TH1F*)(fCommonHists4th->GetHistPtRP())->Clone();\r
4268   yield6thPt = (TH1F*)(fCommonHists6th->GetHistPtRP())->Clone();\r
4269   yield8thPt = (TH1F*)(fCommonHists8th->GetHistPtRP())->Clone();  \r
4270  } \r
4271  \r
4272  Int_t nBinsPt = yield2ndPt->GetNbinsX();\r
4273  \r
4274  TH1D *flow2ndPt = NULL;\r
4275  TH1D *flow4thPt = NULL;\r
4276  TH1D *flow6thPt = NULL;\r
4277  TH1D *flow8thPt = NULL;\r
4278  \r
4279  // to be improved (hardwired pt index)\r
4280  flow2ndPt = (TH1D*)fDiffFlow[t][0][0]->Clone();\r
4281  flow4thPt = (TH1D*)fDiffFlow[t][0][1]->Clone();\r
4282  flow6thPt = (TH1D*)fDiffFlow[t][0][2]->Clone();\r
4283  flow8thPt = (TH1D*)fDiffFlow[t][0][3]->Clone(); \r
4284    \r
4285  Double_t dvn2nd = 0., dvn4th = 0., dvn6th = 0., dvn8th = 0.; // differential flow\r
4286  Double_t dErrvn2nd = 0., dErrvn4th = 0., dErrvn6th = 0., dErrvn8th = 0.; // error on differential flow\r
4287  \r
4288  Double_t dVn2nd = 0., dVn4th = 0., dVn6th = 0., dVn8th = 0.; // integrated flow \r
4289  Double_t dErrVn2nd = 0., dErrVn4th = 0., dErrVn6th = 0., dErrVn8th = 0.; // error on integrated flow\r
4290 \r
4291  Double_t dYield2nd = 0., dYield4th = 0., dYield6th = 0., dYield8th = 0.; // pt yield \r
4292  Double_t dSum2nd = 0., dSum4th = 0., dSum6th = 0., dSum8th = 0.; // needed for normalizing integrated flow\r
4293  \r
4294  // looping over pt bins:\r
4295  for(Int_t p=1;p<nBinsPt+1;p++)\r
4296  {\r
4297   dvn2nd = flow2ndPt->GetBinContent(p);\r
4298   dvn4th = flow4thPt->GetBinContent(p);\r
4299   dvn6th = flow6thPt->GetBinContent(p);\r
4300   dvn8th = flow8thPt->GetBinContent(p);\r
4301   \r
4302   dErrvn2nd = flow2ndPt->GetBinError(p);\r
4303   dErrvn4th = flow4thPt->GetBinError(p);\r
4304   dErrvn6th = flow6thPt->GetBinError(p);\r
4305   dErrvn8th = flow8thPt->GetBinError(p);\r
4306 \r
4307   dYield2nd = yield2ndPt->GetBinContent(p);  \r
4308   dYield4th = yield4thPt->GetBinContent(p);\r
4309   dYield6th = yield6thPt->GetBinContent(p);\r
4310   dYield8th = yield8thPt->GetBinContent(p);\r
4311   \r
4312   dVn2nd += dvn2nd*dYield2nd;\r
4313   dVn4th += dvn4th*dYield4th;\r
4314   dVn6th += dvn6th*dYield6th;\r
4315   dVn8th += dvn8th*dYield8th;\r
4316   \r
4317   dSum2nd += dYield2nd;\r
4318   dSum4th += dYield4th;\r
4319   dSum6th += dYield6th;\r
4320   dSum8th += dYield8th;\r
4321   \r
4322   dErrVn2nd += dYield2nd*dYield2nd*dErrvn2nd*dErrvn2nd; // ro be improved (check this relation)\r
4323   dErrVn4th += dYield4th*dYield4th*dErrvn4th*dErrvn4th;\r
4324   dErrVn6th += dYield6th*dYield6th*dErrvn6th*dErrvn6th;\r
4325   dErrVn8th += dYield8th*dYield8th*dErrvn8th*dErrvn8th;\r
4326     \r
4327  } // end of for(Int_t p=1;p<nBinsPt+1;p++)\r
4328 \r
4329  // normalizing the results for integrated flow:\r
4330  if(dSum2nd) \r
4331  {\r
4332   dVn2nd /= dSum2nd;\r
4333   dErrVn2nd /= (dSum2nd*dSum2nd);\r
4334   dErrVn2nd = TMath::Sqrt(dErrVn2nd);\r
4335  } \r
4336  if(dSum4th) \r
4337  {\r
4338   dVn4th /= dSum4th;\r
4339   dErrVn4th /= (dSum4th*dSum4th);\r
4340   dErrVn4th = TMath::Sqrt(dErrVn4th);\r
4341  } \r
4342  //if(dSum6th) dVn6th/=dSum6th;\r
4343  //if(dSum8th) dVn8th/=dSum8th;\r
4344   \r
4345  // storing the results for integrated flow in common histos: (to be improved: new method for this?)\r
4346  if(type == "POI")\r
4347  {\r
4348   fCommonHistsResults2nd->FillIntegratedFlowPOI(dVn2nd,dErrVn2nd); \r
4349   fCommonHistsResults4th->FillIntegratedFlowPOI(dVn4th,dErrVn4th); \r
4350   fCommonHistsResults6th->FillIntegratedFlowPOI(dVn6th,0.); // to be improved (errors)\r
4351   fCommonHistsResults8th->FillIntegratedFlowPOI(dVn8th,0.); // to be improved (errors)\r
4352  }\r
4353  else if (type == "RP")\r
4354  {\r
4355   fCommonHistsResults2nd->FillIntegratedFlowRP(dVn2nd,dErrVn2nd); \r
4356   fCommonHistsResults4th->FillIntegratedFlowRP(dVn4th,dErrVn4th);\r
4357   fCommonHistsResults6th->FillIntegratedFlowRP(dVn6th,0.); // to be improved (errors)\r
4358   fCommonHistsResults8th->FillIntegratedFlowRP(dVn8th,0.); // to be improved (errors)\r
4359  }\r
4360  \r
4361  delete flow2ndPt;\r
4362  delete flow4thPt;\r
4363  //delete flow6thPt;\r
4364  //delete flow8thPt;\r
4365  \r
4366  delete yield2ndPt;\r
4367  delete yield4thPt;\r
4368  delete yield6thPt;\r
4369  delete yield8thPt;\r
4370            \r
4371 } // end of AliFlowAnalysisWithQCumulants::CalculateFinalResultsForRPandPOIIntegratedFlow(TString type)\r
4372 \r
4373 \r
4374 //================================================================================================================================\r
4375 \r
4376 \r
4377 void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()\r
4378 {\r
4379  // Initialize all arrays used for distributions.
4380
4381  // a) Initialize arrays of histograms used to hold distributions of correlations;
4382  // b) Initialize array to hold min and max values of correlations.
4383
4384  // a) Initialize arrays of histograms used to hold distributions of correlations:
4385  for(Int_t di=0;di<4;di++) // distribution index\r
4386  {\r
4387   fDistributions[di] = NULL;\r
4388  }\r
4389
4390  // b) Initialize default min and max values of correlations:
4391  //    (Remark: The default values bellow were chosen for v2=5% and M=500)
4392  fMinValueOfCorrelation[0] = -0.01; // <2>_min
4393  fMaxValueOfCorrelation[0] = 0.04; // <2>_max
4394  fMinValueOfCorrelation[1] = -0.00002; // <4>_min
4395  fMaxValueOfCorrelation[1] = 0.00015; // <4>_max
4396  fMinValueOfCorrelation[2] = -0.0000003; // <6>_min
4397  fMaxValueOfCorrelation[2] = 0.0000006; // <6>_max
4398  fMinValueOfCorrelation[3] = -0.000000006; // <8>_min
4399  fMaxValueOfCorrelation[3] = 0.000000003; // <8>_max
4400  \r
4401 } // end of void AliFlowAnalysisWithQCumulants::InitializeArraysForDistributions()\r
4402 \r
4403
4404 //================================================================================================================================\r
4405 \r
4406 \r
4407 void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()\r
4408 {\r
4409  // a) Book profile to hold all flags for distributions of correlations;
4410  // b) Book all histograms to hold distributions of correlations.
4411
4412  TString correlationIndex[4] = {"<2>","<4>","<6>","<8>"}; // to be improved (should I promote this to data members?)
4413
4414  // a) Book profile to hold all flags for distributions of correlations:
4415  TString distributionsFlagsName = "fDistributionsFlags";\r
4416  distributionsFlagsName += fAnalysisLabel->Data();\r
4417  fDistributionsFlags = new TProfile(distributionsFlagsName.Data(),"Flags for Distributions of Correlations",9,0,9);\r
4418  fDistributionsFlags->SetTickLength(-0.01,"Y");\r
4419  fDistributionsFlags->SetMarkerStyle(25);\r
4420  fDistributionsFlags->SetLabelSize(0.05);\r
4421  fDistributionsFlags->SetLabelOffset(0.02,"Y");\r
4422  (fDistributionsFlags->GetXaxis())->SetBinLabel(1,"Store or not?");\r
4423  (fDistributionsFlags->GetXaxis())->SetBinLabel(2,"<2>_{min}");\r
4424  (fDistributionsFlags->GetXaxis())->SetBinLabel(3,"<2>_{max}");\r
4425  (fDistributionsFlags->GetXaxis())->SetBinLabel(4,"<4>_{min}");\r
4426  (fDistributionsFlags->GetXaxis())->SetBinLabel(5,"<4>_{max}");\r
4427  (fDistributionsFlags->GetXaxis())->SetBinLabel(6,"<6>_{min}");\r
4428  (fDistributionsFlags->GetXaxis())->SetBinLabel(7,"<6>_{max}");\r
4429  (fDistributionsFlags->GetXaxis())->SetBinLabel(8,"<8>_{min}");\r
4430  (fDistributionsFlags->GetXaxis())->SetBinLabel(9,"<8>_{max}");\r
4431  fDistributionsList->Add(fDistributionsFlags);\r
4432
4433  // b) Book all histograms to hold distributions of correlations.
4434  if(fStoreDistributions)
4435  {
4436   TString distributionsName = "fDistributions";\r
4437   distributionsName += fAnalysisLabel->Data();\r
4438   for(Int_t di=0;di<4;di++) // distribution index\r
4439   {
4440    fDistributions[di] = new TH1D(Form("Distribution of %s",correlationIndex[di].Data()),Form("Distribution of %s",correlationIndex[di].Data()),10000,fMinValueOfCorrelation[di],fMaxValueOfCorrelation[di]); \r
4441    fDistributions[di]->SetXTitle(correlationIndex[di].Data());\r
4442    fDistributionsList->Add(fDistributions[di]);\r
4443   } // end of for(Int_t di=0;di<4;di++) // distribution index
4444  } // end of if(fStoreDistributions)
4445
4446 } // end of void AliFlowAnalysisWithQCumulants::BookEverythingForDistributions()\r
4447 \r
4448 \r
4449 //================================================================================================================================\r
4450 \r
4451
4452 void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()\r
4453 {\r
4454  // Store all flags for distributiuons of correlations in profile fDistributionsFlags.\r
4455  \r
4456  if(!fDistributionsFlags)\r
4457  {\r
4458   cout<<"WARNING: fDistributionsFlags is NULL in AFAWQC::SDF() !!!!"<<endl;\r
4459   exit(0);\r
4460  } \r
4461 \r
4462  fDistributionsFlags->Fill(0.5,(Int_t)fStoreDistributions); // histos with distributions of correlations stored or not in the output file
4463  // store min and max values of correlations:
4464  for(Int_t di=0;di<4;di++) // distribution index\r
4465  {\r
4466   fDistributionsFlags->Fill(1.5+2.*(Double_t)di,fMinValueOfCorrelation[di]);
4467   fDistributionsFlags->Fill(2.5+2.*(Double_t)di,fMaxValueOfCorrelation[di]);
4468  }\r
4469      \r
4470 } // end of void AliFlowAnalysisWithQCumulants::StoreFlagsForDistributions()\r
4471 \r
4472
4473 //================================================================================================================================\r
4474
4475
4476 void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
4477 {
4478  // Store distributions of correlations.
4479
4480  if(!(fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE))\r
4481  {\r
4482   cout<<"WARNING: fIntFlowCorrelationsEBE && fIntFlowEventWeightsForCorrelationsEBE"<<endl; \r
4483   cout<<"         is NULL in AFAWQC::SDOC() !!!!"<<endl;\r
4484   exit(0);\r
4485  }\r
4486
4487  for(Int_t di=0;di<4;di++) // distribution index\r
4488  {
4489   if(!fDistributions[di])\r
4490   { \r
4491    cout<<"WARNING: fDistributions[di] is NULL in AFAWQC::SDOC() !!!!"<<endl;\r
4492    cout<<"di = "<<di<<endl;\r
4493    exit(0);\r
4494   } else
4495     {
4496      fDistributions[di]->Fill(fIntFlowCorrelationsEBE->GetBinContent(di+1),fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(di+1));
4497     } \r
4498  } // end of for(Int_t di=0;di<4;di++) // distribution index\r
4499
4500 } // end of void AliFlowAnalysisWithQCumulants::StoreDistributionsOfCorrelations()
4501
4502
4503 //================================================================================================================================\r
4504 \r
4505 \r
4506 void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()\r
4507 {\r
4508  // Book and nest all lists nested in the base list fHistList.\r
4509  //  a) Book and nest lists for integrated flow;\r
4510  //  b) Book and nest lists for differential flow;\r
4511  //  c) Book and nest list for particle weights;\r
4512  //  d) Book and nest list for distributions;\r
4513  //  e) Book and nest list for nested loops;\r
4514  \r
4515  // a) Book and nest all lists for integrated flow:\r
4516  // base list for integrated flow:\r
4517  fIntFlowList = new TList();\r
4518  fIntFlowList->SetName("Integrated Flow");\r
4519  fIntFlowList->SetOwner(kTRUE);\r
4520  fHistList->Add(fIntFlowList);\r
4521  // list holding profiles: \r
4522  fIntFlowProfiles = new TList();\r
4523  fIntFlowProfiles->SetName("Profiles");\r
4524  fIntFlowProfiles->SetOwner(kTRUE);\r
4525  fIntFlowList->Add(fIntFlowProfiles);\r
4526  // list holding histograms with results:\r
4527  fIntFlowResults = new TList();\r
4528  fIntFlowResults->SetName("Results");\r
4529  fIntFlowResults->SetOwner(kTRUE);\r
4530  fIntFlowList->Add(fIntFlowResults);\r
4531  \r
4532  // b) Book and nest lists for differential flow;\r
4533  fDiffFlowList = new TList();\r
4534  fDiffFlowList->SetName("Differential Flow");\r
4535  fDiffFlowList->SetOwner(kTRUE); \r
4536  fHistList->Add(fDiffFlowList);\r
4537  // list holding profiles: \r
4538  fDiffFlowProfiles = new TList(); \r
4539  fDiffFlowProfiles->SetName("Profiles");\r
4540  fDiffFlowProfiles->SetOwner(kTRUE);\r
4541  fDiffFlowList->Add(fDiffFlowProfiles);\r
4542  // list holding histograms with results: \r
4543  fDiffFlowResults = new TList();\r
4544  fDiffFlowResults->SetName("Results");\r
4545  fDiffFlowResults->SetOwner(kTRUE);\r
4546  fDiffFlowList->Add(fDiffFlowResults);\r
4547  // flags used for naming nested lists in list fDiffFlowProfiles and fDiffFlowResults:  \r
4548  TList list;\r
4549  list.SetOwner(kTRUE);\r
4550  TString typeFlag[2] = {"RP","POI"};  \r
4551  TString ptEtaFlag[2] = {"p_{T}","#eta"}; \r
4552  TString powerFlag[2] = {"linear","quadratic"};   \r
4553  // nested lists in fDiffFlowProfiles (~/Differential Flow/Profiles):\r
4554  for(Int_t t=0;t<2;t++) // type: RP or POI\r
4555  {\r
4556   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4557   {\r
4558    // list holding profiles with correlations:\r
4559    fDiffFlowCorrelationsProList[t][pe] = (TList*)list.Clone();\r
4560    fDiffFlowCorrelationsProList[t][pe]->SetName(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4561    fDiffFlowProfiles->Add(fDiffFlowCorrelationsProList[t][pe]);\r
4562    // list holding profiles with products of correlations:\r
4563    fDiffFlowProductOfCorrelationsProList[t][pe] = (TList*)list.Clone();\r
4564    fDiffFlowProductOfCorrelationsProList[t][pe]->SetName(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4565    fDiffFlowProfiles->Add(fDiffFlowProductOfCorrelationsProList[t][pe]);\r
4566    // list holding profiles with corrections:\r
4567    fDiffFlowCorrectionsProList[t][pe] = (TList*)list.Clone();\r
4568    fDiffFlowCorrectionsProList[t][pe]->SetName(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4569    fDiffFlowProfiles->Add(fDiffFlowCorrectionsProList[t][pe]);   \r
4570   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
4571  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI   \r
4572  // nested lists in fDiffFlowResults (~/Differential Flow/Results):\r
4573  for(Int_t t=0;t<2;t++) // type: RP or POI\r
4574  {\r
4575   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4576   {\r
4577    // list holding histograms with correlations:\r
4578    fDiffFlowCorrelationsHistList[t][pe] = (TList*)list.Clone();\r
4579    fDiffFlowCorrelationsHistList[t][pe]->SetName(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4580    fDiffFlowResults->Add(fDiffFlowCorrelationsHistList[t][pe]);\r
4581    // list holding histograms with corrections:\r
4582    fDiffFlowCorrectionsHistList[t][pe] = (TList*)list.Clone();\r
4583    fDiffFlowCorrectionsHistList[t][pe]->SetName(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4584    fDiffFlowResults->Add(fDiffFlowCorrectionsHistList[t][pe]);   \r
4585    for(Int_t power=0;power<2;power++)\r
4586    {\r
4587     // list holding histograms with sums of event weights:\r
4588     fDiffFlowSumOfEventWeightsHistList[t][pe][power] = (TList*)list.Clone();\r
4589     fDiffFlowSumOfEventWeightsHistList[t][pe][power]->SetName(Form("Sum of %s event weights (%s, %s)",powerFlag[power].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4590     fDiffFlowResults->Add(fDiffFlowSumOfEventWeightsHistList[t][pe][power]);    \r
4591    } // end of for(Int_t power=0;power<2;power++)\r
4592    // list holding histograms with sums of products of event weights:\r
4593    fDiffFlowSumOfProductOfEventWeightsHistList[t][pe] = (TList*)list.Clone();\r
4594    fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->SetName(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4595    fDiffFlowResults->Add(fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]);\r
4596    // list holding histograms with covariances of correlations:\r
4597    fDiffFlowCovariancesHistList[t][pe] = (TList*)list.Clone();\r
4598    fDiffFlowCovariancesHistList[t][pe]->SetName(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4599    fDiffFlowResults->Add(fDiffFlowCovariancesHistList[t][pe]);\r
4600    // list holding histograms with differential Q-cumulants:\r
4601    fDiffFlowCumulantsHistList[t][pe] = (TList*)list.Clone();\r
4602    fDiffFlowCumulantsHistList[t][pe]->SetName(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4603    fDiffFlowResults->Add(fDiffFlowCumulantsHistList[t][pe]);   \r
4604    // list holding histograms with differential flow estimates from Q-cumulants:\r
4605    fDiffFlowHistList[t][pe] = (TList*)list.Clone();\r
4606    fDiffFlowHistList[t][pe]->SetName(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()));\r
4607    fDiffFlowResults->Add(fDiffFlowHistList[t][pe]);      \r
4608   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
4609  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
4610   \r
4611  // c) Book and nest list for particle weights:\r
4612  fWeightsList->SetName("Weights");\r
4613  fWeightsList->SetOwner(kTRUE);   \r
4614  fHistList->Add(fWeightsList); \r
4615 \r
4616  // d) Book and nest list for distributions:\r
4617  fDistributionsList = new TList();\r
4618  fDistributionsList->SetName("Distributions");\r
4619  fDistributionsList->SetOwner(kTRUE);\r
4620  fHistList->Add(fDistributionsList);\r
4621  \r
4622  // e) Book and nest list for nested loops:\r
4623  fNestedLoopsList = new TList();\r
4624  fNestedLoopsList->SetName("Nested Loops");\r
4625  fNestedLoopsList->SetOwner(kTRUE);\r
4626  fHistList->Add(fNestedLoopsList);\r
4627  \r
4628 } // end of void AliFlowAnalysisWithQCumulants::BookAndNestAllLists()\r
4629 \r
4630 \r
4631 //================================================================================================================================\r
4632 \r
4633 \r
4634 void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type)\r
4635 {\r
4636  // fill common result histograms for differential flow\r
4637  \r
4638  Int_t typeFlag = -1;\r
4639  //Int_t ptEtaFlag = -1;\r
4640 \r
4641  if(type == "RP")\r
4642  {\r
4643   typeFlag = 0;\r
4644  } else if(type == "POI")\r
4645    {\r
4646     typeFlag = 1;\r
4647    } \r
4648   \r
4649  // shortcuts:\r
4650  Int_t t = typeFlag;\r
4651  //Int_t pe = ptEtaFlag;\r
4652 \r
4653  // to be improved (implement protection here)\r
4654      \r
4655  if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))\r
4656  {\r
4657   cout<<"WARNING: fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th"<<endl; \r
4658   cout<<"         is NULL in AFAWQC::FCHRIF() !!!!"<<endl;\r
4659   exit(0);\r
4660  }\r
4661  \r
4662  // pt:\r
4663  for(Int_t p=1;p<=fnBinsPt;p++)\r
4664  {\r
4665   Double_t v2 = fDiffFlow[t][0][0]->GetBinContent(p);\r
4666   Double_t v4 = fDiffFlow[t][0][1]->GetBinContent(p);\r
4667   Double_t v6 = fDiffFlow[t][0][2]->GetBinContent(p);\r
4668   Double_t v8 = fDiffFlow[t][0][3]->GetBinContent(p);\r
4669   \r
4670   Double_t v2Error = fDiffFlow[t][0][0]->GetBinError(p);\r
4671   Double_t v4Error = fDiffFlow[t][0][1]->GetBinError(p);\r
4672   //Double_t v6Error = fFinalFlow1D[t][pW][nua][0][2]->GetBinError(p);\r
4673   //Double_t v8Error = fFinalFlow1D[t][pW][nua][0][3]->GetBinError(p);\r
4674  \r
4675   if(type == "RP")\r
4676   {\r
4677    fCommonHistsResults2nd->FillDifferentialFlowPtRP(p,v2,v2Error);\r
4678    fCommonHistsResults4th->FillDifferentialFlowPtRP(p,v4,v4Error);\r
4679    fCommonHistsResults6th->FillDifferentialFlowPtRP(p,v6,0.);\r
4680    fCommonHistsResults8th->FillDifferentialFlowPtRP(p,v8,0.);\r
4681   } else if(type == "POI")\r
4682     {\r
4683      fCommonHistsResults2nd->FillDifferentialFlowPtPOI(p,v2,v2Error);\r
4684      fCommonHistsResults4th->FillDifferentialFlowPtPOI(p,v4,v4Error);\r
4685      fCommonHistsResults6th->FillDifferentialFlowPtPOI(p,v6,0.);\r
4686      fCommonHistsResults8th->FillDifferentialFlowPtPOI(p,v8,0.);\r
4687     }\r
4688  } // end of for(Int_t p=1;p<=fnBinsPt;p++)   \r
4689  \r
4690  // eta:\r
4691  for(Int_t e=1;e<=fnBinsEta;e++)\r
4692  {\r
4693   Double_t v2 = fDiffFlow[t][1][0]->GetBinContent(e);\r
4694   Double_t v4 = fDiffFlow[t][1][1]->GetBinContent(e);\r
4695   Double_t v6 = fDiffFlow[t][1][2]->GetBinContent(e);\r
4696   Double_t v8 = fDiffFlow[t][1][3]->GetBinContent(e);\r
4697   \r
4698   Double_t v2Error = fDiffFlow[t][1][0]->GetBinError(e);\r
4699   Double_t v4Error = fDiffFlow[t][1][1]->GetBinError(e);\r
4700   //Double_t v6Error = fDiffFlow[t][1][2]->GetBinError(e);\r
4701   //Double_t v8Error = fDiffFlow[t][1][3]->GetBinError(e);\r
4702  \r
4703   if(type == "RP")\r
4704   {\r
4705    fCommonHistsResults2nd->FillDifferentialFlowEtaRP(e,v2,v2Error);\r
4706    fCommonHistsResults4th->FillDifferentialFlowEtaRP(e,v4,v4Error);\r
4707    fCommonHistsResults6th->FillDifferentialFlowEtaRP(e,v6,0.);\r
4708    fCommonHistsResults8th->FillDifferentialFlowEtaRP(e,v8,0.);\r
4709   } else if(type == "POI")\r
4710     {\r
4711      fCommonHistsResults2nd->FillDifferentialFlowEtaPOI(e,v2,v2Error);\r
4712      fCommonHistsResults4th->FillDifferentialFlowEtaPOI(e,v4,v4Error);\r
4713      fCommonHistsResults6th->FillDifferentialFlowEtaPOI(e,v6,0.);\r
4714      fCommonHistsResults8th->FillDifferentialFlowEtaPOI(e,v8,0.);\r
4715     }\r
4716  } // end of for(Int_t e=1;e<=fnBinsEta;e++)    \r
4717  \r
4718 } // end of void AliFlowAnalysisWithQCumulants::FillCommonHistResultsDiffFlow(TString type, Bool_t useParticleWeights, TString eventWeights, Bool_t correctedForNUA)\r
4719 \r
4720 \r
4721 //================================================================================================================================\r
4722 \r
4723 \r
4724 void AliFlowAnalysisWithQCumulants::AccessConstants()\r
4725 {\r
4726  // access needed common constants from AliFlowCommonConstants\r
4727  \r
4728  fnBinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();\r
4729  fPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin();         \r
4730  fPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();\r
4731  if(fnBinsPhi) fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;  \r
4732  fnBinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();\r
4733  fPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin();           \r
4734  fPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();\r
4735  if(fnBinsPt) fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;  \r
4736  fnBinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();\r
4737  fEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin();         \r
4738  fEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();\r
4739  if(fnBinsEta) fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;  \r
4740  \r
4741 } // end of void AliFlowAnalysisWithQCumulants::AccessConstants()\r
4742 \r
4743 \r
4744 //================================================================================================================================\r
4745 \r
4746 \r
4747 void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()\r
4748 {\r
4749  // Calculate sum of linear and quadratic event weights for correlations\r
4750  \r
4751  \r
4752  /*\r
4753  Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
4754 \r
4755  Double_t eventWeight[4] = {0}; \r
4756  \r
4757  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
4758  {\r
4759   eventWeight[0] = dMult*(dMult-1); // event weight for <2> \r
4760   eventWeight[1] = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
4761   eventWeight[2] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
4762   eventWeight[3] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
4763  } else\r
4764    {\r
4765     eventWeight[0] = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
4766     eventWeight[1] = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1)  \r
4767                    + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
4768                    + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
4769     //eventWeight[2] = ... // to be improved (calculated)               \r
4770     //eventWeight[3] = ... // to be improved (calculated)              \r
4771    }\r
4772  */\r
4773         \r
4774                       \r
4775  for(Int_t p=0;p<2;p++) // power-1\r
4776  {\r
4777   for(Int_t ci=0;ci<4;ci++) // correlation index\r
4778   { \r
4779    fIntFlowSumOfEventWeights[p]->Fill(ci+0.5,pow(fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci+1),p+1)); \r
4780   }\r
4781  }\r
4782   \r
4783 } // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfEventWeights()\r
4784 \r
4785 \r
4786 //================================================================================================================================\r
4787 \r
4788 \r
4789 void AliFlowAnalysisWithQCumulants::CalculateIntFlowSumOfProductOfEventWeights()\r
4790 {\r
4791  // Calculate sum of product of event weights for correlations\r
4792  \r
4793  \r
4794  /*\r
4795  Double_t dMult = (*fSMpk)(0,0); // multiplicity \r
4796 \r
4797  Double_t eventWeight[4] = {0}; \r
4798  \r
4799  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
4800  {\r
4801   eventWeight[0] = dMult*(dMult-1); // event weight for <2> \r
4802   eventWeight[1] = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
4803   eventWeight[2] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
4804   eventWeight[3] = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
4805  } else\r
4806    {\r
4807     eventWeight[0] = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j;\r
4808     eventWeight[1] = (*fSMpk)(3,1)-6.*(*fSMpk)(0,2)*(*fSMpk)(1,1)  \r
4809                    + 8.*(*fSMpk)(0,3)*(*fSMpk)(0,1)\r
4810                    + 3.*(*fSMpk)(1,2)-6.*(*fSMpk)(0,4); // dM1111 = sum_{i,j,k,l=1,i!=j!=k!=l}^M w_i w_j w_k w_l\r
4811     //eventWeight[2] = ... // to be improved (calculated)               \r
4812     //eventWeight[3] = ... // to be improved (calculated)              \r
4813    }\r
4814 \r
4815  fIntFlowSumOfProductOfEventWeights->Fill(0.5,eventWeight[0]*eventWeight[1]); \r
4816  fIntFlowSumOfProductOfEventWeights->Fill(1.5,eventWeight[0]*eventWeight[2]); \r
4817  fIntFlowSumOfProductOfEventWeights->Fill(2.5,eventWeight[0]*eventWeight[3]); \r
4818  fIntFlowSumOfProductOfEventWeights->Fill(3.5,eventWeight[1]*eventWeight[2]); \r
4819  fIntFlowSumOfProductOfEventWeights->Fill(4.5,eventWeight[1]*eventWeight[3]); \r
4820  fIntFlowSumOfProductOfEventWeights->Fill(5.5,eventWeight[2]*eventWeight[3]); \r
4821  */\r
4822   \r
4823  \r
4824  Int_t counter = 0;\r
4825  \r
4826  for(Int_t ci1=1;ci1<4;ci1++)\r
4827  {\r
4828   for(Int_t ci2=ci1+1;ci2<=4;ci2++)\r
4829   {\r
4830    fIntFlowSumOfProductOfEventWeights->Fill(0.5+counter++,\r
4831                                             fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci1)*fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(ci2));\r
4832   }\r
4833  }\r
4834 \r
4835  \r
4836 \r
4837 } // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowIntFlowSumOfProductOfEventWeights()\r
4838 \r
4839 \r
4840 //================================================================================================================================\r
4841 \r
4842 \r
4843 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta)\r
4844 {\r
4845  // calculate reduced correlations for RPs or POIs in pt or eta bins\r
4846 \r
4847  // multiplicity:\r
4848  Double_t dMult = (*fSMpk)(0,0);\r
4849  \r
4850  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
4851  Double_t dReQ1n = (*fReQ)(0,0);\r
4852  Double_t dReQ2n = (*fReQ)(1,0);\r
4853  //Double_t dReQ3n = (*fReQ)(2,0);\r
4854  //Double_t dReQ4n = (*fReQ)(3,0);\r
4855  Double_t dImQ1n = (*fImQ)(0,0);\r
4856  Double_t dImQ2n = (*fImQ)(1,0);\r
4857  //Double_t dImQ3n = (*fImQ)(2,0);\r
4858  //Double_t dImQ4n = (*fImQ)(3,0);\r
4859 \r
4860  // reduced correlations are stored in fDiffFlowCorrelationsPro[0=RP,1=POI][0=pt,1=eta][correlation index]. Correlation index runs as follows:\r
4861  // \r
4862  // 0: <<2'>>\r
4863  // 1: <<4'>>\r
4864  // 2: <<6'>>\r
4865  // 3: <<8'>>\r
4866  \r
4867  Int_t t = -1; // type flag \r
4868  Int_t pe = -1; // ptEta flag\r
4869  \r
4870  if(type == "RP")\r
4871  {\r
4872   t = 0;\r
4873  } else if(type == "POI")\r
4874    {\r
4875     t = 1;\r
4876    }\r
4877 \r
4878  if(ptOrEta == "Pt")\r
4879  {\r
4880   pe = 0;\r
4881  } else if(ptOrEta == "Eta")\r
4882    {\r
4883     pe = 1;\r
4884    }\r
4885     \r
4886  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
4887  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
4888  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
4889  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
4890 \r
4891  // looping over all bins and calculating reduced correlations: \r
4892  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
4893  {\r
4894   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
4895   Double_t p1n0kRe = 0.;\r
4896   Double_t p1n0kIm = 0.;\r
4897 \r
4898   // number of POIs in particular pt or eta bin:\r
4899   Double_t mp = 0.;\r
4900 \r
4901   // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
4902   Double_t q1n0kRe = 0.;\r
4903   Double_t q1n0kIm = 0.;\r
4904   Double_t q2n0kRe = 0.;\r
4905   Double_t q2n0kIm = 0.;\r
4906 \r
4907   // number of particles which are both RPs and POIs in particular pt or eta bin:\r
4908   Double_t mq = 0.;\r
4909    \r
4910   if(type == "POI")\r
4911   {\r
4912    // q_{m*n,0}:\r
4913    q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
4914            * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
4915    q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
4916            * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
4917    q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
4918            * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
4919    q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
4920            * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));         \r
4921                  \r
4922    mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
4923   } \r
4924   else if(type == "RP")\r
4925   {\r
4926    // q_{m*n,0}:\r
4927    q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
4928            * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
4929    q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
4930            * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
4931    q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
4932            * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
4933    q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
4934            * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));         \r
4935                  \r
4936    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)  \r
4937   }\r
4938       \r
4939    if(type == "POI")\r
4940    {\r
4941     // p_{m*n,0}:\r
4942     p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
4943             * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
4944     p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
4945             * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
4946             \r
4947     mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
4948     \r
4949     t = 1; // typeFlag = RP or POI\r
4950    }\r
4951    else if(type == "RP")\r
4952    {\r
4953     // p_{m*n,0} = q_{m*n,0}:\r
4954     p1n0kRe = q1n0kRe; \r
4955     p1n0kIm = q1n0kIm; \r
4956             \r
4957     mp = mq; \r
4958     \r
4959     t = 0; // typeFlag = RP or POI\r
4960    }\r
4961       \r
4962    // 2'-particle correlation for particular (pt,eta) bin:\r
4963    Double_t two1n1nPtEta = 0.;\r
4964    if(mp*dMult-mq)\r
4965    {\r
4966     two1n1nPtEta = (p1n0kRe*dReQ1n+p1n0kIm*dImQ1n-mq)\r
4967                  / (mp*dMult-mq);\r
4968    \r
4969     if(type == "POI") // to be improved (I do not this if)\r
4970     { \r
4971      // fill profile to get <<2'>> for POIs\r
4972      fDiffFlowCorrelationsPro[1][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mp*dMult-mq);\r
4973      // histogram to store <2'> for POIs e-b-e (needed in some other methods):\r
4974      fDiffFlowCorrelationsEBE[1][pe][0]->SetBinContent(b,two1n1nPtEta);      \r
4975      fDiffFlowEventWeightsForCorrelationsEBE[1][pe][0]->SetBinContent(b,mp*dMult-mq);      \r
4976     }\r
4977     else if(type == "RP") // to be improved (I do not this if)\r
4978     {\r
4979      // profile to get <<2'>> for RPs:\r
4980      fDiffFlowCorrelationsPro[0][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nPtEta,mp*dMult-mq);\r
4981      // histogram to store <2'> for RPs e-b-e (needed in some other methods):\r
4982      fDiffFlowCorrelationsEBE[0][pe][0]->SetBinContent(b,two1n1nPtEta); \r
4983      fDiffFlowEventWeightsForCorrelationsEBE[0][pe][0]->SetBinContent(b,mp*dMult-mq); \r
4984     }\r
4985    } // end of if(mp*dMult-mq)\r
4986   \r
4987    // 4'-particle correlation:\r
4988    Double_t four1n1n1n1nPtEta = 0.;\r
4989    if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
4990        + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)) // to be improved (introduce a new variable for this expression)\r
4991    {\r
4992     four1n1n1n1nPtEta = ((pow(dReQ1n,2.)+pow(dImQ1n,2.))*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
4993                       - q2n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))\r
4994                       - 2.*q2n0kIm*dReQ1n*dImQ1n\r
4995                       - p1n0kRe*(dReQ1n*dReQ2n+dImQ1n*dImQ2n)\r
4996                       + p1n0kIm*(dImQ1n*dReQ2n-dReQ1n*dImQ2n)\r
4997                       - 2.*dMult*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)\r
4998                       - 2.*(pow(dReQ1n,2.)+pow(dImQ1n,2.))*mq                      \r
4999                       + 6.*(q1n0kRe*dReQ1n+q1n0kIm*dImQ1n)                                            \r
5000                       + 1.*(q2n0kRe*dReQ2n+q2n0kIm*dImQ2n)                      \r
5001                       + 2.*(p1n0kRe*dReQ1n+p1n0kIm*dImQ1n)                       \r
5002                       + 2.*mq*dMult                      \r
5003                       - 6.*mq)        \r
5004                       / ((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5005                           + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
5006     \r
5007     if(type == "POI")\r
5008     {\r
5009      // profile to get <<4'>> for POIs:\r
5010      fDiffFlowCorrelationsPro[1][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,\r
5011                                      (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5012                                      + mq*(dMult-1.)*(dMult-2.)*(dMult-3.)); \r
5013      // histogram to store <4'> for POIs e-b-e (needed in some other methods):\r
5014      fDiffFlowCorrelationsEBE[1][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);                               \r
5015      fDiffFlowEventWeightsForCorrelationsEBE[1][pe][1]->SetBinContent(b,(mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5016                                                                         + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));                               \r
5017     }\r
5018     else if(type == "RP")\r
5019     {\r
5020      // profile to get <<4'>> for RPs:\r
5021      fDiffFlowCorrelationsPro[0][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nPtEta,\r
5022                                        (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5023                                        + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));                   \r
5024      // histogram to store <4'> for RPs e-b-e (needed in some other methods):\r
5025      fDiffFlowCorrelationsEBE[0][pe][1]->SetBinContent(b,four1n1n1n1nPtEta);                   \r
5026      fDiffFlowEventWeightsForCorrelationsEBE[0][pe][1]->SetBinContent(b,(mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5027                                                                         + mq*(dMult-1.)*(dMult-2.)*(dMult-3.));                   \r
5028     }\r
5029    } // end of if((mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5030      //            +mq*(dMult-1.)*(dMult-2.)*(dMult-3.))\r
5031    \r
5032  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5033  \r
5034    \r
5035 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelations(TString type, TString ptOrEta);\r
5036 \r
5037 \r
5038 //================================================================================================================================\r
5039 \r
5040 \r
5041 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights(TString type, TString ptOrEta)\r
5042 {\r
5043  // Calculate sums of various event weights for reduced correlations. \r
5044  // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)\r
5045 \r
5046  Int_t typeFlag = -1;\r
5047  Int_t ptEtaFlag = -1;\r
5048 \r
5049  if(type == "RP")\r
5050  {\r
5051   typeFlag = 0;\r
5052  } else if(type == "POI")\r
5053    {\r
5054     typeFlag = 1;\r
5055    } \r
5056      \r
5057  if(ptOrEta == "Pt")\r
5058  {\r
5059   ptEtaFlag = 0;\r
5060  } else if(ptOrEta == "Eta")\r
5061    {\r
5062     ptEtaFlag = 1;\r
5063    } \r
5064    \r
5065  // shortcuts:\r
5066  Int_t t = typeFlag;\r
5067  Int_t pe = ptEtaFlag;\r
5068  \r
5069  // binning:\r
5070  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5071  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5072  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
5073  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5074  \r
5075  for(Int_t rpq=0;rpq<3;rpq++)\r
5076  {\r
5077   for(Int_t m=0;m<4;m++)\r
5078   {\r
5079    for(Int_t k=0;k<9;k++)\r
5080    {\r
5081     if(!fReRPQ1dEBE[rpq][pe][m][k])\r
5082     {\r
5083      cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;\r
5084      cout<<"pe  = "<<pe<<endl;\r
5085      cout<<"rpq = "<<rpq<<endl;\r
5086      cout<<"m   = "<<m<<endl;\r
5087      cout<<"k   = "<<k<<endl;\r
5088      exit(0); \r
5089     }\r
5090    }\r
5091   }\r
5092  }  \r
5093 \r
5094  // multiplicities:\r
5095  Double_t dMult = (*fSMpk)(0,0); // total event multiplicity\r
5096  //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
5097  Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
5098  Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
5099  \r
5100  // event weights for reduced correlations:\r
5101  Double_t dw2 = 0.; // event weight for <2'>\r
5102  Double_t dw4 = 0.; // event weight for <4'>\r
5103  //Double_t dw6 = 0.; // event weight for <6'>\r
5104  //Double_t dw8 = 0.; // event weight for <8'>\r
5105 \r
5106  // looping over bins:\r
5107  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5108  {\r
5109   if(type == "RP")\r
5110   {\r
5111    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
5112    mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
5113   } else if(type == "POI")\r
5114     {\r
5115      mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
5116      mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);    \r
5117     }\r
5118   \r
5119   // event weight for <2'>:\r
5120   dw2 = mp*dMult-mq;  \r
5121   fDiffFlowSumOfEventWeights[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2);\r
5122   fDiffFlowSumOfEventWeights[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw2,2.));\r
5123   \r
5124   // event weight for <4'>:\r
5125   dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5126      + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);  \r
5127   fDiffFlowSumOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4);\r
5128   fDiffFlowSumOfEventWeights[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw4,2.));\r
5129   \r
5130   // event weight for <6'>:\r
5131   //dw6 = ...;  \r
5132   //fDiffFlowSumOfEventWeights[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6);\r
5133   //fDiffFlowSumOfEventWeights[t][pe][t][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw6,2.));\r
5134   \r
5135   // event weight for <8'>:\r
5136   //dw8 = ...;  \r
5137   //fDiffFlowSumOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw8);\r
5138   //fDiffFlowSumOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],pow(dw8,2.));   \r
5139  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++) \r
5140  \r
5141 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfEventWeights()\r
5142 \r
5143 \r
5144 //================================================================================================================================\r
5145 \r
5146 \r
5147 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)\r
5148 {\r
5149  // Calculate sum of products of various event weights for both types of correlations (the ones for int. and diff. flow). \r
5150  // (These quantitites are needed in expressions for unbiased estimators relevant for the statistical errors.)\r
5151  //\r
5152  // Important: To fill fDiffFlowSumOfProductOfEventWeights[][][][] use bellow table (i,j) with following constraints: \r
5153  // 1.) i<j  \r
5154  // 2.) do not store terms which DO NOT include reduced correlations;\r
5155  // Table:\r
5156  // [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>] x [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>]\r
5157   \r
5158  Int_t typeFlag = -1;\r
5159  Int_t ptEtaFlag = -1;\r
5160 \r
5161  if(type == "RP")\r
5162  {\r
5163   typeFlag = 0;\r
5164  } else if(type == "POI")\r
5165    {\r
5166     typeFlag = 1;\r
5167    } \r
5168      \r
5169  if(ptOrEta == "Pt")\r
5170  {\r
5171   ptEtaFlag = 0;\r
5172  } else if(ptOrEta == "Eta")\r
5173    {\r
5174     ptEtaFlag = 1;\r
5175    } \r
5176      \r
5177  // shortcuts:\r
5178  Int_t t = typeFlag;\r
5179  Int_t pe = ptEtaFlag;\r
5180   \r
5181  // binning:\r
5182  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5183  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5184  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
5185  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5186  \r
5187  // protection:\r
5188  for(Int_t rpq=0;rpq<3;rpq++)\r
5189  {\r
5190   for(Int_t m=0;m<4;m++)\r
5191   {\r
5192    for(Int_t k=0;k<9;k++)\r
5193    {\r
5194     if(!fReRPQ1dEBE[rpq][pe][m][k])\r
5195     {\r
5196      cout<<"WARNING: fReRPQ1dEBE[rpq][pe][m][k] is NULL in AFAWQC::CSAPOEWFDF() !!!!"<<endl;\r
5197      cout<<"pe  = "<<pe<<endl;\r
5198      cout<<"rpq = "<<rpq<<endl;\r
5199      cout<<"m   = "<<m<<endl;\r
5200      cout<<"k   = "<<k<<endl;\r
5201      exit(0); \r
5202     }\r
5203    }\r
5204   }\r
5205  }  \r
5206  \r
5207  // multiplicities:\r
5208  Double_t dMult = (*fSMpk)(0,0); // total event multiplicity\r
5209  //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
5210  Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
5211  Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
5212  \r
5213  // event weights for correlations:\r
5214  Double_t dW2 = dMult*(dMult-1); // event weight for <2> \r
5215  Double_t dW4 = dMult*(dMult-1)*(dMult-2)*(dMult-3); // event weight for <4> \r
5216  Double_t dW6 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5); // event weight for <6> \r
5217  Double_t dW8 = dMult*(dMult-1)*(dMult-2)*(dMult-3)*(dMult-4)*(dMult-5)*(dMult-6)*(dMult-7); // event weight for <8> \r
5218 \r
5219  // event weights for reduced correlations:\r
5220  Double_t dw2 = 0.; // event weight for <2'>\r
5221  Double_t dw4 = 0.; // event weight for <4'>\r
5222  //Double_t dw6 = 0.; // event weight for <6'>\r
5223  //Double_t dw8 = 0.; // event weight for <8'>\r
5224  \r
5225  // looping over bins:\r
5226  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5227  {\r
5228   if(type == "RP")\r
5229   {\r
5230    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
5231    mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
5232   } else if(type == "POI")\r
5233     {\r
5234      mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
5235      mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);    \r
5236     }\r
5237   \r
5238   // event weight for <2'>:\r
5239   dw2 = mp*dMult-mq;  \r
5240   fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw2); // storing product of even weights for <2> and <2'>\r
5241   fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW4); // storing product of even weights for <4> and <2'>\r
5242   fDiffFlowSumOfProductOfEventWeights[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW6); // storing product of even weights for <6> and <2'>\r
5243   fDiffFlowSumOfProductOfEventWeights[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dW8); // storing product of even weights for <8> and <2'>\r
5244   \r
5245   // event weight for <4'>:\r
5246   dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5247      + mq*(dMult-1.)*(dMult-2.)*(dMult-3.);  \r
5248   fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw4); // storing product of even weights for <2> and <4'>\r
5249   fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw4); // storing product of even weights for <2'> and <4'>\r
5250   fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw4); // storing product of even weights for <4> and <4'>\r
5251   fDiffFlowSumOfProductOfEventWeights[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW6); // storing product of even weights for <6> and <4'> \r
5252   fDiffFlowSumOfProductOfEventWeights[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dW8); // storing product of even weights for <8> and <4'>\r
5253 \r
5254   // event weight for <6'>:\r
5255   //dw6 = ...;  \r
5256   //fDiffFlowSumOfProductOfEventWeights[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw6); // storing product of even weights for <2> and <6'>\r
5257   //fDiffFlowSumOfProductOfEventWeights[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw6); // storing product of even weights for <2'> and <6'>\r
5258   //fDiffFlowSumOfProductOfEventWeights[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw6); // storing product of even weights for <4> and <6'>\r
5259   //fDiffFlowSumOfProductOfEventWeights[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw6); // storing product of even weights for <4'> and <6'> \r
5260   //fDiffFlowSumOfProductOfEventWeights[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw6); // storing product of even weights for <6> and <6'>\r
5261   //fDiffFlowSumOfProductOfEventWeights[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dW8); // storing product of even weights for <6'> and <8>\r
5262   //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>\r
5263 \r
5264   // event weight for <8'>:\r
5265   //dw8 = ...;  \r
5266   //fDiffFlowSumOfProductOfEventWeights[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW2*dw8); // storing product of even weights for <2> and <8'>\r
5267   //fDiffFlowSumOfProductOfEventWeights[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw2*dw8); // storing product of even weights for <2'> and <8'>\r
5268   //fDiffFlowSumOfProductOfEventWeights[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW4*dw8); // storing product of even weights for <4> and <8'>\r
5269   //fDiffFlowSumOfProductOfEventWeights[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw4*dw8); // storing product of even weights for <4'> and <8'> \r
5270   //fDiffFlowSumOfProductOfEventWeights[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW6*dw8); // storing product of even weights for <6> and <8'>\r
5271   //fDiffFlowSumOfProductOfEventWeights[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dw6*dw8); // storing product of even weights for <6'> and <8'>\r
5272   //fDiffFlowSumOfProductOfEventWeights[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],dW8*dw8); // storing product of even weights for <8> and <8'>\r
5273   \r
5274   // Table:\r
5275   // [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>] x [0=<2>,1=<2'>,2=<4>,3=<4'>,4=<6>,5=<6'>,6=<8>,7=<8'>]\r
5276    \r
5277  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5278  \r
5279 \r
5280 \r
5281 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowSumOfProductOfEventWeights(TString type, TString ptOrEta)\r
5282 \r
5283 \r
5284 //================================================================================================================================\r
5285 \r
5286 \r
5287 void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)\r
5288 {\r
5289  // Transfer profiles into histograms and calculate statistical errors correctly.\r
5290 \r
5291  Int_t typeFlag = -1;\r
5292  Int_t ptEtaFlag = -1;\r
5293 \r
5294  if(type == "RP")\r
5295  {\r
5296   typeFlag = 0;\r
5297  } else if(type == "POI")\r
5298    {\r
5299     typeFlag = 1;\r
5300    } \r
5301      \r
5302  if(ptOrEta == "Pt")\r
5303  {\r
5304   ptEtaFlag = 0;\r
5305  } else if(ptOrEta == "Eta")\r
5306    {\r
5307     ptEtaFlag = 1;\r
5308    } \r
5309   \r
5310  // shortcuts:\r
5311  Int_t t = typeFlag;\r
5312  Int_t pe = ptEtaFlag;\r
5313              \r
5314  for(Int_t rci=0;rci<4;rci++)\r
5315  {\r
5316   if(!fDiffFlowCorrelationsPro[t][pe][rci])\r
5317   {\r
5318    cout<<"WARNING: fDiffFlowCorrelationsPro[t][pe][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;\r
5319    cout<<"t   = "<<t<<endl; \r
5320    cout<<"pe  = "<<pe<<endl; \r
5321    cout<<"rci = "<<rci<<endl;\r
5322    exit(0); \r
5323   }\r
5324   for(Int_t power=0;power<2;power++)\r
5325   {\r
5326    if(!fDiffFlowSumOfEventWeights[t][pe][power][rci])\r
5327    {\r
5328     cout<<"WARNING: fDiffFlowSumOfEventWeights[t][pe][power][rci] is NULL in AFAWQC::FRC() !!!!"<<endl;\r
5329     cout<<"t     = "<<t<<endl; \r
5330     cout<<"pe    = "<<pe<<endl;\r
5331     cout<<"power = "<<power<<endl; \r
5332     cout<<"rci   = "<<rci<<endl;\r
5333     exit(0); \r
5334    }   \r
5335   } // end of for(Int_t power=0;power<2;power++)\r
5336  } // end of for(Int_t rci=0;rci<4;rci++)\r
5337     \r
5338  // common:\r
5339  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5340  \r
5341  // transfer 1D profile into 1D histogram:\r
5342  Double_t correlation = 0.;\r
5343  Double_t spread = 0.;\r
5344  Double_t sumOfWeights = 0.; // sum of weights for particular reduced correlations for particular pt or eta bin\r
5345  Double_t sumOfSquaredWeights = 0.; // sum of squared weights for particular reduced correlations for particular pt or eta bin\r
5346  Double_t error = 0.; // error = termA * spread * termB\r
5347                       // termA = (sqrt(sumOfSquaredWeights)/sumOfWeights) \r
5348                       // termB = 1/pow(1-termA^2,0.5)\r
5349  Double_t termA = 0.;                      \r
5350  Double_t termB = 0.;                      \r
5351  for(Int_t rci=0;rci<4;rci++) // index of reduced correlation\r
5352  {\r
5353   for(Int_t b=1;b<=nBinsPtEta[pe];b++) // number of pt or eta bins\r
5354   {\r
5355    correlation = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(b); \r
5356    spread = fDiffFlowCorrelationsPro[t][pe][rci]->GetBinError(b);\r
5357    sumOfWeights = fDiffFlowSumOfEventWeights[t][pe][0][rci]->GetBinContent(b);\r
5358    sumOfSquaredWeights = fDiffFlowSumOfEventWeights[t][pe][1][rci]->GetBinContent(b);\r
5359    if(sumOfWeights) termA = (pow(sumOfSquaredWeights,0.5)/sumOfWeights);\r
5360    if(1.-pow(termA,2.)>0.) termB = 1./pow(1.-pow(termA,2.),0.5); \r
5361    error = termA*spread*termB; // final error (unbiased estimator for standard deviation)\r
5362    fDiffFlowCorrelationsHist[t][pe][rci]->SetBinContent(b,correlation); \r
5363    fDiffFlowCorrelationsHist[t][pe][rci]->SetBinError(b,error); \r
5364   } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5365  } // end of for(Int_t rci=0;rci<4;rci++)\r
5366  \r
5367 } // end of void AliFlowAnalysisWithQCumulants::FinalizeReducedCorrelations(TString type, TString ptOrEta)\r
5368 \r
5369 \r
5370 //================================================================================================================================\r
5371 \r
5372 \r
5373 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)\r
5374 {\r
5375  // store products: <2><2'>, <2><4'>, <2><6'>, <2><8'>, <2'><4>, \r
5376  //                 <2'><4'>, <2'><6>, <2'><6'>, <2'><8>, <2'><8'>,\r
5377  //                 <4><4'>, <4><6'>, <4><8'>, <4'><6>, <4'><6'>, \r
5378  //                 <4'><8>, <4'><8'>, <6><6'>, <6><8'>, <6'><8>, \r
5379  //                 <6'><8'>, <8><8'>.\r
5380   \r
5381  Int_t typeFlag = -1;\r
5382  Int_t ptEtaFlag = -1;\r
5383 \r
5384  if(type == "RP")\r
5385  {\r
5386   typeFlag = 0;\r
5387  } else if(type == "POI")\r
5388    {\r
5389     typeFlag = 1;\r
5390    } \r
5391      \r
5392  if(ptOrEta == "Pt")\r
5393  {\r
5394   ptEtaFlag = 0;\r
5395  } else if(ptOrEta == "Eta")\r
5396    {\r
5397     ptEtaFlag = 1;\r
5398    } \r
5399   \r
5400  // shortcuts:\r
5401  Int_t t = typeFlag;\r
5402  Int_t pe = ptEtaFlag;\r
5403      \r
5404  // common:\r
5405  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5406  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5407  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5408    \r
5409  // protections // to be improved (add protection for all pointers in this method)\r
5410  if(!fIntFlowCorrelationsEBE)\r
5411  {\r
5412   cout<<"WARNING: fIntFlowCorrelationsEBE is NULL in AFAWQC::CDFPOC() !!!!"<<endl;\r
5413   exit(0);\r
5414  } \r
5415  \r
5416  /*    \r
5417  Double_t dMult = (*fSMpk)(0,0); // multiplicity (number of particles used to determine the reaction plane)\r
5418  //Double_t mr = 0.; // number of RPs in particular pt or eta bin\r
5419  Double_t mp = 0.; // number of POIs in particular pt or eta bin \r
5420  Double_t mq = 0.; // number of particles which are both RPs and POIs in particular pt or eta bin\r
5421  */\r
5422 \r
5423  // e-b-e correlations:\r
5424  Double_t twoEBE = fIntFlowCorrelationsEBE->GetBinContent(1); // <2>\r
5425  Double_t fourEBE = fIntFlowCorrelationsEBE->GetBinContent(2); // <4>\r
5426  Double_t sixEBE = fIntFlowCorrelationsEBE->GetBinContent(3); // <6>\r
5427  Double_t eightEBE = fIntFlowCorrelationsEBE->GetBinContent(4); // <8>\r
5428  \r
5429  // event weights for correlations:\r
5430  Double_t dW2 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(1); // event weight for <2> \r
5431  Double_t dW4 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(2); // event weight for <4> \r
5432  Double_t dW6 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(3); // event weight for <6> \r
5433  Double_t dW8 = fIntFlowEventWeightsForCorrelationsEBE->GetBinContent(4); // event weight for <8> \r
5434   \r
5435  // e-b-e reduced correlations:\r
5436  Double_t twoReducedEBE = 0.; // <2'>\r
5437  Double_t fourReducedEBE = 0.; // <4'>\r
5438  Double_t sixReducedEBE = 0.; // <6'>\r
5439  Double_t eightReducedEBE = 0.; // <8'> \r
5440  \r
5441  // event weights for reduced correlations:\r
5442  Double_t dw2 = 0.; // event weight for <2'>\r
5443  Double_t dw4 = 0.; // event weight for <4'>\r
5444  //Double_t dw6 = 0.; // event weight for <6'>\r
5445  //Double_t dw8 = 0.; // event weight for <8'>\r
5446 \r
5447  // looping over bins:\r
5448  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5449  {\r
5450   // e-b-e reduced correlations:\r
5451   twoReducedEBE = fDiffFlowCorrelationsEBE[t][pe][0]->GetBinContent(b);\r
5452   fourReducedEBE = fDiffFlowCorrelationsEBE[t][pe][1]->GetBinContent(b);\r
5453   sixReducedEBE = fDiffFlowCorrelationsEBE[t][pe][2]->GetBinContent(b);\r
5454   eightReducedEBE = fDiffFlowCorrelationsEBE[t][pe][3]->GetBinContent(b);\r
5455   \r
5456   /*\r
5457   // to be improved (I should not do this here again)\r
5458   if(type == "RP")\r
5459   {\r
5460    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(b);\r
5461    mp = mq; // trick to use the very same Eqs. bellow both for RP's and POI's diff. flow\r
5462   } else if(type == "POI")\r
5463     {\r
5464      mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(b);\r
5465      mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(b);    \r
5466     }\r
5467   \r
5468   // event weights for reduced correlations:\r
5469   dw2 = mp*dMult-mq; // weight for <2'> \r
5470   dw4 = (mp-mq)*dMult*(dMult-1.)*(dMult-2.)\r
5471      + mq*(dMult-1.)*(dMult-2.)*(dMult-3.); // weight for <4'>\r
5472   //dw6 = ...     \r
5473   //dw8 = ...     \r
5474   \r
5475   */\r
5476   \r
5477   dw2 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->GetBinContent(b);\r
5478   dw4 = fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->GetBinContent(b);\r
5479  \r
5480   // storing all products:\r
5481   fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*twoReducedEBE,dW2*dw2); // storing <2><2'>\r
5482   fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*twoReducedEBE,dW4*dw2); // storing <4><2'>\r
5483   fDiffFlowProductOfCorrelationsPro[t][pe][1][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*twoReducedEBE,dW6*dw2); // storing <6><2'>\r
5484   fDiffFlowProductOfCorrelationsPro[t][pe][1][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*twoReducedEBE,dW8*dw2); // storing <8><2'>\r
5485   \r
5486   // event weight for <4'>:\r
5487   fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*fourReducedEBE,dW2*dw4); // storing <2><4'>\r
5488   fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*fourReducedEBE,dw2*dw4); // storing <2'><4'>\r
5489   fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*fourReducedEBE,dW4*dw4); // storing <4><4'>\r
5490   fDiffFlowProductOfCorrelationsPro[t][pe][3][4]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*fourReducedEBE,dW6*dw4); // storing <6><4'> \r
5491   fDiffFlowProductOfCorrelationsPro[t][pe][3][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*fourReducedEBE,dW8*dw4); // storing <8><4'>\r
5492 \r
5493   // event weight for <6'>:\r
5494   //dw6 = ...;  \r
5495   //fDiffFlowProductOfCorrelationsPro[t][pe][0][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*sixReducedEBE,dW2*dw6); // storing <2><6'>\r
5496   //fDiffFlowProductOfCorrelationsPro[t][pe][1][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*sixReducedEBE,dw2*dw6); // storing <2'><6'>\r
5497   //fDiffFlowProductOfCorrelationsPro[t][pe][2][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*sixReducedEBE,dW4*dw6); // storing <4><6'>\r
5498   //fDiffFlowProductOfCorrelationsPro[t][pe][3][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*sixReducedEBE,dw4*dw6); // storing <4'><6'> \r
5499   //fDiffFlowProductOfCorrelationsPro[t][pe][4][5]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*sixReducedEBE,dW6*dw6); // storing <6><6'>\r
5500   //fDiffFlowProductOfCorrelationsPro[t][pe][5][6]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightEBE,dw6*dW8); // storing <6'><8>\r
5501   //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>\r
5502 \r
5503   // event weight for <8'>:\r
5504   //dw8 = ...;  \r
5505   //fDiffFlowProductOfCorrelationsPro[t][pe][0][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoEBE*eightReducedEBE,dW2*dw8); // storing <2><8'>\r
5506   //fDiffFlowProductOfCorrelationsPro[t][pe][1][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],twoReducedEBE*eightReducedEBE,dw2*dw8); // storing <2'><8'>\r
5507   //fDiffFlowProductOfCorrelationsPro[t][pe][2][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourEBE*eightReducedEBE,dW4*dw8); // storing <4><8'>\r
5508   //fDiffFlowProductOfCorrelationsPro[t][pe][3][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],fourReducedEBE*eightReducedEBE,dw4*dw8); // storing <4'><8'> \r
5509   //fDiffFlowProductOfCorrelationsPro[t][pe][4][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixEBE*eightReducedEBE,dW6*dw8); // storing <6><8'>\r
5510   //fDiffFlowProductOfCorrelationsPro[t][pe][5][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sixReducedEBE*eightReducedEBE,dw6*dw8); // storing <6'><8'>\r
5511   //fDiffFlowProductOfCorrelationsPro[t][pe][6][7]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],eightEBE*eightReducedEBE,dW8*dw8); // storing <8><8'> \r
5512  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++       \r
5513      \r
5514 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowProductOfCorrelations(TString type, TString ptOrEta)\r
5515 \r
5516 \r
5517 //================================================================================================================================\r
5518     \r
5519     \r
5520 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta) // to be improved (reimplemented)\r
5521 {\r
5522  // a) Calculate unbiased estimators Cov(<2>,<2'>), Cov(<2>,<4'>), Cov(<4>,<2'>), Cov(<4>,<4'>) and Cov(<2'>,<4'>)\r
5523  //    for covariances V(<2>,<2'>), V(<2>,<4'>), V(<4>,<2'>), V(<4>,<4'>) and V(<2'>,<4'>).  \r
5524  // b) Store in histogram fDiffFlowCovariances[t][pe][index] for instance the following: \r
5525  //\r
5526  //             Cov(<2>,<2'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)]\r
5527  // \r
5528  //     where N is the number of events, w_{<2>} is event weight for <2> and w_{<2'>} is event weight for <2'>.\r
5529  // c) Binning of fDiffFlowCovariances[t][pe][index] is organized as follows:\r
5530  // \r
5531  //     1st bin: Cov(<2>,<2'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)] \r
5532  //     2nd bin: Cov(<2>,<4'>) * (sum_{i=1}^{N} w_{<2>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<2>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5533  //     3rd bin: Cov(<4>,<2'>) * (sum_{i=1}^{N} w_{<4>}_i w_{<2'>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<2'>}_j)] \r
5534  //     4th bin: Cov(<4>,<4'>) * (sum_{i=1}^{N} w_{<4>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<4>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5535  //     5th bin: Cov(<2'>,<4'>) * (sum_{i=1}^{N} w_{<2'>}_i w_{<4'>}_i )/[(sum_{i=1}^{N} w_{<2'>}_i) * (sum_{j=1}^{N} w_{<4'>}_j)] \r
5536  //     ...\r
5537   \r
5538  Int_t typeFlag = -1;\r
5539  Int_t ptEtaFlag = -1;\r
5540 \r
5541  if(type == "RP")\r
5542  {\r
5543   typeFlag = 0;\r
5544  } else if(type == "POI")\r
5545    {\r
5546     typeFlag = 1;\r
5547    } \r
5548      \r
5549  if(ptOrEta == "Pt")\r
5550  {\r
5551   ptEtaFlag = 0;\r
5552  } else if(ptOrEta == "Eta")\r
5553    {\r
5554     ptEtaFlag = 1;\r
5555    } \r
5556   \r
5557  // shortcuts:\r
5558  Int_t t = typeFlag;\r
5559  Int_t pe = ptEtaFlag;\r
5560      \r
5561  // common:\r
5562  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5563  //Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
5564  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
5565  //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
5566  \r
5567  // average correlations:\r
5568  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
5569  Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
5570  //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>\r
5571  //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>\r
5572  \r
5573  // sum of weights for correlation:\r
5574  Double_t sumOfWeightsForTwo = fIntFlowSumOfEventWeights[0]->GetBinContent(1); // sum_{i=1}^{N} w_{<2>}\r
5575  Double_t sumOfWeightsForFour = fIntFlowSumOfEventWeights[0]->GetBinContent(2); // sum_{i=1}^{N} w_{<4>}\r
5576  //Double_t sumOfWeightsForSix = fIntFlowSumOfEventWeights[0]->GetBinContent(3); // sum_{i=1}^{N} w_{<6>}\r
5577  //Double_t sumOfWeightsForEight = fIntFlowSumOfEventWeights[0]->GetBinContent(4); // sum_{i=1}^{N} w_{<8>}\r
5578  \r
5579  // average reduced correlations:\r
5580  Double_t twoReduced = 0.; // <<2'>> \r
5581  Double_t fourReduced = 0.; // <<4'>>\r
5582  //Double_t sixReduced = 0.; // <<6'>>\r
5583  //Double_t eightReduced = 0.; // <<8'>>\r
5584 \r
5585  // sum of weights for reduced correlation:\r
5586  Double_t sumOfWeightsForTwoReduced = 0.; // sum_{i=1}^{N} w_{<2'>}\r
5587  Double_t sumOfWeightsForFourReduced = 0.; // sum_{i=1}^{N} w_{<4'>}\r
5588  //Double_t sumOfWeightsForSixReduced = 0.; // sum_{i=1}^{N} w_{<6'>}\r
5589  //Double_t sumOfWeightsForEightReduced = 0.; // sum_{i=1}^{N} w_{<8'>}\r
5590   \r
5591  // product of weights for reduced correlation:\r
5592  Double_t productOfWeightsForTwoTwoReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<2'>}\r
5593  Double_t productOfWeightsForTwoFourReduced = 0.; // sum_{i=1}^{N} w_{<2>}w_{<4'>}\r
5594  Double_t productOfWeightsForFourTwoReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<2'>}\r
5595  Double_t productOfWeightsForFourFourReduced = 0.; // sum_{i=1}^{N} w_{<4>}w_{<4'>}\r
5596  Double_t productOfWeightsForTwoReducedFourReduced = 0.; // sum_{i=1}^{N} w_{<2'>}w_{<4'>}\r
5597  // ...\r
5598  \r
5599  // products for differential flow:\r
5600  Double_t twoTwoReduced = 0; // <<2><2'>> \r
5601  Double_t twoFourReduced = 0; // <<2><4'>> \r
5602  Double_t fourTwoReduced = 0; // <<4><2'>> \r
5603  Double_t fourFourReduced = 0; // <<4><4'>> \r
5604  Double_t twoReducedFourReduced = 0; // <<2'><4'>> \r
5605 \r
5606  // denominators in the expressions for the unbiased estimators for covariances:\r
5607  // denominator = 1 - term1/(term2*term3)\r
5608  // prefactor = term1/(term2*term3)\r
5609  Double_t denominator = 0.; \r
5610  Double_t prefactor = 0.;\r
5611  Double_t term1 = 0.; \r
5612  Double_t term2 = 0.; \r
5613  Double_t term3 = 0.; \r
5614  \r
5615  // unbiased estimators for covariances for differential flow:\r
5616  Double_t covTwoTwoReduced = 0.; // Cov(<2>,<2'>)\r
5617  Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(w_{<2>},w_{<2'>})\r
5618  Double_t covTwoFourReduced = 0.; // Cov(<2>,<4'>)\r
5619  Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(w_{<2>},w_{<4'>})\r
5620  Double_t covFourTwoReduced = 0.; // Cov(<4>,<2'>)\r
5621  Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(w_{<4>},w_{<2'>})\r
5622  Double_t covFourFourReduced = 0.; // Cov(<4>,<4'>)\r
5623  Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(w_{<4>},w_{<4'>})\r
5624  Double_t covTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>)\r
5625  Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(w_{<2'>},w_{<4'>})\r
5626  \r
5627  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5628  {\r
5629   // average reduced corelations:\r
5630   twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);\r
5631   fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);\r
5632   // average products:\r
5633   twoTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][1]->GetBinContent(b);\r
5634   twoFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][0][3]->GetBinContent(b);\r
5635   fourTwoReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][2]->GetBinContent(b);\r
5636   fourFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][2][3]->GetBinContent(b);\r
5637   twoReducedFourReduced = fDiffFlowProductOfCorrelationsPro[t][pe][1][3]->GetBinContent(b);  \r
5638   // sum of weights for reduced correlations:\r
5639   sumOfWeightsForTwoReduced = fDiffFlowSumOfEventWeights[t][pe][0][0]->GetBinContent(b);\r
5640   sumOfWeightsForFourReduced = fDiffFlowSumOfEventWeights[t][pe][0][1]->GetBinContent(b);\r
5641   // products of weights for correlations:\r
5642   productOfWeightsForTwoTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][1]->GetBinContent(b); \r
5643   productOfWeightsForTwoFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][0][3]->GetBinContent(b);\r
5644   productOfWeightsForFourTwoReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][2]->GetBinContent(b);\r
5645   productOfWeightsForFourFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][2][3]->GetBinContent(b);\r
5646   productOfWeightsForTwoReducedFourReduced = fDiffFlowSumOfProductOfEventWeights[t][pe][1][3]->GetBinContent(b);\r
5647   // denominator for the unbiased estimator for covariances: 1 - term1/(term2*term3) \r
5648   // prefactor (multiplies Cov's) = term1/(term2*term3)       \r
5649   // <2>,<2'>:\r
5650   term1 = productOfWeightsForTwoTwoReduced;      \r
5651   term2 = sumOfWeightsForTwo;\r
5652   term3 = sumOfWeightsForTwoReduced;        \r
5653   if(term2*term3>0.)\r
5654   {\r
5655    denominator = 1.-term1/(term2*term3);\r
5656    prefactor = term1/(term2*term3);\r
5657    if(denominator!=0)\r
5658    {\r
5659     covTwoTwoReduced = (twoTwoReduced-two*twoReduced)/denominator;            \r
5660     wCovTwoTwoReduced = covTwoTwoReduced*prefactor; \r
5661     fDiffFlowCovariances[t][pe][0]->SetBinContent(b,wCovTwoTwoReduced);\r
5662    }\r
5663   }\r
5664   // <2>,<4'>:\r
5665   term1 = productOfWeightsForTwoFourReduced;      \r
5666   term2 = sumOfWeightsForTwo;\r
5667   term3 = sumOfWeightsForFourReduced;        \r
5668   if(term2*term3>0.)\r
5669   {\r
5670    denominator = 1.-term1/(term2*term3);\r
5671    prefactor = term1/(term2*term3);\r
5672    if(denominator!=0)\r
5673    {\r
5674     covTwoFourReduced = (twoFourReduced-two*fourReduced)/denominator;            \r
5675     wCovTwoFourReduced = covTwoFourReduced*prefactor; \r
5676     fDiffFlowCovariances[t][pe][1]->SetBinContent(b,wCovTwoFourReduced);\r
5677    }\r
5678   }\r
5679   // <4>,<2'>:\r
5680   term1 = productOfWeightsForFourTwoReduced;      \r
5681   term2 = sumOfWeightsForFour;\r
5682   term3 = sumOfWeightsForTwoReduced;        \r
5683   if(term2*term3>0.)\r
5684   {\r
5685    denominator = 1.-term1/(term2*term3);\r
5686    prefactor = term1/(term2*term3);\r
5687    if(denominator!=0)\r
5688    {\r
5689     covFourTwoReduced = (fourTwoReduced-four*twoReduced)/denominator;            \r
5690     wCovFourTwoReduced = covFourTwoReduced*prefactor; \r
5691     fDiffFlowCovariances[t][pe][2]->SetBinContent(b,wCovFourTwoReduced);\r
5692    }\r
5693   }\r
5694   // <4>,<4'>:\r
5695   term1 = productOfWeightsForFourFourReduced;      \r
5696   term2 = sumOfWeightsForFour;\r
5697   term3 = sumOfWeightsForFourReduced;        \r
5698   if(term2*term3>0.)\r
5699   {\r
5700    denominator = 1.-term1/(term2*term3);\r
5701    prefactor = term1/(term2*term3);\r
5702    if(denominator!=0)\r
5703    {\r
5704     covFourFourReduced = (fourFourReduced-four*fourReduced)/denominator;            \r
5705     wCovFourFourReduced = covFourFourReduced*prefactor; \r
5706     fDiffFlowCovariances[t][pe][3]->SetBinContent(b,wCovFourFourReduced);\r
5707    }\r
5708   }\r
5709   // <2'>,<4'>:\r
5710   term1 = productOfWeightsForTwoReducedFourReduced;      \r
5711   term2 = sumOfWeightsForTwoReduced;\r
5712   term3 = sumOfWeightsForFourReduced;        \r
5713   if(term2*term3>0.)\r
5714   {\r
5715    denominator = 1.-term1/(term2*term3);\r
5716    prefactor = term1/(term2*term3);\r
5717    if(denominator!=0)\r
5718    {\r
5719     covTwoReducedFourReduced = (twoReducedFourReduced-twoReduced*fourReduced)/denominator;            \r
5720     wCovTwoReducedFourReduced = covTwoReducedFourReduced*prefactor; \r
5721     fDiffFlowCovariances[t][pe][4]->SetBinContent(b,wCovTwoReducedFourReduced);\r
5722    }\r
5723   }   \r
5724  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5725   \r
5726 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCovariances(TString type, TString ptOrEta)\r
5727 \r
5728 \r
5729 //================================================================================================================================\r
5730 \r
5731 \r
5732 void AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, TString ptOrEta)\r
5733 {\r
5734  // calculate differential flow from differential cumulants and previously obtained integrated flow: (to be improved: description)\r
5735  \r
5736  Int_t typeFlag = -1;\r
5737  Int_t ptEtaFlag = -1;\r
5738 \r
5739  if(type == "RP")\r
5740  {\r
5741   typeFlag = 0;\r
5742  } else if(type == "POI")\r
5743    {\r
5744     typeFlag = 1;\r
5745    } \r
5746      \r
5747  if(ptOrEta == "Pt")\r
5748  {\r
5749   ptEtaFlag = 0;\r
5750  } else if(ptOrEta == "Eta")\r
5751    {\r
5752     ptEtaFlag = 1;\r
5753    } \r
5754   \r
5755  // shortcuts:\r
5756  Int_t t = typeFlag;\r
5757  Int_t pe = ptEtaFlag;\r
5758      \r
5759  // common:\r
5760  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
5761    \r
5762  // correlations:\r
5763  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
5764  Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
5765  \r
5766  // statistical errors of correlations:\r
5767  Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1);\r
5768  Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2);   \r
5769     \r
5770  // reduced correlations:\r
5771  Double_t twoReduced = 0.; // <<2'>>\r
5772  Double_t fourReduced = 0.; // <<4'>>\r
5773  \r
5774  // statistical errors of reduced correlations:\r
5775  Double_t twoReducedError = 0.; \r
5776  Double_t fourReducedError = 0.; \r
5777 \r
5778  // covariances:\r
5779  Double_t wCovTwoFour = fIntFlowCovariances->GetBinContent(1);// // Cov(<2>,<4>) * prefactor(<2>,<4>)\r
5780  Double_t wCovTwoTwoReduced = 0.; // Cov(<2>,<2'>) * prefactor(<2>,<2'>)\r
5781  Double_t wCovTwoFourReduced = 0.; // Cov(<2>,<4'>) * prefactor(<2>,<4'>)\r
5782  Double_t wCovFourTwoReduced = 0.; // Cov(<4>,<2'>) * prefactor(<4>,<2'>)\r
5783  Double_t wCovFourFourReduced = 0.; // Cov(<4>,<4'>) * prefactor(<4>,<4'>)\r
5784  Double_t wCovTwoReducedFourReduced = 0.; // Cov(<2'>,<4'>) * prefactor(<2'>,<4'>)\r
5785  \r
5786  // differential flow:\r
5787  Double_t v2Prime = 0.; // v'{2}                   \r
5788  Double_t v4Prime = 0.; // v'{4}\r
5789  \r
5790  // statistical error of differential flow:\r
5791  Double_t v2PrimeError = 0.;                    \r
5792  Double_t v4PrimeError = 0.; \r
5793  \r
5794  // squared statistical error of differential flow:\r
5795  Double_t v2PrimeErrorSquared = 0.;                    \r
5796  Double_t v4PrimeErrorSquared = 0.; \r
5797  \r
5798  // loop over pt or eta bins:\r
5799  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
5800  {\r
5801   // reduced correlations and statistical errors:\r
5802   twoReduced = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b);\r
5803   twoReducedError = fDiffFlowCorrelationsHist[t][pe][0]->GetBinError(b);\r
5804   fourReduced = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b);\r
5805   fourReducedError = fDiffFlowCorrelationsHist[t][pe][1]->GetBinError(b);\r
5806   // covariances:\r
5807   wCovTwoTwoReduced = fDiffFlowCovariances[t][pe][0]->GetBinContent(b);\r
5808   wCovTwoFourReduced = fDiffFlowCovariances[t][pe][1]->GetBinContent(b);\r
5809   wCovFourTwoReduced = fDiffFlowCovariances[t][pe][2]->GetBinContent(b);\r
5810   wCovFourFourReduced = fDiffFlowCovariances[t][pe][3]->GetBinContent(b);\r
5811   wCovTwoReducedFourReduced = fDiffFlowCovariances[t][pe][4]->GetBinContent(b);\r
5812   // differential flow:\r
5813   // v'{2}:\r
5814   if(two>0.) \r
5815   {\r
5816    v2Prime = twoReduced/pow(two,0.5);\r
5817    v2PrimeErrorSquared = (1./4.)*pow(two,-3.)*\r
5818                          (pow(twoReduced,2.)*pow(twoError,2.)\r
5819                           + 4.*pow(two,2.)*pow(twoReducedError,2.)\r
5820                           - 4.*two*twoReduced*wCovTwoTwoReduced);\r
5821      \r
5822                                                             \r
5823    if(v2PrimeErrorSquared>0.) v2PrimeError = pow(v2PrimeErrorSquared,0.5);\r
5824    fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime); \r
5825    fDiffFlow[t][pe][0]->SetBinError(b,v2PrimeError);     \r
5826   }\r
5827   // differential flow:\r
5828   // v'{4}\r
5829   if(2.*pow(two,2.)-four > 0.) \r
5830   {\r
5831    v4Prime = (2.*two*twoReduced-fourReduced)/pow(2.*pow(two,2.)-four,3./4.);\r
5832    v4PrimeErrorSquared = pow(2.*pow(two,2.)-four,-7./2.)*\r
5833                          (pow(2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced,2.)*pow(twoError,2.)\r
5834                           + (9./16.)*pow(2.*two*twoReduced-fourReduced,2.)*pow(fourError,2.)\r
5835                           + 4.*pow(two,2.)*pow(2.*pow(two,2.)-four,2.)*pow(twoReducedError,2.)\r
5836                           + pow(2.*pow(two,2.)-four,2.)*pow(fourReducedError,2.)                          \r
5837                           - (3./2.)*(2.*two*twoReduced-fourReduced)\r
5838                           * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFour\r
5839                           - 4.*two*(2.*pow(two,2.)-four)\r
5840                           * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoTwoReduced\r
5841                           + 2.*(2.*pow(two,2.)-four)\r
5842                           * (2.*pow(two,2.)*twoReduced-3.*two*fourReduced+2.*four*twoReduced)*wCovTwoFourReduced\r
5843                           + 3.*two*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourTwoReduced\r
5844                           - (3./2.)*(2.*pow(two,2.)-four)*(2.*two*twoReduced-fourReduced)*wCovFourFourReduced \r
5845                           - 4.*two*pow(2.*pow(two,2.)-four,2.)*wCovTwoReducedFourReduced);  \r
5846    if(v4PrimeErrorSquared>0.) v4PrimeError = pow(v4PrimeErrorSquared,0.5);        \r
5847    fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime);\r
5848    fDiffFlow[t][pe][1]->SetBinError(b,v4PrimeError);     \r
5849   }\r
5850   \r
5851  } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)\r
5852  \r
5853    \r
5854  \r
5855  \r
5856  /*\r
5857  // 2D:\r
5858  for(Int_t nua=0;nua<2;nua++)\r
5859  {\r
5860   for(Int_t p=1;p<=fnBinsPt;p++)\r
5861   {\r
5862    for(Int_t e=1;e<=fnBinsEta;e++) \r
5863    { \r
5864     // differential cumulants:\r
5865     Double_t qc2Prime = fFinalCumulants2D[t][pW][eW][nua][0]->GetBinContent(fFinalCumulants2D[t][pW][eW][nua][0]->GetBin(p,e)); // QC{2'}                    \r
5866     Double_t qc4Prime = fFinalCumulants2D[t][pW][eW][nua][1]->GetBinContent(fFinalCumulants2D[t][pW][eW][nua][1]->GetBin(p,e)); // QC{4'}\r
5867     // differential flow:\r
5868     Double_t v2Prime = 0.;                    \r
5869     Double_t v4Prime = 0.; \r
5870     if(v2) \r
5871     {\r
5872      v2Prime = qc2Prime/v2;\r
5873      fFinalFlow2D[t][pW][eW][nua][0]->SetBinContent(fFinalFlow2D[t][pW][eW][nua][0]->GetBin(p,e),v2Prime);  \r
5874     }                   \r
5875     if(v4)\r
5876     {\r
5877      v4Prime = -qc4Prime/pow(v4,3.); \r
5878      fFinalFlow2D[t][pW][eW][nua][1]->SetBinContent(fFinalFlow2D[t][pW][eW][nua][1]->GetBin(p,e),v4Prime);  \r
5879     }                    \r
5880    } // end of for(Int_t e=1;e<=fnBinsEta;e++)\r
5881   } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
5882  } // end of for(Int_t nua=0;nua<2;nua++)\r
5883  */\r
5884 \r
5885 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlow(TString type, Bool_t useParticleWeights)\r
5886 \r
5887 \r
5888 //================================================================================================================================\r
5889 \r
5890 \r
5891 void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()\r
5892 {\r
5893  // a) Store all flags for integrated flow in profile fIntFlowFlags.\r
5894  \r
5895  if(!fIntFlowFlags)\r
5896  {\r
5897   cout<<"WARNING: fIntFlowFlags is NULL in AFAWQC::SFFIF() !!!!"<<endl;\r
5898   exit(0);\r
5899  } \r
5900 \r
5901  fIntFlowFlags->Fill(0.5,(Int_t)fUsePhiWeights||fUsePtWeights||fUseEtaWeights); // particle weights used or not\r
5902  //fIntFlowFlags->Fill(1.5,""); // which event weight was used? // to be improved\r
5903  fIntFlowFlags->Fill(2.5,(Int_t)fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not\r
5904   \r
5905 } // end of void AliFlowAnalysisWithQCumulants::StoreIntFlowFlags()\r
5906 \r
5907 \r
5908 //================================================================================================================================\r
5909 \r
5910 \r
5911 void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()\r
5912 {\r
5913  // Store all flags for differential flow in the profile fDiffFlowFlags.\r
5914   \r
5915  if(!fDiffFlowFlags)\r
5916  {\r
5917   cout<<"WARNING: fDiffFlowFlags is NULL in AFAWQC::SFFDF() !!!!"<<endl;\r
5918   exit(0);\r
5919  } \r
5920  \r
5921  fDiffFlowFlags->Fill(0.5,fUsePhiWeights||fUsePtWeights||fUseEtaWeights); // particle weights used or not\r
5922  //fDiffFlowFlags->Fill(1.5,""); // which event weight was used? // to be improved\r
5923  fDiffFlowFlags->Fill(2.5,fApplyCorrectionForNUA); // corrected for non-uniform acceptance or not\r
5924  fDiffFlowFlags->Fill(3.5,fCalculate2DFlow); // calculate also 2D differential flow in (pt,eta) or not\r
5925     \r
5926 } // end of void AliFlowAnalysisWithQCumulants::StoreDiffFlowFlags()\r
5927 \r
5928 \r
5929 //================================================================================================================================\r
5930 \r
5931 \r
5932 void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms(TList *outputListHistos) \r
5933 {\r
5934  // Access all pointers to common control and common result histograms and profiles.\r
5935  \r
5936  if(outputListHistos)  \r
5937  {\r
5938   TString commonHistsName = "AliFlowCommonHistQC";\r
5939   commonHistsName += fAnalysisLabel->Data();\r
5940   AliFlowCommonHist *commonHist = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHistsName.Data()));\r
5941   if(commonHist) this->SetCommonHists(commonHist); \r
5942   TString commonHists2ndOrderName = "AliFlowCommonHist2ndOrderQC";\r
5943   commonHists2ndOrderName += fAnalysisLabel->Data();\r
5944   AliFlowCommonHist *commonHist2nd = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists2ndOrderName.Data()));\r
5945   if(commonHist2nd) this->SetCommonHists2nd(commonHist2nd);   \r
5946   TString commonHists4thOrderName = "AliFlowCommonHist4thOrderQC";\r
5947   commonHists4thOrderName += fAnalysisLabel->Data();\r
5948   AliFlowCommonHist *commonHist4th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists4thOrderName.Data()));\r
5949   if(commonHist4th) this->SetCommonHists4th(commonHist4th);  \r
5950   TString commonHists6thOrderName = "AliFlowCommonHist6thOrderQC";\r
5951   commonHists6thOrderName += fAnalysisLabel->Data();\r
5952   AliFlowCommonHist *commonHist6th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists6thOrderName.Data()));\r
5953   if(commonHist6th) this->SetCommonHists6th(commonHist6th);  \r
5954   TString commonHists8thOrderName = "AliFlowCommonHist8thOrderQC";\r
5955   commonHists8thOrderName += fAnalysisLabel->Data();\r
5956   AliFlowCommonHist *commonHist8th = dynamic_cast<AliFlowCommonHist*>(outputListHistos->FindObject(commonHists8thOrderName.Data()));\r
5957   if(commonHist8th) this->SetCommonHists8th(commonHist8th);  \r
5958   TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderQC"; \r
5959   commonHistResults2ndOrderName += fAnalysisLabel->Data(); \r
5960   AliFlowCommonHistResults *commonHistRes2nd = dynamic_cast<AliFlowCommonHistResults*>\r
5961                                                (outputListHistos->FindObject(commonHistResults2ndOrderName.Data()));\r
5962   if(commonHistRes2nd) this->SetCommonHistsResults2nd(commonHistRes2nd);   \r
5963   TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderQC";\r
5964   commonHistResults4thOrderName += fAnalysisLabel->Data();\r
5965   AliFlowCommonHistResults *commonHistRes4th = dynamic_cast<AliFlowCommonHistResults*>\r
5966                                                (outputListHistos->FindObject(commonHistResults4thOrderName.Data()));\r
5967   if(commonHistRes4th) this->SetCommonHistsResults4th(commonHistRes4th);  \r
5968   TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderQC";\r
5969   commonHistResults6thOrderName += fAnalysisLabel->Data();\r
5970   AliFlowCommonHistResults *commonHistRes6th = dynamic_cast<AliFlowCommonHistResults*>\r
5971                                                (outputListHistos->FindObject(commonHistResults6thOrderName.Data()));\r
5972   if(commonHistRes6th) this->SetCommonHistsResults6th(commonHistRes6th);  \r
5973   TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderQC";\r
5974   commonHistResults8thOrderName += fAnalysisLabel->Data();\r
5975   AliFlowCommonHistResults *commonHistRes8th = dynamic_cast<AliFlowCommonHistResults*>\r
5976                                                (outputListHistos->FindObject(commonHistResults8thOrderName.Data()));  \r
5977   if(commonHistRes8th) this->SetCommonHistsResults8th(commonHistRes8th);\r
5978  } else\r
5979    {\r
5980     cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFCH() !!!!"<<endl;\r
5981     exit(0);\r
5982    }\r
5983         \r
5984 } // end of void AliFlowAnalysisWithQCumulants::GetPointersForCommonHistograms(TList *outputListHistos) \r
5985 \r
5986 \r
5987 //================================================================================================================================\r
5988 \r
5989 \r
5990 void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms(TList *outputListHistos) \r
5991 {\r
5992  // Get pointers for histograms with particle weights.\r
5993 \r
5994  if(outputListHistos)\r
5995  {\r
5996   TList *weightsList = dynamic_cast<TList*>(outputListHistos->FindObject("Weights"));\r
5997   if(weightsList) this->SetWeightsList(weightsList);\r
5998   TString fUseParticleWeightsName = "fUseParticleWeightsQC"; // to be improved (hirdwired label QC)\r
5999   fUseParticleWeightsName += fAnalysisLabel->Data();\r
6000   TProfile *useParticleWeights = dynamic_cast<TProfile*>(weightsList->FindObject(fUseParticleWeightsName.Data()));\r
6001   if(useParticleWeights)\r
6002   {\r
6003    this->SetUseParticleWeights(useParticleWeights);  \r
6004    fUsePhiWeights = (Int_t)fUseParticleWeights->GetBinContent(1); \r
6005    fUsePtWeights = (Int_t)fUseParticleWeights->GetBinContent(2); \r
6006    fUseEtaWeights = (Int_t)fUseParticleWeights->GetBinContent(3);  \r
6007   }\r
6008  } else\r
6009    {\r
6010     cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFPWH() !!!!"<<endl;\r
6011     exit(0);\r
6012    }\r
6013 \r
6014 } // end of void AliFlowAnalysisWithQCumulants::GetPointersForParticleWeightsHistograms(TList *outputListHistos); \r
6015 \r
6016 \r
6017 //================================================================================================================================\r
6018 \r
6019 \r
6020 void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms(TList *outputListHistos) \r
6021 {\r
6022  // Get pointers for histograms and profiles relevant for integrated flow:\r
6023  //  a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults.\r
6024  //  b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow.\r
6025  //  c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds. \r
6026  //  d) Get pointer to list fIntFlowResults and pointers to all objects that she holds. \r
6027   \r
6028  TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data member?)\r
6029  TString powerFlag[2] = {"linear","quadratic"}; // to be improved (should I promote this to data member?)\r
6030  \r
6031  if(outputListHistos)\r
6032  {\r
6033   // a) Get pointer to base list for integrated flow holding profile fIntFlowFlags and lists fIntFlowProfiles and fIntFlowResults:\r
6034   TList *intFlowList = NULL;\r
6035   intFlowList = dynamic_cast<TList*>(outputListHistos->FindObject("Integrated Flow"));\r
6036   if(!intFlowList) \r
6037   {\r
6038    cout<<"WARNING: intFlowList is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6039    exit(0); \r
6040   }  \r
6041   \r
6042   // b) Get pointer to profile fIntFlowFlags holding all flags for integrated flow:\r
6043   TString intFlowFlagsName = "fIntFlowFlags";\r
6044   intFlowFlagsName += fAnalysisLabel->Data();\r
6045   TProfile *intFlowFlags = dynamic_cast<TProfile*>(intFlowList->FindObject(intFlowFlagsName.Data()));\r
6046   Bool_t bApplyCorrectionForNUA = kFALSE;\r
6047   if(intFlowFlags)\r
6048   {\r
6049    this->SetIntFlowFlags(intFlowFlags);  \r
6050    bApplyCorrectionForNUA = (Int_t)intFlowFlags->GetBinContent(3); \r
6051    this->SetApplyCorrectionForNUA(bApplyCorrectionForNUA);      \r
6052   } else \r
6053     {\r
6054      cout<<"WARNING: intFlowFlags is NULL in FAWQC::GPFIFH() !!!!"<<endl;\r
6055     }\r
6056   \r
6057   // c) Get pointer to list fIntFlowProfiles and pointers to all objects that she holds:\r
6058   TList *intFlowProfiles = NULL;\r
6059   intFlowProfiles = dynamic_cast<TList*>(intFlowList->FindObject("Profiles"));\r
6060   if(intFlowProfiles)  \r
6061   {\r
6062    // average multiplicities:\r
6063    TString avMultiplicityName = "fAvMultiplicity";\r
6064    avMultiplicityName += fAnalysisLabel->Data();\r
6065    TProfile *avMultiplicity = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(avMultiplicityName.Data()));\r
6066    if(avMultiplicity) \r
6067    {\r
6068     this->SetAvMultiplicity(avMultiplicity);\r
6069    } else \r
6070      {\r
6071       cout<<"WARNING: avMultiplicity is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6072      }\r
6073    // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with wrong errors!):\r
6074    TString intFlowCorrelationsProName = "fIntFlowCorrelationsPro";\r
6075    intFlowCorrelationsProName += fAnalysisLabel->Data();\r
6076    TProfile *intFlowCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsProName.Data()));\r
6077    if(intFlowCorrelationsPro) \r
6078    {\r
6079     this->SetIntFlowCorrelationsPro(intFlowCorrelationsPro);\r
6080    } else \r
6081      {\r
6082       cout<<"WARNING: intFlowCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6083      } \r
6084    // average all correlations for integrated flow (with wrong errors!):\r
6085    TString intFlowCorrelationsAllProName = "fIntFlowCorrelationsAllPro";\r
6086    intFlowCorrelationsAllProName += fAnalysisLabel->Data();\r
6087    TProfile *intFlowCorrelationsAllPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowCorrelationsAllProName.Data()));\r
6088    if(intFlowCorrelationsAllPro) \r
6089    {\r
6090     this->SetIntFlowCorrelationsAllPro(intFlowCorrelationsAllPro);\r
6091    } else \r
6092      {\r
6093       cout<<"WARNING: intFlowCorrelationsAllPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6094      }     \r
6095    // average extra correlations for integrated flow (which appear only when particle weights are used):\r
6096    // (to be improved: Weak point in implementation, I am assuming here that method GetPointersForParticleWeightsHistograms() was called)\r
6097    if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
6098    {\r
6099     TString intFlowExtraCorrelationsProName = "fIntFlowExtraCorrelationsPro";\r
6100     intFlowExtraCorrelationsProName += fAnalysisLabel->Data();\r
6101     TProfile *intFlowExtraCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowExtraCorrelationsProName.Data()));\r
6102     if(intFlowExtraCorrelationsPro) \r
6103     {\r
6104      this->SetIntFlowExtraCorrelationsPro(intFlowExtraCorrelationsPro);\r
6105     } else \r
6106       {\r
6107        cout<<"WARNING: intFlowExtraCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6108       }\r
6109    } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)        \r
6110    // average products of correlations <2>, <4>, <6> and <8>:  \r
6111    TString intFlowProductOfCorrelationsProName = "fIntFlowProductOfCorrelationsPro";\r
6112    intFlowProductOfCorrelationsProName += fAnalysisLabel->Data();\r
6113    TProfile *intFlowProductOfCorrelationsPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject(intFlowProductOfCorrelationsProName.Data()));\r
6114    if(intFlowProductOfCorrelationsPro) \r
6115    {\r
6116     this->SetIntFlowProductOfCorrelationsPro(intFlowProductOfCorrelationsPro);\r
6117    } else \r
6118      {\r
6119       cout<<"WARNING: intFlowProductOfCorrelationsPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6120      }     \r
6121    // average correction terms for non-uniform acceptance (with wrong errors!):\r
6122    for(Int_t sc=0;sc<2;sc++)\r
6123    {\r
6124     TString intFlowCorrectionTermsForNUAProName = "fIntFlowCorrectionTermsForNUAPro";\r
6125     intFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
6126     TProfile *intFlowCorrectionTermsForNUAPro = dynamic_cast<TProfile*>(intFlowProfiles->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAProName.Data(),sinCosFlag[sc].Data()))));\r
6127     if(intFlowCorrectionTermsForNUAPro) \r
6128     {\r
6129      this->SetIntFlowCorrectionTermsForNUAPro(intFlowCorrectionTermsForNUAPro,sc);\r
6130     } else \r
6131       {\r
6132        cout<<"WARNING: intFlowCorrectionTermsForNUAPro is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6133        cout<<"sc = "<<sc<<endl;\r
6134       } \r
6135    } // end of for(Int_t sc=0;sc<2;sc++)           \r
6136   } else // to if(intFlowProfiles)  \r
6137     {\r
6138      cout<<"WARNING: intFlowProfiles is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6139     }\r
6140    \r
6141   //  d) Get pointer to list fIntFlowResults and pointers to all objects that she holds. \r
6142   TList *intFlowResults = NULL;\r
6143   intFlowResults = dynamic_cast<TList*>(intFlowList->FindObject("Results"));\r
6144   if(intFlowResults)\r
6145   {\r
6146    // average correlations <<2>>, <<4>>, <<6>> and <<8>> (with correct errors!):\r
6147    TString intFlowCorrelationsHistName = "fIntFlowCorrelationsHist";\r
6148    intFlowCorrelationsHistName += fAnalysisLabel->Data();\r
6149    TH1D *intFlowCorrelationsHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsHistName.Data()));\r
6150    if(intFlowCorrelationsHist) \r
6151    {\r
6152     this->SetIntFlowCorrelationsHist(intFlowCorrelationsHist);\r
6153    } else \r
6154      {\r
6155       cout<<"WARNING: intFlowCorrelationsHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6156      } \r
6157    // average all correlations for integrated flow (with correct errors!):\r
6158    TString intFlowCorrelationsAllHistName = "fIntFlowCorrelationsAllHist";\r
6159    intFlowCorrelationsAllHistName += fAnalysisLabel->Data();\r
6160    TH1D *intFlowCorrelationsAllHist = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCorrelationsAllHistName.Data()));\r
6161    if(intFlowCorrelationsAllHist) \r
6162    {\r
6163     this->SetIntFlowCorrelationsAllHist(intFlowCorrelationsAllHist);\r
6164    } else \r
6165      {\r
6166       cout<<"WARNING: intFlowCorrelationsAllHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6167      }  \r
6168    // average correction terms for non-uniform acceptance (with correct errors!):\r
6169    TString intFlowCorrectionTermsForNUAHistName = "fIntFlowCorrectionTermsForNUAHist";\r
6170    intFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
6171    for(Int_t sc=0;sc<2;sc++)\r
6172    {\r
6173     TH1D *intFlowCorrectionTermsForNUAHist = dynamic_cast<TH1D*>(intFlowResults->FindObject((Form("%s: %s terms",intFlowCorrectionTermsForNUAHistName.Data(),sinCosFlag[sc].Data()))));\r
6174     if(intFlowCorrectionTermsForNUAHist) \r
6175     {\r
6176      this->SetIntFlowCorrectionTermsForNUAHist(intFlowCorrectionTermsForNUAHist,sc);\r
6177     } else \r
6178       {\r
6179        cout<<"WARNING: intFlowCorrectionTermsForNUAHist is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6180        cout<<"sc = "<<sc<<endl;\r
6181       } \r
6182    } // end of for(Int_t sc=0;sc<2;sc++)           \r
6183    // covariances (multiplied with weight dependent prefactor):\r
6184    TString intFlowCovariancesName = "fIntFlowCovariances";\r
6185    intFlowCovariancesName += fAnalysisLabel->Data();\r
6186    TH1D *intFlowCovariances = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowCovariancesName.Data()));\r
6187    if(intFlowCovariances) \r
6188    {\r
6189     this->SetIntFlowCovariances(intFlowCovariances); \r
6190    } else \r
6191      {\r
6192       cout<<"WARNING: intFlowCovariances is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6193      } \r
6194    // sum of linear and quadratic event weights for <2>, <4>, <6> and <8>:\r
6195    TString intFlowSumOfEventWeightsName = "fIntFlowSumOfEventWeights";\r
6196    intFlowSumOfEventWeightsName += fAnalysisLabel->Data();\r
6197    for(Int_t power=0;power<2;power++)\r
6198    {\r
6199     TH1D *intFlowSumOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(Form("%s: %s",intFlowSumOfEventWeightsName.Data(),powerFlag[power].Data())));\r
6200     if(intFlowSumOfEventWeights) \r
6201     {\r
6202      this->SetIntFlowSumOfEventWeights(intFlowSumOfEventWeights,power);\r
6203     } else \r
6204       {\r
6205        cout<<"WARNING: intFlowSumOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6206        cout<<"power = "<<power<<endl;\r
6207       }                                   \r
6208    } // end of for(Int_t power=0;power<2;power++)                                                                  \r
6209    // sum of products of event weights for correlations <2>, <4>, <6> and <8>:  \r
6210    TString intFlowSumOfProductOfEventWeightsName = "fIntFlowSumOfProductOfEventWeights";\r
6211    intFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();\r
6212    TH1D *intFlowSumOfProductOfEventWeights = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowSumOfProductOfEventWeightsName.Data()));\r
6213    if(intFlowSumOfProductOfEventWeights) \r
6214    {\r
6215     this->SetIntFlowSumOfProductOfEventWeights(intFlowSumOfProductOfEventWeights);\r
6216    } else \r
6217      {\r
6218       cout<<"WARNING: intFlowSumOfProductOfEventWeights is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6219      } \r
6220    // final results for integrated Q-cumulants:\r
6221    TString intFlowQcumulantsName = "fIntFlowQcumulants";\r
6222    intFlowQcumulantsName += fAnalysisLabel->Data();\r
6223    TH1D *intFlowQcumulants = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowQcumulantsName.Data()));\r
6224    if(intFlowQcumulants) \r
6225    {\r
6226     this->SetIntFlowQcumulants(intFlowQcumulants);\r
6227    } else \r
6228      {\r
6229       cout<<"WARNING: intFlowQcumulants is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6230      }  \r
6231    // final integrated flow estimates from Q-cumulants:\r
6232    TString intFlowName = "fIntFlow";\r
6233    intFlowName += fAnalysisLabel->Data();\r
6234    TH1D *intFlow = dynamic_cast<TH1D*>(intFlowResults->FindObject(intFlowName.Data()));\r
6235    if(intFlow) \r
6236    {\r
6237     this->SetIntFlow(intFlow);\r
6238    } else \r
6239      {\r
6240       cout<<"WARNING: intFlow is NULL in AFAWQC::GPFIFH() !!!!"<<endl; \r
6241      }   \r
6242   } else // to if(intFlowResults)\r
6243     {\r
6244      cout<<"WARNING: intFlowResults is NULL in AFAWQC::GPFIFH() !!!!"<<endl;\r
6245     }\r
6246  } // end of if(outputListHistos)\r
6247 \r
6248 } // end of void AliFlowAnalysisWithQCumulants::GetPointersForIntFlowHistograms(TList *outputListHistos)\r
6249 \r
6250 \r
6251 //================================================================================================================================\r
6252 \r
6253 \r
6254 void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms(TList *outputListHistos)\r
6255 {\r
6256  // Get pointer to all objects relevant for differential flow.\r
6257  //  a) Define flags locally (to be improved: should I promote flags to data members?);\r
6258  //  b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults;\r
6259  //  c) Get pointer to profile fDiffFlowFlags holding all flags for differential flow;\r
6260  //  d) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;\r
6261  //  e) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.\r
6262  \r
6263  // a) Define flags locally (to be improved: should I promote flags to data members?): \r
6264  TString typeFlag[2] = {"RP","POI"}; \r
6265  TString ptEtaFlag[2] = {"p_{T}","#eta"};\r
6266  TString powerFlag[2] = {"linear","quadratic"};\r
6267  TString sinCosFlag[2] = {"sin","cos"};\r
6268  TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};  \r
6269  TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};  \r
6270  TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};\r
6271  TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};\r
6272  TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"}; \r
6273   \r
6274  // b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults:\r
6275  TList *diffFlowList = NULL;\r
6276  diffFlowList = dynamic_cast<TList*>(outputListHistos->FindObject("Differential Flow"));  \r
6277  if(!diffFlowList)\r
6278  { \r
6279   cout<<"WARNING: diffFlowList is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6280   exit(0);\r
6281  }\r
6282  // list holding nested lists containing profiles:\r
6283  TList *diffFlowListProfiles = NULL;\r
6284  diffFlowListProfiles = dynamic_cast<TList*>(diffFlowList->FindObject("Profiles"));\r
6285  if(!diffFlowListProfiles)\r
6286  { \r
6287   cout<<"WARNING: diffFlowListProfiles is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6288   exit(0);\r
6289  }\r
6290  // list holding nested lists containing 2D and 1D histograms with final results:\r
6291  TList *diffFlowListResults = NULL;\r
6292  diffFlowListResults = dynamic_cast<TList*>(diffFlowList->FindObject("Results"));\r
6293  if(!diffFlowListResults)\r
6294  { \r
6295   cout<<"WARNING: diffFlowListResults is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6296   exit(0);\r
6297  }\r
6298  \r
6299  // c) Get pointer to profile holding all flags for differential flow;\r
6300  TString diffFlowFlagsName = "fDiffFlowFlags";\r
6301  diffFlowFlagsName += fAnalysisLabel->Data();\r
6302  TProfile *diffFlowFlags = dynamic_cast<TProfile*>(diffFlowList->FindObject(diffFlowFlagsName.Data()));\r
6303  Bool_t bCalculate2DFlow = kFALSE;\r
6304  if(diffFlowFlags)\r
6305  {\r
6306   this->SetDiffFlowFlags(diffFlowFlags);  \r
6307   bCalculate2DFlow = (Int_t)diffFlowFlags->GetBinContent(4);\r
6308   this->SetCalculate2DFlow(bCalculate2DFlow); // to be improved (shoul I call this setter somewhere else?)     \r
6309  }\r
6310   \r
6311  // d) Get pointers to all nested lists in fDiffFlowListProfiles and to profiles which they hold;\r
6312  // correlations:\r
6313  TList *diffFlowCorrelationsProList[2][2] = {{NULL}};\r
6314  TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";\r
6315  diffFlowCorrelationsProName += fAnalysisLabel->Data();\r
6316  TProfile *diffFlowCorrelationsPro[2][2][4] = {{{NULL}}};   \r
6317  // products of correlations:\r
6318  TList *diffFlowProductOfCorrelationsProList[2][2] = {{NULL}};\r
6319  TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";\r
6320  diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();  \r
6321  TProfile *diffFlowProductOfCorrelationsPro[2][2][8][8] = {{{{NULL}}}};   \r
6322  // corrections:\r
6323  TList *diffFlowCorrectionsProList[2][2] = {{NULL}};\r
6324  TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";\r
6325  diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();  \r
6326  TProfile *diffFlowCorrectionTermsForNUAPro[2][2][2][10] = {{{{NULL}}}};   \r
6327  for(Int_t t=0;t<2;t++)\r
6328  {\r
6329   for(Int_t pe=0;pe<2;pe++)\r
6330   {\r
6331    diffFlowCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6332    if(!diffFlowCorrelationsProList[t][pe])\r
6333    { \r
6334     cout<<"WARNING: diffFlowCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6335     cout<<"t = "<<t<<endl;\r
6336     cout<<"pe = "<<pe<<endl;\r
6337     exit(0);\r
6338    }\r
6339    for(Int_t ci=0;ci<4;ci++) // correlation index\r
6340    {\r
6341     diffFlowCorrelationsPro[t][pe][ci] = dynamic_cast<TProfile*>(diffFlowCorrelationsProList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[ci].Data())));\r
6342     if(diffFlowCorrelationsPro[t][pe][ci])\r
6343     {\r
6344      this->SetDiffFlowCorrelationsPro(diffFlowCorrelationsPro[t][pe][ci],t,pe,ci);\r
6345     } else\r
6346       {\r
6347        cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6348        cout<<"t  = "<<t<<endl;\r
6349        cout<<"pe = "<<pe<<endl;   \r
6350        cout<<"ci = "<<ci<<endl;\r
6351       }     \r
6352    } // end of for(Int_t ci=0;ci<4;ci++) // correlation index  \r
6353    // products of correlations:    \r
6354    diffFlowProductOfCorrelationsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with products of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data()))); \r
6355    if(!diffFlowProductOfCorrelationsProList[t][pe])\r
6356    { \r
6357     cout<<"WARNING: ddiffFlowProductOfCorrelationsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6358     cout<<"t = "<<t<<endl;\r
6359     cout<<"pe = "<<pe<<endl;\r
6360     exit(0);\r
6361    }\r
6362    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6363    {\r
6364     for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6365     {\r
6366      diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = dynamic_cast<TProfile*>(diffFlowProductOfCorrelationsProList[t][pe]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data())));\r
6367      if(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2])\r
6368      {\r
6369       this->SetDiffFlowProductOfCorrelationsPro(diffFlowProductOfCorrelationsPro[t][pe][mci1][mci2],t,pe,mci1,mci2);\r
6370      } else\r
6371        {\r
6372         cout<<"WARNING: diffFlowCorrelationsPro[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6373         cout<<"t    = "<<t<<endl;\r
6374         cout<<"pe   = "<<pe<<endl;   \r
6375         cout<<"mci1 = "<<mci1<<endl;\r
6376         cout<<"mci2 = "<<mci2<<endl;\r
6377        }\r
6378      if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6379     } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6380    } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index    \r
6381    // corrections:\r
6382    diffFlowCorrectionsProList[t][pe] = dynamic_cast<TList*>(diffFlowListProfiles->FindObject(Form("Profiles with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6383    if(!diffFlowCorrectionsProList[t][pe])\r
6384    { \r
6385     cout<<"WARNING: diffFlowCorrectionsProList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6386     cout<<"t = "<<t<<endl;\r
6387     cout<<"pe = "<<pe<<endl;\r
6388     exit(0);\r
6389    }\r
6390    // correction terms for NUA:\r
6391    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6392    {\r
6393     for(Int_t cti=0;cti<9;cti++) // correction term index\r
6394     {\r
6395      diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = dynamic_cast<TProfile*>(diffFlowCorrectionsProList[t][pe]->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
6396      if(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti])\r
6397      {\r
6398       this->SetDiffFlowCorrectionTermsForNUAPro(diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti],t,pe,sc,cti);\r
6399      } else\r
6400        {\r
6401         cout<<"WARNING: diffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6402         cout<<"t   = "<<t<<endl;\r
6403         cout<<"pe  = "<<pe<<endl;   \r
6404         cout<<"sc  = "<<sc<<endl;\r
6405         cout<<"cti = "<<cti<<endl;\r
6406        }    \r
6407     } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
6408    } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6409    // ...\r
6410   } // end of for(Int_t pe=0;pe<2;pe++)\r
6411  } // end of for(Int_t t=0;t<2;t++)\r
6412   \r
6413  // e) Get pointers to all nested lists in fDiffFlowListResults and to histograms which they hold.\r
6414  // reduced correlations:\r
6415  TList *diffFlowCorrelationsHistList[2][2] = {{NULL}};\r
6416  TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";\r
6417  diffFlowCorrelationsHistName += fAnalysisLabel->Data();  \r
6418  TH1D *diffFlowCorrelationsHist[2][2][4] = {{{NULL}}};\r
6419  // corrections for NUA:\r
6420  TList *diffFlowCorrectionsHistList[2][2] = {{NULL}};\r
6421  TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";\r
6422  diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();  \r
6423  TH1D *diffFlowCorrectionTermsForNUAHist[2][2][2][10] = {{{{NULL}}}};\r
6424  // differential Q-cumulants:\r
6425  TList *diffFlowCumulantsHistList[2][2] = {{NULL}};\r
6426  TString diffFlowCumulantsName = "fDiffFlowCumulants";\r
6427  diffFlowCumulantsName += fAnalysisLabel->Data();  \r
6428  TH1D *diffFlowCumulants[2][2][4] = {{{NULL}}};\r
6429  // differential flow estimates from Q-cumulants:\r
6430  TList *diffFlowHistList[2][2] = {{NULL}};\r
6431  TString diffFlowName = "fDiffFlow";\r
6432  diffFlowName += fAnalysisLabel->Data();  \r
6433  TH1D *diffFlow[2][2][4] = {{{NULL}}};\r
6434  // differential covariances:\r
6435  TList *diffFlowCovariancesHistList[2][2] = {{NULL}};\r
6436  TString diffFlowCovariancesName = "fDiffFlowCovariances";\r
6437  diffFlowCovariancesName += fAnalysisLabel->Data();  \r
6438  TH1D *diffFlowCovariances[2][2][5] = {{{NULL}}};\r
6439  for(Int_t t=0;t<2;t++) // type: RP or POI\r
6440  { \r
6441   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6442   {\r
6443    // reduced correlations:\r
6444    diffFlowCorrelationsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6445    if(!diffFlowCorrelationsHistList[t][pe])\r
6446    { \r
6447     cout<<"WARNING: diffFlowCorrelationsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6448     cout<<"t = "<<t<<endl;\r
6449     cout<<"pe = "<<pe<<endl;\r
6450     exit(0);\r
6451    }\r
6452    for(Int_t index=0;index<4;index++) \r
6453    {\r
6454     diffFlowCorrelationsHist[t][pe][index] = dynamic_cast<TH1D*>(diffFlowCorrelationsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data())));\r
6455     if(diffFlowCorrelationsHist[t][pe][index])\r
6456     {\r
6457      this->SetDiffFlowCorrelationsHist(diffFlowCorrelationsHist[t][pe][index],t,pe,index);\r
6458     } else \r
6459       {\r
6460        cout<<"WARNING: diffFlowCorrelationsHist[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6461        cout<<"t     = "<<t<<endl;\r
6462        cout<<"pe    = "<<pe<<endl;\r
6463        cout<<"index = "<<index<<endl;\r
6464        exit(0);       \r
6465       } \r
6466    } // end of for(Int_t index=0;index<4;index++)\r
6467    // corrections:\r
6468    diffFlowCorrectionsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Histograms with correction terms for NUA (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6469    if(!diffFlowCorrectionsHistList[t][pe])\r
6470    { \r
6471     cout<<"WARNING: diffFlowCorrectionsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6472     cout<<"t = "<<t<<endl;\r
6473     cout<<"pe = "<<pe<<endl;\r
6474     exit(0);\r
6475    }\r
6476    // correction terms for NUA:\r
6477    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6478    {\r
6479     for(Int_t cti=0;cti<9;cti++) // correction term index\r
6480     {\r
6481      diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = dynamic_cast<TH1D*>(diffFlowCorrectionsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
6482      if(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti])\r
6483      {\r
6484       this->SetDiffFlowCorrectionTermsForNUAHist(diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti],t,pe,sc,cti);\r
6485      } else\r
6486        {\r
6487         cout<<"WARNING: diffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6488         cout<<"t   = "<<t<<endl;\r
6489         cout<<"pe  = "<<pe<<endl;   \r
6490         cout<<"sc  = "<<sc<<endl;\r
6491         cout<<"cti = "<<cti<<endl;\r
6492        }    \r
6493     } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
6494    } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6495    // ...\r
6496    // differential Q-cumulants:\r
6497    diffFlowCumulantsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential Q-cumulants (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6498    if(!diffFlowCumulantsHistList[t][pe])\r
6499    { \r
6500     cout<<"WARNING: diffFlowCumulantsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6501     cout<<"t  = "<<t<<endl;\r
6502     cout<<"pe = "<<pe<<endl;\r
6503     exit(0);\r
6504    }\r
6505    for(Int_t index=0;index<4;index++) \r
6506    {\r
6507     diffFlowCumulants[t][pe][index] = dynamic_cast<TH1D*>(diffFlowCumulantsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data())));\r
6508     if(diffFlowCumulants[t][pe][index])\r
6509     {\r
6510      this->SetDiffFlowCumulants(diffFlowCumulants[t][pe][index],t,pe,index);\r
6511     } else \r
6512       {\r
6513        cout<<"WARNING: diffFlowCumulants[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6514        cout<<"t     = "<<t<<endl;\r
6515        cout<<"pe    = "<<pe<<endl;\r
6516        cout<<"index = "<<index<<endl;\r
6517        exit(0);       \r
6518       } \r
6519    } // end of for(Int_t index=0;index<4;index++)\r
6520    // differential flow estimates from Q-cumulants:\r
6521    diffFlowHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Differential flow (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6522    if(!diffFlowHistList[t][pe])\r
6523    { \r
6524     cout<<"WARNING: diffFlowHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6525     cout<<"t  = "<<t<<endl;\r
6526     cout<<"pe = "<<pe<<endl;\r
6527     exit(0);\r
6528    }\r
6529    for(Int_t index=0;index<4;index++) \r
6530    {\r
6531     diffFlow[t][pe][index] = dynamic_cast<TH1D*>(diffFlowHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data())));\r
6532     if(diffFlow[t][pe][index])\r
6533     {\r
6534      this->SetDiffFlow(diffFlow[t][pe][index],t,pe,index);\r
6535     } else \r
6536       {\r
6537        cout<<"WARNING: diffFlow[t][pe][index] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6538        cout<<"t     = "<<t<<endl;\r
6539        cout<<"pe    = "<<pe<<endl;\r
6540        cout<<"index = "<<index<<endl;\r
6541        exit(0);       \r
6542       } \r
6543    } // end of for(Int_t index=0;index<4;index++)\r
6544    // differential covariances:\r
6545    diffFlowCovariancesHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Covariances of correlations (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6546    if(!diffFlowCovariancesHistList[t][pe])\r
6547    { \r
6548     cout<<"WARNING: diffFlowCovariancesHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6549     cout<<"t  = "<<t<<endl;\r
6550     cout<<"pe = "<<pe<<endl;\r
6551     exit(0);\r
6552    }\r
6553    for(Int_t covIndex=0;covIndex<5;covIndex++) \r
6554    {\r
6555     diffFlowCovariances[t][pe][covIndex] = dynamic_cast<TH1D*>(diffFlowCovariancesHistList[t][pe]->FindObject(Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data())));\r
6556     if(diffFlowCovariances[t][pe][covIndex])\r
6557     {\r
6558      this->SetDiffFlowCovariances(diffFlowCovariances[t][pe][covIndex],t,pe,covIndex);\r
6559     } else \r
6560       {\r
6561        cout<<"WARNING: diffFlowCovariances[t][pe][covIndex] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6562        cout<<"t        = "<<t<<endl;\r
6563        cout<<"pe       = "<<pe<<endl;\r
6564        cout<<"covIndex = "<<covIndex<<endl;\r
6565        exit(0);       \r
6566       } \r
6567    } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index    \r
6568   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6569  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI \r
6570  // sum of event weights for reduced correlations:\r
6571  TList *diffFlowSumOfEventWeightsHistList[2][2][2] = {{{NULL}}};\r
6572  TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";\r
6573  diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();  \r
6574  TH1D *diffFlowSumOfEventWeights[2][2][2][4] = {{{{NULL}}}};\r
6575  for(Int_t t=0;t<2;t++) // type is RP or POI\r
6576  { \r
6577   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6578   { \r
6579    for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2\r
6580    {\r
6581     diffFlowSumOfEventWeightsHistList[t][pe][p] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of %s event weights (%s, %s)",powerFlag[p].Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6582     if(!diffFlowSumOfEventWeightsHistList[t][pe][p])\r
6583     { \r
6584      cout<<"WARNING: diffFlowSumOfEventWeightsHistList[t][pe][p] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6585      cout<<"t     = "<<t<<endl;\r
6586      cout<<"pe    = "<<pe<<endl;\r
6587      cout<<"power = "<<p<<endl;\r
6588      exit(0);\r
6589     }\r
6590     for(Int_t ew=0;ew<4;ew++) // index of reduced correlation\r
6591     {\r
6592      diffFlowSumOfEventWeights[t][pe][p][ew] = dynamic_cast<TH1D*>(diffFlowSumOfEventWeightsHistList[t][pe][p]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data())));    \r
6593      if(diffFlowSumOfEventWeights[t][pe][p][ew])\r
6594      {\r
6595       this->SetDiffFlowSumOfEventWeights(diffFlowSumOfEventWeights[t][pe][p][ew],t,pe,p,ew);\r
6596      } else \r
6597        {\r
6598         cout<<"WARNING: diffFlowSumOfEventWeights[t][pe][p][ew] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6599         cout<<"t     = "<<t<<endl;\r
6600         cout<<"pe    = "<<pe<<endl;\r
6601         cout<<"power = "<<p<<endl;\r
6602         cout<<"ew    = "<<ew<<endl;\r
6603         exit(0);       \r
6604        } \r
6605     }\r
6606    } // end of for(Int_t p=0;p<2;p++) // power of event weights is either 1 or 2\r
6607   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6608  } // end of for(Int_t t=0;t<2;t++) // type is RP or POI\r
6609  //  \r
6610  TList *diffFlowSumOfProductOfEventWeightsHistList[2][2] = {{NULL}};\r
6611  TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";\r
6612  diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();  \r
6613  TH1D *diffFlowSumOfProductOfEventWeights[2][2][8][8] = {{{{NULL}}}};\r
6614  for(Int_t t=0;t<2;t++) // type is RP or POI\r
6615  { \r
6616   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6617   { \r
6618    diffFlowSumOfProductOfEventWeightsHistList[t][pe] = dynamic_cast<TList*>(diffFlowListResults->FindObject(Form("Sum of products of event weights (%s, %s)",typeFlag[t].Data(),ptEtaFlag[pe].Data())));\r
6619    if(!diffFlowSumOfProductOfEventWeightsHistList[t][pe])\r
6620    { \r
6621     cout<<"WARNING: diffFlowSumOfProductOfEventWeightsHistList[t][pe] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6622     cout<<"t     = "<<t<<endl;\r
6623     cout<<"pe    = "<<pe<<endl;\r
6624     exit(0);\r
6625    }\r
6626    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6627    {\r
6628     for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6629     {\r
6630      diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = dynamic_cast<TH1D*>(diffFlowSumOfProductOfEventWeightsHistList[t][pe]->FindObject(Form("%s, %s, %s, %s, %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data())));    \r
6631       if(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2])\r
6632       {\r
6633        this->SetDiffFlowSumOfProductOfEventWeights(diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2],t,pe,mci1,mci2);\r
6634       } else \r
6635         {\r
6636          cout<<"WARNING: diffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
6637          cout<<"t    = "<<t<<endl;\r
6638          cout<<"pe   = "<<pe<<endl;\r
6639          cout<<"mci1 = "<<mci1<<endl;\r
6640          cout<<"mci2 = "<<mci2<<endl;\r
6641          exit(0);       \r
6642         } \r
6643      if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6644     } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6645    } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6646   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6647  } // end of for(Int_t t=0;t<2;t++) // type is RP or POI\r
6648 \r
6649 } // end void AliFlowAnalysisWithQCumulants::GetPointersForDiffFlowHistograms(TList *outputListHistos)\r
6650 \r
6651 \r
6652 //================================================================================================================================\r
6653 \r
6654 \r
6655 void AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()\r
6656 {\r
6657  // Book all histograms and profiles needed for differential flow.\r
6658  //  a) Define flags locally (to be improved: should I promote flags to data members?);\r
6659  //  b) Book profile to hold all flags for differential flow;\r
6660  //  c) Book e-b-e quantities;\r
6661  //  d) Book profiles;\r
6662  //  e) Book histograms holding final results. \r
6663  \r
6664  // a) Define flags locally (to be improved: should I promote flags to data members?): \r
6665  TString typeFlag[2] = {"RP","POI"}; \r
6666  TString ptEtaFlag[2] = {"p_{T}","#eta"};\r
6667  TString powerFlag[2] = {"linear","quadratic"};\r
6668  TString sinCosFlag[2] = {"sin","cos"};\r
6669  TString differentialCumulantIndex[4] = {"QC{2'}","QC{4'}","QC{6'}","QC{8'}"};  \r
6670  TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};  \r
6671  TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"};\r
6672  TString mixedCorrelationIndex[8] = {"<2>","<2'>","<4>","<4'>","<6>","<6'>","<8>","<8'>"};\r
6673  TString covarianceName[5] = {"Cov(<2>,<2'>)","Cov(<2>,<4'>)","Cov(<4>,<2'>)","Cov(<4>,<4'>)","Cov(<2'>,<4'>)"}; \r
6674  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
6675  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
6676  Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
6677   \r
6678  // b) Book profile to hold all flags for differential flow:\r
6679  TString diffFlowFlagsName = "fDiffFlowFlags";\r
6680  diffFlowFlagsName += fAnalysisLabel->Data();\r
6681  fDiffFlowFlags = new TProfile(diffFlowFlagsName.Data(),"Flags for Differential Flow",4,0,4);\r
6682  fDiffFlowFlags->SetTickLength(-0.01,"Y");\r
6683  fDiffFlowFlags->SetMarkerStyle(25);\r
6684  fDiffFlowFlags->SetLabelSize(0.05);\r
6685  fDiffFlowFlags->SetLabelOffset(0.02,"Y");\r
6686  (fDiffFlowFlags->GetXaxis())->SetBinLabel(1,"Particle Weights");\r
6687  (fDiffFlowFlags->GetXaxis())->SetBinLabel(2,"Event Weights");\r
6688  (fDiffFlowFlags->GetXaxis())->SetBinLabel(3,"Corrected for NUA?");\r
6689  (fDiffFlowFlags->GetXaxis())->SetBinLabel(4,"Calculated 2D flow?");\r
6690  fDiffFlowList->Add(fDiffFlowFlags);\r
6691 \r
6692  // c) Book e-b-e quantities:\r
6693  // Event-by-event r_{m*n,k}(pt,eta), p_{m*n,k}(pt,eta) and q_{m*n,k}(pt,eta)\r
6694  // Explanantion of notation:\r
6695  //  1.) n is harmonic, m is multiple of harmonic;\r
6696  //  2.) k is power of particle weight;\r
6697  //  3.) r_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for RPs in particular (pt,eta) bin (i-th RP is weighted with w_i^k);   \r
6698  //  4.) p_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for POIs in particular (pt,eta) bin \r
6699  //                          (if i-th POI is also RP, than it is weighted with w_i^k);   \r
6700  //  5.) q_{m*n,k}(pt,eta) = Q-vector evaluated in harmonic m*n for particles which are both RPs and POIs in particular (pt,eta) bin \r
6701  //                          (i-th RP&&POI is weighted with w_i^k)            \r
6702   \r
6703  // 1D:\r
6704  for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP && POI )\r
6705  { \r
6706   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6707   {\r
6708    for(Int_t m=0;m<4;m++) // multiple of harmonic\r
6709    {\r
6710     for(Int_t k=0;k<9;k++) // power of particle weight\r
6711     {\r
6712      fReRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),\r
6713                                              Form("TypeFlag%dpteta%dmultiple%dpower%dRe",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6714      fImRPQ1dEBE[t][pe][m][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),\r
6715                                              Form("TypeFlag%dpteta%dmultiple%dpower%dIm",t,pe,m,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6716     }\r
6717    }\r
6718   }\r
6719  } \r
6720  // to be improved (add explanation of fs1dEBE[t][pe][k]):   \r
6721  for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6722  { \r
6723   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6724   {\r
6725    for(Int_t k=0;k<9;k++) // power of particle weight\r
6726    {\r
6727     fs1dEBE[t][pe][k] = new TProfile(Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),\r
6728                                      Form("TypeFlag%dpteta%dmultiple%d",t,pe,k),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6729    }\r
6730   }\r
6731  }\r
6732  // correction terms for nua:\r
6733  for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6734  { \r
6735   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6736   {\r
6737    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6738    {\r
6739     for(Int_t cti=0;cti<9;cti++) // correction term index\r
6740     {\r
6741      fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti] = new TH1D(Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),\r
6742                                              Form("typeFlag%d pteta%d sincos%d cti%d",t,pe,sc,cti),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6743     }\r
6744    }\r
6745   }\r
6746  } \r
6747  // 2D:\r
6748  TProfile2D styleRe("typeMultiplePowerRe","typeMultiplePowerRe",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6749  TProfile2D styleIm("typeMultiplePowerIm","typeMultiplePowerIm",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6750  for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6751  { \r
6752   for(Int_t m=0;m<4;m++)\r
6753   {\r
6754    for(Int_t k=0;k<9;k++)\r
6755    {\r
6756     fReRPQ2dEBE[t][m][k] = (TProfile2D*)styleRe.Clone(Form("typeFlag%dmultiple%dpower%dRe",t,m,k)); \r
6757     fImRPQ2dEBE[t][m][k] = (TProfile2D*)styleIm.Clone(Form("typeFlag%dmultiple%dpower%dIm",t,m,k));\r
6758    }\r
6759   } \r
6760  } \r
6761  TProfile2D styleS("typePower","typePower",fnBinsPt,fPtMin,fPtMax,fnBinsEta,fEtaMin,fEtaMax);\r
6762  for(Int_t t=0;t<3;t++) // typeFlag (0 = RP, 1 = POI, 2 = RP&&POI )\r
6763  { \r
6764   for(Int_t k=0;k<9;k++)\r
6765   {\r
6766    fs2dEBE[t][k] = (TProfile2D*)styleS.Clone(Form("typeFlag%dpower%d",t,k));\r
6767   }\r
6768  }\r
6769  // reduced correlations e-b-e:\r
6770  TString diffFlowCorrelationsEBEName = "fDiffFlowCorrelationsEBE";\r
6771  diffFlowCorrelationsEBEName += fAnalysisLabel->Data();\r
6772  for(Int_t t=0;t<2;t++) // type: RP or POI\r
6773  { \r
6774   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6775   {\r
6776    for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
6777    {\r
6778     fDiffFlowCorrelationsEBE[t][pe][rci] = new TH1D(Form("%s, %s, %s, %s",diffFlowCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6779    } // end of for(Int_t ci=0;ci<4;ci++) // correlation index\r
6780   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6781  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6782  // event weights for reduced correlations e-b-e:\r
6783  TString diffFlowEventWeightsForCorrelationsEBEName = "fDiffFlowEventWeightsForCorrelationsEBE";\r
6784  diffFlowEventWeightsForCorrelationsEBEName += fAnalysisLabel->Data();\r
6785  for(Int_t t=0;t<2;t++) // type: RP or POI\r
6786  { \r
6787   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6788   {\r
6789    for(Int_t rci=0;rci<4;rci++) // event weight for reduced correlation index\r
6790    {\r
6791     fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci] = new TH1D(Form("%s, %s, %s, eW for %s",diffFlowEventWeightsForCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, eW for %s",diffFlowEventWeightsForCorrelationsEBEName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6792    } // end of for(Int_t ci=0;ci<4;ci++) // correlation index\r
6793   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6794  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6795       \r
6796  // d) Book profiles;\r
6797  // reduced correlations:\r
6798  TString diffFlowCorrelationsProName = "fDiffFlowCorrelationsPro";\r
6799  diffFlowCorrelationsProName += fAnalysisLabel->Data();\r
6800  // corrections terms:\r
6801  TString diffFlowCorrectionTermsForNUAProName = "fDiffFlowCorrectionTermsForNUAPro";\r
6802  diffFlowCorrectionTermsForNUAProName += fAnalysisLabel->Data();\r
6803  for(Int_t t=0;t<2;t++) // type: RP or POI\r
6804  { \r
6805   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6806   {\r
6807    for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
6808    {\r
6809     // reduced correlations:\r
6810     fDiffFlowCorrelationsPro[t][pe][rci] = new TProfile(Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[rci].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe],"s");\r
6811     fDiffFlowCorrelationsPro[t][pe][rci]->SetXTitle(ptEtaFlag[pe].Data());\r
6812     fDiffFlowCorrelationsProList[t][pe]->Add(fDiffFlowCorrelationsPro[t][pe][rci]); // to be improved (add dedicated list to hold reduced correlations)\r
6813    } // end of for(Int_t rci=0;rci<4;rci++) // correlation index\r
6814   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6815  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6816  // correction terms for nua:\r
6817  for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6818  { \r
6819   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6820   {\r
6821    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6822    {\r
6823     for(Int_t cti=0;cti<9;cti++) // correction term index\r
6824     {\r
6825      fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti] = new TProfile(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6826      fDiffFlowCorrectionsProList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]);\r
6827     }\r
6828    }\r
6829   }\r
6830  } \r
6831  // e) Book histograms holding final results. \r
6832  // reduced correlations:\r
6833  TString diffFlowCorrelationsHistName = "fDiffFlowCorrelationsHist";\r
6834  diffFlowCorrelationsHistName += fAnalysisLabel->Data();\r
6835  // corrections terms:\r
6836  TString diffFlowCorrectionTermsForNUAHistName = "fDiffFlowCorrectionTermsForNUAHist";\r
6837  diffFlowCorrectionTermsForNUAHistName += fAnalysisLabel->Data();\r
6838  // differential covariances:\r
6839  TString diffFlowCovariancesName = "fDiffFlowCovariances";\r
6840  diffFlowCovariancesName += fAnalysisLabel->Data();\r
6841  // differential Q-cumulants:\r
6842  TString diffFlowCumulantsName = "fDiffFlowCumulants";\r
6843  diffFlowCumulantsName += fAnalysisLabel->Data();\r
6844  // differential flow:\r
6845  TString diffFlowName = "fDiffFlow";\r
6846  diffFlowName += fAnalysisLabel->Data();\r
6847  for(Int_t t=0;t<2;t++) // type: RP or POI\r
6848  { \r
6849   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6850   {\r
6851    for(Int_t index=0;index<4;index++) \r
6852    {\r
6853     // reduced correlations:\r
6854     fDiffFlowCorrelationsHist[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowCorrelationsHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6855     fDiffFlowCorrelationsHist[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6856     fDiffFlowCorrelationsHistList[t][pe]->Add(fDiffFlowCorrelationsHist[t][pe][index]); \r
6857     // differential Q-cumulants:\r
6858     fDiffFlowCumulants[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowCumulantsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialCumulantIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6859     fDiffFlowCumulants[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6860     fDiffFlowCumulantsHistList[t][pe]->Add(fDiffFlowCumulants[t][pe][index]); \r
6861     // differential flow estimates from Q-cumulants:\r
6862     fDiffFlow[t][pe][index] = new TH1D(Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data()),Form("%s, %s, %s, %s",diffFlowName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),differentialFlowIndex[index].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6863     fDiffFlow[t][pe][index]->SetXTitle(ptEtaFlag[pe].Data());\r
6864     fDiffFlowHistList[t][pe]->Add(fDiffFlow[t][pe][index]); \r
6865    } // end of for(Int_t index=0;index<4;index++) \r
6866    for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index \r
6867    {\r
6868     // differential covariances:\r
6869     fDiffFlowCovariances[t][pe][covIndex] = new TH1D(Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data()),Form("%s, %s, %s, %s",diffFlowCovariancesName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),covarianceName[covIndex].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);\r
6870     fDiffFlowCovariances[t][pe][covIndex]->SetXTitle(ptEtaFlag[pe].Data());\r
6871     fDiffFlowCovariancesHistList[t][pe]->Add(fDiffFlowCovariances[t][pe][covIndex]); \r
6872    } // end of for(Int_t covIndex=0;covIndex<5;covIndex++) // covariance index\r
6873    // products of both types of correlations: \r
6874    TString diffFlowProductOfCorrelationsProName = "fDiffFlowProductOfCorrelationsPro";\r
6875    diffFlowProductOfCorrelationsProName += fAnalysisLabel->Data();  \r
6876    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6877    {\r
6878     for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6879     {\r
6880      fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2] = new TProfile(Form("%s, %s, %s, %s, %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),Form("%s, %s, %s, %s #times %s",diffFlowProductOfCorrelationsProName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6881      fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());\r
6882      fDiffFlowProductOfCorrelationsProList[t][pe]->Add(fDiffFlowProductOfCorrelationsPro[t][pe][mci1][mci2]); \r
6883      if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6884     } // end of for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6885    } // end of for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index    \r
6886   } // end of for(Int_t pe=0;pe<2;pe++) // pt or eta \r
6887  } // end of for(Int_t t=0;t<2;t++) // type: RP or POI\r
6888  // sums of event weights for reduced correlations: \r
6889  TString diffFlowSumOfEventWeightsName = "fDiffFlowSumOfEventWeights";\r
6890  diffFlowSumOfEventWeightsName += fAnalysisLabel->Data();  \r
6891  for(Int_t t=0;t<2;t++) // type is RP or POI\r
6892  { \r
6893   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6894   { \r
6895    for(Int_t p=0;p<2;p++) // power of weights is either 1 or 2\r
6896    {\r
6897     for(Int_t ew=0;ew<4;ew++) // index of reduced correlation\r
6898     {\r
6899      fDiffFlowSumOfEventWeights[t][pe][p][ew] = new TH1D(Form("%s, %s, %s, %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data()),Form("%s, %s, %s, power = %s, %s",diffFlowSumOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),powerFlag[p].Data(),reducedCorrelationIndex[ew].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6900      fDiffFlowSumOfEventWeights[t][pe][p][ew]->SetXTitle(ptEtaFlag[pe].Data());\r
6901      fDiffFlowSumOfEventWeightsHistList[t][pe][p]->Add(fDiffFlowSumOfEventWeights[t][pe][p][ew]); // to be improved (add dedicated list to hold all this)\r
6902     }\r
6903    }\r
6904   }\r
6905  } \r
6906  // sum of products of event weights for both types of correlations: \r
6907  TString diffFlowSumOfProductOfEventWeightsName = "fDiffFlowSumOfProductOfEventWeights";\r
6908  diffFlowSumOfProductOfEventWeightsName += fAnalysisLabel->Data();  \r
6909  for(Int_t t=0;t<2;t++) // type is RP or POI\r
6910  {\r
6911   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6912   { \r
6913    for(Int_t mci1=0;mci1<8;mci1++) // mixed correlation index\r
6914    {\r
6915     for(Int_t mci2=mci1+1;mci2<8;mci2++) // mixed correlation index\r
6916     {\r
6917      fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2] = new TH1D(Form("%s, %s, %s, %s, %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),Form("%s, %s, %s, %s #times %s",diffFlowSumOfProductOfEventWeightsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),mixedCorrelationIndex[mci1].Data(),mixedCorrelationIndex[mci2].Data()),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6918      fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]->SetXTitle(ptEtaFlag[pe].Data());\r
6919      fDiffFlowSumOfProductOfEventWeightsHistList[t][pe]->Add(fDiffFlowSumOfProductOfEventWeights[t][pe][mci1][mci2]); \r
6920      if(mci1%2 == 0) mci2++; // products which DO NOT include reduced correlations are not stored here\r
6921     }\r
6922    }\r
6923   }\r
6924  } \r
6925  // correction terms for nua:\r
6926  for(Int_t t=0;t<2;t++) // typeFlag (0 = RP, 1 = POI)\r
6927  { \r
6928   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
6929   {\r
6930    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
6931    {\r
6932     for(Int_t cti=0;cti<9;cti++) // correction term index\r
6933     {\r
6934      fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti] = new TH1D(Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),Form("%s, %s, %s, %s, cti = %d",diffFlowCorrectionTermsForNUAHistName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1),nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]); \r
6935      fDiffFlowCorrectionsHistList[t][pe]->Add(fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]);\r
6936     }\r
6937    }\r
6938   }\r
6939  } \r
6940           \r
6941 } // end of AliFlowAnalysisWithQCumulants::BookEverythingForDifferentialFlow()\r
6942 \r
6943 \r
6944 //================================================================================================================================\r
6945 \r
6946 /*\r
6947 void AliFlowAnalysisWithQCumulants::CalculateCorrectionsForNUAForIntQcumulants() // to be improved (do I really need this method?)\r
6948 {\r
6949  // Calculate final corrections for non-uniform acceptance for Q-cumulants.\r
6950   \r
6951  // Corrections for non-uniform acceptance are stored in histogram fCorrectionsForNUA,\r
6952  // binning of fCorrectionsForNUA is organized as follows:\r
6953  //\r
6954  // 1st bin: correction to QC{2}\r
6955  // 2nd bin: correction to QC{4}\r
6956  // 3rd bin: correction to QC{6}\r
6957  // 4th bin: correction to QC{8}\r
6958   \r
6959  // shortcuts flags:\r
6960  Int_t pW = (Int_t)(useParticleWeights);\r
6961  \r
6962  Int_t eW = -1;\r
6963  \r
6964  if(eventWeights == "exact")\r
6965  {\r
6966   eW = 0;\r
6967  }\r
6968 \r
6969  for(Int_t sc=0;sc<2;sc++) // sin or cos terms flag\r
6970  {\r
6971   if(!(fQCorrelations[pW][eW] && fQCorrections[pW][eW][sc] && fCorrections[pW][eW]))\r
6972   {\r
6973    cout<<"WARNING: fQCorrelations[pW][eW] && fQCorrections[pW][eW][sc] && fCorrections[pW][eW] is NULL in AFAWQC::CFCFNUAFIF() !!!!"<<endl;\r
6974    cout<<"pW = "<<pW<<endl;\r
6975    cout<<"eW = "<<eW<<endl;\r
6976    cout<<"sc = "<<sc<<endl;\r
6977    exit(0);\r
6978   }\r
6979  }  \r
6980 \r
6981  // measured 2-, 4-, 6- and 8-particle azimuthal correlations (biased with non-uniform acceptance!):\r
6982  Double_t two = fQCorrelations[pW][eW]->GetBinContent(1); // <<2>>\r
6983  //Double_t four = fQCorrelations[pW][eW]->GetBinContent(11); // <<4>>\r
6984  //Double_t six = fQCorrelations[pW][eW]->GetBinContent(24); // <<6>>\r
6985  //Double_t eight = fQCorrelations[pW][eW]->GetBinContent(31); // <<8>>\r
6986  \r
6987  // correction terms to QC{2}:\r
6988  // <<cos(n*phi1)>>^2\r
6989  Double_t two1stTerm = pow(fQCorrections[pW][eW][1]->GetBinContent(1),2); \r
6990  // <<sin(n*phi1)>>^2\r
6991  Double_t two2ndTerm = pow(fQCorrections[pW][eW][0]->GetBinContent(1),2); \r
6992  // final corrections for non-uniform acceptance to QC{2}:\r
6993  Double_t correctionQC2 = -1.*two1stTerm-1.*two2ndTerm;\r
6994  fCorrections[pW][eW]->SetBinContent(1,correctionQC2); \r
6995  \r
6996  // correction terms to QC{4}:\r
6997  // <<cos(n*phi1)>> <<cos(n*(phi1-phi2-phi3))>>\r
6998  Double_t four1stTerm = fQCorrections[pW][eW][1]->GetBinContent(1)*fQCorrections[pW][eW][1]->GetBinContent(3);  \r
6999  // <<sin(n*phi1)>> <<sin(n*(phi1-phi2-phi3))>>\r
7000  Double_t four2ndTerm = fQCorrections[pW][eW][0]->GetBinContent(1)*fQCorrections[pW][eW][0]->GetBinContent(3);  \r
7001  // <<cos(n*(phi1+phi2))>>^2\r
7002  Double_t four3rdTerm = pow(fQCorrections[pW][eW][1]->GetBinContent(2),2); \r
7003  // <<sin(n*(phi1+phi2))>>^2\r
7004  Double_t four4thTerm = pow(fQCorrections[pW][eW][0]->GetBinContent(2),2); \r
7005  // <<cos(n*(phi1+phi2))>> (<<cos(n*phi1)>>^2 - <<sin(n*phi1)>>^2)\r
7006  Double_t four5thTerm = fQCorrections[pW][eW][1]->GetBinContent(2)\r
7007                       * (pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)-pow(fQCorrections[pW][eW][0]->GetBinContent(1),2));\r
7008  // <<sin(n*(phi1+phi2))>> <<cos(n*phi1)>> <<sin(n*phi1)>>\r
7009  Double_t four6thTerm = fQCorrections[pW][eW][0]->GetBinContent(2)\r
7010                       * fQCorrections[pW][eW][1]->GetBinContent(1)\r
7011                       * fQCorrections[pW][eW][0]->GetBinContent(1);         \r
7012  // <<cos(n*(phi1-phi2))>> (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)\r
7013  Double_t four7thTerm = two*(pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)+pow(fQCorrections[pW][eW][0]->GetBinContent(1),2));  \r
7014  // (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)^2\r
7015  Double_t four8thTerm = pow(pow(fQCorrections[pW][eW][1]->GetBinContent(1),2)+pow(fQCorrections[pW][eW][0]->GetBinContent(1),2),2);      \r
7016  // final correction to QC{4}:\r
7017  Double_t correctionQC4 = -4.*four1stTerm+4.*four2ndTerm-four3rdTerm-four4thTerm\r
7018                         + 4.*four5thTerm+8.*four6thTerm+8.*four7thTerm-6.*four8thTerm;                            \r
7019  fCorrections[pW][eW]->SetBinContent(2,correctionQC4);   \r
7020 \r
7021  // ... to be improved (continued for 6th and 8th order)                                                    \r
7022 \r
7023 \r
7024 } // end of AliFlowAnalysisWithQCumulants::CalculateCorrectionsForNUAForIntQcumulants()\r
7025 */\r
7026 \r
7027 //================================================================================================================================\r
7028 \r
7029 \r
7030 void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()\r
7031 {\r
7032  // Calculate generalized Q-cumulants (cumulants corrected for non-unifom acceptance).\r
7033  \r
7034  // measured 2-, 4-, 6- and 8-particle correlations (biased by non-uniform acceptance!):\r
7035  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
7036  Double_t four = fIntFlowCorrelationsHist->GetBinContent(2); // <<4>>\r
7037  //Double_t six = fIntFlowCorrelationsHist->GetBinContent(3); // <<6>>\r
7038  //Double_t eight = fIntFlowCorrelationsHist->GetBinContent(4); // <<8>>\r
7039  \r
7040  // statistical error of measured 2-, 4-, 6- and 8-particle correlations:\r
7041  //Double_t twoError = fIntFlowCorrelationsHist->GetBinError(1); // statistical error of <<2>>\r
7042  //Double_t fourError = fIntFlowCorrelationsHist->GetBinError(2); // statistical error of <<4>>\r
7043  //Double_t sixError = fIntFlowCorrelationsHist->GetBinError(3); // statistical error of <<6>>\r
7044  //Double_t eightError = fIntFlowCorrelationsHist->GetBinError(4); // statistical error of <<8>>\r
7045 \r
7046  // QC{2}:\r
7047  // <<cos(n*phi1)>>^2\r
7048  Double_t two1stTerm = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2); \r
7049  //Double_t two1stTermErrorSquared = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinError(1),2); \r
7050  // <<sin(n*phi1)>>^2\r
7051  Double_t two2ndTerm = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2); \r
7052  //Double_t two2ndTermErrorSquared = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinError(1),2); \r
7053  // generalized QC{2}:\r
7054  Double_t gQC2 = two - two1stTerm - two2ndTerm; // to be improved (terminology, notation)\r
7055  fIntFlowQcumulants->SetBinContent(1,gQC2); \r
7056  //fIntFlowQcumulants->SetBinError(1,0.); // to be improved (propagate error) \r
7057  \r
7058  // QC{4}:\r
7059  // <<cos(n*phi1)>> <<cos(n*(phi1-phi2-phi3))>>\r
7060  Double_t four1stTerm = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1)\r
7061                       * fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3);  \r
7062  // <<sin(n*phi1)>> <<sin(n*(phi1-phi2-phi3))>>\r
7063  Double_t four2ndTerm = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1)\r
7064                       * fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3);  \r
7065  // <<cos(n*(phi1+phi2))>>^2\r
7066  Double_t four3rdTerm = pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2),2); \r
7067  // <<sin(n*(phi1+phi2))>>^2\r
7068  Double_t four4thTerm = pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2),2); \r
7069  // <<cos(n*(phi1+phi2))>> (<<cos(n*phi1)>>^2 - <<sin(n*phi1)>>^2)\r
7070  Double_t four5thTerm = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2)\r
7071                       * (pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
7072                       - pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2));\r
7073  // <<sin(n*(phi1+phi2))>> <<cos(n*phi1)>> <<sin(n*phi1)>>\r
7074  Double_t four6thTerm = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2)\r
7075                       * fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1)\r
7076                       * fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1);         \r
7077  // <<cos(n*(phi1-phi2))>> (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)\r
7078  Double_t four7thTerm = two*(pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
7079                       + pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2));  \r
7080  // (<<cos(n*phi1)>>^2 + <<sin(n*phi1)>>^2)^2\r
7081  Double_t four8thTerm = pow(pow(fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1),2)\r
7082                       + pow(fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1),2),2);      \r
7083  // generalized QC{4}:\r
7084  Double_t gQC4 = four-2.*pow(two,2.)-4.*four1stTerm+4.*four2ndTerm-four3rdTerm\r
7085                - four4thTerm+4.*four5thTerm+8.*four6thTerm+8.*four7thTerm-6.*four8thTerm;                            \r
7086  fIntFlowQcumulants->SetBinContent(2,gQC4);   \r
7087  //fIntFlowQcumulants->SetBinError(2,0.); // to be improved (propagate error) \r
7088 \r
7089  // ... to be improved (continued for 6th and 8th order)                                                    \r
7090     \r
7091 } // end of void AliFlowAnalysisWithQCumulants::CalculateQcumulantsCorrectedForNUAIntFlow()\r
7092 \r
7093 \r
7094 //================================================================================================================================\r
7095 \r
7096 \r
7097 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectedForNUA()\r
7098 {\r
7099  // Calculate integrated flow from generalized Q-cumulants (corrected for non-uniform acceptance).\r
7100  \r
7101  // to be improved: add protection for NULL pointers, propagate statistical errors from \r
7102  // measured correlations and correction terms\r
7103  \r
7104  // generalized Q-cumulants:\r
7105  Double_t qc2 = fIntFlowQcumulants->GetBinContent(1); // QC{2}  \r
7106  Double_t qc4 = fIntFlowQcumulants->GetBinContent(2); // QC{4}  \r
7107  //Double_t qc6 = fIntFlowQcumulants->GetBinContent(3); // QC{6}  \r
7108  //Double_t qc8 = fIntFlowQcumulants->GetBinContent(4); // QC{8}\r
7109  \r
7110  // integrated flow estimates:\r
7111  Double_t v2 = 0.; // v{2,QC}  \r
7112  Double_t v4 = 0.; // v{4,QC}  \r
7113  //Double_t v6 = 0.; // v{6,QC}  \r
7114  //Double_t v8 = 0.; // v{8,QC}\r
7115 \r
7116  // calculate integrated flow estimates from generalized Q-cumulants: \r
7117  if(qc2>=0.) v2 = pow(qc2,1./2.); \r
7118  if(qc4<=0.) v4 = pow(-1.*qc4,1./4.); \r
7119  //if(qc6>=0.) v6 = pow((1./4.)*qc6,1./6.); \r
7120  //if(qc8<=0.) v8 = pow((-1./33.)*qc8,1./8.); \r
7121 \r
7122  // store integrated flow estimates from generalized Q-cumulants:\r
7123  fIntFlow->SetBinContent(1,v2);\r
7124  fIntFlow->SetBinContent(2,v4);\r
7125  //fIntFlow->SetBinContent(3,v6);\r
7126  //fIntFlow->SetBinContent(4,v8);\r
7127 \r
7128 } // end of void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectedForNUA()\r
7129 \r
7130    \r
7131 //================================================================================================================================\r
7132 \r
7133 \r
7134 void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow() \r
7135 {\r
7136  // From profile fIntFlowCorrectionTermsForNUAPro[2] access measured corretion terms\r
7137  // and their spread, correctly calculate the statistical errors and store the final \r
7138  // results and statistical errors for correction terms in histogram fIntFlowCorrectionTermsForNUAHist[2].\r
7139  //\r
7140  // Remark: Statistical error of correction temrs is calculated as:\r
7141  //\r
7142  //          statistical error = termA * spread * termB:\r
7143  //          termA = sqrt{sum_{i=1}^{N} w^2}/(sum_{i=1}^{N} w)\r
7144  //          termB = 1/sqrt(1-termA^2)   \r
7145  \r
7146  /* // to be improved (implement protection here)\r
7147  for(Int_t power=0;power<2;power++)\r
7148  { \r
7149   if(!(fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power])) \r
7150   {\r
7151    cout<<"WARNING: fIntFlowCorrelationsHist && fIntFlowCorrelationsPro && fIntFlowSumOfEventWeights[power] is NULL in AFAWQC::FCIF() !!!!"<<endl;\r
7152    cout<<"power = "<<power<<endl;\r
7153    exit(0);\r
7154   }\r
7155  }\r
7156  */\r
7157   \r
7158  for(Int_t sc=0;sc<2;sc++) // sin or cos correction terms \r
7159  {\r
7160   for(Int_t ci=1;ci<=10;ci++) // correction term index\r
7161   {\r
7162    Double_t correction = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci);\r
7163    //Double_t spread = fIntFlowCorrectionTermsForNUAPro[sc]->GetBinError(ci);\r
7164    //Double_t sumOfLinearEventWeights = fIntFlowSumOfEventWeights[0]->GetBinContent(ci);\r
7165    //Double_t sumOfQuadraticEventWeights = fIntFlowSumOfEventWeights[1]->GetBinContent(ci);\r
7166    //Double_t termA = 0.;\r
7167    //Double_t termB = 0.;\r
7168    //if(sumOfLinearEventWeights)\r
7169    //{\r
7170    // termA = pow(sumOfQuadraticEventWeights,0.5)/sumOfLinearEventWeights;\r
7171    //} else\r
7172    // {\r
7173    //  cout<<"WARNING: sumOfLinearEventWeights == 0 in AFAWQC::FCIF() !!!!"<<endl;\r
7174    //  cout<<"         (for "<<2*ci<<"-particle correlation)"<<endl;\r
7175    // }\r
7176    /*\r
7177    if(1.-pow(termA,2.) > 0.)\r
7178    {\r
7179     termB = 1./pow(1-pow(termA,2.),0.5);\r
7180    } else\r
7181      {\r
7182       cout<<"WARNING: 1.-pow(termA,2.) <= 0 in AFAWQC::FCIF() !!!!"<<endl;   \r
7183       cout<<"         (for "<<2*ci<<"-particle correlation)"<<endl;\r
7184      }     \r
7185    Double_t statisticalError = termA * spread * termB;\r
7186    */\r
7187    fIntFlowCorrectionTermsForNUAHist[sc]->SetBinContent(ci,correction);\r
7188    //fIntFlowCorrectionTermsForNUAHist[sc]->SetBinError(ci,statisticalError);\r
7189   } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index\r
7190  } // end of for(Int sc=0;sc<2;sc++) // sin or cos correction terms \r
7191                                                                                                                                                                                                \r
7192 } // end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUAIntFlow()\r
7193 \r
7194 \r
7195 //================================================================================================================================\r
7196 \r
7197 \r
7198 void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms(TList *outputListHistos)\r
7199 {\r
7200  // Get pointers to all objects relevant for calculations with nested loops.\r
7201    \r
7202  if(outputListHistos)\r
7203  {\r
7204   TList *nestedLoopsList = dynamic_cast<TList*>(outputListHistos->FindObject("Nested Loops"));\r
7205   if(nestedLoopsList) \r
7206   {\r
7207    this->SetNestedLoopsList(nestedLoopsList);\r
7208   } else\r
7209     {\r
7210      cout<<"WARNING: nestedLoopsList is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7211      exit(0);\r
7212     }\r
7213     \r
7214   TString sinCosFlag[2] = {"sin","cos"}; // to be improved (should I promote this to data members?)\r
7215   TString typeFlag[2] = {"RP","POI"}; // to be improved (should I promote this to data members?)\r
7216   TString ptEtaFlag[2] = {"p_{T}","#eta"}; // to be improved (should I promote this to data members?)\r
7217   TString reducedCorrelationIndex[4] = {"<2'>","<4'>","<6'>","<8'>"}; // to be improved (should I promote this to data members?)\r
7218    \r
7219   TString evaluateNestedLoopsName = "fEvaluateNestedLoops";\r
7220   evaluateNestedLoopsName += fAnalysisLabel->Data();  \r
7221   TProfile *evaluateNestedLoops = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(evaluateNestedLoopsName.Data()));\r
7222   Bool_t bEvaluateIntFlowNestedLoops = kFALSE;\r
7223   Bool_t bEvaluateDiffFlowNestedLoops = kFALSE;\r
7224   if(evaluateNestedLoops)\r
7225   {\r
7226    this->SetEvaluateNestedLoops(evaluateNestedLoops);\r
7227    bEvaluateIntFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(1);\r
7228    bEvaluateDiffFlowNestedLoops = (Int_t)evaluateNestedLoops->GetBinContent(2);\r
7229   }\r
7230   // nested loops relevant for integrated flow:  \r
7231   if(bEvaluateIntFlowNestedLoops)\r
7232   {\r
7233    // correlations:\r
7234    TString intFlowDirectCorrelationsName = "fIntFlowDirectCorrelations";\r
7235    intFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
7236    TProfile *intFlowDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowDirectCorrelationsName.Data()));\r
7237    if(intFlowDirectCorrelations) \r
7238    { \r
7239     this->SetIntFlowDirectCorrelations(intFlowDirectCorrelations);\r
7240    } else\r
7241      {\r
7242       cout<<"WARNING: intFlowDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7243       exit(0);\r
7244      }\r
7245    if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)  \r
7246    {\r
7247     TString intFlowExtraDirectCorrelationsName = "fIntFlowExtraDirectCorrelations";\r
7248     intFlowExtraDirectCorrelationsName += fAnalysisLabel->Data();\r
7249     TProfile *intFlowExtraDirectCorrelations = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(intFlowExtraDirectCorrelationsName.Data()));\r
7250     if(intFlowExtraDirectCorrelations) \r
7251     { \r
7252      this->SetIntFlowExtraDirectCorrelations(intFlowExtraDirectCorrelations);\r
7253     } else\r
7254       {\r
7255        cout<<"WARNING: intFlowExtraDirectCorrelations is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7256        exit(0);\r
7257       }       \r
7258    } // end of if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)  \r
7259    // correction terms for non-uniform acceptance:\r
7260    TString intFlowDirectCorrectionTermsForNUAName = "fIntFlowDirectCorrectionTermsForNUA";\r
7261    intFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();\r
7262    TProfile *intFlowDirectCorrectionTermsForNUA[2] = {NULL};\r
7263    for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
7264    {\r
7265     intFlowDirectCorrectionTermsForNUA[sc] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s: %s terms",intFlowDirectCorrectionTermsForNUAName.Data(),sinCosFlag[sc].Data())));\r
7266     if(intFlowDirectCorrectionTermsForNUA[sc]) \r
7267     { \r
7268      this->SetIntFlowDirectCorrectionTermsForNUA(intFlowDirectCorrectionTermsForNUA[sc],sc);\r
7269     } else\r
7270       {\r
7271        cout<<"WARNING: intFlowDirectCorrectionTermsForNUA[sc] is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7272        cout<<"sc = "<<sc<<endl;\r
7273        exit(0);\r
7274       }\r
7275    } // end of for(Int_t sc=0;sc<2;sc++) \r
7276   } // end of if(bEvaluateIntFlowNestedLoops)\r
7277     \r
7278   // nested loops relevant for differential flow:  \r
7279   if(bEvaluateDiffFlowNestedLoops)\r
7280   {\r
7281    // correlations:\r
7282    TString diffFlowDirectCorrelationsName = "fDiffFlowDirectCorrelations";\r
7283    diffFlowDirectCorrelationsName += fAnalysisLabel->Data();\r
7284    TProfile *diffFlowDirectCorrelations[2][2][4] = {{{NULL}}};\r
7285    for(Int_t t=0;t<2;t++)\r
7286    {\r
7287     for(Int_t pe=0;pe<2;pe++)\r
7288     {\r
7289      for(Int_t ci=0;ci<4;ci++) // correlation index\r
7290      {\r
7291       diffFlowDirectCorrelations[t][pe][ci] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s, %s, %s, %s",diffFlowDirectCorrelationsName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),reducedCorrelationIndex[ci].Data())));\r
7292       if(diffFlowDirectCorrelations[t][pe][ci])\r
7293       {\r
7294        this->SetDiffFlowDirectCorrelations(diffFlowDirectCorrelations[t][pe][ci],t,pe,ci);\r
7295       } else\r
7296         {\r
7297          cout<<"WARNING: diffFlowDirectCorrelations[t][pe][ci] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
7298          cout<<"t  = "<<t<<endl;\r
7299          cout<<"pe = "<<pe<<endl;   \r
7300          cout<<"ci = "<<ci<<endl;\r
7301         }     \r
7302      } // end of for(Int_t ci=0;ci<4;ci++) // correlation index  \r
7303     } // end of for(Int_t pe=0;pe<2;pe++)\r
7304    } // end of for(Int_t t=0;t<2;t++)   \r
7305    // correction terms for non-uniform acceptance:\r
7306    TString diffFlowDirectCorrectionTermsForNUAName = "fDiffFlowDirectCorrectionTermsForNUA";\r
7307    diffFlowDirectCorrectionTermsForNUAName += fAnalysisLabel->Data();  \r
7308    TProfile *diffFlowDirectCorrectionTermsForNUA[2][2][2][10] = {{{{NULL}}}};   \r
7309    for(Int_t t=0;t<2;t++)\r
7310    {\r
7311     for(Int_t pe=0;pe<2;pe++)\r
7312     {\r
7313      // correction terms for NUA:\r
7314      for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7315      {\r
7316       for(Int_t cti=0;cti<9;cti++) // correction term index\r
7317       {\r
7318        diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] = dynamic_cast<TProfile*>(nestedLoopsList->FindObject(Form("%s, %s, %s, %s, cti = %d",diffFlowDirectCorrectionTermsForNUAName.Data(),typeFlag[t].Data(),ptEtaFlag[pe].Data(),sinCosFlag[sc].Data(),cti+1)));\r
7319        if(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti])\r
7320        {\r
7321         this->SetDiffFlowDirectCorrectionTermsForNUA(diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti],t,pe,sc,cti);\r
7322        } else\r
7323          {\r
7324           cout<<"WARNING: diffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti] is NULL in AFAWQC::GPFDFH() !!!!"<<endl;\r
7325           cout<<"t   = "<<t<<endl;\r
7326           cout<<"pe  = "<<pe<<endl;   \r
7327           cout<<"sc  = "<<sc<<endl;\r
7328           cout<<"cti = "<<cti<<endl;\r
7329          }    \r
7330       } // end of for(Int_t cti=0;cti<9;cti++) // correction term index\r
7331      } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7332     } // end of for(Int_t pe=0;pe<2;pe++)\r
7333    } // end of for(Int_t t=0;t<2;t++)\r
7334   } // end of if(bEvaluateDiffFlowNestedLoops)\r
7335  } else // to if(outputListHistos)\r
7336    {\r
7337     cout<<"WARNING: outputListHistos is NULL in AFAWQC::GPFNLH() !!!!"<<endl;\r
7338     exit(0);\r
7339    }\r
7340 \r
7341 } // end of void AliFlowAnalysisWithQCumulants::GetPointersForNestedLoopsHistograms(TList *outputListHistos)\r
7342 \r
7343 \r
7344 //================================================================================================================================\r
7345 \r
7346 \r
7347 void AliFlowAnalysisWithQCumulants::StoreHarmonic()\r
7348 {\r
7349  // Store flow harmonic in common control histograms.\r
7350 \r
7351  (fCommonHists->GetHarmonic())->Fill(0.5,fHarmonic);\r
7352  (fCommonHists2nd->GetHarmonic())->Fill(0.5,fHarmonic);\r
7353  (fCommonHists4th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7354  (fCommonHists6th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7355  (fCommonHists8th->GetHarmonic())->Fill(0.5,fHarmonic);\r
7356 \r
7357 } // end of void AliFlowAnalysisWithQCumulants::StoreHarmonic()\r
7358 \r
7359 \r
7360 //================================================================================================================================\r
7361 \r
7362 \r
7363 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta) // type = RP or POI \r
7364 {\r
7365  // Calculate all correlations needed for differential flow using particle weights.\r
7366  \r
7367  Int_t t = -1; // type flag \r
7368  Int_t pe = -1; // ptEta flag\r
7369  \r
7370  if(type == "RP")\r
7371  {\r
7372   t = 0;\r
7373  } else if(type == "POI")\r
7374    {\r
7375     t = 1;\r
7376    }\r
7377 \r
7378  if(ptOrEta == "Pt")\r
7379  {\r
7380   pe = 0;\r
7381  } else if(ptOrEta == "Eta")\r
7382    {\r
7383     pe = 1;\r
7384    }\r
7385     \r
7386  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7387  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7388  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7389  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7390 \r
7391  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7392  Double_t dReQ1n1k = (*fReQ)(0,1);\r
7393  Double_t dReQ2n2k = (*fReQ)(1,2);\r
7394  Double_t dReQ1n3k = (*fReQ)(0,3);\r
7395  //Double_t dReQ4n4k = (*fReQ)(3,4);\r
7396  Double_t dImQ1n1k = (*fImQ)(0,1);\r
7397  Double_t dImQ2n2k = (*fImQ)(1,2);\r
7398  Double_t dImQ1n3k = (*fImQ)(0,3);\r
7399  //Double_t dImQ4n4k = (*fImQ)(3,4);\r
7400  \r
7401  // S^M_{p,k} (see .h file for the definition of fSMpk):\r
7402  Double_t dSM1p1k = (*fSMpk)(0,1);\r
7403  Double_t dSM1p2k = (*fSMpk)(0,2);\r
7404  Double_t dSM1p3k = (*fSMpk)(0,3);\r
7405  Double_t dSM2p1k = (*fSMpk)(1,1);\r
7406  Double_t dSM3p1k = (*fSMpk)(2,1);\r
7407  \r
7408  // looping over all bins and calculating reduced correlations: \r
7409  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7410  {\r
7411   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular (pt,eta) bin):  \r
7412   Double_t p1n0kRe = 0.;\r
7413   Double_t p1n0kIm = 0.;\r
7414 \r
7415   // number of POIs in particular (pt,eta) bin):\r
7416   Double_t mp = 0.;\r
7417 \r
7418   // real and imaginary parts of q_{m*n,k}: \r
7419   // (weighted Q-vector evaluated for particles which are both RPs and POIs in particular (pt,eta) bin)\r
7420   Double_t q1n2kRe = 0.;\r
7421   Double_t q1n2kIm = 0.;\r
7422   Double_t q2n1kRe = 0.;\r
7423   Double_t q2n1kIm = 0.;\r
7424 \r
7425   // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
7426   Double_t s1p1k = 0.; \r
7427   Double_t s1p2k = 0.; \r
7428   Double_t s1p3k = 0.; \r
7429    \r
7430   // M0111 from Eq. (118) in QC2c (to be improved (notation))\r
7431   Double_t dM0111 = 0.;\r
7432  \r
7433   if(type == "POI")\r
7434   {\r
7435    p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7436            * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7437    p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
7438            * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7439             \r
7440    mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7441     \r
7442    t = 1; // typeFlag = RP or POI\r
7443     \r
7444    // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!)) \r
7445    q1n2kRe = fReRPQ1dEBE[2][pe][0][2]->GetBinContent(fReRPQ1dEBE[2][pe][0][2]->GetBin(b))\r
7446            * fReRPQ1dEBE[2][pe][0][2]->GetBinEntries(fReRPQ1dEBE[2][pe][0][2]->GetBin(b));\r
7447    q1n2kIm = fImRPQ1dEBE[2][pe][0][2]->GetBinContent(fImRPQ1dEBE[2][pe][0][2]->GetBin(b))\r
7448            * fImRPQ1dEBE[2][pe][0][2]->GetBinEntries(fImRPQ1dEBE[2][pe][0][2]->GetBin(b));\r
7449    q2n1kRe = fReRPQ1dEBE[2][pe][1][1]->GetBinContent(fReRPQ1dEBE[2][pe][1][1]->GetBin(b))\r
7450            * fReRPQ1dEBE[2][pe][1][1]->GetBinEntries(fReRPQ1dEBE[2][pe][1][1]->GetBin(b));\r
7451    q2n1kIm = fImRPQ1dEBE[2][pe][1][1]->GetBinContent(fImRPQ1dEBE[2][pe][1][1]->GetBin(b))\r
7452            * fImRPQ1dEBE[2][pe][1][1]->GetBinEntries(fImRPQ1dEBE[2][pe][1][1]->GetBin(b));\r
7453        \r
7454    // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
7455    s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.); \r
7456    s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.); \r
7457    s1p3k = pow(fs1dEBE[2][pe][3]->GetBinContent(b)*fs1dEBE[2][pe][3]->GetBinEntries(b),1.); \r
7458      \r
7459    // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
7460    dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
7461           - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
7462           + 2.*(s1p3k-s1p2k*dSM1p1k));\r
7463   }\r
7464    else if(type == "RP")\r
7465    {\r
7466     // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!)) \r
7467     q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
7468             * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
7469     q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
7470             * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
7471     q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
7472             * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
7473     q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
7474             * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
7475 \r
7476     // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
7477     s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.); \r
7478     s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.); \r
7479     s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.); \r
7480     \r
7481     // to be improved (cross-checked):\r
7482     p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7483             * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7484     p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))  \r
7485             * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7486             \r
7487     mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7488      \r
7489     t = 0; // typeFlag = RP or POI\r
7490     \r
7491     // M0111 from Eq. (118) in QC2c (to be improved (notation)):\r
7492     dM0111 = mp*(dSM3p1k-3.*dSM1p1k*dSM1p2k+2.*dSM1p3k)\r
7493            - 3.*(s1p1k*(dSM2p1k-dSM1p2k)\r
7494            + 2.*(s1p3k-s1p2k*dSM1p1k));\r
7495     //...............................................................................................   \r
7496    }\r
7497    \r
7498    // 2'-particle correlation:\r
7499    Double_t two1n1nW0W1 = 0.;\r
7500    if(mp*dSM1p1k-s1p1k)\r
7501    {\r
7502     two1n1nW0W1 = (p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k-s1p1k)\r
7503                 / (mp*dSM1p1k-s1p1k);\r
7504    \r
7505     // fill profile to get <<2'>>     \r
7506     fDiffFlowCorrelationsPro[t][pe][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],two1n1nW0W1,mp*dSM1p1k-s1p1k);\r
7507     // histogram to store <2'> e-b-e (needed in some other methods):\r
7508     fDiffFlowCorrelationsEBE[t][pe][0]->SetBinContent(b,two1n1nW0W1);      \r
7509     fDiffFlowEventWeightsForCorrelationsEBE[t][pe][0]->SetBinContent(b,mp*dSM1p1k-s1p1k);      \r
7510    } // end of if(mp*dSM1p1k-s1p1k)\r
7511    \r
7512    // 4'-particle correlation:\r
7513    Double_t four1n1n1n1nW0W1W1W1 = 0.;\r
7514    if(dM0111)\r
7515    {\r
7516     four1n1n1n1nW0W1W1W1 = ((pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
7517                          - q2n1kRe*(pow(dReQ1n1k,2.)-pow(dImQ1n1k,2.))\r
7518                          - 2.*q2n1kIm*dReQ1n1k*dImQ1n1k\r
7519                          - p1n0kRe*(dReQ1n1k*dReQ2n2k+dImQ1n1k*dImQ2n2k)\r
7520                          + p1n0kIm*(dImQ1n1k*dReQ2n2k-dReQ1n1k*dImQ2n2k)\r
7521                          - 2.*dSM1p2k*(p1n0kRe*dReQ1n1k+p1n0kIm*dImQ1n1k)\r
7522                          - 2.*(pow(dReQ1n1k,2.)+pow(dImQ1n1k,2.))*s1p1k                                            \r
7523                          + 6.*(q1n2kRe*dReQ1n1k+q1n2kIm*dImQ1n1k)                                           \r
7524                          + 1.*(q2n1kRe*dReQ2n2k+q2n1kIm*dImQ2n2k)                         \r
7525                          + 2.*(p1n0kRe*dReQ1n3k+p1n0kIm*dImQ1n3k)                      \r
7526                          + 2.*s1p1k*dSM1p2k                                      \r
7527                          - 6.*s1p3k)        \r
7528                          / dM0111; // to be improved (notation of dM0111)\r
7529    \r
7530     // fill profile to get <<4'>>     \r
7531     fDiffFlowCorrelationsPro[t][pe][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],four1n1n1n1nW0W1W1W1,dM0111);\r
7532     // histogram to store <4'> e-b-e (needed in some other methods):\r
7533     fDiffFlowCorrelationsEBE[t][pe][1]->SetBinContent(b,four1n1n1n1nW0W1W1W1);      \r
7534     fDiffFlowEventWeightsForCorrelationsEBE[t][pe][1]->SetBinContent(b,dM0111);      \r
7535    } // end of if(dM0111)\r
7536  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7537 \r
7538 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrelationsUsingParticleWeights(TString type, TString ptOrEta); // type = RP or POI \r
7539 \r
7540 \r
7541 //================================================================================================================================\r
7542 \r
7543 \r
7544 void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)\r
7545 {\r
7546  // Fill common control histograms.\r
7547  \r
7548  Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)\r
7549  fCommonHists->FillControlHistograms(anEvent); \r
7550  if(nRP>1)\r
7551  {\r
7552   fCommonHists2nd->FillControlHistograms(anEvent);                                        \r
7553   if(nRP>3)\r
7554   {\r
7555    fCommonHists4th->FillControlHistograms(anEvent);                                        \r
7556    if(nRP>5)\r
7557    {\r
7558     fCommonHists6th->FillControlHistograms(anEvent);                                        \r
7559     if(nRP>7)\r
7560     {\r
7561      fCommonHists8th->FillControlHistograms(anEvent);                                        \r
7562     } // end of if(nRP>7)  \r
7563    } // end of if(nRP>5) \r
7564   } // end of if(nRP>3)                                                                                                                      \r
7565  } // end of if(nRP>1) \r
7566  \r
7567 } // end of void AliFlowAnalysisWithQCumulants::FillCommonControlHistograms(AliFlowEventSimple *anEvent)\r
7568 \r
7569 \r
7570 //================================================================================================================================\r
7571 \r
7572 \r
7573 void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities()\r
7574 {\r
7575  // Reset all event by event quantities.\r
7576  \r
7577  // integrated flow:\r
7578  fReQ->Zero();\r
7579  fImQ->Zero();\r
7580  fSMpk->Zero();\r
7581  fIntFlowCorrelationsEBE->Reset();\r
7582  fIntFlowEventWeightsForCorrelationsEBE->Reset();\r
7583  fIntFlowCorrelationsAllEBE->Reset();\r
7584  \r
7585  if(fApplyCorrectionForNUA)  \r
7586  {\r
7587   for(Int_t sc=0;sc<2;sc++)\r
7588   {\r
7589    fIntFlowCorrectionTermsForNUAEBE[sc]->Reset();\r
7590   } \r
7591  }\r
7592     \r
7593  // differential flow:\r
7594  // 1D:\r
7595  for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
7596  {\r
7597   for(Int_t pe=0;pe<2;pe++) // 1D in pt or eta\r
7598   {\r
7599    for(Int_t m=0;m<4;m++) // multiple of harmonic\r
7600    {\r
7601     for(Int_t k=0;k<9;k++) // power of weight\r
7602     {\r
7603      if(fReRPQ1dEBE[t][pe][m][k]) fReRPQ1dEBE[t][pe][m][k]->Reset();\r
7604      if(fImRPQ1dEBE[t][pe][m][k]) fImRPQ1dEBE[t][pe][m][k]->Reset();\r
7605     }   \r
7606    }\r
7607   }\r
7608  }\r
7609   \r
7610  for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )\r
7611  { \r
7612   for(Int_t pe=0;pe<2;pe++) // 1D in pt or eta\r
7613   {\r
7614    for(Int_t k=0;k<9;k++)\r
7615    {\r
7616     if(fs1dEBE[t][pe][k]) fs1dEBE[t][pe][k]->Reset();\r
7617    }\r
7618   }\r
7619  }\r
7620 \r
7621  // e-b-e reduced correlations:\r
7622  for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)\r
7623  {  \r
7624   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
7625   {\r
7626    for(Int_t rci=0;rci<4;rci++) // reduced correlation index\r
7627    {\r
7628     if(fDiffFlowCorrelationsEBE[t][pe][rci]) fDiffFlowCorrelationsEBE[t][pe][rci]->Reset();\r
7629     if(fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]) fDiffFlowEventWeightsForCorrelationsEBE[t][pe][rci]->Reset();\r
7630    }\r
7631   }\r
7632  }\r
7633     \r
7634  // correction terms for NUA:\r
7635  for(Int_t t=0;t<2;t++) // type (0 = RP, 1 = POI)\r
7636  {  \r
7637   for(Int_t pe=0;pe<2;pe++) // pt or eta\r
7638   {\r
7639    for(Int_t sc=0;sc<2;sc++) // sin or cos\r
7640    {\r
7641     for(Int_t cti=0;cti<9;cti++) // correction term index\r
7642     {\r
7643      fDiffFlowCorrectionTermsForNUAEBE[t][pe][sc][cti]->Reset();  \r
7644     }\r
7645    }\r
7646   }      \r
7647  }\r
7648     \r
7649  // 2D (pt,eta)\r
7650  if(fCalculate2DFlow)\r
7651  {\r
7652   for(Int_t t=0;t<3;t++) // type (RP, POI, POI&&RP)\r
7653   {\r
7654    for(Int_t m=0;m<4;m++) // multiple of harmonic\r
7655    {\r
7656     for(Int_t k=0;k<9;k++) // power of weight\r
7657     {\r
7658      if(fReRPQ2dEBE[t][m][k]) fReRPQ2dEBE[t][m][k]->Reset();\r
7659      if(fImRPQ2dEBE[t][m][k]) fImRPQ2dEBE[t][m][k]->Reset();\r
7660     }   \r
7661    }\r
7662   }\r
7663   for(Int_t t=0;t<3;t++) // type (0 = RP, 1 = POI, 2 = RP&&POI )\r
7664   { \r
7665    for(Int_t k=0;k<9;k++)\r
7666    {\r
7667     if(fs2dEBE[t][k]) fs2dEBE[t][k]->Reset();\r
7668    }\r
7669   }  \r
7670  } // end of if(fCalculate2DFlow) \r
7671 \r
7672 } // end of void AliFlowAnalysisWithQCumulants::ResetEventByEventQuantities();\r
7673 \r
7674 \r
7675 //================================================================================================================================\r
7676 \r
7677 \r
7678 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)\r
7679 {\r
7680  // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).\r
7681  \r
7682  // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:\r
7683  //  0: <<sin n(psi1)>>\r
7684  //  1: <<sin n(psi1+phi2)>>\r
7685  //  2: <<sin n(psi1+phi2-phi3)>>\r
7686  //  3: <<sin n(psi1-phi2-phi3)>>:\r
7687  //  4:\r
7688  //  5:\r
7689  //  6:\r
7690  \r
7691  // multiplicity:\r
7692  Double_t dMult = (*fSMpk)(0,0);\r
7693  \r
7694  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7695  Double_t dReQ1n = (*fReQ)(0,0);\r
7696  Double_t dReQ2n = (*fReQ)(1,0);\r
7697  //Double_t dReQ3n = (*fReQ)(2,0);\r
7698  //Double_t dReQ4n = (*fReQ)(3,0);\r
7699  Double_t dImQ1n = (*fImQ)(0,0);\r
7700  Double_t dImQ2n = (*fImQ)(1,0);\r
7701  //Double_t dImQ3n = (*fImQ)(2,0);\r
7702  //Double_t dImQ4n = (*fImQ)(3,0);\r
7703 \r
7704  Int_t t = -1; // type flag \r
7705  Int_t pe = -1; // ptEta flag\r
7706  \r
7707  if(type == "RP")\r
7708  {\r
7709   t = 0;\r
7710  } else if(type == "POI")\r
7711    {\r
7712     t = 1;\r
7713    }\r
7714 \r
7715  if(ptOrEta == "Pt")\r
7716  {\r
7717   pe = 0;\r
7718  } else if(ptOrEta == "Eta")\r
7719    {\r
7720     pe = 1;\r
7721    }\r
7722     \r
7723  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7724  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7725  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7726  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7727 \r
7728  // looping over all bins and calculating correction terms: \r
7729  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7730  {\r
7731   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
7732   Double_t p1n0kRe = 0.;\r
7733   Double_t p1n0kIm = 0.;\r
7734 \r
7735   // number of POIs in particular pt or eta bin:\r
7736   Double_t mp = 0.;\r
7737 \r
7738   // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
7739   Double_t q1n0kRe = 0.;\r
7740   Double_t q1n0kIm = 0.;\r
7741   Double_t q2n0kRe = 0.;\r
7742   Double_t q2n0kIm = 0.;\r
7743 \r
7744   // number of particles which are both RPs and POIs in particular pt or eta bin:\r
7745   Double_t mq = 0.;\r
7746    \r
7747   if(type == "POI")\r
7748   {\r
7749    // q_{m*n,0}:\r
7750    q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7751            * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7752    q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7753            * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7754    q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7755            * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
7756    q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7757            * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));         \r
7758                  \r
7759    mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7760   } \r
7761   else if(type == "RP")\r
7762   {\r
7763    // q_{m*n,0}:\r
7764    q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7765            * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7766    q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7767            * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7768    q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7769            * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
7770    q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7771            * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));         \r
7772                  \r
7773    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)  \r
7774   }    \r
7775   if(type == "POI")\r
7776   {\r
7777    // p_{m*n,0}:\r
7778    p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7779            * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7780    p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
7781            * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7782             \r
7783    mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7784     \r
7785    t = 1; // typeFlag = RP or POI\r
7786   }\r
7787   else if(type == "RP")\r
7788   {\r
7789    // p_{m*n,0} = q_{m*n,0}:\r
7790    p1n0kRe = q1n0kRe; \r
7791    p1n0kIm = q1n0kIm; \r
7792            \r
7793    mp = mq; \r
7794    \r
7795    t = 0; // typeFlag = RP or POI\r
7796   }\r
7797 \r
7798   // <<sin n(psi1)>>:\r
7799   Double_t sinP1nPsi = 0.;\r
7800   if(mp)\r
7801   {\r
7802    sinP1nPsi = p1n0kIm/mp;\r
7803    // fill profile for <<sin n(psi1)>>:\r
7804    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);\r
7805    // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):\r
7806    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);\r
7807   } // end of if(mp)   \r
7808   \r
7809   // <<sin n(psi1+phi2)>>:\r
7810   Double_t sinP1nPsiP1nPhi = 0.;\r
7811   if(mp*dMult-mq)\r
7812   {\r
7813    sinP1nPsiP1nPhi = (p1n0kRe*dImQ1n+p1n0kIm*dReQ1n-q2n0kIm)/(mp*dMult-mq);\r
7814    // fill profile for <<sin n(psi1+phi2)>>:\r
7815    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhi,mp*dMult-mq);\r
7816    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7817    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhi);\r
7818   } // end of if(mp*dMult-mq)   \r
7819   \r
7820   // <<sin n(psi1+phi2-phi3)>>:\r
7821   Double_t sinP1nPsi1P1nPhi2MPhi3 = 0.;\r
7822   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7823   {\r
7824    sinP1nPsi1P1nPhi2MPhi3 = (p1n0kIm*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
7825                           - 1.*(q2n0kIm*dReQ1n-q2n0kRe*dImQ1n)  \r
7826                           - mq*dImQ1n+2.*q1n0kIm)\r
7827                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7828    // fill profile for <<sin n(psi1+phi2)>>:\r
7829    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7830    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7831    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3);\r
7832   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
7833   \r
7834   // <<sin n(psi1-phi2-phi3)>>:\r
7835   Double_t sinP1nPsi1M1nPhi2MPhi3 = 0.;\r
7836   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
7837   {\r
7838    sinP1nPsi1M1nPhi2MPhi3 = (p1n0kIm*(pow(dReQ1n,2.)-pow(dImQ1n,2.))-2.*p1n0kRe*dReQ1n*dImQ1n\r
7839                           - 1.*(p1n0kIm*dReQ2n-p1n0kRe*dImQ2n)\r
7840                           + 2.*mq*dImQ1n-2.*q1n0kIm)\r
7841                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7842    // fill profile for <<sin n(psi1+phi2)>>:\r
7843    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
7844    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7845    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3);\r
7846   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
7847  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7848  \r
7849 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTerms(TString type, TString ptOrEta)\r
7850 \r
7851 \r
7852 //================================================================================================================================\r
7853 \r
7854 \r
7855 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)\r
7856 {\r
7857  // Calculate correction terms for non-uniform acceptance for differential flow (cos terms).\r
7858  \r
7859  // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:\r
7860  //  0: <<cos n(psi)>>\r
7861  //  1: <<cos n(psi1+phi2)>>\r
7862  //  2: <<cos n(psi1+phi2-phi3)>>\r
7863  //  3: <<cos n(psi1-phi2-phi3)>>\r
7864  //  4:\r
7865  //  5:\r
7866  //  6:\r
7867  \r
7868  // multiplicity:\r
7869  Double_t dMult = (*fSMpk)(0,0);\r
7870  \r
7871  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
7872  Double_t dReQ1n = (*fReQ)(0,0);\r
7873  Double_t dReQ2n = (*fReQ)(1,0);\r
7874  //Double_t dReQ3n = (*fReQ)(2,0);\r
7875  //Double_t dReQ4n = (*fReQ)(3,0);\r
7876  Double_t dImQ1n = (*fImQ)(0,0);\r
7877  Double_t dImQ2n = (*fImQ)(1,0);\r
7878  //Double_t dImQ3n = (*fImQ)(2,0);\r
7879  //Double_t dImQ4n = (*fImQ)(3,0);\r
7880 \r
7881  Int_t t = -1; // type flag \r
7882  Int_t pe = -1; // ptEta flag\r
7883  \r
7884  if(type == "RP")\r
7885  {\r
7886   t = 0;\r
7887  } else if(type == "POI")\r
7888    {\r
7889     t = 1;\r
7890    }\r
7891 \r
7892  if(ptOrEta == "Pt")\r
7893  {\r
7894   pe = 0;\r
7895  } else if(ptOrEta == "Eta")\r
7896    {\r
7897     pe = 1;\r
7898    }\r
7899     \r
7900  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
7901  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
7902  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
7903  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
7904 \r
7905  // looping over all bins and calculating correction terms: \r
7906  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
7907  {\r
7908   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
7909   Double_t p1n0kRe = 0.;\r
7910   Double_t p1n0kIm = 0.;\r
7911 \r
7912   // number of POIs in particular pt or eta bin:\r
7913   Double_t mp = 0.;\r
7914 \r
7915   // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
7916   Double_t q1n0kRe = 0.;\r
7917   Double_t q1n0kIm = 0.;\r
7918   Double_t q2n0kRe = 0.;\r
7919   Double_t q2n0kIm = 0.;\r
7920 \r
7921   // number of particles which are both RPs and POIs in particular pt or eta bin:\r
7922   Double_t mq = 0.;\r
7923    \r
7924   if(type == "POI")\r
7925   {\r
7926    // q_{m*n,0}:\r
7927    q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7928            * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7929    q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
7930            * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
7931    q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7932            * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
7933    q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
7934            * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));         \r
7935                  \r
7936    mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7937   } \r
7938   else if(type == "RP")\r
7939   {\r
7940    // q_{m*n,0}:\r
7941    q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7942            * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7943    q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
7944            * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
7945    q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7946            * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
7947    q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
7948            * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));         \r
7949                  \r
7950    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)  \r
7951   }    \r
7952   if(type == "POI")\r
7953   {\r
7954    // p_{m*n,0}:\r
7955    p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
7956            * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7957    p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
7958            * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
7959             \r
7960    mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
7961     \r
7962    t = 1; // typeFlag = RP or POI\r
7963   }\r
7964   else if(type == "RP")\r
7965   {\r
7966    // p_{m*n,0} = q_{m*n,0}:\r
7967    p1n0kRe = q1n0kRe; \r
7968    p1n0kIm = q1n0kIm; \r
7969            \r
7970    mp = mq; \r
7971    \r
7972    t = 0; // typeFlag = RP or POI\r
7973   }\r
7974 \r
7975   // <<cos n(psi1)>>:\r
7976   Double_t cosP1nPsi = 0.;\r
7977   if(mp)\r
7978   {\r
7979    cosP1nPsi = p1n0kRe/mp;\r
7980    \r
7981    // fill profile for <<cos n(psi1)>>:\r
7982    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi,mp);\r
7983    // histogram to store <cos n(psi1)> e-b-e (needed in some other methods):\r
7984    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsi);\r
7985   } // end of if(mp)   \r
7986   \r
7987   // <<cos n(psi1+phi2)>>:\r
7988   Double_t cosP1nPsiP1nPhi = 0.;\r
7989   if(mp*dMult-mq)\r
7990   {\r
7991    cosP1nPsiP1nPhi = (p1n0kRe*dReQ1n-p1n0kIm*dImQ1n-q2n0kRe)/(mp*dMult-mq);\r
7992    // fill profile for <<sin n(psi1+phi2)>>:\r
7993    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhi,mp*dMult-mq);\r
7994    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
7995    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhi);\r
7996   } // end of if(mp*dMult-mq)   \r
7997   \r
7998   // <<cos n(psi1+phi2-phi3)>>:\r
7999   Double_t cosP1nPsi1P1nPhi2MPhi3 = 0.;\r
8000   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
8001   {\r
8002    cosP1nPsi1P1nPhi2MPhi3 = (p1n0kRe*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
8003                           - 1.*(q2n0kRe*dReQ1n+q2n0kIm*dImQ1n)  \r
8004                           - mq*dReQ1n+2.*q1n0kRe)\r
8005                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
8006    // fill profile for <<sin n(psi1+phi2)>>:\r
8007    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
8008    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
8009    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3);\r
8010   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
8011   \r
8012   // <<cos n(psi1-phi2-phi3)>>:\r
8013   Double_t cosP1nPsi1M1nPhi2MPhi3 = 0.;\r
8014   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
8015   {\r
8016    cosP1nPsi1M1nPhi2MPhi3 = (p1n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))+2.*p1n0kIm*dReQ1n*dImQ1n\r
8017                           - 1.*(p1n0kRe*dReQ2n+p1n0kIm*dImQ2n)  \r
8018                           - 2.*mq*dReQ1n+2.*q1n0kRe)\r
8019                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
8020    // fill profile for <<sin n(psi1+phi2)>>:\r
8021    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
8022    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
8023    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3);\r
8024   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
8025  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8026  \r
8027 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTerms(TString type, TString ptOrEta)\r
8028 \r
8029 \r
8030 //==================================================================================================================================\r
8031 \r
8032 \r
8033 void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)\r
8034 {\r
8035  // Transfer prolfiles into histogams and correctly propagate the error (to be improved: description)\r
8036  \r
8037  // to be improved: debugged - I do not correctly transfer all profiles into histos (bug appears only after merging) \r
8038   \r
8039  Int_t t = -1; // type flag \r
8040  Int_t pe = -1; // ptEta flag\r
8041  \r
8042  if(type == "RP")\r
8043  {\r
8044   t = 0;\r
8045  } else if(type == "POI")\r
8046    {\r
8047     t = 1;\r
8048    }\r
8049 \r
8050  if(ptOrEta == "Pt")\r
8051  {\r
8052   pe = 0;\r
8053  } else if(ptOrEta == "Eta")\r
8054    {\r
8055     pe = 1;\r
8056    }\r
8057     \r
8058  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
8059  //Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
8060  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
8061  //Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
8062 \r
8063  for(Int_t sc=0;sc<2;sc++) // sin or cos\r
8064  {\r
8065   for(Int_t cti=0;cti<9;cti++) // correction term index\r
8066   {\r
8067    for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8068    {\r
8069     Double_t correctionTerm = fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(b);\r
8070     fDiffFlowCorrectionTermsForNUAHist[t][pe][sc][cti]->SetBinContent(b,correctionTerm);\r
8071     // to be improved (propagate error correctly)\r
8072     // ...\r
8073    } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8074   } // correction term index\r
8075  } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos\r
8076 \r
8077 }// end of void AliFlowAnalysisWithQCumulants::FinalizeCorrectionTermsForNUADiffFlow(TString type, TString ptOrEta)\r
8078 \r
8079 \r
8080 //==================================================================================================================================\r
8081 \r
8082 \r
8083 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)\r
8084 { \r
8085  // Calculate generalized differential flow Q-cumulants (corrected for non-uniform acceptance)\r
8086   \r
8087  Int_t typeFlag = -1;\r
8088  Int_t ptEtaFlag = -1;\r
8089 \r
8090  if(type == "RP")\r
8091  {\r
8092   typeFlag = 0;\r
8093  } else if(type == "POI")\r
8094    {\r
8095     typeFlag = 1;\r
8096    } \r
8097      \r
8098  if(ptOrEta == "Pt")\r
8099  {\r
8100   ptEtaFlag = 0;\r
8101  } else if(ptOrEta == "Eta")\r
8102    {\r
8103     ptEtaFlag = 1;\r
8104    } \r
8105   \r
8106  // shortcuts:\r
8107  Int_t t = typeFlag;\r
8108  Int_t pe = ptEtaFlag;\r
8109      \r
8110  // common:\r
8111  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
8112  \r
8113  // 2-particle correlation:\r
8114  Double_t two = fIntFlowCorrelationsHist->GetBinContent(1); // <<2>>\r
8115  // sin term coming from integrated flow: \r
8116  Double_t sinP1nPhi = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(1); // <<sin(n*phi1)>>\r
8117  Double_t sinP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(2); // <<sin(n*(phi1+phi2))>>\r
8118  Double_t sinP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[0]->GetBinContent(3); // <<sin(n*(phi1-phi2-phi3))>>\r
8119  // cos term coming from integrated flow: \r
8120  Double_t cosP1nPhi = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(1); // <<cos(n*phi1)>>\r
8121  Double_t cosP1nPhi1P1nPhi2 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(2); // <<cos(n*(phi1+phi2))>>\r
8122  Double_t cosP1nPhi1M1nPhi2M1nPhi3 = fIntFlowCorrectionTermsForNUAHist[1]->GetBinContent(3); // <<cos(n*(phi1-phi2-phi3))>>\r
8123 \r
8124  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8125  {\r
8126   Double_t twoPrime = fDiffFlowCorrelationsHist[t][pe][0]->GetBinContent(b); // <<2'>>\r
8127   Double_t fourPrime = fDiffFlowCorrelationsHist[t][pe][1]->GetBinContent(b); // <<4'>>\r
8128   Double_t sinP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][0]->GetBinContent(b); // <<sin n(Psi)>> \r
8129   Double_t cosP1nPsi = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][0]->GetBinContent(b); // <<cos n(Psi)>> \r
8130   Double_t sinP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][1]->GetBinContent(b); // <<sin n(psi1+phi2)>> \r
8131   Double_t cosP1nPsi1P1nPhi2 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][1]->GetBinContent(b); // <<cos n(psi1+phi2)>> \r
8132   Double_t sinP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][2]->GetBinContent(b); // <<sin n(psi1+phi2-phi3)>> \r
8133   Double_t cosP1nPsi1P1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][2]->GetBinContent(b); // <<cos n(psi1+phi2-phi3)>> \r
8134   Double_t sinP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][0][3]->GetBinContent(b); // <<sin n(psi1-phi2-phi3)>> \r
8135   Double_t cosP1nPsi1M1nPhi2M1nPhi3 = fDiffFlowCorrectionTermsForNUAHist[t][pe][1][3]->GetBinContent(b); // <<cos n(psi1-phi2-phi3)>> \r
8136   // generalized QC{2'}:\r
8137   Double_t qc2Prime = twoPrime - sinP1nPsi*sinP1nPhi - cosP1nPsi*cosP1nPhi;\r
8138   fDiffFlowCumulants[t][pe][0]->SetBinContent(b,qc2Prime);\r
8139   // generalized QC{4'}:\r
8140   Double_t qc4Prime = fourPrime-2.*twoPrime*two\r
8141                     - cosP1nPsi*cosP1nPhi1M1nPhi2M1nPhi3\r
8142                     + sinP1nPsi*sinP1nPhi1M1nPhi2M1nPhi3\r
8143                     - cosP1nPhi*cosP1nPsi1M1nPhi2M1nPhi3\r
8144                     + sinP1nPhi*sinP1nPsi1M1nPhi2M1nPhi3\r
8145                     - 2.*cosP1nPhi*cosP1nPsi1P1nPhi2M1nPhi3\r
8146                     - 2.*sinP1nPhi*sinP1nPsi1P1nPhi2M1nPhi3\r
8147                     - cosP1nPsi1P1nPhi2*cosP1nPhi1P1nPhi2\r
8148                     - sinP1nPsi1P1nPhi2*sinP1nPhi1P1nPhi2\r
8149                     + 2.*cosP1nPhi1P1nPhi2*(cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)\r
8150                     + 2.*sinP1nPhi1P1nPhi2*(cosP1nPsi*sinP1nPhi+sinP1nPsi*cosP1nPhi)\r
8151                     + 4.*two*(cosP1nPsi*cosP1nPhi+sinP1nPsi*sinP1nPhi)\r
8152                     + 2.*cosP1nPsi1P1nPhi2*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.))\r
8153                     + 4.*sinP1nPsi1P1nPhi2*cosP1nPhi*sinP1nPhi\r
8154                     + 4.*twoPrime*(pow(cosP1nPhi,2.)+pow(sinP1nPhi,2.))\r
8155                     - 6.*(pow(cosP1nPhi,2.)-pow(sinP1nPhi,2.)) \r
8156                     * (cosP1nPsi*cosP1nPhi-sinP1nPsi*sinP1nPhi)\r
8157                     - 12.*cosP1nPhi*sinP1nPhi\r
8158                     * (sinP1nPsi*cosP1nPhi+cosP1nPsi*sinP1nPhi);\r
8159   fDiffFlowCumulants[t][pe][1]->SetBinContent(b,qc4Prime);   \r
8160  } // end of for(Int_t p=1;p<=fnBinsPt;p++)\r
8161  \r
8162 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCumulantsCorrectedForNUA(TString type, TString ptOrEta)\r
8163 \r
8164 \r
8165 //==================================================================================================================================\r
8166     \r
8167 \r
8168 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta)\r
8169 {\r
8170  // Calculate differential flow corrected for non-uniform acceptance.\r
8171  \r
8172  // to be improved (rewritten completely)\r
8173  \r
8174  Int_t typeFlag = -1;\r
8175  Int_t ptEtaFlag = -1;\r
8176 \r
8177  if(type == "RP")\r
8178  {\r
8179   typeFlag = 0;\r
8180  } else if(type == "POI")\r
8181    {\r
8182     typeFlag = 1;\r
8183    } \r
8184      \r
8185  if(ptOrEta == "Pt")\r
8186  {\r
8187   ptEtaFlag = 0;\r
8188  } else if(ptOrEta == "Eta")\r
8189    {\r
8190     ptEtaFlag = 1;\r
8191    } \r
8192   \r
8193  // shortcuts:\r
8194  Int_t t = typeFlag;\r
8195  Int_t pe = ptEtaFlag;\r
8196      \r
8197  // common:\r
8198  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
8199    \r
8200  // to be improved: access here generalized QC{2} and QC{4} instead: \r
8201  Double_t dV2 = fIntFlow->GetBinContent(1); \r
8202  Double_t dV4 = fIntFlow->GetBinContent(2); \r
8203  \r
8204  // loop over pt or eta bins:\r
8205  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
8206  {\r
8207   // generalized QC{2'}:\r
8208   Double_t gQC2Prime = fDiffFlowCumulants[t][pe][0]->GetBinContent(b);\r
8209   // v'{2}:\r
8210   if(dV2>0)\r
8211   { \r
8212    Double_t v2Prime = gQC2Prime/dV2;\r
8213    fDiffFlow[t][pe][0]->SetBinContent(b,v2Prime); \r
8214   }  \r
8215   // generalized QC{4'}:\r
8216   Double_t gQC4Prime = fDiffFlowCumulants[t][pe][1]->GetBinContent(b);\r
8217   // v'{4}:\r
8218   if(dV4>0)\r
8219   { \r
8220    Double_t v4Prime = -gQC4Prime/pow(dV4,3.);\r
8221    fDiffFlow[t][pe][1]->SetBinContent(b,v4Prime); \r
8222   }  \r
8223  } // end of for(Int_t b=1;b<=fnBinsPtEta[pe];b++)\r
8224   \r
8225 } // end of void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectedForNUA(TString type, TString ptOrEta); \r
8226 \r
8227 \r
8228 //==================================================================================================================================\r
8229 \r
8230 \r
8231 void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)\r
8232 {\r
8233  // Evaluate with nested loops multiparticle correlations for integrated flow (without using the particle weights). \r
8234 \r
8235  // Remark: Results are stored in profile fIntFlowDirectCorrelations whose binning is organized as follows:\r
8236  // \r
8237  //  1st bin: <2>_{1n|1n} = two1n1n = cos(n*(phi1-phi2))>\r
8238  //  2nd bin: <2>_{2n|2n} = two2n2n = cos(2n*(phi1-phi2))>\r
8239  //  3rd bin: <2>_{3n|3n} = two3n3n = cos(3n*(phi1-phi2))> \r
8240  //  4th bin: <2>_{4n|4n} = two4n4n = cos(4n*(phi1-phi2))>\r
8241  //  5th bin:           ----  EMPTY ----\r
8242  //  6th bin: <3>_{2n|1n,1n} = three2n1n1n = <cos(n*(2.*phi1-phi2-phi3))>\r
8243  //  7th bin: <3>_{3n|2n,1n} = three3n2n1n = <cos(n*(3.*phi1-2.*phi2-phi3))>\r
8244  //  8th bin: <3>_{4n|2n,2n} = three4n2n2n = <cos(n*(4.*phi1-2.*phi2-2.*phi3))>\r
8245  //  9th bin: <3>_{4n|3n,1n} = three4n3n1n = <cos(n*(4.*phi1-3.*phi2-phi3))>\r
8246  // 10th bin:           ----  EMPTY ----\r
8247  // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1n = <cos(n*(phi1+phi2-phi3-phi4))>\r
8248  // 12th bin: <4>_{2n,1n|2n,1n} = four2n1n2n1n = <cos(2.*n*(phi1+phi2-phi3-phi4))>\r
8249  // 13th bin: <4>_{2n,2n|2n,2n} = four2n2n2n2n = <cos(n*(2.*phi1+phi2-2.*phi3-phi4))>\r
8250  // 14th bin: <4>_{3n|1n,1n,1n} = four3n1n1n1n = <cos(n*(3.*phi1-phi2-phi3-phi4))> \r
8251  // 15th bin: <4>_{3n,1n|3n,1n} = four3n1n3n1n = <cos(n*(4.*phi1-2.*phi2-phi3-phi4))>\r
8252  // 16th bin: <4>_{3n,1n|2n,2n} = four3n1n2n2n = <cos(n*(3.*phi1+phi2-2.*phi3-2.*phi4))>\r
8253  // 17th bin: <4>_{4n|2n,1n,1n} = four4n2n1n1n = <cos(n*(3.*phi1+phi2-3.*phi3-phi4))> \r
8254  // 18th bin:           ----  EMPTY ----\r
8255  // 19th bin: <5>_{2n|1n,1n,1n,1n} = five2n1n1n1n1n = <cos(n*(2.*phi1+phi2-phi3-phi4-phi5))>\r
8256  // 20th bin: <5>_{2n,2n|2n,1n,1n} = five2n2n2n1n1n = <cos(n*(2.*phi1+2.*phi2-2.*phi3-phi4-phi5))>\r
8257  // 21st bin: <5>_{3n,1n|2n,1n,1n} = five3n1n2n1n1n = <cos(n*(3.*phi1+phi2-2.*phi3-phi4-phi5))>\r
8258  // 22nd bin: <5>_{4n|1n,1n,1n,1n} = five4n1n1n1n1n = <cos(n*(4.*phi1-phi2-phi3-phi4-phi5))>\r
8259  // 23rd bin:           ----  EMPTY ----\r
8260  // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = six1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3-phi4-phi5-phi6))>\r
8261  // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = six2n1n1n2n1n1n = <cos(n*(2.*phi1+2.*phi2-phi3-phi4-phi5-phi6))>\r
8262  // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = six2n2n1n1n1n1n = <cos(n*(3.*phi1+phi2-phi3-phi4-phi5-phi6))>\r
8263  // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = six3n1n1n1n1n1n = <cos(n*(2.*phi1+phi2+phi3-2.*phi4-phi5-phi6))>\r
8264  // 28th bin:           ----  EMPTY ----\r
8265  // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = seven2n1n1n1n1n1n1n =  <cos(n*(2.*phi1+phi2+phi3-phi4-phi5-phi6-phi7))>\r
8266  // 30th bin:           ----  EMPTY ----\r
8267  // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = eight1n1n1n1n1n1n1n1n = <cos(n*(phi1+phi2+phi3+phi4-phi5-phi6-phi7-phi8))>\r
8268  \r
8269  Int_t nPrim = anEvent->NumberOfTracks(); \r
8270  AliFlowTrackSimple *aftsTrack = NULL; \r
8271  Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.; \r
8272  Int_t n = fHarmonic; \r
8273  Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8274  Double_t dMult = (*fSMpk)(0,0);\r
8275  cout<<endl;\r
8276  cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8277  if(dMult<2)\r
8278  {\r
8279   cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8280  } else if (dMult>fMaxAllowedMultiplicity)\r
8281    {\r
8282     cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8283    } else \r
8284      { \r
8285       cout<<"... evaluating nested loops (without using particle weights)..."<<endl;\r
8286      } \r
8287  \r
8288  // 2-particle correlations:       \r
8289  if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8290  {\r
8291   for(Int_t i1=0;i1<nPrim;i1++)\r
8292   {\r
8293    aftsTrack=anEvent->GetTrack(i1);\r
8294    if(!(aftsTrack->InRPSelection())) continue;\r
8295    phi1=aftsTrack->Phi(); \r
8296    for(Int_t i2=0;i2<nPrim;i2++)\r
8297    {\r
8298     if(i2==i1)continue;\r
8299     aftsTrack=anEvent->GetTrack(i2);\r
8300     if(!(aftsTrack->InRPSelection())) continue;\r
8301     phi2=aftsTrack->Phi();\r
8302     if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8303     // fill the profile with 2-p correlations: \r
8304     fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),1.);    // <cos(n*(phi1-phi2))>\r
8305     fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),1.); // <cos(2n*(phi1-phi2))>\r
8306     fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),1.); // <cos(3n*(phi1-phi2))>\r
8307     fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),1.); // <cos(4n*(phi1-phi2))>   \r
8308    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8309   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8310  } // end of if(nPrim>=2)\r
8311  \r
8312  // 3-particle correlations:         \r
8313  if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8314  {\r
8315   for(Int_t i1=0;i1<nPrim;i1++)\r
8316   {\r
8317    aftsTrack=anEvent->GetTrack(i1);\r
8318    if(!(aftsTrack->InRPSelection())) continue;\r
8319    phi1=aftsTrack->Phi();\r
8320    for(Int_t i2=0;i2<nPrim;i2++)\r
8321    {\r
8322     if(i2==i1)continue;\r
8323     aftsTrack=anEvent->GetTrack(i2);\r
8324     if(!(aftsTrack->InRPSelection())) continue;\r
8325     phi2=aftsTrack->Phi();\r
8326     for(Int_t i3=0;i3<nPrim;i3++)\r
8327     {\r
8328      if(i3==i1||i3==i2)continue;\r
8329      aftsTrack=anEvent->GetTrack(i3);\r
8330      if(!(aftsTrack->InRPSelection())) continue;\r
8331      phi3=aftsTrack->Phi();\r
8332      if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;\r
8333      // fill the profile with 3-p correlations:   \r
8334      fIntFlowDirectCorrelations->Fill(5.,cos(2.*n*phi1-n*(phi2+phi3)),1.);       //<3>_{2n|nn,n}\r
8335      fIntFlowDirectCorrelations->Fill(6.,cos(3.*n*phi1-2.*n*phi2-n*phi3),1.);    //<3>_{3n|2n,n}\r
8336      fIntFlowDirectCorrelations->Fill(7.,cos(4.*n*phi1-2.*n*phi2-2.*n*phi3),1.); //<3>_{4n|2n,2n}\r
8337      fIntFlowDirectCorrelations->Fill(8.,cos(4.*n*phi1-3.*n*phi2-n*phi3),1.);    //<3>_{4n|3n,n}\r
8338     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8339    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8340   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8341  } // end of if(nPrim>=3)\r
8342 \r
8343  // 4-particle correlations:\r
8344  if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)\r
8345  {       \r
8346   for(Int_t i1=0;i1<nPrim;i1++)\r
8347   { \r
8348    aftsTrack=anEvent->GetTrack(i1);\r
8349    if(!(aftsTrack->InRPSelection())) continue;\r
8350    phi1=aftsTrack->Phi();\r
8351    for(Int_t i2=0;i2<nPrim;i2++)\r
8352    {\r
8353     if(i2==i1)continue;\r
8354     aftsTrack=anEvent->GetTrack(i2);\r
8355     if(!(aftsTrack->InRPSelection())) continue;\r
8356     phi2=aftsTrack->Phi();\r
8357     for(Int_t i3=0;i3<nPrim;i3++)\r
8358     {\r
8359      if(i3==i1||i3==i2)continue;\r
8360      aftsTrack=anEvent->GetTrack(i3);\r
8361      if(!(aftsTrack->InRPSelection())) continue;\r
8362      phi3=aftsTrack->Phi();\r
8363      for(Int_t i4=0;i4<nPrim;i4++)\r
8364      {\r
8365       if(i4==i1||i4==i2||i4==i3)continue;\r
8366       aftsTrack=anEvent->GetTrack(i4);\r
8367       if(!(aftsTrack->InRPSelection())) continue;\r
8368       phi4=aftsTrack->Phi();\r
8369       if(nPrim==4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush;\r
8370       // fill the profile with 4-p correlations:   \r
8371       fIntFlowDirectCorrelations->Fill(10.,cos(n*phi1+n*phi2-n*phi3-n*phi4),1.);            // <4>_{n,n|n,n} \r
8372       fIntFlowDirectCorrelations->Fill(11.,cos(2.*n*phi1+n*phi2-2.*n*phi3-n*phi4),1.);      // <4>_{2n,n|2n,n}\r
8373       fIntFlowDirectCorrelations->Fill(12.,cos(2.*n*phi1+2*n*phi2-2.*n*phi3-2.*n*phi4),1.); // <4>_{2n,2n|2n,2n}\r
8374       fIntFlowDirectCorrelations->Fill(13.,cos(3.*n*phi1-n*phi2-n*phi3-n*phi4),1.);         // <4>_{3n|n,n,n}\r
8375       fIntFlowDirectCorrelations->Fill(14.,cos(3.*n*phi1+n*phi2-3.*n*phi3-n*phi4),1.);      // <4>_{3n,n|3n,n}   \r
8376       fIntFlowDirectCorrelations->Fill(15.,cos(3.*n*phi1+n*phi2-2.*n*phi3-2.*n*phi4),1.);   // <4>_{3n,n|2n,2n}\r
8377       fIntFlowDirectCorrelations->Fill(16.,cos(4.*n*phi1-2.*n*phi2-n*phi3-n*phi4),1.);      // <4>_{4n|2n,n,n}     \r
8378      } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8379     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8380    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8381   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8382  } // end of if(nPrim>=)\r
8383 \r
8384  // 5-particle correlations:      \r
8385  if(nPrim>=5 && nPrim<=fMaxAllowedMultiplicity)\r
8386  {\r
8387   for(Int_t i1=0;i1<nPrim;i1++)\r
8388   {\r
8389    aftsTrack=anEvent->GetTrack(i1);\r
8390    if(!(aftsTrack->InRPSelection())) continue;  \r
8391    phi1=aftsTrack->Phi();\r
8392    for(Int_t i2=0;i2<nPrim;i2++)\r
8393    {\r
8394     if(i2==i1)continue;\r
8395     aftsTrack=anEvent->GetTrack(i2);\r
8396     if(!(aftsTrack->InRPSelection())) continue;\r
8397     phi2=aftsTrack->Phi();\r
8398     for(Int_t i3=0;i3<nPrim;i3++)\r
8399     {\r
8400      if(i3==i1||i3==i2)continue;\r
8401      aftsTrack=anEvent->GetTrack(i3);\r
8402      if(!(aftsTrack->InRPSelection())) continue;\r
8403      phi3=aftsTrack->Phi();\r
8404      for(Int_t i4=0;i4<nPrim;i4++)\r
8405      {\r
8406       if(i4==i1||i4==i2||i4==i3)continue;\r
8407       aftsTrack=anEvent->GetTrack(i4);\r
8408       if(!(aftsTrack->InRPSelection())) continue;\r
8409       phi4=aftsTrack->Phi();\r
8410       for(Int_t i5=0;i5<nPrim;i5++)\r
8411       {\r
8412        if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8413        aftsTrack=anEvent->GetTrack(i5);\r
8414        if(!(aftsTrack->InRPSelection())) continue;\r
8415        phi5=aftsTrack->Phi();\r
8416        if(nPrim==5) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<"\r"<<flush;\r
8417        // fill the profile with 5-p correlations:   \r
8418        fIntFlowDirectCorrelations->Fill(18.,cos(2.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5),1.);       //<5>_{2n,n|n,n,n}\r
8419        fIntFlowDirectCorrelations->Fill(19.,cos(2.*n*phi1+2.*n*phi2-2.*n*phi3-n*phi4-n*phi5),1.); //<5>_{2n,2n|2n,n,n}\r
8420        fIntFlowDirectCorrelations->Fill(20.,cos(3.*n*phi1+n*phi2-2.*n*phi3-n*phi4-n*phi5),1.);    //<5>_{3n,n|2n,n,n}\r
8421        fIntFlowDirectCorrelations->Fill(21.,cos(4.*n*phi1-n*phi2-n*phi3-n*phi4-n*phi5),1.);       //<5>_{4n|n,n,n,n}\r
8422       } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8423      } // end of for(Int_t i4=0;i4<nPrim;i4++)  \r
8424     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8425    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8426   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8427  } // end of if(nPrim>=5)\r
8428   \r
8429  // 6-particle correlations:\r
8430  if(nPrim>=6 && nPrim<=fMaxAllowedMultiplicity)\r
8431  {\r
8432   for(Int_t i1=0;i1<nPrim;i1++)\r
8433   {\r
8434    aftsTrack=anEvent->GetTrack(i1);\r
8435    if(!(aftsTrack->InRPSelection())) continue;\r
8436    phi1=aftsTrack->Phi();\r
8437    for(Int_t i2=0;i2<nPrim;i2++)\r
8438    {\r
8439     if(i2==i1)continue;\r
8440     aftsTrack=anEvent->GetTrack(i2);\r
8441     if(!(aftsTrack->InRPSelection())) continue;\r
8442     phi2=aftsTrack->Phi();\r
8443     for(Int_t i3=0;i3<nPrim;i3++)\r
8444     {\r
8445      if(i3==i1||i3==i2)continue;\r
8446      aftsTrack=anEvent->GetTrack(i3);\r
8447      if(!(aftsTrack->InRPSelection())) continue;\r
8448      phi3=aftsTrack->Phi();\r
8449      for(Int_t i4=0;i4<nPrim;i4++)\r
8450      {\r
8451       if(i4==i1||i4==i2||i4==i3)continue;\r
8452       aftsTrack=anEvent->GetTrack(i4);\r
8453       if(!(aftsTrack->InRPSelection())) continue;\r
8454       phi4=aftsTrack->Phi();\r
8455       for(Int_t i5=0;i5<nPrim;i5++)\r
8456       {\r
8457        if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8458        aftsTrack=anEvent->GetTrack(i5);\r
8459        if(!(aftsTrack->InRPSelection())) continue;\r
8460        phi5=aftsTrack->Phi();\r
8461        for(Int_t i6=0;i6<nPrim;i6++)\r
8462        {\r
8463         if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8464         aftsTrack=anEvent->GetTrack(i6);\r
8465         if(!(aftsTrack->InRPSelection())) continue;\r
8466         phi6=aftsTrack->Phi(); \r
8467         if(nPrim==6) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<"\r"<<flush;\r
8468         // fill the profile with 6-p correlations:   \r
8469         fIntFlowDirectCorrelations->Fill(23.,cos(n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6),1.);       //<6>_{n,n,n|n,n,n}\r
8470         fIntFlowDirectCorrelations->Fill(24.,cos(2.*n*phi1+n*phi2+n*phi3-2.*n*phi4-n*phi5-n*phi6),1.); //<6>_{2n,n,n|2n,n,n}\r
8471         fIntFlowDirectCorrelations->Fill(25.,cos(2.*n*phi1+2.*n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.); //<6>_{2n,2n|n,n,n,n}\r
8472         fIntFlowDirectCorrelations->Fill(26.,cos(3.*n*phi1+n*phi2-n*phi3-n*phi4-n*phi5-n*phi6),1.);    //<6>_{3n,n|n,n,n,n}  \r
8473        } // end of for(Int_t i6=0;i6<nPrim;i6++)\r
8474       } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8475      } // end of for(Int_t i4=0;i4<nPrim;i4++)\r
8476     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8477    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8478   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8479  } // end of if(nPrim>=6)\r
8480   \r
8481  // 7-particle correlations:\r
8482  if(nPrim>=7 && nPrim<=fMaxAllowedMultiplicity)\r
8483  {\r
8484   for(Int_t i1=0;i1<nPrim;i1++)\r
8485   { \r
8486    aftsTrack=anEvent->GetTrack(i1);\r
8487    if(!(aftsTrack->InRPSelection())) continue;\r
8488    phi1=aftsTrack->Phi();\r
8489    for(Int_t i2=0;i2<nPrim;i2++)\r
8490    {\r
8491     if(i2==i1)continue;\r
8492     aftsTrack=anEvent->GetTrack(i2);\r
8493     if(!(aftsTrack->InRPSelection())) continue;\r
8494     phi2=aftsTrack->Phi();\r
8495     for(Int_t i3=0;i3<nPrim;i3++)\r
8496     {\r
8497      if(i3==i1||i3==i2)continue;\r
8498      aftsTrack=anEvent->GetTrack(i3);\r
8499      if(!(aftsTrack->InRPSelection())) continue;\r
8500      phi3=aftsTrack->Phi();\r
8501      for(Int_t i4=0;i4<nPrim;i4++)\r
8502      {\r
8503       if(i4==i1||i4==i2||i4==i3)continue;\r
8504       aftsTrack=anEvent->GetTrack(i4);\r
8505       if(!(aftsTrack->InRPSelection())) continue;\r
8506       phi4=aftsTrack->Phi();\r
8507       for(Int_t i5=0;i5<nPrim;i5++)\r
8508       {\r
8509        if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8510        aftsTrack=anEvent->GetTrack(i5);\r
8511        if(!(aftsTrack->InRPSelection())) continue;\r
8512        phi5=aftsTrack->Phi();\r
8513        for(Int_t i6=0;i6<nPrim;i6++)\r
8514        {\r
8515         if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8516         aftsTrack=anEvent->GetTrack(i6);\r
8517         if(!(aftsTrack->InRPSelection())) continue;\r
8518         phi6=aftsTrack->Phi(); \r
8519         for(Int_t i7=0;i7<nPrim;i7++)\r
8520         {\r
8521          if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;\r
8522          aftsTrack=anEvent->GetTrack(i7);\r
8523          if(!(aftsTrack->InRPSelection())) continue;\r
8524          phi7=aftsTrack->Phi(); \r
8525          if(nPrim==7) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<"\r"<<flush;\r
8526          // fill the profile with 7-p correlation:   \r
8527          fIntFlowDirectCorrelations->Fill(28.,cos(2.*n*phi1+n*phi2+n*phi3-n*phi4-n*phi5-n*phi6-n*phi7),1.); // <7>_{2n,n,n|n,n,n,n}\r
8528         } // end of for(Int_t i7=0;i7<nPrim;i7++)\r
8529        } // end of for(Int_t i6=0;i6<nPrim;i6++) \r
8530       } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8531      } // end of for(Int_t i4=0;i4<nPrim;i4++)  \r
8532     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8533    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8534   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8535  } // end of if(nPrim>=7)\r
8536  \r
8537  // 8-particle correlations:\r
8538  if(nPrim>=8 && nPrim<=fMaxAllowedMultiplicity)\r
8539  {\r
8540   for(Int_t i1=0;i1<nPrim;i1++)\r
8541   {\r
8542    aftsTrack=anEvent->GetTrack(i1);\r
8543    if(!(aftsTrack->InRPSelection())) continue;\r
8544    phi1=aftsTrack->Phi();\r
8545    for(Int_t i2=0;i2<nPrim;i2++)\r
8546    {\r
8547     if(i2==i1)continue;\r
8548     aftsTrack=anEvent->GetTrack(i2);\r
8549     if(!(aftsTrack->InRPSelection())) continue;\r
8550     phi2=aftsTrack->Phi();\r
8551     for(Int_t i3=0;i3<nPrim;i3++)\r
8552     {\r
8553      if(i3==i1||i3==i2)continue;\r
8554      aftsTrack=anEvent->GetTrack(i3);\r
8555      if(!(aftsTrack->InRPSelection())) continue;\r
8556      phi3=aftsTrack->Phi();\r
8557      for(Int_t i4=0;i4<nPrim;i4++)\r
8558      {\r
8559       if(i4==i1||i4==i2||i4==i3)continue;\r
8560       aftsTrack=anEvent->GetTrack(i4);\r
8561       if(!(aftsTrack->InRPSelection())) continue;\r
8562       phi4=aftsTrack->Phi();\r
8563       for(Int_t i5=0;i5<nPrim;i5++)\r
8564       {\r
8565        if(i5==i1||i5==i2||i5==i3||i5==i4)continue;\r
8566        aftsTrack=anEvent->GetTrack(i5);\r
8567        if(!(aftsTrack->InRPSelection())) continue;\r
8568        phi5=aftsTrack->Phi();\r
8569        for(Int_t i6=0;i6<nPrim;i6++)\r
8570        {\r
8571         if(i6==i1||i6==i2||i6==i3||i6==i4||i6==i5)continue;\r
8572         aftsTrack=anEvent->GetTrack(i6);\r
8573         if(!(aftsTrack->InRPSelection())) continue;\r
8574         phi6=aftsTrack->Phi();\r
8575         for(Int_t i7=0;i7<nPrim;i7++)\r
8576         {\r
8577          if(i7==i1||i7==i2||i7==i3||i7==i4||i7==i5||i7==i6)continue;\r
8578          aftsTrack=anEvent->GetTrack(i7);\r
8579          if(!(aftsTrack->InRPSelection())) continue;\r
8580          phi7=aftsTrack->Phi();\r
8581          for(Int_t i8=0;i8<nPrim;i8++)\r
8582          {\r
8583           if(i8==i1||i8==i2||i8==i3||i8==i4||i8==i5||i8==i6||i8==i7)continue;\r
8584           aftsTrack=anEvent->GetTrack(i8);\r
8585           if(!(aftsTrack->InRPSelection())) continue;\r
8586           phi8=aftsTrack->Phi();\r
8587           cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<" "<<i5<<" "<<i6<<" "<<i7<<" "<<i8<<"\r"<<flush;\r
8588           // fill the profile with 8-p correlation:   \r
8589           fIntFlowDirectCorrelations->Fill(30.,cos(n*phi1+n*phi2+n*phi3+n*phi4-n*phi5-n*phi6-n*phi7-n*phi8),1.); // <8>_{n,n,n,n|n,n,n,n}\r
8590          } // end of for(Int_t i8=0;i8<nPrim;i8++)\r
8591         } // end of for(Int_t i7=0;i7<nPrim;i7++) \r
8592        } // end of for(Int_t i6=0;i6<nPrim;i6++) \r
8593       } // end of for(Int_t i5=0;i5<nPrim;i5++)\r
8594      } // end of for(Int_t i4=0;i4<nPrim;i4++)  \r
8595     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8596    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8597   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8598  } // end of if(nPrim>=8)\r
8599  \r
8600  cout<<endl;\r
8601 \r
8602 } // end of AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent)\r
8603 \r
8604 \r
8605 //==================================================================================================================================\r
8606 \r
8607 \r
8608 void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()\r
8609 {\r
8610  // Cross-check results for multiparticle correlations needed for int. flow: results from Q-vectors vs results from nested loops.\r
8611 \r
8612  cout<<endl;\r
8613  cout<<endl;\r
8614  cout<<"   *****************************************"<<endl;\r
8615  cout<<"   **** cross-checking the correlations ****"<<endl;\r
8616  cout<<"   ****       for integrated flow       ****"<<endl;\r
8617  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
8618  {\r
8619   cout<<"   ****   (particle weights not used)   ****"<<endl;\r
8620  } else\r
8621    {\r
8622     cout<<"   ****     (particle weights used)     ****"<<endl;\r
8623    } \r
8624  cout<<"   *****************************************"<<endl;\r
8625  cout<<endl;\r
8626  cout<<endl;\r
8627 \r
8628  Int_t ciMax = 32; // to be improved (removed eventually when I calculate 6th and 8th order with particle weights)\r
8629  \r
8630  if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)\r
8631  {\r
8632   ciMax = 11;\r
8633  }\r
8634 \r
8635  for(Int_t ci=1;ci<=ciMax;ci++)\r
8636  {\r
8637   if(strcmp((fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)\r
8638   cout<<(fIntFlowCorrelationsAllPro->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)\r
8639   cout<<"from Q-vectors    = "<<fIntFlowCorrelationsAllPro->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)\r
8640   cout<<"from nested loops = "<<fIntFlowDirectCorrelations->GetBinContent(ci)<<endl;\r
8641   cout<<endl;\r
8642  }\r
8643   \r
8644 } // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrelations()\r
8645 \r
8646 \r
8647 //================================================================================================================================\r
8648 \r
8649 \r
8650 void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA()\r
8651 {\r
8652  // Cross-check results for corrections terms for non-uniform acceptance needed for int. flow: results from Q-vectors vs results from nested loops.\r
8653 \r
8654  cout<<endl;\r
8655  cout<<endl;\r
8656  cout<<"   *********************************************"<<endl;\r
8657  cout<<"   **** cross-checking the correction terms ****"<<endl;\r
8658  cout<<"   **** for non-uniform acceptance relevant ****"<<endl;\r
8659  cout<<"   ****         for integrated flow         ****"<<endl;\r
8660  if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))\r
8661  {\r
8662   cout<<"   ****     (particle weights not used)     ****"<<endl;\r
8663  } else\r
8664    {\r
8665     cout<<"   ****       (particle weights used)       ****"<<endl;\r
8666    } \r
8667  cout<<"   *********************************************"<<endl;\r
8668  cout<<endl;\r
8669  cout<<endl;\r
8670 \r
8671  for(Int_t ci=1;ci<=10;ci++) // correction term index\r
8672  {\r
8673   for(Int_t sc=0;sc<2;sc++) // sin or cos term\r
8674   {\r
8675    if(strcmp((fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci), "") == 0) continue; // to be improved (access finalized histogram here)\r
8676    cout<<(fIntFlowCorrectionTermsForNUAPro[sc]->GetXaxis())->GetBinLabel(ci)<<":"<<endl; // to be improved (access finalized histogram here)\r
8677    cout<<"from Q-vectors    = "<<fIntFlowCorrectionTermsForNUAPro[sc]->GetBinContent(ci)<<endl; // to be improved (access finalized histogram here)\r
8678    cout<<"from nested loops = "<<fIntFlowDirectCorrectionTermsForNUA[sc]->GetBinContent(ci)<<endl;\r
8679    cout<<endl;\r
8680   } // end of for(Int_t sc=0;sc<2;sc++) // sin or cos term\r
8681  } // end of for(Int_t ci=1;ci<=10;ci++) // correction term index\r
8682   \r
8683 } // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowCorrectionTermsForNUA() \r
8684 \r
8685 \r
8686 //================================================================================================================================\r
8687 \r
8688 \r
8689 void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
8690 {\r
8691  // Evaluate with nested loops multiparticle correlations for integrated flow (using the particle weights). \r
8692 \r
8693  // Results are stored in profile fIntFlowDirectCorrelations. \r
8694  // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrelations is organized as follows:\r
8695  //\r
8696  //  1st bin: <2>_{1n|1n} = two1n1nW1W1 = <w1 w2 cos(n*(phi1-phi2))>\r
8697  //  2nd bin: <2>_{2n|2n} = two2n2nW2W2 = <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
8698  //  3rd bin: <2>_{3n|3n} = two3n3nW3W3 = <w1^3 w2^3 cos(3n*(phi1-phi2))> \r
8699  //  4th bin: <2>_{4n|4n} = two4n4nW4W4 = <w1^4 w2^4 cos(4n*(phi1-phi2))>\r
8700  //  5th bin:           ----  EMPTY ----\r
8701  //  6th bin: <3>_{2n|1n,1n} = three2n1n1nW2W1W1 = <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
8702  //  7th bin: <3>_{3n|2n,1n} = ...\r
8703  //  8th bin: <3>_{4n|2n,2n} = ...\r
8704  //  9th bin: <3>_{4n|3n,1n} = ...\r
8705  // 10th bin:           ----  EMPTY ----\r
8706  // 11th bin: <4>_{1n,1n|1n,1n} = four1n1n1n1nW1W1W1W1 = <w1 w2 w3 w4 cos(n*(phi1+phi2-phi3-phi4))>\r
8707  // 12th bin: <4>_{2n,1n|2n,1n} = ...\r
8708  // 13th bin: <4>_{2n,2n|2n,2n} = ...\r
8709  // 14th bin: <4>_{3n|1n,1n,1n} = ... \r
8710  // 15th bin: <4>_{3n,1n|3n,1n} = ...\r
8711  // 16th bin: <4>_{3n,1n|2n,2n} = ...\r
8712  // 17th bin: <4>_{4n|2n,1n,1n} = ... \r
8713  // 18th bin:           ----  EMPTY ----\r
8714  // 19th bin: <5>_{2n|1n,1n,1n,1n} = ...\r
8715  // 20th bin: <5>_{2n,2n|2n,1n,1n} = ...\r
8716  // 21st bin: <5>_{3n,1n|2n,1n,1n} = ...\r
8717  // 22nd bin: <5>_{4n|1n,1n,1n,1n} = ...\r
8718  // 23rd bin:           ----  EMPTY ----\r
8719  // 24th bin: <6>_{1n,1n,1n|1n,1n,1n} = ...\r
8720  // 25th bin: <6>_{2n,1n,1n|2n,1n,1n} = ...\r
8721  // 26th bin: <6>_{2n,2n|1n,1n,1n,1n} = ...\r
8722  // 27th bin: <6>_{3n,1n|1n,1n,1n,1n} = ...\r
8723  // 28th bin:           ----  EMPTY ----\r
8724  // 29th bin: <7>_{2n,1n,1n|1n,1n,1n,1n} = ...\r
8725  // 30th bin:           ----  EMPTY ----\r
8726  // 31st bin: <8>_{1n,1n,1n,1n|1n,1n,1n,1n} = ...\r
8727  \r
8728  // Remark 2: When particle weights are used there are some extra correlations. They are stored in \r
8729  // fIntFlowExtraDirectCorrelations binning of which is organized as follows:\r
8730  \r
8731  // 1st bin: two1n1nW3W1 = <w1^3 w2 cos(n*(phi1-phi2))>\r
8732  // 2nd bin: two1n1nW1W1W2 = <w1 w2 w3^2 cos(n*(phi1-phi2))>  \r
8733  // ...\r
8734  \r
8735  Int_t nPrim = anEvent->NumberOfTracks(); \r
8736  AliFlowTrackSimple *aftsTrack = NULL;\r
8737  //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;\r
8738  //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;\r
8739  Double_t phi1=0., phi2=0., phi3=0., phi4=0.;\r
8740  Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1.;\r
8741  Int_t n = fHarmonic; \r
8742  Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8743  Double_t dMult = (*fSMpk)(0,0);\r
8744  cout<<endl;\r
8745  cout<<"Multiparticle correlations: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8746  if(dMult<2)\r
8747  {\r
8748   cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8749  } else if (dMult>fMaxAllowedMultiplicity)\r
8750    {\r
8751     cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8752    } else \r
8753      { \r
8754       cout<<"... evaluating nested loops (using particle weights) ..."<<endl;\r
8755      } \r
8756       \r
8757  // 2-particle correlations:       \r
8758  if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8759  {\r
8760   // 2 nested loops multiparticle correlations using particle weights:       \r
8761   for(Int_t i1=0;i1<nPrim;i1++)\r
8762   {\r
8763    aftsTrack=anEvent->GetTrack(i1);\r
8764    if(!(aftsTrack->InRPSelection())) continue;\r
8765    phi1=aftsTrack->Phi();\r
8766    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8767    for(Int_t i2=0;i2<nPrim;i2++)\r
8768    {\r
8769     if(i2==i1)continue;\r
8770     aftsTrack=anEvent->GetTrack(i2);\r
8771     if(!(aftsTrack->InRPSelection())) continue;\r
8772     phi2=aftsTrack->Phi();\r
8773     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));   \r
8774     if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8775     // 2-p correlations using particle weights:\r
8776     if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),wPhi1*wPhi2);                  // <w1   w2   cos( n*(phi1-phi2))>\r
8777     if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(1.5,cos(2.*n*(phi1-phi2)),pow(wPhi1,2)*pow(wPhi2,2)); // <w1^2 w2^2 cos(2n*(phi1-phi2))>\r
8778     if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(2.5,cos(3.*n*(phi1-phi2)),pow(wPhi1,3)*pow(wPhi2,3)); // <w1^3 w2^3 cos(3n*(phi1-phi2))>\r
8779     if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(3.5,cos(4.*n*(phi1-phi2)),pow(wPhi1,4)*pow(wPhi2,4)); // <w1^4 w2^4 cos(4n*(phi1-phi2))> \r
8780     // extra correlations: \r
8781     // 2-p extra correlations (do not appear if particle weights are not used):\r
8782     if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(0.5,cos(n*(phi1-phi2)),pow(wPhi1,3)*wPhi2); // <w1^3 w2 cos(n*(phi1-phi2))>\r
8783     // ...\r
8784    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8785   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8786  } // end of if(nPrim>=2)\r
8787 \r
8788  if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8789  { \r
8790   // 3 nested loops multiparticle correlations using particle weights:       \r
8791   for(Int_t i1=0;i1<nPrim;i1++)\r
8792   {\r
8793    aftsTrack=anEvent->GetTrack(i1);\r
8794    if(!(aftsTrack->InRPSelection())) continue;\r
8795    phi1=aftsTrack->Phi();\r
8796    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8797    for(Int_t i2=0;i2<nPrim;i2++)\r
8798    {\r
8799     if(i2==i1)continue;\r
8800     aftsTrack=anEvent->GetTrack(i2);\r
8801     if(!(aftsTrack->InRPSelection())) continue;\r
8802     phi2=aftsTrack->Phi();\r
8803     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
8804     for(Int_t i3=0;i3<nPrim;i3++)\r
8805     {\r
8806      if(i3==i1||i3==i2)continue;\r
8807      aftsTrack=anEvent->GetTrack(i3);\r
8808      if(!(aftsTrack->InRPSelection())) continue;\r
8809      phi3=aftsTrack->Phi();\r
8810      if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
8811      if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;\r
8812      // 3-p correlations using particle weights:\r
8813      if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(5.5,cos(2.*n*phi1-n*(phi2+phi3)),pow(wPhi1,2)*wPhi2*wPhi3); // <w1^2 w2 w3 cos(n*(2phi1-phi2-phi3))>\r
8814      // ...\r
8815      // extra correlations: \r
8816      // 2-p extra correlations (do not appear if particle weights are not used):\r
8817       if(fUsePhiWeights) fIntFlowExtraDirectCorrelations->Fill(1.5,cos(n*(phi1-phi2)),wPhi1*wPhi2*pow(wPhi3,2)); // <w1 w2 w3^2 cos(n*(phi1-phi2))>\r
8818      // ...\r
8819      // 3-p extra correlations (do not appear if particle weights are not used):\r
8820      // ...\r
8821     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8822    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8823   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8824  } // end of if(nPrim>=3)\r
8825  \r
8826  if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)\r
8827  {\r
8828   // 4 nested loops multiparticle correlations using particle weights:       \r
8829   for(Int_t i1=0;i1<nPrim;i1++)\r
8830   {\r
8831    aftsTrack=anEvent->GetTrack(i1);\r
8832    if(!(aftsTrack->InRPSelection())) continue;\r
8833    phi1=aftsTrack->Phi();\r
8834    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
8835    for(Int_t i2=0;i2<nPrim;i2++)\r
8836    {\r
8837     if(i2==i1)continue;\r
8838     aftsTrack=anEvent->GetTrack(i2);\r
8839     if(!(aftsTrack->InRPSelection())) continue;\r
8840     phi2=aftsTrack->Phi();\r
8841     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
8842     for(Int_t i3=0;i3<nPrim;i3++)\r
8843     {\r
8844      if(i3==i1||i3==i2)continue;\r
8845      aftsTrack=anEvent->GetTrack(i3);\r
8846      if(!(aftsTrack->InRPSelection())) continue;\r
8847      phi3=aftsTrack->Phi();\r
8848      if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
8849      for(Int_t i4=0;i4<nPrim;i4++)\r
8850      {\r
8851       if(i4==i1||i4==i2||i4==i3)continue;\r
8852       aftsTrack=anEvent->GetTrack(i4);\r
8853       if(!(aftsTrack->InRPSelection())) continue;\r
8854       phi4=aftsTrack->Phi();\r
8855       if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));\r
8856       if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))\r
8857       // 4-p correlations using particle weights:\r
8858       if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4); \r
8859       // extra correlations: \r
8860       // 2-p extra correlations (do not appear if particle weights are not used):\r
8861       // ...\r
8862       // 3-p extra correlations (do not appear if particle weights are not used):\r
8863       // ...\r
8864       // 4-p extra correlations (do not appear if particle weights are not used):\r
8865       // ...\r
8866      } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
8867     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
8868    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8869   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8870  } // end of if(nPrim>=4)\r
8871 \r
8872  cout<<endl; \r
8873 \r
8874 } // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
8875 \r
8876 \r
8877 //================================================================================================================================\r
8878 \r
8879 \r
8880 void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()\r
8881 {\r
8882  // Cross-check results for extra multiparticle correlations needed for int. flow \r
8883  // which appear only when particle weights are used: results from Q-vectors vs results from nested loops.\r
8884 \r
8885  cout<<endl;\r
8886  cout<<endl;\r
8887  cout<<"   ***********************************************"<<endl;\r
8888  cout<<"   **** cross-checking the extra correlations ****"<<endl;\r
8889  cout<<"   ****          for integrated flow          ****"<<endl;\r
8890  cout<<"   ***********************************************"<<endl;\r
8891  cout<<endl;\r
8892  cout<<endl;\r
8893  \r
8894  for(Int_t eci=1;eci<=2;eci++) // to be improved (increased eciMax eventually when I calculate 6th and 8th)\r
8895  {\r
8896   if(strcmp((fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci), "") == 0) continue;\r
8897   cout<<(fIntFlowExtraCorrelationsPro->GetXaxis())->GetBinLabel(eci)<<":"<<endl;\r
8898   cout<<"from Q-vectors    = "<<fIntFlowExtraCorrelationsPro->GetBinContent(eci)<<endl;\r
8899   cout<<"from nested loops = "<<fIntFlowExtraDirectCorrelations->GetBinContent(eci)<<endl;\r
8900   cout<<endl;\r
8901  }\r
8902 \r
8903 } // end of void AliFlowAnalysisWithQCumulants::CrossCheckIntFlowExtraCorrelations()\r
8904 \r
8905 \r
8906 //================================================================================================================================\r
8907 \r
8908 \r
8909 void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoops(AliFlowEventSimple* anEvent)\r
8910 {\r
8911  // Evaluate with nested loops correction terms for non-uniform acceptance relevant for NONAME integrated flow (to be improved (name)).\r
8912  //\r
8913  // Remark: Both sin and cos correction terms are calculated in this method. Sin terms are stored in fIntFlowDirectCorrectionTermsForNUA[0],\r
8914  // and cos terms in fIntFlowDirectCorrectionTermsForNUA[1]. Binning of fIntFlowDirectCorrectionTermsForNUA[sc] is organized as follows \r
8915  // (sc stands for either sin or cos):\r
8916  \r
8917  //  1st bin: <<sc(n*(phi1))>> \r
8918  //  2nd bin: <<sc(n*(phi1+phi2))>> \r
8919  //  3rd bin: <<sc(n*(phi1-phi2-phi3))>>\r
8920  //  ...\r
8921  \r
8922  Int_t nPrim = anEvent->NumberOfTracks(); \r
8923  AliFlowTrackSimple *aftsTrack = NULL;\r
8924  Double_t phi1=0., phi2=0., phi3=0.;\r
8925  Int_t n = fHarmonic; \r
8926  Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
8927  Double_t dMult = (*fSMpk)(0,0);\r
8928  cout<<endl;\r
8929  cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
8930  if(dMult<1)\r
8931  {\r
8932   cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
8933  } else if (dMult>fMaxAllowedMultiplicity)\r
8934    {\r
8935     cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
8936    } else \r
8937      { \r
8938       cout<<"... evaluating nested loops (without using particle weights)..."<<endl;\r
8939      }\r
8940  \r
8941  if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)\r
8942  {\r
8943   // 1-particle correction terms for non-uniform acceptance:       \r
8944   for(Int_t i1=0;i1<nPrim;i1++)\r
8945   {\r
8946    aftsTrack=anEvent->GetTrack(i1);\r
8947    if(!(aftsTrack->InRPSelection())) continue;\r
8948    phi1=aftsTrack->Phi();\r
8949    if(nPrim==1) cout<<i1<<"\r"<<flush;\r
8950    // sin terms:\r
8951    fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),1.); // <sin(n*phi1)>  \r
8952    // cos terms:\r
8953    fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),1.); // <cos(n*phi1)>\r
8954   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8955  } // end of if(nPrim>=1) \r
8956   \r
8957  if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
8958  {\r
8959   // 2-particle correction terms for non-uniform acceptance:       \r
8960   for(Int_t i1=0;i1<nPrim;i1++)\r
8961   {\r
8962    aftsTrack=anEvent->GetTrack(i1);\r
8963    if(!(aftsTrack->InRPSelection())) continue;\r
8964    phi1=aftsTrack->Phi();  \r
8965    for(Int_t i2=0;i2<nPrim;i2++)\r
8966    {\r
8967     if(i2==i1)continue;\r
8968     aftsTrack=anEvent->GetTrack(i2);\r
8969     if(!(aftsTrack->InRPSelection())) continue;\r
8970     phi2=aftsTrack->Phi();\r
8971     if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
8972     // sin terms:\r
8973     fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),1.); // <<sin(n*(phi1+phi2))>>\r
8974     // cos terms:\r
8975     fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),1.); // <<cos(n*(phi1+phi2))>>\r
8976    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
8977   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
8978  } // end of if(nPrim>=2)\r
8979 \r
8980  if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
8981  {\r
8982   // 3-particle correction terms for non-uniform acceptance:       \r
8983   for(Int_t i1=0;i1<nPrim;i1++)\r
8984   {\r
8985    aftsTrack=anEvent->GetTrack(i1);\r
8986    if(!(aftsTrack->InRPSelection())) continue;\r
8987    phi1=aftsTrack->Phi();\r
8988    for(Int_t i2=0;i2<nPrim;i2++)\r
8989    {\r
8990     if(i2==i1)continue;\r
8991     aftsTrack=anEvent->GetTrack(i2);\r
8992     if(!(aftsTrack->InRPSelection())) continue;\r
8993     phi2=aftsTrack->Phi();\r
8994     for(Int_t i3=0;i3<nPrim;i3++)\r
8995     {\r
8996      if(i3==i1||i3==i2)continue;\r
8997      aftsTrack=anEvent->GetTrack(i3);\r
8998      if(!(aftsTrack->InRPSelection())) continue;\r
8999      phi3=aftsTrack->Phi();\r
9000      if(nPrim>=3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush; // to be improved (eventually I will change this if statement)\r
9001      // sin terms:\r
9002      fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),1.); // <<sin(n*(phi1-phi2-phi3))>>\r
9003      // cos terms:\r
9004      fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),1.); // <<cos(n*(phi1-phi2-phi3))>>\r
9005     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
9006    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
9007   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
9008  } // end of if(nPrim>=3)\r
9009 \r
9010  cout<<endl;\r
9011 }\r
9012 //================================================================================================================================\r
9013 void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9014 {\r
9015  // Evaluate reduced correlations with nested loops without using the particle weights.\r
9016  \r
9017  // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
9018  // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:\r
9019  //           [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>] \r
9020  // Remark 3: <2'> = <cos(n*(psi1-phi2))>\r
9021  //           <4'> = <cos(n*(psi1+phi2-phi3-phi4))>\r
9022  // ...\r
9023  \r
9024  Int_t typeFlag = -1;\r
9025  Int_t ptEtaFlag = -1;\r
9026  if(type == "RP")\r
9027  {\r
9028   typeFlag = 0;\r
9029  } else if(type == "POI")\r
9030    {\r
9031     typeFlag = 1;\r
9032    }      \r
9033  if(ptOrEta == "Pt")\r
9034  {\r
9035   ptEtaFlag = 0;\r
9036  } else if(ptOrEta == "Eta")\r
9037    {\r
9038     ptEtaFlag = 1;\r
9039    } \r
9040  // shortcuts:\r
9041  Int_t t = typeFlag;\r
9042  Int_t pe = ptEtaFlag;\r
9043       \r
9044  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9045  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9046  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9047  \r
9048  Int_t nPrim = anEvent->NumberOfTracks(); \r
9049  AliFlowTrackSimple *aftsTrack = NULL;\r
9050  \r
9051  Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
9052  \r
9053  Int_t n = fHarmonic; \r
9054  \r
9055  // 2'-particle correlations:\r
9056  for(Int_t i1=0;i1<nPrim;i1++)\r
9057  {\r
9058   aftsTrack=anEvent->GetTrack(i1);\r
9059   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9060   if(ptOrEta == "Pt")\r
9061   { \r
9062    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9063   } else if (ptOrEta == "Eta")\r
9064     {\r
9065      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;    \r
9066     }\r
9067   psi1=aftsTrack->Phi(); \r
9068   for(Int_t i2=0;i2<nPrim;i2++)\r
9069   {\r
9070    if(i2==i1)continue;\r
9071    aftsTrack=anEvent->GetTrack(i2);\r
9072    // RP condition (!(first) particle in the correlator must be RP):\r
9073    if(!(aftsTrack->InRPSelection()))continue;\r
9074    phi2=aftsTrack->Phi();   \r
9075    // 2'-particle correlations: \r
9076    fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),1.); // <cos(n*(psi1-phi2))  \r
9077   }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
9078  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9079  \r
9080  /*\r
9081  \r
9082  // 3'-particle correlations:\r
9083  for(Int_t i1=0;i1<nPrim;i1++)\r
9084  {\r
9085   aftsTrack=anEvent->GetTrack(i1);\r
9086   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9087   if(ptOrEta == "Pt")\r
9088   { \r
9089    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9090   } else if (ptOrEta == "Eta")\r
9091     {\r
9092      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;    \r
9093     }\r
9094   psi1=aftsTrack->Phi();\r
9095   for(Int_t i2=0;i2<nPrim;i2++)\r
9096   {\r
9097    if(i2==i1)continue;\r
9098    aftsTrack=anEvent->GetTrack(i2);\r
9099    // RP condition (!(first) particle in the correlator must be RP):\r
9100    if(!(aftsTrack->InRPSelection())) continue;\r
9101    phi2=aftsTrack->Phi();\r
9102    for(Int_t i3=0;i3<nPrim;i3++)\r
9103    {\r
9104     if(i3==i1||i3==i2)continue;\r
9105     aftsTrack=anEvent->GetTrack(i3);\r
9106     // RP condition (!(first) particle in the correlator must be RP):\r
9107     if(!(aftsTrack->InRPSelection())) continue;\r
9108     phi3=aftsTrack->Phi();\r
9109     // to be improved : where to store it? ->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(2.*phi1-phi2-phi3)),1.); // <w1 w2 w3 cos(n(2psi1-phi2-phi3))> \r
9110    }//end of for(Int_t i3=0;i3<nPrim;i3++)  \r
9111   }//end of for(Int_t i2=0;i2<nPrim;i2++)  \r
9112  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9113  \r
9114  */\r
9115  \r
9116  // 4'-particle correlations:\r
9117  for(Int_t i1=0;i1<nPrim;i1++)\r
9118  {\r
9119   aftsTrack=anEvent->GetTrack(i1);\r
9120   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9121   if(ptOrEta == "Pt")\r
9122   { \r
9123    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9124   } else if (ptOrEta == "Eta")\r
9125     {\r
9126      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;    \r
9127     }\r
9128   psi1=aftsTrack->Phi();\r
9129   for(Int_t i2=0;i2<nPrim;i2++)\r
9130   {\r
9131    if(i2==i1) continue;\r
9132    aftsTrack=anEvent->GetTrack(i2);\r
9133    // RP condition (!(first) particle in the correlator must be RP): \r
9134    if(!(aftsTrack->InRPSelection())) continue;\r
9135    phi2=aftsTrack->Phi();\r
9136    for(Int_t i3=0;i3<nPrim;i3++)\r
9137    { \r
9138     if(i3==i1||i3==i2) continue;\r
9139     aftsTrack=anEvent->GetTrack(i3);\r
9140     // RP condition (!(first) particle in the correlator must be RP):\r
9141     if(!(aftsTrack->InRPSelection())) continue;\r
9142     phi3=aftsTrack->Phi();\r
9143     for(Int_t i4=0;i4<nPrim;i4++)\r
9144     {\r
9145      if(i4==i1||i4==i2||i4==i3) continue;\r
9146      aftsTrack=anEvent->GetTrack(i4);\r
9147      // RP condition (!(first) particle in the correlator must be RP):\r
9148      if(!(aftsTrack->InRPSelection())) continue;  \r
9149      phi4=aftsTrack->Phi();\r
9150      // 4'-particle correlations:\r
9151      fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),1.); // <cos(n(psi1+phi2-phi3-phi4))>     \r
9152     }//end of for(Int_t i4=0;i4<nPrim;i4++)\r
9153    }//end of for(Int_t i3=0;i3<nPrim;i3++)\r
9154   }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
9155  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9156       \r
9157  \r
9158 } // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9159 \r
9160 \r
9161 //================================================================================================================================\r
9162 \r
9163 \r
9164 void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)\r
9165 {\r
9166  // Compare correlations needed for diff. flow calculated with nested loops and those calculated from Q-vectors\r
9167  \r
9168  Int_t typeFlag = -1;\r
9169  Int_t ptEtaFlag = -1;\r
9170  if(type == "RP")\r
9171  {\r
9172   typeFlag = 0;\r
9173  } else if(type == "POI")\r
9174    {\r
9175     typeFlag = 1;\r
9176    }      \r
9177  if(ptOrEta == "Pt")\r
9178  {\r
9179   ptEtaFlag = 0;\r
9180  } else if(ptOrEta == "Eta")\r
9181    {\r
9182     ptEtaFlag = 1;\r
9183    } \r
9184  // shortcuts:\r
9185  Int_t t = typeFlag;\r
9186  Int_t pe = ptEtaFlag;\r
9187       \r
9188  TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9189  TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9190  TString reducedCorrelations[4] = {"<<cos(n(psi1-phi2))>>","<<cos(n(psi1+phi2-phi3-phi4))>>","",""}; // to be improved (access this from pro or hist)\r
9191  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9192  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9193  \r
9194  Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};\r
9195  \r
9196 \r
9197  cout<<endl;\r
9198  cout<<"   *****************************************"<<endl;\r
9199  cout<<"   **** cross-checking the correlations ****"<<endl;\r
9200  cout<<"   ****      for differential flow      ****"<<endl;\r
9201  cout<<"   ****               "<<rpORpoiString[t]<<"               ****"<<endl;\r
9202  cout<<"   *****************************************"<<endl; \r
9203  cout<<endl;\r
9204  cout<<"           "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;\r
9205  cout<<endl;\r
9206  \r
9207  for(Int_t rci=0;rci<2;rci++) // to be improved (calculate 6th and 8th order)\r
9208  {\r
9209   cout<<"      "<<reducedCorrelations[rci].Data()<<":"<<endl;\r
9210   cout<<"      from Q-vectors    = "<<fDiffFlowCorrelationsPro[t][pe][rci]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;\r
9211   cout<<"      from nested loops = "<<fDiffFlowDirectCorrelations[t][pe][rci]->GetBinContent(1)<<endl;\r
9212   cout<<endl;  \r
9213  } // end of for(Int_t rci=0;rci<4;rci++)\r
9214        \r
9215 } // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrelations(TString type, TString ptOrEta)\r
9216 \r
9217 \r
9218 //================================================================================================================================\r
9219 \r
9220 \r
9221 void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9222 {\r
9223  // Evaluate reduced correlations with nested loops without using the particle weights.\r
9224  \r
9225  // Remark 1: Reduced correlations are evaluated in pt bin number fCrossCheckInPtBinNo and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
9226  // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrelations[t][pe][ci], where indices runs as follows:\r
9227  //           [0=RP,1=POI][0=Pt,1=Eta][0=<2'>,1=<4'>,2=<6'>,3=<8'>] \r
9228  // Remark 3: <2'> = <w2 cos(n*(psi1-phi2))>\r
9229  //           <4'> = <w2 w3 w4 cos(n*(psi1+phi2-phi3-phi4))>\r
9230  // ...\r
9231   \r
9232  Int_t typeFlag = -1;\r
9233  Int_t ptEtaFlag = -1;\r
9234  if(type == "RP")\r
9235  {\r
9236   typeFlag = 0;\r
9237  } else if(type == "POI")\r
9238    {\r
9239     typeFlag = 1;\r
9240    }      \r
9241  if(ptOrEta == "Pt")\r
9242  {\r
9243   ptEtaFlag = 0;\r
9244  } else if(ptOrEta == "Eta")\r
9245    {\r
9246     ptEtaFlag = 1;\r
9247    } \r
9248  // shortcuts:\r
9249  Int_t t = typeFlag;\r
9250  Int_t pe = ptEtaFlag;\r
9251       \r
9252  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9253  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9254  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9255  \r
9256  Int_t nPrim = anEvent->NumberOfTracks(); \r
9257  AliFlowTrackSimple *aftsTrack = NULL;\r
9258  \r
9259  Double_t psi1=0., phi2=0., phi3=0., phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
9260  Double_t wPhi2=1., wPhi3=1., wPhi4=1.;// wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;\r
9261  \r
9262  Int_t n = fHarmonic; \r
9263  \r
9264  // 2'-particle correlations:\r
9265  for(Int_t i1=0;i1<nPrim;i1++)\r
9266  {\r
9267   aftsTrack=anEvent->GetTrack(i1);\r
9268   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9269   if(ptOrEta == "Pt")\r
9270   { \r
9271    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9272   } else if (ptOrEta == "Eta")\r
9273     {\r
9274      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
9275     }\r
9276   psi1=aftsTrack->Phi(); \r
9277   for(Int_t i2=0;i2<nPrim;i2++)\r
9278   {\r
9279    if(i2==i1) continue;\r
9280    aftsTrack=anEvent->GetTrack(i2);\r
9281    // RP condition (!(first) particle in the correlator must be RP):\r
9282    if(!(aftsTrack->InRPSelection())) continue;\r
9283    phi2=aftsTrack->Phi();   \r
9284    if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9285    // 2'-particle correlations: \r
9286    fDiffFlowDirectCorrelations[t][pe][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(1.*n*(psi1-phi2)),wPhi2); // <w2 cos(n*(psi1-phi2))  \r
9287   }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
9288  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9289  \r
9290  // 4'-particle correlations:\r
9291  for(Int_t i1=0;i1<nPrim;i1++)\r
9292  {\r
9293   aftsTrack=anEvent->GetTrack(i1);\r
9294   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9295   if(ptOrEta == "Pt")\r
9296   { \r
9297    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9298   } else if (ptOrEta == "Eta")\r
9299     {\r
9300      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
9301     }\r
9302   psi1=aftsTrack->Phi();\r
9303   for(Int_t i2=0;i2<nPrim;i2++)\r
9304   {\r
9305    if(i2==i1) continue;\r
9306    aftsTrack=anEvent->GetTrack(i2);\r
9307    // RP condition (!(first) particle in the correlator must be RP): \r
9308    if(!(aftsTrack->InRPSelection())) continue;\r
9309    phi2=aftsTrack->Phi();\r
9310    if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9311    for(Int_t i3=0;i3<nPrim;i3++)\r
9312    { \r
9313     if(i3==i1||i3==i2) continue;\r
9314     aftsTrack=anEvent->GetTrack(i3);\r
9315     // RP condition (!(first) particle in the correlator must be RP):\r
9316     if(!(aftsTrack->InRPSelection())) continue;\r
9317     phi3=aftsTrack->Phi();\r
9318     if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
9319     for(Int_t i4=0;i4<nPrim;i4++)\r
9320     {\r
9321      if(i4==i1||i4==i2||i4==i3) continue;\r
9322      aftsTrack=anEvent->GetTrack(i4);\r
9323      // RP condition (!(first) particle in the correlator must be RP):\r
9324      if(!(aftsTrack->InRPSelection())) continue;  \r
9325      phi4=aftsTrack->Phi();\r
9326      if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));\r
9327      // 4'-particle correlations <w2 w3 w4 cos(n(psi1+phi2-phi3-phi4))>:\r
9328      fDiffFlowDirectCorrelations[t][pe][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3-phi4)),wPhi2*wPhi3*wPhi4); \r
9329     }//end of for(Int_t i4=0;i4<nPrim;i4++)\r
9330    }//end of for(Int_t i3=0;i3<nPrim;i3++)\r
9331   }//end of for(Int_t i2=0;i2<nPrim;i2++) \r
9332  }//end of for(Int_t i1=0;i1<nPrim;i1++)      \r
9333  \r
9334 } // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrelationsWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9335 \r
9336 \r
9337 //================================================================================================================================\r
9338 \r
9339    \r
9340 void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9341 {\r
9342  // Evaluate with nested loops correction terms for non-uniform acceptance (both sin and cos terms) relevant for differential flow.\r
9343  \r
9344  // Remark 1: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo \r
9345  //           and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
9346  // Remark 2: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as: \r
9347  //           [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows: \r
9348  //  cti: \r
9349  //    0: <<sc n(psi1)>>\r
9350  //    1: <<sc n(psi1+phi2)>> \r
9351  //    2: <<sc n(psi1+phi2-phi3)>>\r
9352  //    3: <<sc n(psi1-phi2-phi3)>>\r
9353  //    4:\r
9354  //    5:\r
9355  //    6:\r
9356   \r
9357  Int_t typeFlag = -1;\r
9358  Int_t ptEtaFlag = -1;\r
9359  if(type == "RP")\r
9360  {\r
9361   typeFlag = 0;\r
9362  } else if(type == "POI")\r
9363    {\r
9364     typeFlag = 1;\r
9365    }      \r
9366  if(ptOrEta == "Pt")\r
9367  {\r
9368   ptEtaFlag = 0;\r
9369  } else if(ptOrEta == "Eta")\r
9370    {\r
9371     ptEtaFlag = 1;\r
9372    } \r
9373  // shortcuts:\r
9374  Int_t t = typeFlag;\r
9375  Int_t pe = ptEtaFlag;\r
9376       \r
9377  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9378  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9379  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9380  \r
9381  Int_t nPrim = anEvent->NumberOfTracks(); \r
9382  AliFlowTrackSimple *aftsTrack = NULL;\r
9383  \r
9384  Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
9385  \r
9386  Int_t n = fHarmonic; \r
9387  \r
9388  // 1-particle correction terms:\r
9389  for(Int_t i1=0;i1<nPrim;i1++)\r
9390  {\r
9391   aftsTrack=anEvent->GetTrack(i1);\r
9392   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9393   if(ptOrEta == "Pt")\r
9394   { \r
9395    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9396   } else if (ptOrEta == "Eta")\r
9397     {\r
9398      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
9399     }\r
9400   psi1=aftsTrack->Phi(); \r
9401   // sin terms: \r
9402   fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>  \r
9403   // cos terms: \r
9404   fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>  \r
9405  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9406    \r
9407  // 2-particle correction terms:\r
9408  for(Int_t i1=0;i1<nPrim;i1++)\r
9409  {\r
9410   aftsTrack=anEvent->GetTrack(i1);\r
9411   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9412   if(ptOrEta == "Pt")\r
9413   { \r
9414    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
9415   } else if (ptOrEta == "Eta")\r
9416     {\r
9417      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
9418     }\r
9419   psi1=aftsTrack->Phi(); \r
9420   for(Int_t i2=0;i2<nPrim;i2++)\r
9421   {\r
9422    if(i2==i1) continue;\r
9423    aftsTrack=anEvent->GetTrack(i2);\r
9424    // RP condition (!(first) particle in the correlator must be RP):\r
9425    if(!(aftsTrack->InRPSelection())) continue;\r
9426    phi2=aftsTrack->Phi();   \r
9427    // sin terms: \r
9428    fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),1.); // <<sin(n*(psi1+phi2))>>  \r
9429    // cos terms: \r
9430    fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),1.); // <<cos(n*(psi1+phi2))>>  \r
9431   }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
9432  }//end of for(Int_t i1=0;i1<nPrim;i1++)   \r
9433  \r
9434  // 3-particle correction terms:\r
9435  for(Int_t i1=0;i1<nPrim;i1++)\r
9436  {\r
9437   aftsTrack=anEvent->GetTrack(i1);\r
9438   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
9439   if(ptOrEta == "Pt")\r
9440   { \r
9441    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
9442   } else if (ptOrEta == "Eta")\r
9443     {\r
9444      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;    \r
9445     }\r
9446   psi1=aftsTrack->Phi();\r
9447   for(Int_t i2=0;i2<nPrim;i2++)\r
9448   {\r
9449    if(i2==i1) continue;\r
9450    aftsTrack=anEvent->GetTrack(i2);\r
9451    // RP condition (!(first) particle in the correlator must be RP):\r
9452    if(!(aftsTrack->InRPSelection())) continue;\r
9453    phi2=aftsTrack->Phi();\r
9454    for(Int_t i3=0;i3<nPrim;i3++)\r
9455    {\r
9456     if(i3==i1||i3==i2) continue;\r
9457     aftsTrack=anEvent->GetTrack(i3);\r
9458     // RP condition (!(first) particle in the correlator must be RP):\r
9459     if(!(aftsTrack->InRPSelection())) continue;\r
9460     phi3=aftsTrack->Phi();\r
9461     // sin terms: \r
9462     fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),1.); // <<sin(n*(psi1+phi2-phi3))>>  \r
9463     fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),1.); // <<sin(n*(psi1-phi2-phi3))>>  \r
9464     // cos terms: \r
9465     fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),1.); // <<cos(n*(psi1+phi2-phi3))>>  \r
9466     fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),1.); // <<cos(n*(psi1-phi2-phi3))>>  \r
9467    }//end of for(Int_t i3=0;i3<nPrim;i3++)  \r
9468   }//end of for(Int_t i2=0;i2<nPrim;i2++)  \r
9469  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
9470    \r
9471 } // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoops(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
9472 \r
9473 \r
9474 //================================================================================================================================\r
9475 \r
9476 \r
9477 void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)\r
9478 {\r
9479  // Compare corrections temrs for non-uniform acceptance needed for diff. flow calculated with nested loops and those calculated from Q-vectors\r
9480  \r
9481  Int_t typeFlag = -1;\r
9482  Int_t ptEtaFlag = -1;\r
9483  if(type == "RP")\r
9484  {\r
9485   typeFlag = 0;\r
9486  } else if(type == "POI")\r
9487    {\r
9488     typeFlag = 1;\r
9489    }      \r
9490  if(ptOrEta == "Pt")\r
9491  {\r
9492   ptEtaFlag = 0;\r
9493  } else if(ptOrEta == "Eta")\r
9494    {\r
9495     ptEtaFlag = 1;\r
9496    } \r
9497  // shortcuts:\r
9498  Int_t t = typeFlag;\r
9499  Int_t pe = ptEtaFlag;\r
9500       \r
9501  TString rpORpoiString[2] = {"RP ","POI"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9502  TString ptORetaString[2] = {"pt","eta"}; // to be improved (name in the same way as in the other methods, eventually promote to data member) \r
9503  //TString sinCosFlag[2] = {"sin","cos"}; // to be improved (eventually promote to data member)\r
9504  TString reducedCorrectionSinTerms[4] = {"<<sin(n(psi1))>>","<<sin(n(psi1+phi2))>>","<<sin(n*(psi1+phi2-phi3))>>","<<sin(n*(psi1-phi2-phi3))>>"}; // to be improved (access this from pro or hist)\r
9505  TString reducedCorrectionCosTerms[4] = {"<<cos(n(psi1))>>","<<cos(n(psi1+phi2))>>","<<cos(n*(psi1+phi2-phi3))>>","<<cos(n*(psi1-phi2-phi3))>>"}; // to be improved (access this from pro or hist)\r
9506  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
9507  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
9508  \r
9509  Int_t crossCheckInPtEtaBinNo[2] = {fCrossCheckInPtBinNo,fCrossCheckInEtaBinNo};\r
9510  \r
9511  cout<<endl;\r
9512  cout<<"   ******************************************"<<endl;\r
9513  cout<<"   ****  cross-checking the correction   ****"<<endl;\r
9514  cout<<"   **** terms for non-uniform acceptance ****"<<endl;\r
9515  cout<<"   ****      for differential flow       ****"<<endl;\r
9516  cout<<"   ****              "<<rpORpoiString[t]<<"                 ****"<<endl;\r
9517  cout<<"   ******************************************"<<endl; \r
9518  cout<<endl;\r
9519  cout<<"           "<<ptORetaString[pe]<<" bin: "<<lowerPtEtaEdge[pe]<<" <= "<<ptORetaString[pe]<<" < "<<upperPtEtaEdge[pe]<<endl;\r
9520  cout<<endl;\r
9521  \r
9522  for(Int_t cti=0;cti<4;cti++) // correction term index\r
9523  {\r
9524   for(Int_t sc=0;sc<2;sc++) // sin or cos terms\r
9525   {\r
9526    if(sc==0) // to be improved (this can be implemented better)\r
9527    { \r
9528     cout<<"      "<<reducedCorrectionSinTerms[cti].Data()<<":"<<endl;\r
9529    } else\r
9530      {\r
9531       cout<<"      "<<reducedCorrectionCosTerms[cti].Data()<<":"<<endl;     \r
9532      }\r
9533    cout<<"      from Q-vectors    = "<<fDiffFlowCorrectionTermsForNUAPro[t][pe][sc][cti]->GetBinContent(crossCheckInPtEtaBinNo[pe])<<endl;\r
9534    cout<<"      from nested loops = "<<fDiffFlowDirectCorrectionTermsForNUA[t][pe][sc][cti]->GetBinContent(1)<<endl;\r
9535    cout<<endl;  \r
9536   } \r
9537  } // end of for(Int_t rci=0;rci<4;rci++)\r
9538 \r
9539 } // end of void AliFlowAnalysisWithQCumulants::CrossCheckDiffFlowCorrectionTermsForNUA(TString type, TString ptOrEta)\r
9540 \r
9541 \r
9542 //================================================================================================================================
9543
9544 \r
9545 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()\r
9546 {\r
9547  // Calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (cos terms).\r
9548  \r
9549  //                                  **********************************************************************\r
9550  //                                  **** weighted corrections for non-uniform acceptance (cos terms): ****\r
9551  //                                  **********************************************************************\r
9552
9553  // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[1] is organized as follows:\r
9554  //
9555  // 1st bin: <<w1 cos(n*(phi1))>> = cosP1nW1\r
9556  // 2nd bin: <<w1 w2 cos(n*(phi1+phi2))>> = cosP1nP1nW1W1\r
9557  // 3rd bin: <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>> = cosP1nM1nM1nW1W1W1 \r
9558  // ...\r
9559
9560  // multiplicity (number of particles used to determine the reaction plane)\r
9561  Double_t dMult = (*fSMpk)(0,0);\r
9562  \r
9563  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
9564  Double_t dReQ1n1k = (*fReQ)(0,1);\r
9565  Double_t dReQ2n2k = (*fReQ)(1,2);\r
9566  //Double_t dReQ3n3k = (*fReQ)(2,3);\r
9567  //Double_t dReQ4n4k = (*fReQ)(3,4);\r
9568  Double_t dReQ1n3k = (*fReQ)(0,3);\r
9569  Double_t dImQ1n1k = (*fImQ)(0,1);\r
9570  Double_t dImQ2n2k = (*fImQ)(1,2);\r
9571  //Double_t dImQ3n3k = (*fImQ)(2,3);\r
9572  //Double_t dImQ4n4k = (*fImQ)(3,4);\r
9573  //Double_t dImQ1n3k = (*fImQ)(0,3);\r
9574 \r
9575  // dMs are variables introduced in order to simplify some Eqs. bellow:\r
9576  //..............................................................................................\r
9577  Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
9578  Double_t dM111 = (*fSMpk)(2,1)-3.*(*fSMpk)(0,2)*(*fSMpk)(0,1)
9579                 + 2.*(*fSMpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k\r
9580  //..............................................................................................\r
9581         \r // 1-particle:\r
9582  Double_t cosP1nW1 = 0.; // <<w1 cos(n*(phi1))>>\r
9583    \r
9584  if(dMult>0 && (*fSMpk)(0,1) !=0.)\r
9585  {\r
9586   cosP1nW1 = dReQ1n1k/(*fSMpk)(0,1); \r
9587   \r
9588   // average weighted 1-particle correction (cos terms) for non-uniform acceptance for single event:\r
9589   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(1,cosP1nW1);\r
9590   \r
9591   // final average weighted 1-particle correction (cos terms) for non-uniform acceptance for all events:\r
9592   fIntFlowCorrectionTermsForNUAPro[1]->Fill(0.5,cosP1nW1,(*fSMpk)(0,1));  \r
9593  } \r
9594  \r
9595  // 2-particle:\r
9596  Double_t cosP1nP1nW1W1 = 0.; // <<w1 w2 cos(n*(phi1+phi2))>>\r
9597  \r
9598  if(dMult>1 && dM11 !=0.)\r
9599  {\r
9600   cosP1nP1nW1W1 = (pow(dReQ1n1k,2)-pow(dImQ1n1k,2)-dReQ2n2k)/dM11; \r
9601   \r
9602   // average weighted 2-particle correction (cos terms) for non-uniform acceptance for single event:\r
9603   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(2,cosP1nP1nW1W1);\r
9604   \r
9605   // final average weighted 2-particle correction (cos terms) for non-uniform acceptance for all events:\r
9606   fIntFlowCorrectionTermsForNUAPro[1]->Fill(1.5,cosP1nP1nW1W1,dM11);  \r
9607  } \r
9608  \r
9609  // 3-particle:\r
9610  Double_t cosP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 cos(n*(phi1-phi2-phi3))>>\r
9611  \r
9612  if(dMult>2 && dM111 !=0.)\r
9613  {\r
9614   cosP1nM1nM1nW1W1W1 = (dReQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
9615                      - dReQ1n1k*dReQ2n2k-dImQ1n1k*dImQ2n2k
9616                      - 2.*((*fSMpk)(0,2))*dReQ1n1k
9617                      + 2.*dReQ1n3k) \r
9618                      / dM111; \r
9619   \r
9620   // average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for single event:\r
9621   fIntFlowCorrectionTermsForNUAEBE[1]->SetBinContent(3,cosP1nM1nM1nW1W1W1);\r
9622   \r
9623   // final average non-weighted 3-particle correction (cos terms) for non-uniform acceptance for all events:\r
9624   fIntFlowCorrectionTermsForNUAPro[1]->Fill(2.5,cosP1nM1nM1nW1W1W1,dM111);  \r
9625  } \r
9626  \r
9627 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUACosTermsUsingParticleWeights()\r
9628 \r
9629 \r
9630 //================================================================================================================================\r
9631 \r
9632 \r
9633 void AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()\r
9634 {\r
9635  // calculate corrections using particle weights for non-uniform acceptance of the detector for no-name integrated flow (sin terms)\r
9636  \r
9637  //                                  **********************************************************************\r
9638  //                                  **** weighted corrections for non-uniform acceptance (sin terms): ****\r
9639  //                                  **********************************************************************\r
9640
9641  // Remark 1: When particle weights are used the binning of fIntFlowCorrectionTermsForNUAPro[0] is organized as follows:\r
9642  //
9643  // 1st bin: <<w1 sin(n*(phi1))>> = sinP1nW1\r
9644  // 2nd bin: <<w1 w2 sin(n*(phi1+phi2))>> = sinP1nP1nW1W1\r
9645  // 3rd bin: <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>> = sinP1nM1nM1nW1W1W1 \r
9646  // ...\r
9647
9648  // multiplicity (number of particles used to determine the reaction plane)\r
9649  Double_t dMult = (*fSMpk)(0,0);\r
9650  \r
9651  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
9652  Double_t dReQ1n1k = (*fReQ)(0,1);\r
9653  Double_t dReQ2n2k = (*fReQ)(1,2);\r
9654  //Double_t dReQ3n3k = (*fReQ)(2,3);\r
9655  //Double_t dReQ4n4k = (*fReQ)(3,4);\r
9656  //Double_t dReQ1n3k = (*fReQ)(0,3);\r
9657  Double_t dImQ1n1k = (*fImQ)(0,1);\r
9658  Double_t dImQ2n2k = (*fImQ)(1,2);\r
9659  //Double_t dImQ3n3k = (*fImQ)(2,3);\r
9660  //Double_t dImQ4n4k = (*fImQ)(3,4);\r
9661  Double_t dImQ1n3k = (*fImQ)(0,3);\r
9662 \r
9663  // dMs are variables introduced in order to simplify some Eqs. bellow:\r
9664  //..............................................................................................\r
9665  Double_t dM11 = (*fSMpk)(1,1)-(*fSMpk)(0,2); // dM11 = sum_{i,j=1,i!=j}^M w_i w_j\r
9666  Double_t dM111 = (*fSMpk)(2,1)-3.*(*fSMpk)(0,2)*(*fSMpk)(0,1)
9667                 + 2.*(*fSMpk)(0,3); // dM111 = sum_{i,j,k=1,i!=j!=k}^M w_i w_j w_k\r
9668  //..............................................................................................\r
9669  \r
9670  // 1-particle:\r
9671  Double_t sinP1nW1 = 0.; // <<w1 sin(n*(phi1))>>\r
9672  \r
9673  if(dMult>0 && (*fSMpk)(0,1) !=0.)\r
9674  {\r
9675   sinP1nW1 = dImQ1n1k/((*fSMpk)(0,1)); \r
9676      \r
9677   // average weighted 1-particle correction (sin terms) for non-uniform acceptance for single event:\r
9678   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(1,sinP1nW1);\r
9679   \r
9680   // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:   \r
9681   fIntFlowCorrectionTermsForNUAPro[0]->Fill(0.5,sinP1nW1,(*fSMpk)(0,1));  \r
9682  } \r
9683  \r
9684  // 2-particle:\r
9685  Double_t sinP1nP1nW1W1 = 0.; // <<w1 w2 sin(n*(phi1+phi2))>>\r
9686  \r
9687  if(dMult>1 && dM11 !=0.)\r
9688  {\r
9689   sinP1nP1nW1W1 = (2.*dReQ1n1k*dImQ1n1k-dImQ2n2k)/dM11; \r
9690      \r
9691   // average weighted 2-particle correction (sin terms) for non-uniform acceptance for single event:\r
9692   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(2,sinP1nP1nW1W1);\r
9693   \r
9694   // final average weighted 1-particle correction (sin terms) for non-uniform acceptance for all events:      \r
9695   fIntFlowCorrectionTermsForNUAPro[0]->Fill(1.5,sinP1nP1nW1W1,dM11);  \r
9696  } \r
9697  \r
9698  // 3-particle:\r
9699  Double_t sinP1nM1nM1nW1W1W1 = 0.; // <<w1 w2 w3 sin(n*(phi1-phi2-phi3))>>\r
9700  \r
9701  if(dMult>2 && dM111 !=0.)\r
9702  {\r
9703   sinP1nM1nM1nW1W1W1 = (-dImQ1n1k*(pow(dReQ1n1k,2)+pow(dImQ1n1k,2))
9704                      + dReQ1n1k*dImQ2n2k-dImQ1n1k*dReQ2n2k
9705                      + 2.*((*fSMpk)(0,2))*dImQ1n1k
9706                      - 2.*dImQ1n3k)\r
9707                      / dM111; \r
9708   \r
9709   // average weighted 3-particle correction (sin terms) for non-uniform acceptance for single event:\r
9710   fIntFlowCorrectionTermsForNUAEBE[0]->SetBinContent(3,sinP1nM1nM1nW1W1W1);\r
9711   \r
9712   // final average weighted 3-particle correction (sin terms) for non-uniform acceptance for all events:  \r
9713   fIntFlowCorrectionTermsForNUAPro[0]->Fill(2.5,sinP1nM1nM1nW1W1W1,dM111);  \r
9714  } \r
9715  \r
9716 } // end of AliFlowAnalysisWithQCumulants::CalculateIntFlowCorrectionsForNUASinTermsUsingParticleWeights()\r
9717 \r
9718 \r
9719 //================================================================================================================================
9720 \r
9721 \r
9722 void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
9723 {\r
9724  // Evaluate with nested loops correction terms for non-uniform acceptance for integrated flow (using the particle weights). \r
9725 \r
9726  // Results are stored in profiles fIntFlowDirectCorrectionTermsForNUA[0] (sin terms) and
9727  // fIntFlowDirectCorrectionTermsForNUA[1] (cos terms).
9728  \r
9729  // Remark 1: When particle weights are used the binning of fIntFlowDirectCorrectionTermsForNUA[sc] is
9730  // organized as follows (sc stands for either sin or cos):\r
9731  //\r
9732  // 1st bin: <<w1 sc(n*(phi1))>> = scP1nW1\r
9733  // 2nd bin: <<w1 w2 sc(n*(phi1+phi2))>> = scP1nP1nW1W1\r
9734  // 3rd bin: <<w1 w2 w3 sc(n*(phi1-phi2-phi3))>> = scP1nM1nM1nW1W1W1 \r
9735  // ...\r
9736  \r
9737  Int_t nPrim = anEvent->NumberOfTracks(); \r
9738  AliFlowTrackSimple *aftsTrack = NULL;\r
9739  //Double_t phi1=0., phi2=0., phi3=0., phi4=0., phi5=0., phi6=0., phi7=0., phi8=0.;\r
9740  //Double_t wPhi1=1., wPhi2=1., wPhi3=1., wPhi4=1., wPhi5=1., wPhi6=1., wPhi7=1., wPhi8=1.;\r
9741  Double_t phi1=0., phi2=0., phi3=0.;\r
9742  Double_t wPhi1=1., wPhi2=1., wPhi3=1.;\r
9743  Int_t n = fHarmonic; \r
9744  Int_t eventNo = (Int_t)fAvMultiplicity->GetBinEntries(1); // to be improved (is this casting safe in general?)\r
9745  Double_t dMult = (*fSMpk)(0,0);\r
9746  cout<<endl;\r
9747  cout<<"Correction terms for non-uniform acceptance: Event number: "<<eventNo<<", multiplicity is "<<dMult<<endl;\r
9748  if(dMult<1)\r
9749  {\r
9750   cout<<"... skipping this event (multiplicity too low) ..."<<endl;\r
9751  } else if (dMult>fMaxAllowedMultiplicity)\r
9752    {\r
9753     cout<<"... skipping this event (multiplicity too high) ..."<<endl;\r
9754    } else \r
9755      { \r
9756       cout<<"... evaluating nested loops (using particle weights) ..."<<endl;\r
9757      } \r
9758       \r
9759  // 1-particle correction terms using particle weights:       \r
9760  if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)\r
9761  {\r
9762   for(Int_t i1=0;i1<nPrim;i1++)\r
9763   {\r
9764    aftsTrack=anEvent->GetTrack(i1);\r
9765    if(!(aftsTrack->InRPSelection())) continue;\r
9766    phi1=aftsTrack->Phi();\r
9767    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
9768    // 1-particle correction terms using particle weights:
9769    if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(0.5,sin(n*phi1),wPhi1); // <w1 sin(n*phi1)>\r
9770    if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(0.5,cos(n*phi1),wPhi1); // <w1 cos(n*phi1)>\r
9771   } // end of for(Int_t i1=0;i1<nPrim;i1++)
9772  } // end of if(nPrim>=1 && nPrim<=fMaxAllowedMultiplicity)
9773
9774  // 2-particle correction terms using particle weights:       \r
9775  if(nPrim>=2 && nPrim<=fMaxAllowedMultiplicity)\r
9776  {\r
9777   for(Int_t i1=0;i1<nPrim;i1++)\r
9778   {\r
9779    aftsTrack=anEvent->GetTrack(i1);\r
9780    if(!(aftsTrack->InRPSelection())) continue;\r
9781    phi1=aftsTrack->Phi();\r
9782    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
9783    for(Int_t i2=0;i2<nPrim;i2++)\r
9784    {\r
9785     if(i2==i1)continue;\r
9786     aftsTrack=anEvent->GetTrack(i2);\r
9787     if(!(aftsTrack->InRPSelection())) continue;\r
9788     phi2=aftsTrack->Phi();\r
9789     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));   \r
9790     if(nPrim==2) cout<<i1<<" "<<i2<<"\r"<<flush;\r
9791     // 2-p correction terms using particle weights:
9792     if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(1.5,sin(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 sin(n*(phi1+phi2))>\r
9793     if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(1.5,cos(n*(phi1+phi2)),wPhi1*wPhi2); // <w1 w2 cos(n*(phi1+phi2))>\r
9794    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
9795   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
9796  } // end of if(nPrim>=2)\r
9797 \r
9798  // 3-particle correction terms using particle weights:       \r
9799  if(nPrim>=3 && nPrim<=fMaxAllowedMultiplicity)\r
9800  { \r
9801   for(Int_t i1=0;i1<nPrim;i1++)\r
9802   {\r
9803    aftsTrack=anEvent->GetTrack(i1);\r
9804    if(!(aftsTrack->InRPSelection())) continue;\r
9805    phi1=aftsTrack->Phi();\r
9806    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
9807    for(Int_t i2=0;i2<nPrim;i2++)\r
9808    {\r
9809     if(i2==i1)continue;\r
9810     aftsTrack=anEvent->GetTrack(i2);\r
9811     if(!(aftsTrack->InRPSelection())) continue;\r
9812     phi2=aftsTrack->Phi();\r
9813     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9814     for(Int_t i3=0;i3<nPrim;i3++)\r
9815     {\r
9816      if(i3==i1||i3==i2)continue;\r
9817      aftsTrack=anEvent->GetTrack(i3);\r
9818      if(!(aftsTrack->InRPSelection())) continue;\r
9819      phi3=aftsTrack->Phi();\r
9820      if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
9821      if(nPrim==3) cout<<i1<<" "<<i2<<" "<<i3<<"\r"<<flush;\r
9822      // 3-p correction terms using particle weights:
9823      if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[0]->Fill(2.5,sin(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 sin(n*(phi1-phi2-phi3))>\r
9824      if(fUsePhiWeights) fIntFlowDirectCorrectionTermsForNUA[1]->Fill(2.5,cos(n*(phi1-phi2-phi3)),wPhi1*wPhi2*wPhi3); // <w1 w2 w3 cos(n*(phi1-phi2-phi3))>\r
9825     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
9826    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
9827   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
9828  } // end of if(nPrim>=3)\r
9829  \r
9830  /*
9831
9832  if(nPrim>=4 && nPrim<=fMaxAllowedMultiplicity)\r
9833  {\r
9834   // 4 nested loops multiparticle correlations using particle weights:       \r
9835   for(Int_t i1=0;i1<nPrim;i1++)\r
9836   {\r
9837    aftsTrack=anEvent->GetTrack(i1);\r
9838    if(!(aftsTrack->InRPSelection())) continue;\r
9839    phi1=aftsTrack->Phi();\r
9840    if(fUsePhiWeights && fPhiWeights) wPhi1 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi1*fnBinsPhi/TMath::TwoPi())));\r
9841    for(Int_t i2=0;i2<nPrim;i2++)\r
9842    {\r
9843     if(i2==i1)continue;\r
9844     aftsTrack=anEvent->GetTrack(i2);\r
9845     if(!(aftsTrack->InRPSelection())) continue;\r
9846     phi2=aftsTrack->Phi();\r
9847     if(fUsePhiWeights && fPhiWeights) wPhi2 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi2*fnBinsPhi/TMath::TwoPi())));\r
9848     for(Int_t i3=0;i3<nPrim;i3++)\r
9849     {\r
9850      if(i3==i1||i3==i2)continue;\r
9851      aftsTrack=anEvent->GetTrack(i3);\r
9852      if(!(aftsTrack->InRPSelection())) continue;\r
9853      phi3=aftsTrack->Phi();\r
9854      if(fUsePhiWeights && fPhiWeights) wPhi3 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi3*fnBinsPhi/TMath::TwoPi())));\r
9855      for(Int_t i4=0;i4<nPrim;i4++)\r
9856      {\r
9857       if(i4==i1||i4==i2||i4==i3)continue;\r
9858       aftsTrack=anEvent->GetTrack(i4);\r
9859       if(!(aftsTrack->InRPSelection())) continue;\r
9860       phi4=aftsTrack->Phi();\r
9861       if(fUsePhiWeights && fPhiWeights) wPhi4 = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(phi4*fnBinsPhi/TMath::TwoPi())));\r
9862       if(nPrim>=4) cout<<i1<<" "<<i2<<" "<<i3<<" "<<i4<<"\r"<<flush; // to be improved (replace eventually this if statement with if(nPrim==4))\r
9863       // 4-p correlations using particle weights:\r
9864       if(fUsePhiWeights) fIntFlowDirectCorrelations->Fill(10.5,cos(n*phi1+n*phi2-n*phi3-n*phi4),wPhi1*wPhi2*wPhi3*wPhi4); \r
9865       // extra correlations: \r
9866       // 2-p extra correlations (do not appear if particle weights are not used):\r
9867       // ...\r
9868       // 3-p extra correlations (do not appear if particle weights are not used):\r
9869       // ...\r
9870       // 4-p extra correlations (do not appear if particle weights are not used):\r
9871       // ...\r
9872      } // end of for(Int_t i4=0;i4<nPrim;i4++) \r
9873     } // end of for(Int_t i3=0;i3<nPrim;i3++)\r
9874    } // end of for(Int_t i2=0;i2<nPrim;i2++)\r
9875   } // end of for(Int_t i1=0;i1<nPrim;i1++)\r
9876  } // end of if(nPrim>=4)\r
9877
9878  */\r
9879
9880  cout<<endl; \r
9881 \r
9882 } // end of void AliFlowAnalysisWithQCumulants::EvaluateIntFlowCorrectionsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent)\r
9883 \r
9884 \r
9885 //================================================================================================================================
9886 \r
9887 \r
9888 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)\r
9889 {\r
9890  // Calculate correction terms for non-uniform acceptance for differential flow (cos terms) using particle weights.\r
9891
9892  type+=""; // to be removed
9893  ptOrEta+=""; // to be removed
9894
9895 // Remark: w1 bellow is a particle weight used only for particles which were flagged both as POI and RP.
9896  \r
9897  // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][1][cti], where cti runs as follows:\r
9898  //
9899  //  0: <<w1 cos n(psi)>>\r
9900  //  1: <<w1 w2 cos n(psi1+phi2)>>\r
9901  //  2: <<w1 w2 w3 cos n(psi1+phi2-phi3)>>\r
9902  //  3: <<w1 w2 w3 cos n(psi1-phi2-phi3)>>\r
9903  //  4:\r
9904  //  5:\r
9905  //  6:\r
9906  \r
9907  /*
9908
9909  // multiplicity:\r
9910  Double_t dMult = (*fSMpk)(0,0);\r
9911  \r
9912  // real and imaginary parts of weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
9913  Double_t dReQ1n1k = (*fReQ)(0,1);\r
9914  Double_t dReQ2n2k = (*fReQ)(1,2);\r
9915  Double_t dReQ1n3k = (*fReQ)(0,3);\r
9916  //Double_t dReQ4n4k = (*fReQ)(3,4);\r
9917  Double_t dImQ1n1k = (*fImQ)(0,1);\r
9918  Double_t dImQ2n2k = (*fImQ)(1,2);\r
9919  Double_t dImQ1n3k = (*fImQ)(0,3);\r
9920  //Double_t dImQ4n4k = (*fImQ)(3,4);\r
9921
9922  // S^M_{p,k} (see .h file for the definition of fSMpk):\r
9923  Double_t dSM1p1k = (*fSMpk)(0,1);\r
9924  Double_t dSM1p2k = (*fSMpk)(0,2);\r
9925  Double_t dSM1p3k = (*fSMpk)(0,3);\r
9926  Double_t dSM2p1k = (*fSMpk)(1,1);\r
9927  Double_t dSM3p1k = (*fSMpk)(2,1);\r
9928 \r
9929  Int_t t = -1; // type flag \r
9930  Int_t pe = -1; // ptEta flag\r
9931  \r
9932  if(type == "RP")\r
9933  {\r
9934   t = 0;\r
9935  } else if(type == "POI")\r
9936    {\r
9937     t = 1;\r
9938    }\r
9939 \r
9940  if(ptOrEta == "Pt")\r
9941  {\r
9942   pe = 0;\r
9943  } else if(ptOrEta == "Eta")\r
9944    {\r
9945     pe = 1;\r
9946    }\r
9947     \r
9948  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
9949  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
9950  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
9951  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
9952 \r
9953  // looping over all bins and calculating correction terms: \r
9954  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
9955  {\r
9956   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
9957   Double_t p1n0kRe = 0.;\r
9958   Double_t p1n0kIm = 0.;\r
9959 \r
9960   // number of POIs in particular pt or eta bin:\r
9961   Double_t mp = 0.;\r
9962 \r
9963   // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
9964   Double_t q1n0kRe = 0.;\r
9965   Double_t q1n0kIm = 0.;\r
9966   Double_t q2n0kRe = 0.;\r
9967   Double_t q2n0kIm = 0.;\r
9968 \r
9969   // real and imaginary parts of q_{m*n,0} (weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
9970   Double_t q1n1kRe = 0.;\r
9971   Double_t q1n1kIm = 0.;\r
9972   Double_t q1n2kRe = 0.;\r
9973   Double_t q1n2kIm = 0.;\r
9974   Double_t q2n1kRe = 0.;\r
9975   Double_t q2n1kIm = 0.;\r
9976   Double_t q2n2kRe = 0.;\r
9977   Double_t q2n2kIm = 0.;\r
9978
9979   // number of particles which are both RPs and POIs in particular pt or eta bin:\r
9980   Double_t mq = 0.;\r
9981
9982   // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
9983   Double_t s1p1k = 0.; \r
9984   Double_t s1p2k = 0.; \r
9985   Double_t s1p3k = 0.; \r
9986
9987   if(type == "POI")\r
9988   {\r
9989    // p_{m*n,k}:
9990    p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
9991            * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
9992    p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
9993            * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));
9994    mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)                \r
9995    // q_{m*n,k}:\r
9996    q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
9997            * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
9998    q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
9999            * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
10000    q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
10001            * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
10002    q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
10003            * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));         \r
10004    q1n1kRe = fReRPQ1dEBE[2][pe][0][1]->GetBinContent(fReRPQ1dEBE[2][pe][0][1]->GetBin(b))\r
10005            * fReRPQ1dEBE[2][pe][0][1]->GetBinEntries(fReRPQ1dEBE[2][pe][0][1]->GetBin(b));\r
10006    q1n1kIm = fImRPQ1dEBE[2][pe][0][1]->GetBinContent(fImRPQ1dEBE[2][pe][0][1]->GetBin(b))\r
10007            * fImRPQ1dEBE[2][pe][0][1]->GetBinEntries(fImRPQ1dEBE[2][pe][0][1]->GetBin(b));\r
10008    q2n2kRe = fReRPQ1dEBE[2][pe][1][2]->GetBinContent(fReRPQ1dEBE[2][pe][1][2]->GetBin(b))\r
10009            * fReRPQ1dEBE[2][pe][1][2]->GetBinEntries(fReRPQ1dEBE[2][pe][1][2]->GetBin(b));\r
10010    q2n2kIm = fImRPQ1dEBE[2][pe][1][2]->GetBinContent(fImRPQ1dEBE[2][pe][1][2]->GetBin(b))\r
10011            * fImRPQ1dEBE[2][pe][1][2]->GetBinEntries(fImRPQ1dEBE[2][pe][1][2]->GetBin(b));
10012    mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
10013    // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
10014    s1p1k = pow(fs1dEBE[2][pe][1]->GetBinContent(b)*fs1dEBE[2][pe][1]->GetBinEntries(b),1.); \r
10015    s1p2k = pow(fs1dEBE[2][pe][2]->GetBinContent(b)*fs1dEBE[2][pe][2]->GetBinEntries(b),1.); \r
10016    s1p3k = pow(fs1dEBE[2][pe][3]->GetBinContent(b)*fs1dEBE[2][pe][3]->GetBinEntries(b),1.);
10017    // typeFlag = RP (0) or POI (1):
10018    t = 1; \r
10019   }else if(type == "RP")\r
10020    {\r
10021     // q_{m*n,k}: (Remark: m=1 is 0, k=0 iz zero (to be improved!)) \r
10022     q1n2kRe = fReRPQ1dEBE[0][pe][0][2]->GetBinContent(fReRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
10023             * fReRPQ1dEBE[0][pe][0][2]->GetBinEntries(fReRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
10024     q1n2kIm = fImRPQ1dEBE[0][pe][0][2]->GetBinContent(fImRPQ1dEBE[0][pe][0][2]->GetBin(b))\r
10025             * fImRPQ1dEBE[0][pe][0][2]->GetBinEntries(fImRPQ1dEBE[0][pe][0][2]->GetBin(b));\r
10026     q2n1kRe = fReRPQ1dEBE[0][pe][1][1]->GetBinContent(fReRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
10027             * fReRPQ1dEBE[0][pe][1][1]->GetBinEntries(fReRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
10028     q2n1kIm = fImRPQ1dEBE[0][pe][1][1]->GetBinContent(fImRPQ1dEBE[0][pe][1][1]->GetBin(b))\r
10029             * fImRPQ1dEBE[0][pe][1][1]->GetBinEntries(fImRPQ1dEBE[0][pe][1][1]->GetBin(b));\r
10030     // s_{1,1}, s_{1,2} and s_{1,3} // to be improved (add explanation)  \r
10031     s1p1k = pow(fs1dEBE[0][pe][1]->GetBinContent(b)*fs1dEBE[0][pe][1]->GetBinEntries(b),1.); \r
10032     s1p2k = pow(fs1dEBE[0][pe][2]->GetBinContent(b)*fs1dEBE[0][pe][2]->GetBinEntries(b),1.); \r
10033     s1p3k = pow(fs1dEBE[0][pe][3]->GetBinContent(b)*fs1dEBE[0][pe][3]->GetBinEntries(b),1.); \r
10034     \r
10035     // to be improved (cross-checked):\r
10036     p1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
10037             * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
10038     p1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))  \r
10039             * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
10040     mp = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
10041     // typeFlag = RP (0) or POI (1): \r
10042     t = 0;\r
10043   }    \r
10044   \r
10045   // <<w1 cos n(psi1)>>:\r
10046   Double_t cosP1nPsiW1 = 0.;\r
10047   if(mp-mq+s1p1k)\r
10048   {\r
10049    cosP1nPsiW1 = (p1n0kRe-q1n0kRe+q1n1kRe)/(mp-mq+s1p1k);\r
10050    \r
10051    // fill profile for <<w1 cos n(psi1)>>:\r
10052    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiW1,mp-mq+s1p1k);\r
10053    // histogram to store <w1 cos n(psi1)> e-b-e (needed in some other methods):\r
10054    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][0]->SetBinContent(b,cosP1nPsiW1);\r
10055   } // end of if(mp-mq+s1p1k)   \r
10056   \r
10057
10058
10059   // <<w1 w2 cos n(psi1+phi2)>>:\r
10060   Double_t cosP1nPsiP1nPhi = 0.;\r
10061   if(mp*dMult-mq)\r
10062   {\r
10063    cosP1nPsiP1nPhi = (p1n0kRe*dReQ1n-p1n0kIm*dImQ1n-q2n0kRe)/(mp*dMult-mq);\r
10064    // fill profile for <<w1 w2 cos n(psi1+phi2)>>:\r
10065    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsiP1nPhi,mp*dMult-mq);\r
10066    // histogram to store <w1 w2 cos n(psi1+phi2)> e-b-e (needed in some other methods):\r
10067    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][1]->SetBinContent(b,cosP1nPsiP1nPhi);\r
10068   } // end of if(mp*dMult-mq)   \r
10069   \r
10070   // <<w1 w2 w3 cos n(psi1+phi2-phi3)>>:\r
10071   Double_t cosP1nPsi1P1nPhi2MPhi3 = 0.;\r
10072   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
10073   {\r
10074    cosP1nPsi1P1nPhi2MPhi3 = (p1n0kRe*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
10075                           - 1.*(q2n0kRe*dReQ1n+q2n0kIm*dImQ1n)  \r
10076                           - mq*dReQ1n+2.*q1n0kRe)\r
10077                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10078    // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:\r
10079    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10080    // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):\r
10081    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][2]->SetBinContent(b,cosP1nPsi1P1nPhi2MPhi3);\r
10082   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
10083   \r
10084   // <<w1 w2 w3 cos n(psi1-phi2-phi3)>>:\r
10085   Double_t cosP1nPsi1M1nPhi2MPhi3 = 0.;\r
10086   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
10087   {\r
10088    cosP1nPsi1M1nPhi2MPhi3 = (p1n0kRe*(pow(dReQ1n,2.)-pow(dImQ1n,2.))+2.*p1n0kIm*dReQ1n*dImQ1n\r
10089                           - 1.*(p1n0kRe*dReQ2n+p1n0kIm*dImQ2n)  \r
10090                           - 2.*mq*dReQ1n+2.*q1n0kRe)\r
10091                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10092    // fill profile for <<w1 w2 w3 cos n(psi1+phi2)>>:\r
10093    fDiffFlowCorrectionTermsForNUAPro[t][pe][1][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],cosP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10094    // histogram to store <w1 w2 w3 cos n(psi1+phi2)> e-b-e (needed in some other methods):\r
10095    fDiffFlowCorrectionTermsForNUAEBE[t][pe][1][3]->SetBinContent(b,cosP1nPsi1M1nPhi2MPhi3);\r
10096   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
10097
10098
10099  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
10100
10101  */
10102
10103 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUACosTermsUsingParticleWeights(TString type, TString ptOrEta)
10104
10105 \r
10106 //================================================================================================================================\r
10107 \r
10108 \r
10109 void AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)\r
10110 {\r
10111  // Calculate correction terms for non-uniform acceptance for differential flow (sin terms).\r
10112
10113  type+=""; // to be removed
10114  ptOrEta+=""; // to be removed
10115
10116  // Results are stored in fDiffFlowCorrectionTermsForNUAPro[t][pe][0][cti], where cti runs as follows:\r
10117  //  0: <<sin n(psi1)>>\r
10118  //  1: <<sin n(psi1+phi2)>>\r
10119  //  2: <<sin n(psi1+phi2-phi3)>>\r
10120  //  3: <<sin n(psi1-phi2-phi3)>>:\r
10121  //  4:\r
10122  //  5:\r
10123  //  6:\r
10124
10125  /*
10126
10127  // multiplicity:\r
10128  Double_t dMult = (*fSMpk)(0,0);\r
10129  \r
10130  // real and imaginary parts of non-weighted Q-vectors evaluated in harmonics n, 2n, 3n and 4n: \r
10131  Double_t dReQ1n = (*fReQ)(0,0);\r
10132  Double_t dReQ2n = (*fReQ)(1,0);\r
10133  //Double_t dReQ3n = (*fReQ)(2,0);\r
10134  //Double_t dReQ4n = (*fReQ)(3,0);\r
10135  Double_t dImQ1n = (*fImQ)(0,0);\r
10136  Double_t dImQ2n = (*fImQ)(1,0);\r
10137  //Double_t dImQ3n = (*fImQ)(2,0);\r
10138  //Double_t dImQ4n = (*fImQ)(3,0);\r
10139 \r
10140  Int_t t = -1; // type flag \r
10141  Int_t pe = -1; // ptEta flag\r
10142  \r
10143  if(type == "RP")\r
10144  {\r
10145   t = 0;\r
10146  } else if(type == "POI")\r
10147    {\r
10148     t = 1;\r
10149    }\r
10150 \r
10151  if(ptOrEta == "Pt")\r
10152  {\r
10153   pe = 0;\r
10154  } else if(ptOrEta == "Eta")\r
10155    {\r
10156     pe = 1;\r
10157    }\r
10158     \r
10159  Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};\r
10160  Double_t minPtEta[2] = {fPtMin,fEtaMin};\r
10161  //Double_t maxPtEta[2] = {fPtMax,fEtaMax};\r
10162  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
10163 \r
10164  // looping over all bins and calculating correction terms: \r
10165  for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
10166  {\r
10167   // real and imaginary parts of p_{m*n,0} (non-weighted Q-vector evaluated for POIs in particular pt or eta bin): \r
10168   Double_t p1n0kRe = 0.;\r
10169   Double_t p1n0kIm = 0.;\r
10170 \r
10171   // number of POIs in particular pt or eta bin:\r
10172   Double_t mp = 0.;\r
10173 \r
10174   // real and imaginary parts of q_{m*n,0} (non-weighted Q-vector evaluated for particles which are both RPs and POIs in particular pt or eta bin):\r
10175   Double_t q1n0kRe = 0.;\r
10176   Double_t q1n0kIm = 0.;\r
10177   Double_t q2n0kRe = 0.;\r
10178   Double_t q2n0kIm = 0.;\r
10179 \r
10180   // number of particles which are both RPs and POIs in particular pt or eta bin:\r
10181   Double_t mq = 0.;\r
10182    \r
10183   if(type == "POI")\r
10184   {\r
10185    // q_{m*n,0}:\r
10186    q1n0kRe = fReRPQ1dEBE[2][pe][0][0]->GetBinContent(fReRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
10187            * fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
10188    q1n0kIm = fImRPQ1dEBE[2][pe][0][0]->GetBinContent(fImRPQ1dEBE[2][pe][0][0]->GetBin(b))\r
10189            * fImRPQ1dEBE[2][pe][0][0]->GetBinEntries(fImRPQ1dEBE[2][pe][0][0]->GetBin(b));\r
10190    q2n0kRe = fReRPQ1dEBE[2][pe][1][0]->GetBinContent(fReRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
10191            * fReRPQ1dEBE[2][pe][1][0]->GetBinEntries(fReRPQ1dEBE[2][pe][1][0]->GetBin(b));\r
10192    q2n0kIm = fImRPQ1dEBE[2][pe][1][0]->GetBinContent(fImRPQ1dEBE[2][pe][1][0]->GetBin(b))\r
10193            * fImRPQ1dEBE[2][pe][1][0]->GetBinEntries(fImRPQ1dEBE[2][pe][1][0]->GetBin(b));         \r
10194                  \r
10195    mq = fReRPQ1dEBE[2][pe][0][0]->GetBinEntries(fReRPQ1dEBE[2][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
10196   } \r
10197   else if(type == "RP")\r
10198   {\r
10199    // q_{m*n,0}:\r
10200    q1n0kRe = fReRPQ1dEBE[0][pe][0][0]->GetBinContent(fReRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
10201            * fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
10202    q1n0kIm = fImRPQ1dEBE[0][pe][0][0]->GetBinContent(fImRPQ1dEBE[0][pe][0][0]->GetBin(b))\r
10203            * fImRPQ1dEBE[0][pe][0][0]->GetBinEntries(fImRPQ1dEBE[0][pe][0][0]->GetBin(b));\r
10204    q2n0kRe = fReRPQ1dEBE[0][pe][1][0]->GetBinContent(fReRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
10205            * fReRPQ1dEBE[0][pe][1][0]->GetBinEntries(fReRPQ1dEBE[0][pe][1][0]->GetBin(b));\r
10206    q2n0kIm = fImRPQ1dEBE[0][pe][1][0]->GetBinContent(fImRPQ1dEBE[0][pe][1][0]->GetBin(b))\r
10207            * fImRPQ1dEBE[0][pe][1][0]->GetBinEntries(fImRPQ1dEBE[0][pe][1][0]->GetBin(b));         \r
10208                  \r
10209    mq = fReRPQ1dEBE[0][pe][0][0]->GetBinEntries(fReRPQ1dEBE[0][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)  \r
10210   }    \r
10211   if(type == "POI")\r
10212   {\r
10213    // p_{m*n,0}:\r
10214    p1n0kRe = fReRPQ1dEBE[1][pe][0][0]->GetBinContent(fReRPQ1dEBE[1][pe][0][0]->GetBin(b))\r
10215            * fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
10216    p1n0kIm = fImRPQ1dEBE[1][pe][0][0]->GetBinContent(fImRPQ1dEBE[1][pe][0][0]->GetBin(b))  \r
10217            * fImRPQ1dEBE[1][pe][0][0]->GetBinEntries(fImRPQ1dEBE[1][pe][0][0]->GetBin(b));\r
10218             \r
10219    mp = fReRPQ1dEBE[1][pe][0][0]->GetBinEntries(fReRPQ1dEBE[1][pe][0][0]->GetBin(b)); // to be improved (cross-checked by accessing other profiles here)\r
10220     \r
10221    t = 1; // typeFlag = RP or POI\r
10222   }\r
10223   else if(type == "RP")\r
10224   {\r
10225    // p_{m*n,0} = q_{m*n,0}:\r
10226    p1n0kRe = q1n0kRe; \r
10227    p1n0kIm = q1n0kIm; \r
10228            \r
10229    mp = mq; \r
10230    \r
10231    t = 0; // typeFlag = RP or POI\r
10232   }\r
10233 \r
10234   // <<sin n(psi1)>>:\r
10235   Double_t sinP1nPsi = 0.;\r
10236   if(mp)\r
10237   {\r
10238    sinP1nPsi = p1n0kIm/mp;\r
10239    // fill profile for <<sin n(psi1)>>:\r
10240    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][0]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi,mp);\r
10241    // histogram to store <sin n(psi1)> e-b-e (needed in some other methods):\r
10242    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][0]->SetBinContent(b,sinP1nPsi);\r
10243   } // end of if(mp)   \r
10244   \r
10245   // <<sin n(psi1+phi2)>>:\r
10246   Double_t sinP1nPsiP1nPhi = 0.;\r
10247   if(mp*dMult-mq)\r
10248   {\r
10249    sinP1nPsiP1nPhi = (p1n0kRe*dImQ1n+p1n0kIm*dReQ1n-q2n0kIm)/(mp*dMult-mq);\r
10250    // fill profile for <<sin n(psi1+phi2)>>:\r
10251    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][1]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsiP1nPhi,mp*dMult-mq);\r
10252    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
10253    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][1]->SetBinContent(b,sinP1nPsiP1nPhi);\r
10254   } // end of if(mp*dMult-mq)   \r
10255   \r
10256   // <<sin n(psi1+phi2-phi3)>>:\r
10257   Double_t sinP1nPsi1P1nPhi2MPhi3 = 0.;\r
10258   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
10259   {\r
10260    sinP1nPsi1P1nPhi2MPhi3 = (p1n0kIm*(pow(dImQ1n,2.)+pow(dReQ1n,2.)-dMult)\r
10261                           - 1.*(q2n0kIm*dReQ1n-q2n0kRe*dImQ1n)  \r
10262                           - mq*dImQ1n+2.*q1n0kIm)\r
10263                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10264    // fill profile for <<sin n(psi1+phi2)>>:\r
10265    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][2]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1P1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10266    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
10267    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][2]->SetBinContent(b,sinP1nPsi1P1nPhi2MPhi3);\r
10268   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
10269   \r
10270   // <<sin n(psi1-phi2-phi3)>>:\r
10271   Double_t sinP1nPsi1M1nPhi2MPhi3 = 0.;\r
10272   if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))\r
10273   {\r
10274    sinP1nPsi1M1nPhi2MPhi3 = (p1n0kIm*(pow(dReQ1n,2.)-pow(dImQ1n,2.))-2.*p1n0kRe*dReQ1n*dImQ1n\r
10275                           - 1.*(p1n0kIm*dReQ2n-p1n0kRe*dImQ2n)\r
10276                           + 2.*mq*dImQ1n-2.*q1n0kIm)\r
10277                           / (mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10278    // fill profile for <<sin n(psi1+phi2)>>:\r
10279    fDiffFlowCorrectionTermsForNUAPro[t][pe][0][3]->Fill(minPtEta[pe]+(b-1)*binWidthPtEta[pe],sinP1nPsi1M1nPhi2MPhi3,mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.));\r
10280    // histogram to store <sin n(psi1+phi2)> e-b-e (needed in some other methods):\r
10281    fDiffFlowCorrectionTermsForNUAEBE[t][pe][0][3]->SetBinContent(b,sinP1nPsi1M1nPhi2MPhi3);\r
10282   } // end of if(mq*(dMult-1.)*(dMult-2.)+(mp-mq)*dMult*(dMult-1.))   \r
10283  } // end of for(Int_t b=1;b<=nBinsPtEta[pe];b++)\r
10284  \r
10285  */
10286
10287 } // end of AliFlowAnalysisWithQCumulants::CalculateDiffFlowCorrectionsForNUASinTermsUsingParticleWeights(TString type, TString ptOrEta)\r
10288 \r
10289 \r
10290 //================================================================================================================================\r
10291 \r
10292    \r
10293 void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
10294 {\r
10295  // Evaluate with nested loops correction terms for non-uniform acceptance
10296  // with using particle weights (both sin and cos terms) relevant for differential flow.\r
10297  \r
10298  anEvent->NumberOfTracks(); // to be removed
10299  ptOrEta+=""; // to be removed
10300  type+=""; // to be removed
10301
10302  // Remark 1: "w1" in expressions bellow is a particle weight used only for particles which were
10303  //           flagged both as POI and RP.
10304  // Remark 2: Reduced correction terms for non-uniform acceptance are evaluated in pt bin number fCrossCheckInPtBinNo \r
10305  //           and eta bin number fCrossCheckInEtaBinNo both for RPs and POIs.\r
10306  // Remark 3: Results are stored in 1 bin profiles fDiffFlowDirectCorrections[t][pe][sc][cti], where first three indices runs as: \r
10307  //           [0=RP,1=POI][0=Pt,1=Eta][0=sin terms,1=cos terms], whilst the cti (correction term index) runs as follows: \r
10308  //  cti: \r
10309  //    0: <<w1 sc n(psi1)>>\r
10310  //    1: <<w1 w2 sc n(psi1+phi2)>> \r
10311  //    2: <<w1 w2 w3 sc n(psi1+phi2-phi3)>>\r
10312  //    3: <<w1 w2 w3 sc n(psi1-phi2-phi3)>>\r
10313  //    4:\r
10314  //    5:\r
10315  //    6:\r
10316     \r
10317  /*
10318
10319  Int_t typeFlag = -1;\r
10320  Int_t ptEtaFlag = -1;\r
10321  if(type == "RP")\r
10322  {\r
10323   typeFlag = 0;\r
10324  } else if(type == "POI")\r
10325    {\r
10326     typeFlag = 1;\r
10327    }      \r
10328  if(ptOrEta == "Pt")\r
10329  {\r
10330   ptEtaFlag = 0;\r
10331  } else if(ptOrEta == "Eta")\r
10332    {\r
10333     ptEtaFlag = 1;\r
10334    } \r
10335  // shortcuts:\r
10336  Int_t t = typeFlag;\r
10337  Int_t pe = ptEtaFlag;\r
10338       \r
10339  Double_t lowerPtEtaEdge[2] = {fPtMin+(fCrossCheckInPtBinNo-1)*fPtBinWidth,fEtaMin+(fCrossCheckInEtaBinNo-1)*fEtaBinWidth};\r
10340  Double_t upperPtEtaEdge[2] = {fPtMin+fCrossCheckInPtBinNo*fPtBinWidth,fEtaMin+fCrossCheckInEtaBinNo*fEtaBinWidth};\r
10341  Double_t binWidthPtEta[2] = {fPtBinWidth,fEtaBinWidth};\r
10342  \r
10343  Int_t nPrim = anEvent->NumberOfTracks(); \r
10344  AliFlowTrackSimple *aftsTrack = NULL;\r
10345  \r
10346  Double_t psi1=0., phi2=0., phi3=0.;// phi4=0.;// phi5=0., phi6=0., phi7=0., phi8=0.;\r
10347  \r
10348  Int_t n = fHarmonic; \r
10349  \r
10350  // 1-particle correction terms:\r
10351  for(Int_t i1=0;i1<nPrim;i1++)\r
10352  {\r
10353   aftsTrack=anEvent->GetTrack(i1);\r
10354   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
10355   if(ptOrEta == "Pt")\r
10356   { \r
10357    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
10358   } else if (ptOrEta == "Eta")\r
10359     {\r
10360      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
10361     }\r
10362   psi1=aftsTrack->Phi(); \r
10363   // sin terms: \r
10364   fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*psi1),1.); // <<sin(n*(psi1))>>  \r
10365   // cos terms: \r
10366   fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][0]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*psi1),1.); // <<cos(n*(psi1))>>  \r
10367  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
10368    \r
10369  // 2-particle correction terms:\r
10370  for(Int_t i1=0;i1<nPrim;i1++)\r
10371  {\r
10372   aftsTrack=anEvent->GetTrack(i1);\r
10373   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
10374   if(ptOrEta == "Pt")\r
10375   { \r
10376    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;\r
10377   } else if (ptOrEta == "Eta")\r
10378     {\r
10379      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection()))) continue;    \r
10380     }\r
10381   psi1=aftsTrack->Phi(); \r
10382   for(Int_t i2=0;i2<nPrim;i2++)\r
10383   {\r
10384    if(i2==i1) continue;\r
10385    aftsTrack=anEvent->GetTrack(i2);\r
10386    // RP condition (!(first) particle in the correlator must be RP):\r
10387    if(!(aftsTrack->InRPSelection())) continue;\r
10388    phi2=aftsTrack->Phi();   \r
10389    // sin terms: \r
10390    fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2)),1.); // <<sin(n*(psi1+phi2))>>  \r
10391    // cos terms: \r
10392    fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][1]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2)),1.); // <<cos(n*(psi1+phi2))>>  \r
10393   }//end of for(Int_t i2=0;i2<nPrim;i2++)\r
10394  }//end of for(Int_t i1=0;i1<nPrim;i1++)   \r
10395  \r
10396  // 3-particle correction terms:\r
10397  for(Int_t i1=0;i1<nPrim;i1++)\r
10398  {\r
10399   aftsTrack=anEvent->GetTrack(i1);\r
10400   // POI condition (first particle in the correlator must be POI): // to be improved (this can be implemented much better)\r
10401   if(ptOrEta == "Pt")\r
10402   { \r
10403    if(!((aftsTrack->Pt()>=lowerPtEtaEdge[pe] && aftsTrack->Pt()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;\r
10404   } else if (ptOrEta == "Eta")\r
10405     {\r
10406      if(!((aftsTrack->Eta()>=lowerPtEtaEdge[pe] && aftsTrack->Eta()<upperPtEtaEdge[pe]) && (aftsTrack->InPOISelection())))continue;    \r
10407     }\r
10408   psi1=aftsTrack->Phi();\r
10409   for(Int_t i2=0;i2<nPrim;i2++)\r
10410   {\r
10411    if(i2==i1) continue;\r
10412    aftsTrack=anEvent->GetTrack(i2);\r
10413    // RP condition (!(first) particle in the correlator must be RP):\r
10414    if(!(aftsTrack->InRPSelection())) continue;\r
10415    phi2=aftsTrack->Phi();\r
10416    for(Int_t i3=0;i3<nPrim;i3++)\r
10417    {\r
10418     if(i3==i1||i3==i2) continue;\r
10419     aftsTrack=anEvent->GetTrack(i3);\r
10420     // RP condition (!(first) particle in the correlator must be RP):\r
10421     if(!(aftsTrack->InRPSelection())) continue;\r
10422     phi3=aftsTrack->Phi();\r
10423     // sin terms: \r
10424     fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1+phi2-phi3)),1.); // <<sin(n*(psi1+phi2-phi3))>>  \r
10425     fDiffFlowDirectCorrectionTermsForNUA[t][pe][0][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,sin(n*(psi1-phi2-phi3)),1.); // <<sin(n*(psi1-phi2-phi3))>>  \r
10426     // cos terms: \r
10427     fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][2]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1+phi2-phi3)),1.); // <<cos(n*(psi1+phi2-phi3))>>  \r
10428     fDiffFlowDirectCorrectionTermsForNUA[t][pe][1][3]->Fill(lowerPtEtaEdge[pe]+binWidthPtEta[pe]/2.,cos(n*(psi1-phi2-phi3)),1.); // <<cos(n*(psi1-phi2-phi3))>>  \r
10429    }//end of for(Int_t i3=0;i3<nPrim;i3++)  \r
10430   }//end of for(Int_t i2=0;i2<nPrim;i2++)  \r
10431  }//end of for(Int_t i1=0;i1<nPrim;i1++)\r
10432
10433  */
10434                \r
10435 } // end of void AliFlowAnalysisWithQCumulants::EvaluateDiffFlowCorrectionTermsForNUAWithNestedLoopsUsingParticleWeights(AliFlowEventSimple* anEvent, TString type, TString ptOrEta)\r
10436 \r
10437 \r
10438
10439
10440