ROOT logo
/*************************************************************************
* Copyright(c) 1998-2008, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  * 
**************************************************************************/

/* $Id$ */

/************************************************* 
 * Flow analysis with cumulants. In this class   *
 * cumulants are calculated by making use of the *
 * formalism of generating functions proposed by *
 * Ollitrault et al.                             *
 *                                               * 
 *      Author: Ante Bilandzic                   * 
 *              (abilandzic@gmail.com)           *
 *************************************************/ 

#define AliFlowAnalysisWithCumulants_cxx

#include "Riostream.h"
#include "TMath.h"
#include "TFile.h"
#include "TList.h"
#include "TProfile.h"
#include "TProfile2D.h" 
#include "TProfile3D.h"
#include "TH1F.h"
#include "TH1D.h"
#include "TMatrixD.h"
#include "TVectorD.h"

#include "AliFlowCommonConstants.h"
#include "AliFlowCommonHist.h"
#include "AliFlowCommonHistResults.h"
#include "AliFlowEventSimple.h"
#include "AliFlowTrackSimple.h"
#include "AliFlowAnalysisWithCumulants.h"
#include "AliFlowVector.h"

//================================================================================================================

using std::endl;
using std::cout;
ClassImp(AliFlowAnalysisWithCumulants)

AliFlowAnalysisWithCumulants::AliFlowAnalysisWithCumulants(): 
 fHistList(NULL),
 fHistListName(NULL),
 fAnalysisSettings(NULL),
 fCommonHists(NULL),
 fCommonHistsResults2nd(NULL),
 fCommonHistsResults4th(NULL),
 fCommonHistsResults6th(NULL),
 fCommonHistsResults8th(NULL),
 fnBinsPhi(0),
 fPhiMin(0),
 fPhiMax(0),
 fPhiBinWidth(0),
 fnBinsPt(0),
 fPtMin(0),
 fPtMax(0),
 fPtBinWidth(0),
 fnBinsEta(0),
 fEtaMin(0),
 fEtaMax(0),
 fEtaBinWidth(0),
 fHarmonic(2),
 fMultiple(1),
 fR0(2.2),
 fWeightsList(NULL),
 fUsePhiWeights(kFALSE),
 fUsePtWeights(kFALSE),
 fUseEtaWeights(kFALSE),
 fPhiWeights(NULL),
 fPtWeights(NULL),
 fEtaWeights(NULL),
 fMultiplicityWeight(NULL),
 fReferenceFlowList(NULL),
 fReferenceFlowProfiles(NULL),
 fReferenceFlowResults(NULL),
 fReferenceFlowFlags(NULL),
 fCalculateVsMultiplicity(kFALSE),
 fnBinsMult(10000),  
 fMinMult(0.),   
 fMaxMult(10000.),
 fGEBE(NULL), 
 fReferenceFlowGenFun(NULL),
 fQvectorComponents(NULL),
 fAverageOfSquaredWeight(NULL),
 fReferenceFlowGenFunVsM(NULL),
 fQvectorComponentsVsM(NULL),
 fAverageOfSquaredWeightVsM(NULL),
 fAvMVsM(NULL),
 fAvM(0.),
 fnEvts(0), 
 fReferenceFlowCumulants(NULL), 
 fReferenceFlow(NULL),
 fChi(NULL),
 fDiffFlowList(NULL),
 fDiffFlowProfiles(NULL),
 fDiffFlowResults(NULL),
 fDiffFlowFlags(NULL),
 fTuningList(NULL), 
 fTuningProfiles(NULL),
 fTuningResults(NULL),
 fTuningFlags(NULL),
 fTuneParameters(kFALSE),
 fTuningAvM(NULL)   
 {
  // Constructor. 
  
  // Base list to hold all output objects:
  fHistList = new TList();
  fHistListName = new TString("cobjGFC");
  fHistList->SetName(fHistListName->Data());
  fHistList->SetOwner(kTRUE);
 
  // Multiplicity weight:
  fMultiplicityWeight = new TString("unit");
   
  // Initialize all arrays:
  this->InitializeArrays();
 
} // end of AliFlowAnalysisWithCumulants::AliFlowAnalysisWithCumulants()

//================================================================================================================

AliFlowAnalysisWithCumulants::~AliFlowAnalysisWithCumulants()
{
 // Desctructor.
 
 delete fHistList; 

} // end of AliFlowAnalysisWithCumulants::~AliFlowAnalysisWithCumulants()

//================================================================================================================

void AliFlowAnalysisWithCumulants::Init()
{
 // Initialize and book all objects. 
 
 // a) Cross check if the user settings make sense before starting; 
 // b) Access all common constants;
 // c) Book and fill weights histograms;
 // d) Book and nest all lists in the base list fHistList;
 // e) Book and fill profile holding analysis settings;
 // f) Book common control and results histograms;
 // g) Store flags for reference flow;
 // h) Store flags for differential flow;
 // i) Book all objects needed for tuning;
 // j) Book all objects needed for calculation versus multiplicity.
 
 //save old value and prevent histograms from being added to directory
 //to avoid name clashes in case multiple analaysis objects are used
 //in an analysis
 Bool_t oldHistAddStatus = TH1::AddDirectoryStatus();
 TH1::AddDirectory(kFALSE);
 
 this->CrossCheckSettings();
 this->AccessConstants();
 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights){this->BookAndFillWeightsHistograms();}
 this->BookAndNestAllLists();
 this->BookProfileHoldingSettings();
 this->BookCommonHistograms();
 this->BookEverythingForReferenceFlow();
 this->BookEverythingForDiffFlow();
 this->StoreReferenceFlowFlags();
 this->StoreDiffFlowFlags();
 if(fTuneParameters){this->BookEverythingForTuning();}
 if(fCalculateVsMultiplicity){this->BookEverythingForCalculationVsMultiplicity();}
 
 (fCommonHists->GetHarmonic())->Fill(0.5,fHarmonic); // to be improved (moved somewhere else?)
 
 TH1::AddDirectory(oldHistAddStatus);

} // end of void AliFlowAnalysisWithCumulants::Init()

//================================================================================================================

void AliFlowAnalysisWithCumulants::Make(AliFlowEventSimple* anEvent)
{
 // Running over data only in this method.
 
 // a) Check all pointers used in this method;
 // b) If tuning enabled, fill generating functions for different values of tuning parameters;
 // c) For default values of tuning parameters (r0 = 2.2 and cutoff at 10th order):
 //  c1) Fill common control histograms;
 //  c2) Fill generating function for reference flow;
 //  c3) Fill profile holding average values of various Q-vector components;   
 //  c4) Fill generating function for differential flow.
 
 this->CheckPointersUsedInMake();
 if(fTuneParameters) {this->FillGeneratingFunctionsForDifferentTuningParameters(anEvent);} 
 Int_t nRP = anEvent->GetEventNSelTracksRP(); // number of RPs (i.e. number of particles used to determine the reaction plane)
 if(nRP<10) {return;} // generating function formalism make sense only for nRPs >= 10 for default settings 
 fCommonHists->FillControlHistograms(anEvent);                                                               
 this->FillGeneratingFunctionForReferenceFlow(anEvent);
 this->FillQvectorComponents(anEvent);
 this->FillGeneratingFunctionForDiffFlow(anEvent);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
} // end of void AliFlowAnalysisWithCumulants::Make()

//================================================================================================================

void AliFlowAnalysisWithCumulants::Finish()
{
 // Calculate the final results.
 
 // a) Check all pointers used in this method;
 // b) Access all common constants;
 // c) Access settings for analysis with Generating Function Cumulants;
 // d) From relevant common control histogram get average multiplicity of RPs and number of events;
 // e) Calculate cumulants for reference flow;
 // f) Calculate from isotropic cumulants reference flow;
 // g) Calculate error for reference flow estimates;
 // h) Store the final results for reference flow in common hist results;
 // i) Print on the screen the final results for reference flow;
 // j) Calculate cumulants for differential flow;
 // k) Calculate differential flow for RPs/POIs vs pt/eta from cumulants;
 // l) Calculate integrated flow of RPs and POIs;
 // m) Print on the screen the final results for integrated flow of RPs and POIs;
 // n) If tuning enabled, calculate results for different tuning parameters.
 
 this->CheckPointersUsedInFinish();
 this->AccessConstants(); 
 this->AccessSettings();
 this->GetAvMultAndNoOfEvts();
 this->CalculateCumulantsForReferenceFlow(); 
 this->CalculateReferenceFlow();
 this->CalculateReferenceFlowError();
 this->FillCommonHistResultsForReferenceFlow();
 if(fPrintFinalResults[0]){this->PrintFinalResults("RF");}
 this->CalculateCumulantsForDiffFlow("RP","pt");
 this->CalculateCumulantsForDiffFlow("RP","eta");
 this->CalculateCumulantsForDiffFlow("POI","pt");
 this->CalculateCumulantsForDiffFlow("POI","eta");
 this->CalculateDifferentialFlow("RP","pt");
 this->CalculateDifferentialFlow("RP","eta");
 this->CalculateDifferentialFlow("POI","pt");
 this->CalculateDifferentialFlow("POI","eta");
 this->CalculateDifferentialFlowErrors("RP","pt");
 this->CalculateDifferentialFlowErrors("RP","eta");
 this->CalculateDifferentialFlowErrors("POI","pt");
 this->CalculateDifferentialFlowErrors("POI","eta");
 this->FillCommonHistResultsForDifferentialFlow("RP");
 this->FillCommonHistResultsForDifferentialFlow("POI");
 this->CalculateIntegratedFlow("RP");
 this->CalculateIntegratedFlow("POI");
 if(fPrintFinalResults[1]){this->PrintFinalResults("RP");}
 if(fPrintFinalResults[2]){this->PrintFinalResults("POI");}
 if(fTuneParameters){this->FinalizeTuning();}
     
} // end of void AliFlowAnalysisWithCumulants::Finish()

//================================================================================================================

void AliFlowAnalysisWithCumulants::FinalizeTuning()
{
 // Finalize results with tuned inerpolating parameters.

 for(Int_t r=0;r<10;r++)
 {
  if(TMath::Abs(fTuningR0[r])<1.e-10) continue; // protection against division by r0 bellow
  for(Int_t pq=0;pq<5;pq++)
  {
   Int_t pMax = fTuningGenFun[r][pq]->GetXaxis()->GetNbins();
   Int_t qMax = fTuningGenFun[r][pq]->GetYaxis()->GetNbins(); 
   fAvM = fTuningAvM->GetBinContent(pq+1);
   // <G[p][q]>
   TMatrixD dAvG(pMax,qMax); 
   dAvG.Zero();
   Bool_t someAvGEntryIsNegative = kFALSE;
   for(Int_t p=0;p<pMax;p++)
   {
    for(Int_t q=0;q<qMax;q++)
    {
     dAvG(p,q) = fTuningGenFun[r][pq]->GetBinContent(fTuningGenFun[r][pq]->GetBin(p+1,q+1));
     if(dAvG(p,q)<0.)
     {
      someAvGEntryIsNegative = kTRUE;
      cout<<endl; 
      cout<<" WARNING: "<<Form("<G[%d][%d]> is negative !!!! GFC results are meaningless for r0 = %f, pq = %i.",p,q,fTuningR0[r],pq)<<endl; 
      cout<<endl; 
     }
    }  
   } 
   // C[p][q] (generating function for the cumulants)    
   TMatrixD dC(pMax,qMax);
   dC.Zero();
   if(fAvM>0. && !someAvGEntryIsNegative)
   {
    for(Int_t p=0;p<pMax;p++)
    {
     for(Int_t q=0;q<qMax;q++)
     {
      dC(p,q) = fAvM*(pow(dAvG(p,q),(1./fAvM))-1.); 
     }
    }
   }
   // Averaging the generating function for cumulants over azimuth
   // in order to eliminate detector effects.
   // <C[p][q]> (Remark: here <> stands for average over azimuth):
   TVectorD dAvC(pMax);
   dAvC.Zero();
   for(Int_t p=0;p<pMax;p++)
   {
    Double_t temp = 0.; 
    for(Int_t q=0;q<qMax;q++)
    {
     temp += 1.*dC(p,q);
    } 
    dAvC[p] = temp/qMax;
   }  
   // Finally, the isotropic cumulants for reference flow and reference flow itself:
   TVectorD cumulant(pMax);
   cumulant.Zero(); 
   TVectorD flow(pMax);
   flow.Zero(); 
   if(pMax==2)
   {
    cumulant[0]=(1./(fTuningR0[r]*fTuningR0[r]))*(2.*dAvC[0]-(1./2.)*dAvC[1]);
    cumulant[1]=(2./pow(fTuningR0[r],4.))*((-2.)*dAvC[0]+1.*dAvC[1]);
    if(cumulant[0]>=0.) {flow[0] = pow(cumulant[0],1./2.);}
    if(cumulant[1]<=0.) {flow[1] = pow(-1.*cumulant[1],1./4.);}
   }
   else if(pMax==3)
   {
    cumulant[0] = (1./(fTuningR0[r]*fTuningR0[r]))*(3.*dAvC[0]-(3./2.)*dAvC[1]+(1./3.)*dAvC[2]);
    cumulant[1] = (2./pow(fTuningR0[r],4.))*((-5.)*dAvC[0]+4.*dAvC[1]-1.*dAvC[2]);
    cumulant[2] = (6./pow(fTuningR0[r],6.))*(3.*dAvC[0]-3.*dAvC[1]+1.*dAvC[2]);
    if(cumulant[0]>=0.) {flow[0] = pow(cumulant[0],1./2.);}
    if(cumulant[1]<=0.) {flow[1] = pow(-1.*cumulant[1],1./4.);}
    if(cumulant[2]>=0.) {flow[2] = pow((1./4.)*cumulant[2],1./6.);}
   }
   else if(pMax==4)
   {
    cumulant[0] = (1./(fTuningR0[r]*fTuningR0[r]))*(4.*dAvC[0]-3.*dAvC[1]+(4./3.)*dAvC[2]-(1./4.)*dAvC[3]);
    cumulant[1] = (1./pow(fTuningR0[r],4.))*((-52./3.)*dAvC[0]+19.*dAvC[1]-(28./3.)*dAvC[2]+(11./6.)*dAvC[3]);
    cumulant[2] = (3./pow(fTuningR0[r],6.))*(18.*dAvC[0]-24.*dAvC[1]+14.*dAvC[2]-3.*dAvC[3]);
    cumulant[3] = (24./pow(fTuningR0[r],8.))*((-4.)*dAvC[0]+6.*dAvC[1]-4.*dAvC[2]+1.*dAvC[3]);
    if(cumulant[0]>=0.) {flow[0] = pow(cumulant[0],1./2.);}
    if(cumulant[1]<=0.) {flow[1] = pow(-1.*cumulant[1],1./4.);}
    if(cumulant[2]>=0.) {flow[2] = pow((1./4.)*cumulant[2],1./6.);}
    if(cumulant[3]<=0.) {flow[3] = pow((-1./33.)*cumulant[3],1./8.);}
   }
   else if(pMax==5)
   {
    cumulant[0] = (-1./(60*fTuningR0[r]*fTuningR0[r]))*((-300.)*dAvC[0]+300.*dAvC[1]-200.*dAvC[2]+75.*dAvC[3]-12.*dAvC[4]);
    cumulant[1] = (-1./(6.*pow(fTuningR0[r],4.)))*(154.*dAvC[0]-214.*dAvC[1]+156.*dAvC[2]-61.*dAvC[3]+10.*dAvC[4]);
    cumulant[2] = (3./(2.*pow(fTuningR0[r],6.)))*(71.*dAvC[0]-118.*dAvC[1]+98.*dAvC[2]-41.*dAvC[3]+7.*dAvC[4]);
    cumulant[3] = (-24./pow(fTuningR0[r],8.))*(14.*dAvC[0]-26.*dAvC[1]+24.*dAvC[2]-11.*dAvC[3]+2.*dAvC[4]);
    cumulant[4] = (120./pow(fTuningR0[r],10.))*(5.*dAvC[0]-10.*dAvC[1]+10.*dAvC[2]-5.*dAvC[3]+1.*dAvC[4]); 
    if(cumulant[0]>=0.) {flow[0] = pow(cumulant[0],1./2.);}
    if(cumulant[1]<=0.) {flow[1] = pow(-1.*cumulant[1],1./4.);}
    if(cumulant[2]>=0.) {flow[2] = pow((1./4.)*cumulant[2],1./6.);}
    if(cumulant[3]<=0.) {flow[3] = pow((-1./33.)*cumulant[3],1./8.);}
    if(cumulant[4]>=0.) {flow[4] = pow((1./456.)*cumulant[4],1./10.);}
   }   
   else if(pMax==8)
   {  
    cumulant[0] = (1./(fTuningR0[r]*fTuningR0[r]))*(8.*dAvC[0]-14.*dAvC[1]+(56./3.)*dAvC[2]-(35./2.)*dAvC[3] 
                + (56./5.)*dAvC[4]-(14./3.)*dAvC[5]+(8./7.)*dAvC[6]-(1./8.)*dAvC[7]);
    cumulant[1] = (1./pow(fTuningR0[r],4.))*((-1924./35.)*dAvC[0]+(621./5.)*dAvC[1]-(8012./45.)*dAvC[2] 
                + (691./4.)*dAvC[3]-(564./5.)*dAvC[4]+(2143./45.)*dAvC[5]-(412./35.)*dAvC[6]+(363./280.)*dAvC[7]);
    cumulant[2] = (1./pow(fTuningR0[r],6.))*(349.*dAvC[0]-(18353./20.)*dAvC[1]+(7173./5.)*dAvC[2]
                - 1457.*dAvC[3]+(4891./5.)*dAvC[4]-(1683./4.)*dAvC[5]+(527./5.)*dAvC[6]-(469./40.)*dAvC[7]);
    cumulant[3] = (1./pow(fTuningR0[r],8.))*((-10528./5.)*dAvC[0]+(30578./5.)*dAvC[1]-(51456./5.)*dAvC[2]
                + 10993.*dAvC[3]-(38176./5.)*dAvC[4]+(16818./5.)*dAvC[5]-(4288./5.)*dAvC[6]+(967./10.)*dAvC[7]);
    cumulant[4] = (1./pow(fTuningR0[r],10.))*(11500.*dAvC[0]-35800.*dAvC[1]+63900.*dAvC[2]-71600.*dAvC[3] 
	    + 51620.*dAvC[4]-23400.*dAvC[5]+6100.*dAvC[6]-700.*dAvC[7]);
    cumulant[5] = (1./pow(fTuningR0[r],12.))*(-52560.*dAvC[0]+172080.*dAvC[1]-321840.*dAvC[2]+376200.*dAvC[3]  
                - 281520.*dAvC[4]+131760.*dAvC[5]-35280.*dAvC[6]+4140.*dAvC[7]);
    cumulant[6] = (1./pow(fTuningR0[r],14.))*(176400.*dAvC[0]-599760.*dAvC[1]+1164240.*dAvC[2]-1411200.*dAvC[3] 
	    + 1093680.*dAvC[4]-529200.*dAvC[5]+146160.*dAvC[6]-17640.*dAvC[7]);
    cumulant[7] = (1./pow(fTuningR0[r],16.))*(-322560*dAvC[0]+1128960.*dAvC[1]-2257920.*dAvC[2]+2822400.*dAvC[3] 
         	    - 2257920.*dAvC[4]+1128960.*dAvC[5]-322560.*dAvC[6]+40320.*dAvC[7]);
    if(cumulant[0]>=0.) {flow[0] = pow(cumulant[0],1./2.);}
    if(cumulant[1]<=0.) {flow[1] = pow(-1.*cumulant[1],1./4.);}
    if(cumulant[2]>=0.) {flow[2] = pow((1./4.)*cumulant[2],1./6.);}
    if(cumulant[3]<=0.) {flow[3] = pow((-1./33.)*cumulant[3],1./8.);}
    if(cumulant[4]>=0.) {flow[4] = pow((1./456.)*cumulant[4],1./10.);}
    if(cumulant[5]<=0.) {flow[5] = pow((-1./9460.)*cumulant[5],1./12.);}
    if(cumulant[6]>=0.) {flow[6] = pow((1./274800.)*cumulant[6],1./14.);}
    if(cumulant[7]<=0.) {flow[7] = pow((-1./10643745.)*cumulant[7],1./16.);}
   }
   // Store cumulants and reference flow:
   for(Int_t co=0;co<pMax;co++) // cumulant order
   {
    fTuningCumulants[r][pq]->SetBinContent(co+1,cumulant[co]);
    fTuningFlow[r][pq]->SetBinContent(co+1,flow[co]);
   }
  } // end of for(Int_t pq=0;pq<5;pq++) 
 } // end of for(Int_t r=0;r<10;r++)

} // end of void AliFlowAnalysisWithCumulants::FinalizeTuning()

//================================================================================================================

void AliFlowAnalysisWithCumulants::FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple *anEvent)
{
 // Fill generating function for reference flow evaluated for different tuning parameters.
 
 Int_t pMax[5] = {2,3,4,5,8};      
 Int_t qMax[5] = {5,7,9,11,17};  
 
 // Particle variables and weights:
 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
 Double_t dPt  = 0.; // transverse momentum
 Double_t dEta = 0.; // pseudorapidity
 Double_t wPhi = 1.; // phi weight
 Double_t wPt  = 1.; // pt weight
 Double_t wEta = 1.; // eta weight

 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI, where:
                                          // nRP   = # of particles used to determine the reaction plane;
                                          // nPOI  = # of particles of interest for a detailed flow analysis.
 
 Int_t nRP = anEvent->GetEventNSelTracksRP(); // nRP = # of particles used to determine the reaction plane;
 for(Int_t pq=0;pq<5;pq++)
 { 
  if(nRP<2.*pMax[pq]) continue; // results doesn't make sense if nRP is smaller than serie's cutoff
  fTuningAvM->Fill(pq+0.5,nRP,1.); // <M> for different classes of events }
 }
  
 Double_t tuningGenFunEBE[10][5][8][17] = {{{{0.}}}}; 
 for(Int_t r=0;r<10;r++)
 {
  for(Int_t pq=0;pq<5;pq++)
  {
   for(Int_t p=0;p<pMax[pq];p++)
   {
    for(Int_t q=0;q<qMax[pq];q++)
    {
     tuningGenFunEBE[r][pq][p][q] = 1.;
    }
   }
  } 
 }
 
 // Looping over tracks:
 for(Int_t i=0;i<nPrim;i++)
 {
  AliFlowTrackSimple *aftsTrack = anEvent->GetTrack(i);
  if(aftsTrack && aftsTrack->InRPSelection())
  {
   // Access particle variables and weights:
   dPhi = aftsTrack->Phi();
   dPt  = aftsTrack->Pt();
   dEta = aftsTrack->Eta();
   if(fUsePhiWeights && fnBinsPhi) // determine phi weight for this particle:
   {
    wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
   }
   if(fUsePtWeights && fnBinsPt) // determine pt weight for this particle:
   {
    wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); 
   }              
   if(fUseEtaWeights && fEtaBinWidth) // determine eta weight for this particle: 
   {
    wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); 
   }    
   // Fill the generating functions:
   for(Int_t r=0;r<10;r++) // 10 different values for interpolating parameter r0
   {
    if(TMath::Abs(fTuningR0[r])<1.e-10) continue;
    for(Int_t pq=0;pq<5;pq++) // 5 different values for set (pMax,qMax)
    {
     if(nRP<2.*pMax[pq]) continue; // results doesn't make sense if nRP is smaller than serie's cutoff
     for(Int_t p=0;p<pMax[pq];p++)
     {
      for(Int_t q=0;q<qMax[pq];q++)
      {
       tuningGenFunEBE[r][pq][p][q] *= (1.+wPhi*wPt*wEta*(2.*fTuningR0[r]*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax[pq]));
      } // end of for(Int_t q=0;q<qMax[pq];q++) 
     } // end of for(Int_t p=0;p<pMax[pq];p++)
    } // end for(Int_t pq=0;pq<5;pq++) // 5 different values for set (pMax,qMax)
   } // end of for(Int_t r=0;r<10;r++) // 10 different values for interpolating parameter r0  
  } // end of if(aftsTrack && aftsTrack->InRPSelection())
 } // end of for(Int_t i=0;i<nPrim;i++) 
  
 // Store G[p][q]:
 for(Int_t r=0;r<10;r++) 
 {
  for(Int_t pq=0;pq<5;pq++) 
  {
   if(nRP<2.*pMax[pq]) continue; // results doesn't make sense if nRP is smaller than serie's cutoff
   for(Int_t p=0;p<pMax[pq];p++)
   {
    for(Int_t q=0;q<qMax[pq];q++)
    {
     if(fTuningGenFun[r][pq]) {fTuningGenFun[r][pq]->Fill((Double_t)p,(Double_t)q,tuningGenFunEBE[r][pq][p][q],1.);} 
    }
   } 
  }
 } 
  
} // end of void AliFlowAnalysisWithCumulants::FillGeneratingFunctionsForDifferentTuningParameters(AliFlowEventSimple *anEvent)

//================================================================================================================

void AliFlowAnalysisWithCumulants::FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple *anEvent)
{
 // Fill generating function for reference flow for current event.
 
 if(!anEvent)
 {
  printf(" WARNING (GFC): anEvent is NULL !!!!");
  return;
 }
 
 // Particle variables and weights:
 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
 Double_t dPt  = 0.; // transverse momentum
 Double_t dEta = 0.; // pseudorapidity
 Double_t wPhi = 1.; // phi weight
 Double_t wPt  = 1.; // pt weight
 Double_t wEta = 1.; // eta weight
  
 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI, where:
                                          // nRP   = # of particles used to determine the reaction plane;
                                          // nPOI  = # of particles of interest for a detailed flow analysis.
 
 Int_t nRP = anEvent->GetEventNSelTracksRP(); // nRP = # of particles used to determine the reaction plane;
 if(fCalculateVsMultiplicity){fAvMVsM->Fill(nRP+0.5,nRP,1.);}
 
 // Initializing the generating function G[p][q] for reference flow for current event: 
 Int_t pMax = fGEBE->GetNrows();
 Int_t qMax = fGEBE->GetNcols();
 for(Int_t p=0;p<pMax;p++)
 {
  for(Int_t q=0;q<qMax;q++)
  {
   (*fGEBE)(p,q) = 1.;
  }   
 }
    
 // Cross-checking the number of RPs in current event:
 Int_t crossCheckRP = 0; 
 
 // Looping over tracks:
 for(Int_t i=0;i<nPrim;i++)
 {
  AliFlowTrackSimple *aftsTrack = anEvent->GetTrack(i);
  if(aftsTrack && aftsTrack->InRPSelection())
  {
   crossCheckRP++;
   // Access particle variables and weights:
   dPhi = aftsTrack->Phi();
   dPt  = aftsTrack->Pt();
   dEta = aftsTrack->Eta();
   if(fUsePhiWeights && fnBinsPhi) // determine phi weight for this particle:
   {
    wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
   }
   if(fUsePtWeights && fnBinsPt) // determine pt weight for this particle:
   {
    wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); 
   }              
   if(fUseEtaWeights && fEtaBinWidth) // determine eta weight for this particle: 
   {
    wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); 
   }    
   // Fill the generating function:
   for(Int_t p=0;p<pMax;p++)
   {
    for(Int_t q=0;q<qMax;q++)
    {
     (*fGEBE)(p,q) *= (1.+wPhi*wPt*wEta*(2.*fR0*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax));
    }
   }
   // Fill the profile to calculate <<w^2>>: 
   fAverageOfSquaredWeight->Fill(0.5,pow(wPhi*wPt*wEta,2.),1.); 
  } // end of if(aftsTrack && aftsTrack->InRPSelection())
 } // end of for(Int_t i=0;i<nPrim;i++) 
 
 // Cross check # of RPs:
 if(anEvent && (crossCheckRP != anEvent->GetEventNSelTracksRP()))
 {
  cout<<endl; 
  cout<<"WARNING (GFC): crossCheckRP != nRP in GFC::Make(). Something is wrong with RP flagging !!!!"<<endl;
  cout<<endl; 
  exit(0);
 }
 
 // Storing the value of G[p][q] in 2D profile in order to get eventually the avarage <G[p][q]>:
 // Determine first the event weight for G[p][q]:
 // (to be improved - this can be implemented much better, this shall be executed only once out of Make(), eventWeight should be a data member)
 Double_t eventWeight = 0.;
 if(!strcmp(fMultiplicityWeight->Data(),"unit"))
 {
  eventWeight = 1.;
 } else if(!strcmp(fMultiplicityWeight->Data(),"multiplicity"))
   {
    eventWeight = anEvent->GetEventNSelTracksRP();           
   }
 // Store G[p][q] weighted appropriately:
 for(Int_t p=0;p<pMax;p++)
 {
  for(Int_t q=0;q<qMax;q++)
  {
   fReferenceFlowGenFun->Fill((Double_t)p,(Double_t)q,(*fGEBE)(p,q),eventWeight); 
   if(fCalculateVsMultiplicity){fReferenceFlowGenFunVsM->Fill(nRP+0.5,(Double_t)p,(Double_t)q,(*fGEBE)(p,q),eventWeight);}
  }
 } 
 
} // end of void AliFlowAnalysisWithCumulants::FillGeneratingFunctionForReferenceFlow(AliFlowEventSimple* anEvent)
 
//================================================================================================================

void AliFlowAnalysisWithCumulants::FillQvectorComponents(AliFlowEventSimple* anEvent)
{
 // Fill components of Q-vector for current event (needed for error calculation).
 
 // Remark: Components are stored in profile fQvectorComponents whose binning is organized as follows:
 //  1st bin: Q_x
 //  2nd bin: Q_y
 //  3rd bin: (Q_x)^2
 //  4th bin: (Q_y)^2
 
 AliFlowVector afv;
 afv.Set(0.,0.);
 afv.SetMult(0);
 
 Int_t n = 2; // to be removed
 
 if(anEvent)
 {
  afv = anEvent->GetQ(1*n,fWeightsList,fUsePhiWeights,fUsePtWeights,fUseEtaWeights); // get the Q-vector for this event
  fQvectorComponents->Fill(0.5,afv.X(),1.); // in the 1st bin fill Q_x
  fQvectorComponents->Fill(1.5,afv.Y(),1.); // in the 2nd bin fill Q_y
  fQvectorComponents->Fill(2.5,pow(afv.X(),2.),1.); // in the 3rd bin fill (Q_x)^2
  fQvectorComponents->Fill(3.5,pow(afv.Y(),2.),1.); // in the 4th bin fill (Q_y)^2
 }
 
} // end of void AliFlowAnalysisWithCumulants::FillQvectorComponents(AliFlowEventSimple* anEvent)

//================================================================================================================

void AliFlowAnalysisWithCumulants::FillGeneratingFunctionForDiffFlow(AliFlowEventSimple* anEvent)
{ 
 // Fill generating function for differential flow for the current event.
 
 // Remark 0: Generating function D[b][p][q] is a complex number => real and imaginary part are calculated separately
 //           (b denotes pt or eta bin);
 // Remark 1: Note that bellow G[p][q] is needed, the value of generating function for reference flow for the CURRENT event.
 //           This values is obtained in method FillGeneratingFunctionForReferenceFlow() as TMatrixD fGEBE;
 // Remark 2: Results for D[b][p][q] are stored in 3D profiles fDiffFlowGenFun[0=Re,1=Im][0=RP,1=POI][0=pt,1=eta] in order to 
 //           automatically get <Re(D[b][p][q])> and <Im(D[b][p][q])> at the end of the day.
 
 // Particle variables and weights:
 Double_t dPhi = 0.; // azimuthal angle in the laboratory frame
 Double_t dPt  = 0.; // transverse momentum
 Double_t dEta = 0.; // pseudorapidity
 Double_t wPhi = 1.; // phi weight
 Double_t wPt  = 1.; // pt weight
 Double_t wEta = 1.; // eta weight
 
 // pMax and qMax:
 Int_t pMax = fGEBE->GetNrows();
 Int_t qMax = fGEBE->GetNcols(); 

 Int_t nPrim = anEvent->NumberOfTracks(); // nPrim = total number of primary tracks, i.e. nPrim = nRP + nPOI, where:
                                          // nRP   = # of particles used to determine the reaction plane;
                                          // nPOI  = # of particles of interest for a detailed flow analysis.
 
 Int_t nRP = anEvent->GetEventNSelTracksRP(); // nRP = # of particles used to determine the reaction plane
       
 // Start the second loop over event in order to evaluate the generating function D[b][p][q] for differential flow: 
 for(Int_t i=0;i<nPrim;i++)
 {
  AliFlowTrackSimple *aftsTrack = anEvent->GetTrack(i);
  if(aftsTrack)
  {
   if(!(aftsTrack->InRPSelection() || aftsTrack->InPOISelection())) continue;
   // Differential flow of POIs:
   if(aftsTrack->InPOISelection())
   {
    // Get azimuthal angle, momentum and pseudorapidity of a particle:
    dPhi = aftsTrack->Phi();
    dPt  = aftsTrack->Pt();
    dEta = aftsTrack->Eta();
    Double_t ptEta[2] = {dPt,dEta};    
   
    // Count number of POIs in pt/eta bin:
    for(Int_t pe=0;pe<2;pe++)
    { 
     fNoOfParticlesInBin[1][pe]->Fill(ptEta[pe],ptEta[pe],1.);
    }
  
    if(!(aftsTrack->InRPSelection())) // particle was flagged only as POI 
    {
     // Fill generating function:
     for(Int_t p=0;p<pMax;p++)
     {
      for(Int_t q=0;q<qMax;q++)
      {
       for(Int_t ri=0;ri<2;ri++)
       {
        for(Int_t pe=0;pe<2;pe++)
        {
         if(ri==0) // Real part (to be improved - this can be implemented better)
         {
          fDiffFlowGenFun[ri][1][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                       (*fGEBE)(p,q)*cos(fMultiple*fHarmonic*dPhi),1.);
         } 
         else if(ri==1) // Imaginary part (to be improved - this can be implemented better)
         {
          fDiffFlowGenFun[ri][1][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                       (*fGEBE)(p,q)*sin(fMultiple*fHarmonic*dPhi),1.);
         }
        } // end of for(Int_t pe=0;pe<2;pe++)
       } // end of for(Int_t ri=0;ri<2;ri++) 
      } // end of for(Int_t q=0;q<qMax;q++)
     } // end of for(Int_t p=0;p<pMax;p++)       
    } // end of if(!(aftsTrack->InRPSelection())) // particle was flagged only as POI 
    else if(aftsTrack->InRPSelection()) // particle was flagged both as RP and POI 
    {
     // If particle weights were used, get them:
     if(fUsePhiWeights && fnBinsPhi) // determine phi weight for this particle:
     {
      wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
     }
     if(fUsePtWeights && fnBinsPt) // determine pt weight for this particle:
     {
      wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); 
     }              
     if(fUseEtaWeights && fEtaBinWidth) // determine eta weight for this particle: 
     {
      wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); 
     }    
     // Fill generating function:
     for(Int_t p=0;p<pMax;p++)
     {
      for(Int_t q=0;q<qMax;q++)
      {
       for(Int_t ri=0;ri<2;ri++)
       {
        for(Int_t pe=0;pe<2;pe++)
        {
         if(ri==0) // Real part (to be improved - this can be implemented better)
         {
          fDiffFlowGenFun[ri][1][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                      (*fGEBE)(p,q)*cos(fMultiple*fHarmonic*dPhi)/(1.+wPhi*wPt*wEta*(2.*fR0*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax)),1.);
         } 
         else if(ri==1) // Imaginary part (to be improved - this can be implemented better)
         {
          fDiffFlowGenFun[ri][1][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                      (*fGEBE)(p,q)*sin(fMultiple*fHarmonic*dPhi)/(1.+wPhi*wPt*wEta*(2.*fR0*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax)),1.);
         }
        } // end of for(Int_t pe=0;pe<2;pe++)
       } // end of for(Int_t ri=0;ri<2;ri++) 
      } // end of for(Int_t q=0;q<qMax;q++)
     } // end of for(Int_t p=0;p<pMax;p++)
    } // end of else if (aftsTrack->InRPSelection()) // particle was flagged both as RP and POI 
   } // end of if(aftsTrack->InPOISelection())
   // Differential flow of RPs:
   if(aftsTrack->InRPSelection()) 
   {
    // Get azimuthal angle, momentum and pseudorapidity of a particle:
    dPhi = aftsTrack->Phi();
    dPt  = aftsTrack->Pt();
    dEta = aftsTrack->Eta();
    Double_t ptEta[2] = {dPt,dEta}; 
    
    // Count number of RPs in pt/eta bin:
    for(Int_t pe=0;pe<2;pe++)
    { 
     fNoOfParticlesInBin[0][pe]->Fill(ptEta[pe],ptEta[pe],1.);
    }
    
    // If particle weights were used, get them:
    if(fUsePhiWeights && fnBinsPhi) // determine phi weight for this particle:
    {
     wPhi = fPhiWeights->GetBinContent(1+(Int_t)(TMath::Floor(dPhi*fnBinsPhi/TMath::TwoPi())));
    }
    if(fUsePtWeights && fnBinsPt) // determine pt weight for this particle: 
    {
     wPt = fPtWeights->GetBinContent(1+(Int_t)(TMath::Floor((dPt-fPtMin)/fPtBinWidth))); 
    }              
    if(fUseEtaWeights && fEtaBinWidth) // determine eta weight for this particle: 
    {
     wEta = fEtaWeights->GetBinContent(1+(Int_t)(TMath::Floor((dEta-fEtaMin)/fEtaBinWidth))); 
    }    
    // Fill generating function:
    for(Int_t p=0;p<pMax;p++)
    {
     for(Int_t q=0;q<qMax;q++)
     {
      for(Int_t ri=0;ri<2;ri++)
      {
       for(Int_t pe=0;pe<2;pe++)
       {
        if(ri==0) // Real part (to be improved - this can be implemented better)
        {
         fDiffFlowGenFun[ri][0][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                     (*fGEBE)(p,q)*cos(fMultiple*fHarmonic*dPhi)/(1.+wPhi*wPt*wEta*(2.*fR0*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax)),1.);
        } 
        else if(ri==1) // Imaginary part (to be improved - this can be implemented better)
        {
         fDiffFlowGenFun[ri][0][pe]->Fill(ptEta[pe],(Double_t)p,(Double_t)q, // to be improved - hardwired weight 1. in the line bellow
                                     (*fGEBE)(p,q)*sin(fMultiple*fHarmonic*dPhi)/(1.+wPhi*wPt*wEta*(2.*fR0*sqrt(p+1.)/nRP)*cos(fHarmonic*dPhi-2.*q*TMath::Pi()/qMax)),1.);
        }
       } // end of for(Int_t pe=0;pe<2;pe++)
      } // end of for(Int_t ri=0;ri<2;ri++) 
     } // end of for(Int_t q=0;q<qMax;q++)
    } // end of for(Int_t p=0;p<pMax;p++)
   } // end of if(aftsTrack->InRPSelection()) 
  } // end of if(aftsTrack)  
 } // end of for(Int_t i=0;i<nPrim;i++)
 
} // end of void AliFlowAnalysisWithCumulants::FillGeneratingFunctionForDiffFlow(AliFlowEventSimple* anEvent)

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetOutputHistograms(TList *outputListHistos) 
{
 // Get pointers to all objects saved in the output file.
 
 if(outputListHistos) 
 {
  this->SetHistList(outputListHistos);
  if(!fHistList)
  {
   cout<<endl;
   cout<<" WARNING (GFC): fHistList is NULL in AFAWGFC::GOH() !!!!"<<endl;
   cout<<endl;
   exit(0);
  }
  this->GetPointersForBaseHistograms();
  this->AccessSettings();
  this->GetPointersForCommonControlHistograms();
  this->GetPointersForCommonResultsHistograms();
  this->GetPointersForReferenceFlowObjects();
  this->GetPointersForDiffFlowObjects();
  if(fTuneParameters){this->GetPointersForTuningObjects();}
 } else 
   {
    cout<<endl;
    cout<<" WARNING (GFC): outputListHistos is NULL in AFAWGFC::GOH() !!!!"<<endl;
    cout<<endl;
    exit(0);
   }

} // end of void AliFlowAnalysisWithCumulants::GetOutputHistograms(TList *outputListHistos) 

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForBaseHistograms() 
{
 // Get pointers to base histograms.
 
 TString analysisSettingsName = "fAnalysisSettings";
 TProfile *analysisSettings = dynamic_cast<TProfile*>(fHistList->FindObject(analysisSettingsName.Data()));
 if(analysisSettings) 
 {
  this->SetAnalysisSettings(analysisSettings); 
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): analysisSettings is NULL in AFAWGFC::GPFBH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   }
   
} // end of void AliFlowAnalysisWithCumulants::GetPointersForBaseHistograms()

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForCommonControlHistograms() 
{
 // Get pointers for common control histograms.
 
 TString commonHistsName = "AliFlowCommonHistGFC";
 AliFlowCommonHist *commonHist = dynamic_cast<AliFlowCommonHist*>(fHistList->FindObject(commonHistsName.Data()));
 if(commonHist) 
 {
  this->SetCommonHists(commonHist); 
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): commonHist is NULL in AFAWGFC::GPFCH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   }
 
} // end of void AliFlowAnalysisWithCumulants::GetPointersForCommonControlHistograms()

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForCommonResultsHistograms() 
{
 // Get pointers for common results histograms.

 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderGFC"; 
 AliFlowCommonHistResults *commonHistRes2nd = dynamic_cast<AliFlowCommonHistResults*> 
                                              (fHistList->FindObject(commonHistResults2ndOrderName.Data()));
 if(commonHistRes2nd) 
 {
  this->SetCommonHistsResults2nd(commonHistRes2nd);   
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): commonHistRes2nd is NULL in AFAWGFC::GPFCRH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   }
 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderGFC";
 AliFlowCommonHistResults *commonHistRes4th = dynamic_cast<AliFlowCommonHistResults*>
                                              (fHistList->FindObject(commonHistResults4thOrderName.Data()));
 if(commonHistRes4th)
 { 
  this->SetCommonHistsResults4th(commonHistRes4th);  
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): commonHistRes4th is NULL in AFAWGFC::GPFCRH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   }
 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderGFC";
 AliFlowCommonHistResults *commonHistRes6th = dynamic_cast<AliFlowCommonHistResults*>
                                              (fHistList->FindObject(commonHistResults6thOrderName.Data()));
 if(commonHistRes6th)
 { 
  this->SetCommonHistsResults6th(commonHistRes6th);  
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): commonHistRes6th is NULL in AFAWGFC::GPFCRH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   }
 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderGFC";
 AliFlowCommonHistResults *commonHistRes8th = dynamic_cast<AliFlowCommonHistResults*>
                                              (fHistList->FindObject(commonHistResults8thOrderName.Data()));  
 if(commonHistRes8th)
 {
  this->SetCommonHistsResults8th(commonHistRes8th);
 } else
   {
    cout<<endl;
    cout<<" WARNING (GFC): commonHistRes8th is NULL in AFAWGFC::GPFCRH() !!!!"<<endl;
    cout<<endl;
    exit(0);  
   } 

} // end of void AliFlowAnalysisWithCumulants::GetPointersForCommonResultsHistograms() 

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForTuningObjects()
{
 // Get pointers to all objects used for tuning.
 
 // a) Get pointers to all lists relevant for tuning;
 // b) Get pointer to profile holding flags for tuning;
 // c) Get pointers to all objects in the list fTuningProfiles;
 // d) Get pointers to all objects in the list fTuningResults.

 // a) Get pointers to all lists relevant for tuning:
 TList *tuningList = dynamic_cast<TList*>(fHistList->FindObject("Tuning"));
 if(!tuningList) 
 {
  cout<<endl; 
  cout<<"WARNING (GFC): uningList is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }  
 TList *tuningProfiles = dynamic_cast<TList*>(tuningList->FindObject("Profiles"));
 if(!tuningProfiles)  
 {
  cout<<endl; 
  cout<<"WARNING (GFC): tuningProfiles is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }
 TList *tuningResults = dynamic_cast<TList*>(tuningList->FindObject("Results"));
 if(!tuningResults)  
 {
  cout<<endl; 
  cout<<"WARNING (GFC): tuningResults is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }

 // b) Get pointer to profile holding flags for tuning:
 TString tuningFlagsName = "fTuningFlags";
 TProfile *tuningFlags = dynamic_cast<TProfile*>(tuningList->FindObject(tuningFlagsName.Data())); 
 if(tuningFlags)
 {
  this->SetTuningFlags(tuningFlags);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): tuningFlags is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
   
 // c) Get pointers to all objects in the list fTuningProfiles:
 // Generating function for different tuning parameters:
 TProfile2D *tuningGenFun[10][5] = {{NULL}};
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   tuningGenFun[r][pq] = dynamic_cast<TProfile2D*>(tuningProfiles->FindObject(Form("fTuningGenFun (r_{0,%i}, pq set %i)",r,pq)));    
   if(tuningGenFun[r][pq])
   {
    this->SetTuningGenFun(tuningGenFun[r][pq],r,pq);  
   } else 
     {
      cout<<endl; 
      cout<<"WARNING (GFC): "<<Form("tuningGenFun[%i][%i]",r,pq)<<" is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
      cout<<endl; 
      exit(0); 
     }
  } // end of for(Int_t pq=0;pq<5;pq++)
 } // end of for(Int_t r=0;r<10;r++)
 // Average multiplicities for events with nRPs >= cuttof 
 TProfile *tuningAvM = dynamic_cast<TProfile*>(tuningProfiles->FindObject("fTuningAvM"));   
 if(tuningAvM)
 {
  this->SetTuningAvM(tuningAvM);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): tuningAvM is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 
 // d) Get pointers to all objects in the list fTuningResults.
 // Cumulants for reference flow for 10 different r0s and 5 different sets of (pmax,qmax): 
 TH1D *tuningCumulants[10][5] = {{NULL}};
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   tuningCumulants[r][pq] = dynamic_cast<TH1D*>(tuningResults->FindObject(Form("fTuningCumulants (r_{0,%i}, pq set %i)",r,pq)));       
   if(tuningCumulants[r][pq])
   {
    this->SetTuningCumulants(tuningCumulants[r][pq],r,pq);  
   } else 
     {
      cout<<endl; 
      cout<<"WARNING (GFC): "<<Form("tuningCumulants[%i][%i]",r,pq)<<" is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
      cout<<endl; 
      exit(0); 
     }
  } // end of for(Int_t pq=0;pq<5;pq++)
 } // end of for(Int_t r=0;r<10;r++)
 // Reference flow for 10 different r0s and 5 different sets of (pmax,qmax):    
 TH1D *tuningFlow[10][5] = {{NULL}};
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   tuningFlow[r][pq] = dynamic_cast<TH1D*>(tuningResults->FindObject(Form("fTuningFlow (r_{0,%i}, pq set %i)",r,pq))); 
   if(tuningFlow[r][pq])
   {
    this->SetTuningFlow(tuningFlow[r][pq],r,pq);  
   } else 
     {
      cout<<endl; 
      cout<<"WARNING (GFC): "<<Form("tuningFlow[%i][%i]",r,pq)<<" is NULL in AFAWGFC::GPFTO() !!!!"<<endl;
      cout<<endl; 
      exit(0); 
     }
  } // end of for(Int_t pq=0;pq<5;pq++)
 } // end of for(Int_t r=0;r<10;r++)

} // end of void AliFlowAnalysisWithCumulants::GetPointersForTuningObjects()

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForReferenceFlowObjects()
{
 // Get pointers for all objects relevant for calculation of reference flow.
  
 // a) Get pointers to all lists relevant for reference flow;
 // b) Get pointer to profile holding flags;
 // c) Get pointers to all objects in the list fReferenceFlowProfiles;
 // d) Get pointers to all objects in the list fReferenceFlowResults;
 // e) Get pointers for all objects relevant for calculation of reference flow versus multiplicity.

 // a) Get pointers to all lists relevant for reference flow:
 TList *referenceFlowList = dynamic_cast<TList*>(fHistList->FindObject("Reference Flow"));
 if(!referenceFlowList) 
 {
  cout<<endl; 
  cout<<"WARNING (GFC): referenceFlowList is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }  
 TList *referenceFlowProfiles = dynamic_cast<TList*>(referenceFlowList->FindObject("Profiles"));
 if(!referenceFlowProfiles)  
 {
  cout<<endl; 
  cout<<"WARNING (GFC): referenceFlowProfiles is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }
 TList *referenceFlowResults = dynamic_cast<TList*>(referenceFlowList->FindObject("Results"));
 if(!referenceFlowResults)  
 {
  cout<<endl; 
  cout<<"WARNING (GFC): referenceFlowResults is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
  cout<<endl; 
  exit(0); 
 }
 
 // b) Get pointer to profile holding flags:
 TString referenceFlowFlagsName = "fReferenceFlowFlags";
 TProfile *referenceFlowFlags = dynamic_cast<TProfile*>(referenceFlowList->FindObject(referenceFlowFlagsName.Data()));
 if(referenceFlowFlags)
 {
  this->SetReferenceFlowFlags(referenceFlowFlags);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): referenceFlowFlags is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 
 // c) Get pointers to all objects in the list fReferenceFlowProfiles:
 TString referenceFlowGenFunName = "fReferenceFlowGenFun";
 TProfile2D *referenceFlowGenFun = dynamic_cast<TProfile2D*>(referenceFlowProfiles->FindObject(referenceFlowGenFunName.Data())); 
 if(referenceFlowGenFun)
 {
  this->SetReferenceFlowGenFun(referenceFlowGenFun);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): referenceFlowGenFun is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 // Averages of various Q-vector components:
 TString qvectorComponentsName = "fQvectorComponents";
 TProfile *qvectorComponents = dynamic_cast<TProfile*>(referenceFlowProfiles->FindObject(qvectorComponentsName.Data()));
 if(qvectorComponents)
 {
  this->SetQvectorComponents(qvectorComponents);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): qvectorComponents is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 // <<w^2>>, where w = wPhi*wPt*wEta:
 TString averageOfSquaredWeightName = "fAverageOfSquaredWeight";
 TProfile *averageOfSquaredWeight = dynamic_cast<TProfile*>(referenceFlowProfiles->FindObject(averageOfSquaredWeightName.Data()));
 if(averageOfSquaredWeight)
 {
  this->SetAverageOfSquaredWeight(averageOfSquaredWeight);
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): averageOfSquaredWeight is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   } 
  
 // d) Get pointers to all objects in the list fReferenceFlowResults:
 // Final results for isotropic cumulants for reference flow:
 TString referenceFlowCumulantsName = "fReferenceFlowCumulants";
 TH1D *referenceFlowCumulants = dynamic_cast<TH1D*>(referenceFlowResults->FindObject(referenceFlowCumulantsName.Data()));
 if(referenceFlowCumulants) 
 {
  this->SetReferenceFlowCumulants(referenceFlowCumulants);
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): referenceFlowCumulants is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }  
 // Final results for reference flow:
 TString referenceFlowName = "fReferenceFlow";
 TH1D *referenceFlow = dynamic_cast<TH1D*>(referenceFlowResults->FindObject(referenceFlowName.Data()));
 if(referenceFlow)
 {
  this->SetReferenceFlow(referenceFlow); 
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): referenceFlow is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   } 
 // Final results for resolution:
 TString chiName = "fChi";
 TH1D *chi = dynamic_cast<TH1D*>(referenceFlowResults->FindObject(chiName.Data()));
 if(chi)
 {
  this->SetChi(chi); 
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): chi is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   } 
 
 // e) Get pointers for all objects relevant for calculation of reference flow versus multiplicity:
 if(!fCalculateVsMultiplicity) {return;}
 // All-event average of the generating function used to calculate reference flow vs multiplicity:
 TString referenceFlowGenFunVsMName = "fReferenceFlowGenFunVsM";
 TProfile3D *referenceFlowGenFunVsM = dynamic_cast<TProfile3D*>(referenceFlowProfiles->FindObject(referenceFlowGenFunVsMName.Data())); 
 if(referenceFlowGenFunVsM)
 {
  this->SetReferenceFlowGenFunVsM(referenceFlowGenFunVsM);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): referenceFlowGenFunVsM is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 // Averages of various Q-vector components versus multiplicity:
 TString qvectorComponentsVsMName = "fQvectorComponentsVsM";
 TProfile2D *qvectorComponentsVsM = dynamic_cast<TProfile2D*>(referenceFlowProfiles->FindObject(qvectorComponentsVsMName.Data()));
 if(qvectorComponentsVsM)
 {
  this->SetQvectorComponentsVsM(qvectorComponentsVsM);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): qvectorComponentsVsM is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
 // <<w^2>>, where w = wPhi*wPt*wEta versus multiplicity:
 TString averageOfSquaredWeightVsMName = "fAverageOfSquaredWeightVsM";
 TProfile2D *averageOfSquaredWeightVsM = dynamic_cast<TProfile2D*>(referenceFlowProfiles->FindObject(averageOfSquaredWeightVsMName.Data()));
 if(averageOfSquaredWeightVsM)
 {
  this->SetAverageOfSquaredWeightVsM(averageOfSquaredWeightVsM);
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): averageOfSquaredWeightVsM is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   } 
 // Final results for reference GF-cumulants versus multiplicity:
 TString cumulantFlag[4] = {"GFC{2}","GFC{4}","GFC{6}","GFC{8}"};
 TString referenceFlowCumulantsVsMName = "fReferenceFlowCumulantsVsM";
 TH1D *referenceFlowCumulantsVsM[4] = {NULL};
 for(Int_t co=0;co<4;co++) // cumulant order
 {
  referenceFlowCumulantsVsM[co] = dynamic_cast<TH1D*>(referenceFlowResults->FindObject(Form("%s, %s",referenceFlowCumulantsVsMName.Data(),cumulantFlag[co].Data())));
  if(referenceFlowCumulantsVsM[co])
  {
   this->SetReferenceFlowCumulantsVsM(referenceFlowCumulantsVsM[co],co);
  } else
    {
     cout<<endl; 
     cout<<"WARNING (GFC): "<<Form("referenceFlowCumulantsVsM[%i]",co)<<" is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
     cout<<endl; 
     exit(0); 
    }   
 } // end of for(Int_t co=0;co<4;co++) // cumulant order
 // <M> vs multiplicity bin: 
 TProfile *avMVsM = dynamic_cast<TProfile*>(referenceFlowProfiles->FindObject("fAvMVsM"));
 if(avMVsM)
 {
  this->SetAvMVsM(avMVsM);
 } else
   {
    cout<<endl; 
    cout<<"WARNING (GFC): avMVsM is NULL in AFAWGFC::GPFRFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }   

}  // end of void AliFlowAnalysisWithCumulants::GetPointersForReferenceFlowObjects()

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetPointersForDiffFlowObjects()
{
 // Get pointers to all objects relevant for differential flow.
 
 //  a) Define flags locally (to be improved: should I promote flags to data members?);
 //  b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults;
 //  c) Get pointer to profile fDiffFlowFlags holding all flags for differential flow;
 //  d) Get pointers to all profiles in the list fDiffFlowProfiles;
 //  e) Get pointers to all profiles in the list fDiffFlowResults.
  
 // a) Define flags locally (to be improved: should I promote flags to data members?): 
 TString reIm[2] = {"Re","Im"};
 TString rpPoi[2] = {"RP","POI"}; 
 TString ptEta[2] = {"p_{t}","#eta"};
 TString order[4] = {"2nd order","4th order","6th order","8th order"}; 
 //TString differentialFlowIndex[4] = {"v'{2}","v'{4}","v'{6}","v'{8}"};  
  
 // b) Get pointer to base list for differential flow fDiffFlowList and nested lists fDiffFlowListProfiles and fDiffFlowListResults:
 TList *diffFlowList = dynamic_cast<TList*>(fHistList->FindObject("Differential Flow")); // to be improved (hardwired name) 
 if(!diffFlowList)
 { 
  cout<<endl;
  cout<<"WARNING: diffFlowList is NULL in AFAWC::GPFDFO() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 TList *diffFlowProfiles = dynamic_cast<TList*>(diffFlowList->FindObject("Profiles")); // to be improved (hardwired name)
 if(!diffFlowProfiles)
 { 
  cout<<endl;
  cout<<"WARNING: diffFlowProfiles is NULL in AFAWC::GPFDFO() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 TList *diffFlowResults = dynamic_cast<TList*>(diffFlowList->FindObject("Results")); // to be improved (hardwired name)
 if(!diffFlowResults)
 { 
  cout<<endl;
  cout<<"WARNING: diffFlowResults is NULL in AFAWC::GPFDFO() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }

 // c) Get pointer to profile holding flags:
 TString diffFlowFlagsName = "fDiffFlowFlags";
 TProfile *diffFlowFlags = dynamic_cast<TProfile*>(diffFlowList->FindObject(diffFlowFlagsName.Data()));
 if(diffFlowFlags)
 {
  this->SetDiffFlowFlags(diffFlowFlags);  
 } else 
   {
    cout<<endl; 
    cout<<"WARNING (GFC): diffFlowFlags is NULL in AFAWGFC::GPFDFO() !!!!"<<endl;
    cout<<endl; 
    exit(0); 
   }
    
 // d) Get pointers to all profiles in the list fDiffFlowListProfiles:
 // Generating functions for differential flow:
 TProfile3D *diffFlowGenFun[2][2][2] = {{{NULL}}};
 for(Int_t ri=0;ri<2;ri++)
 {
  for(Int_t rp=0;rp<2;rp++)
  {
   for(Int_t pe=0;pe<2;pe++)
   {
    diffFlowGenFun[ri][rp][pe] = dynamic_cast<TProfile3D*> // to be improved - harwired name fDiffFlowGenFun in the line bellow
                                 (diffFlowProfiles->FindObject(Form("fDiffFlowGenFun (%s, %s, %s)",reIm[ri].Data(),rpPoi[rp].Data(),ptEta[pe].Data())));
    if(diffFlowGenFun[ri][rp][pe])
    {
     this->SetDiffFlowGenFun(diffFlowGenFun[ri][rp][pe],ri,rp,pe);
    } else 
      {
       cout<<endl; 
       cout<<"WARNING (GFC): "<<Form("diffFlowGenFun[%d][%d][%d]",ri,rp,pe)<<" is NULL in AFAWGFC::GPFDFO() !!!!"<<endl;
       cout<<endl; 
       exit(0); 
      }   
   }
  }   
 } 
 // Number of particles in pt/eta bin for RPs/POIs:
 TProfile *noOfParticlesInBin[2][2] = {{NULL}};
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   noOfParticlesInBin[rp][pe] = dynamic_cast<TProfile*> // to be improved - harwired name fNoOfParticlesInBin in the line bellow
                                 (diffFlowProfiles->FindObject(Form("fNoOfParticlesInBin (%s, %s)",rpPoi[rp].Data(),ptEta[pe].Data())));  
   if(noOfParticlesInBin[rp][pe])
   {
    this->SetNoOfParticlesInBin(noOfParticlesInBin[rp][pe],rp,pe);
   } else 
     {
      cout<<endl; 
      cout<<"WARNING (GFC): "<<Form("noOfParticlesInBin[%d][%d]",rp,pe)<<" is NULL in AFAWGFC::GPFDFO() !!!!"<<endl;
      cout<<endl; 
      exit(0); 
     }   
  }
 }   
 // Differential cumulants per pt/eta bin for RPs/POIs:
 TH1D *diffFlowCumulants[2][2][4] = {{{NULL}}};
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    diffFlowCumulants[rp][pe][co] = dynamic_cast<TH1D*> // to be improved - hardwired name fDiffFlowCumulants in the line bellow
                                    (diffFlowResults->FindObject(Form("fDiffFlowCumulants (%s, %s, %s)",rpPoi[rp].Data(),ptEta[pe].Data(),order[co].Data())));  
    if(diffFlowCumulants[rp][pe][co])
    {
     this->SetDiffFlowCumulants(diffFlowCumulants[rp][pe][co],rp,pe,co);
    } else 
      {
       cout<<endl; 
       cout<<"WARNING (GFC): "<<Form("diffFlowCumulants[%d][%d][%d]",rp,pe,co)<<" is NULL in AFAWGFC::GPFDFO() !!!!"<<endl;
       cout<<endl; 
       exit(0); 
      }
   }      
  }
 }   
 // Differential flow per pt/eta bin for RPs/POIs:
 TH1D *diffFlow[2][2][4] = {{{NULL}}};
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    diffFlow[rp][pe][co] = dynamic_cast<TH1D*> // to be improved - hardwired name fDiffFlow in the line bellow
                           (diffFlowResults->FindObject(Form("fDiffFlow (%s, %s, %s)",rpPoi[rp].Data(),ptEta[pe].Data(),order[co].Data())));  
    if(diffFlow[rp][pe][co])
    {
     this->SetDiffFlow(diffFlow[rp][pe][co],rp,pe,co);
    } else 
      {
       cout<<endl; 
       cout<<"WARNING (GFC): "<<Form("diffFlow[%d][%d][%d]",rp,pe,co)<<" is NULL in AFAWGFC::GPFDFO() !!!!"<<endl;
       cout<<endl; 
       exit(0); 
      }
   }      
  }
 }   

} // end of void AliFlowAnalysisWithCumulants::GetPointersForDiffFlowObjects()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateIntegratedFlow(TString rpPoi)
{
 // Calculate final results for integrated flow of RPs and POIs. 
 // (to be improved - this method can be implemented much better)
  
 Int_t rp = 0;

 if(rpPoi == "RP")
 {
  rp = 0;
 } else if(rpPoi == "POI")
   {
    rp = 1;
   } 
          
 // pt yield:    
 TH1F *yieldPt = NULL;
 
 if(rpPoi == "POI")
 {
  yieldPt = (TH1F*)(fCommonHists->GetHistPtPOI())->Clone();
 } else if(rpPoi == "RP")
   {
    yieldPt = (TH1F*)(fCommonHists->GetHistPtRP())->Clone();
   } 
    
 if(!yieldPt)
 {
  printf("\n WARNING (GFC): yieldPt is NULL in AFAWC::CIF() !!!!\n");
  return;
 } 
  
 TH1D *flow2ndPt = (TH1D*)fDiffFlow[rp][0][0]->Clone();
 TH1D *flow4thPt = (TH1D*)fDiffFlow[rp][0][1]->Clone();
 TH1D *flow6thPt = (TH1D*)fDiffFlow[rp][0][2]->Clone();
 TH1D *flow8thPt = (TH1D*)fDiffFlow[rp][0][3]->Clone();
 Double_t dvn2nd = 0., dvn4th = 0., dvn6th = 0., dvn8th = 0.; // differential flow
 Double_t dErrvn2nd = 0., dErrvn4th = 0., dErrvn6th = 0., dErrvn8th = 0.; // error on differential flow
 Double_t dVn2nd = 0., dVn4th = 0., dVn6th = 0., dVn8th = 0.; // integrated flow 
 Double_t dErrVn2nd = 0., dErrVn4th = 0., dErrVn6th = 0., dErrVn8th = 0.; // error on integrated flow
 Double_t dYield = 0.; // pt yield 
 Double_t dSum2nd = 0., dSum4th = 0., dSum6th = 0., dSum8th = 0.; // needed for normalizing integrated flow
 fnBinsPt = flow2ndPt->GetXaxis()->GetNbins(); 
 // looping over pt bins:
 for(Int_t p=1;p<=fnBinsPt;p++)
 {
  dvn2nd = flow2ndPt->GetBinContent(p);
  dvn4th = flow4thPt->GetBinContent(p);
  dvn6th = flow6thPt->GetBinContent(p);
  dvn8th = flow8thPt->GetBinContent(p);
  
  dErrvn2nd = flow2ndPt->GetBinError(p);
  dErrvn4th = flow4thPt->GetBinError(p);
  dErrvn6th = flow6thPt->GetBinError(p);
  dErrvn8th = flow8thPt->GetBinError(p);

  dYield = yieldPt->GetBinContent(p);  
  
  dVn2nd += dvn2nd*dYield;
  dVn4th += dvn4th*dYield;
  dVn6th += dvn6th*dYield;
  dVn8th += dvn8th*dYield;
  
  dSum2nd += dYield;
  dSum4th += dYield;
  dSum6th += dYield;
  dSum8th += dYield;
  
  dErrVn2nd += dYield*dYield*dErrvn2nd*dErrvn2nd; 
  dErrVn4th += dYield*dYield*dErrvn4th*dErrvn4th;
  dErrVn6th += dYield*dYield*dErrvn6th*dErrvn6th;
  dErrVn8th += dYield*dYield*dErrvn8th*dErrvn8th;
 } // end of for(Int_t p=1;p<=fnBinsPt;p++)

 // normalizing the results for integrated flow:
 if(dSum2nd) 
 {
  dVn2nd /= dSum2nd;
  dErrVn2nd /= (dSum2nd*dSum2nd);
  dErrVn2nd = TMath::Sqrt(dErrVn2nd);
 } 
 if(dSum4th) 
 {
  dVn4th /= dSum4th;
  dErrVn4th /= (dSum4th*dSum4th);
  dErrVn4th = TMath::Sqrt(dErrVn4th);
 } 
 if(dSum6th) 
 {
  dVn6th /= dSum6th;
  dErrVn6th /= (dSum6th*dSum6th);
  dErrVn6th = TMath::Sqrt(dErrVn6th);
 } 
 if(dSum8th) 
 {
  dVn8th /= dSum8th;
  dErrVn8th /= (dSum8th*dSum8th);
  dErrVn8th = TMath::Sqrt(dErrVn8th);
 } 
  
 // storing the results for integrated flow in common hist results: 
 if(rpPoi == "POI")
 {
  fCommonHistsResults2nd->FillIntegratedFlowPOI(dVn2nd,dErrVn2nd); 
  fCommonHistsResults4th->FillIntegratedFlowPOI(dVn4th,dErrVn4th); 
  fCommonHistsResults6th->FillIntegratedFlowPOI(dVn6th,dErrVn6th); 
  fCommonHistsResults8th->FillIntegratedFlowPOI(dVn8th,dErrVn8th); 
 }
 else if(rpPoi == "RP")
 {
  fCommonHistsResults2nd->FillIntegratedFlowRP(dVn2nd,dErrVn2nd); 
  fCommonHistsResults4th->FillIntegratedFlowRP(dVn4th,dErrVn4th);
  fCommonHistsResults6th->FillIntegratedFlowRP(dVn6th,dErrVn6th); 
  fCommonHistsResults8th->FillIntegratedFlowRP(dVn8th,dErrVn8th); 
 }
 
 delete flow2ndPt;
 delete flow4thPt;
 delete flow6thPt;
 delete flow8thPt; 
 delete yieldPt;
 
} // end of void AliFlowAnalysisWithCumulants::CalculateIntegratedFlow(TString rpPoi)

//================================================================================================================

void AliFlowAnalysisWithCumulants::FillCommonHistResultsForDifferentialFlow(TString rpPoi)
{
 // Fill common result histograms for differential flow.
 // (to be improved - this method can be implemented much better)
 
 Int_t rp = 0;

 if(rpPoi == "RP")
 {
  rp = 0;
 } else if(rpPoi == "POI")
   {
    rp = 1;
   } 
   
 // pt:
 for(Int_t p=1;p<=fnBinsPt;p++)
 {
  // Result:
  Double_t v2 = fDiffFlow[rp][0][0]->GetBinContent(p);
  Double_t v4 = fDiffFlow[rp][0][1]->GetBinContent(p);
  Double_t v6 = fDiffFlow[rp][0][2]->GetBinContent(p);
  Double_t v8 = fDiffFlow[rp][0][3]->GetBinContent(p);
  // Error:
  Double_t v2Error = fDiffFlow[rp][0][0]->GetBinError(p);
  Double_t v4Error = fDiffFlow[rp][0][1]->GetBinError(p);
  Double_t v6Error = fDiffFlow[rp][0][2]->GetBinError(p);
  Double_t v8Error = fDiffFlow[rp][0][3]->GetBinError(p);
  // Fill common hist results:
  if(rpPoi == "RP")
  {
   fCommonHistsResults2nd->FillDifferentialFlowPtRP(p,v2,v2Error);
   fCommonHistsResults4th->FillDifferentialFlowPtRP(p,v4,v4Error);
   fCommonHistsResults6th->FillDifferentialFlowPtRP(p,v6,v6Error);
   fCommonHistsResults8th->FillDifferentialFlowPtRP(p,v8,v8Error);
  } else if(rpPoi == "POI")
    {
     fCommonHistsResults2nd->FillDifferentialFlowPtPOI(p,v2,v2Error);
     fCommonHistsResults4th->FillDifferentialFlowPtPOI(p,v4,v4Error);
     fCommonHistsResults6th->FillDifferentialFlowPtPOI(p,v6,v6Error);
     fCommonHistsResults8th->FillDifferentialFlowPtPOI(p,v8,v8Error);
    }
 } // end of for(Int_t p=1;p<=fnBinsPt;p++)   
 
 // eta:
 for(Int_t e=1;e<=fnBinsEta;e++)
 {
  // Results:
  Double_t v2 = fDiffFlow[rp][1][0]->GetBinContent(e);
  Double_t v4 = fDiffFlow[rp][1][1]->GetBinContent(e);
  Double_t v6 = fDiffFlow[rp][1][2]->GetBinContent(e);
  Double_t v8 = fDiffFlow[rp][1][3]->GetBinContent(e);
  // Errors:
  Double_t v2Error = fDiffFlow[rp][1][0]->GetBinError(e);
  Double_t v4Error = fDiffFlow[rp][1][1]->GetBinError(e);
  Double_t v6Error = fDiffFlow[rp][1][2]->GetBinError(e);
  Double_t v8Error = fDiffFlow[rp][1][3]->GetBinError(e); 
  // Fill common hist results:
  if(rpPoi == "RP")
  {
   fCommonHistsResults2nd->FillDifferentialFlowEtaRP(e,v2,v2Error);
   fCommonHistsResults4th->FillDifferentialFlowEtaRP(e,v4,v4Error);
   fCommonHistsResults6th->FillDifferentialFlowEtaRP(e,v6,v6Error);
   fCommonHistsResults8th->FillDifferentialFlowEtaRP(e,v8,v8Error);
  } else if(rpPoi == "POI")
    {
     fCommonHistsResults2nd->FillDifferentialFlowEtaPOI(e,v2,v2Error);
     fCommonHistsResults4th->FillDifferentialFlowEtaPOI(e,v4,v4Error);
     fCommonHistsResults6th->FillDifferentialFlowEtaPOI(e,v6,v6Error);
     fCommonHistsResults8th->FillDifferentialFlowEtaPOI(e,v8,v8Error);
    }
 } // end of for(Int_t e=1;e<=fnBinsEta;e++)    
 
} // end of void AliFlowAnalysisWithCumulants::FillCommonHistResultsForDifferentialFlow(TString rpPoi)

//================================================================================================================ 
   
void AliFlowAnalysisWithCumulants::CalculateDifferentialFlow(TString rpPoi, TString ptEta)
{
 // Calculate differential flow for RPs/POIs vs pt/eta from cumulants.
 
 Int_t rp = 0; // RP or POI
 Int_t pe = 0; // pt or eta

 if(rpPoi == "RP")
 {
  rp = 0;
 } else if(rpPoi == "POI")
   {
    rp = 1;
   } 
 if(ptEta == "pt")
 {
  pe = 0;
 } else if(ptEta == "eta")
   {
    pe = 1;
   } 
 
 // Reference cumulants:
 Double_t gfc2 = fReferenceFlowCumulants->GetBinContent(1); // reference 2nd order cumulant  
 Double_t gfc4 = fReferenceFlowCumulants->GetBinContent(2); // reference 4th order cumulant   
 Double_t gfc6 = fReferenceFlowCumulants->GetBinContent(3); // reference 6th order cumulant   
 Double_t gfc8 = fReferenceFlowCumulants->GetBinContent(4); // reference 8th order cumulant 
 
 Int_t nBins = fDiffFlowCumulants[rp][pe][0]->GetXaxis()->GetNbins();
 
 for(Int_t b=1;b<=nBins;b++)
 { 
  // Differential cumulants:
  Double_t gfd2 = fDiffFlowCumulants[rp][pe][0]->GetBinContent(b); // differential 2nd order cumulant
  Double_t gfd4 = fDiffFlowCumulants[rp][pe][1]->GetBinContent(b); // differential 4th order cumulant
  Double_t gfd6 = fDiffFlowCumulants[rp][pe][2]->GetBinContent(b); // differential 6th order cumulant
  Double_t gfd8 = fDiffFlowCumulants[rp][pe][3]->GetBinContent(b); // differential 8th order cumulant
  // Differential flow:
  Double_t v2 = 0.; // v'{2,GFC}
  Double_t v4 = 0.; // v'{4,GFC}
  Double_t v6 = 0.; // v'{6,GFC}
  Double_t v8 = 0.; // v'{8,GFC}  
  // 2nd order:
  if(gfc2>0.)
  {
   v2 = gfd2/pow(gfc2,0.5);
   fDiffFlow[rp][pe][0]->SetBinContent(b,v2);
  }
  // 4th order:
  if(gfc4<0.)
  {
   v4 = -gfd4/pow(-gfc4,.75);
   fDiffFlow[rp][pe][1]->SetBinContent(b,v4);
  }
  // 6th order:
  if(gfc6>0.)
  {
   v6 = gfd6/(4.*pow((1./4.)*gfc6,(5./6.)));
   fDiffFlow[rp][pe][2]->SetBinContent(b,v6);   
  }
  // 8th order:
  if(gfc8<0.)
  {
   v8 = -gfd8/(33.*pow(-(1./33.)*gfc8,(7./8.))); 
   fDiffFlow[rp][pe][3]->SetBinContent(b,v8);   
  }
 } // end of for(Int_t b=1;b<=nBins;b++)
 
} // end of void AliFlowAnalysisWithCumulants::CalculateDifferentialFlow(TString rpPoi,TString ptEta)

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateDifferentialFlowErrors(TString rpPoi,TString ptEta)
{
 // Calculate errors of differential flow.

 Int_t rp = 0; // RP or POI
 Int_t pe = 0; // pt or eta

 if(rpPoi == "RP")
 {
  rp = 0;
 } else if(rpPoi == "POI")
   {
    rp = 1;
   } 
 if(ptEta == "pt")
 {
  pe = 0;
 } else if(ptEta == "eta")
   {
    pe = 1;
   } 
 
 // Resolution chi:
 Double_t chi2 = fChi->GetBinContent(1);
 Double_t chi4 = fChi->GetBinContent(2);
 //Double_t chi6 = fChi->GetBinContent(3);
 //Double_t chi8 = fChi->GetBinContent(4);
 
 Int_t nBins = fNoOfParticlesInBin[rp][pe]->GetXaxis()->GetNbins();
 for(Int_t b=1;b<=nBins;b++)
 {
  Int_t nParticles = (Int_t)fNoOfParticlesInBin[rp][pe]->GetBinEntries(b);
  // Error of 2nd order estimate:
  if(chi2>0. &&  nParticles>0.)
  {
   Double_t v2Error = pow((1./(2.*nParticles))*((1.+pow(chi2,2.))/pow(chi2,2.)),0.5); 
   fDiffFlow[rp][pe][0]->SetBinError(b,v2Error);
  }
  // Error of 4th order estimate:
  if(chi4>0. &&  nParticles>0.)
  {
   Double_t v4Error = pow((1./(2.*nParticles))*((2.+6.*pow(chi4,2.)+pow(chi4,4.)+pow(chi4,6.))/pow(chi4,6.)),0.5);
   fDiffFlow[rp][pe][1]->SetBinError(b,v4Error);
  }
  // Error of 6th order estimate:
  //if(chi6>0. &&  nParticles>0.)
  //{
  // Double_t v6Error = ... // to be improved - yet to be calculated
   fDiffFlow[rp][pe][2]->SetBinError(b,0.);
  //}
  // Error of 8th order estimate:
  //if(chi8>0. &&  nParticles>0.)
  //{
  // Double_t v8Error = ... // to be improved - yet to be calculated
   fDiffFlow[rp][pe][3]->SetBinError(b,0.);
  //}
 } // end of for(Int_t b=1;b<=nBins;b++)

} // end of void AliFlowAnalysisWithCumulants::CalculateDifferentialFlowErrors(TString rpPoi,TString ptEta)

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateCumulantsForDiffFlow(TString rpPoi,TString ptEta)
{
 // Calculate cumulants for differential flow. 
 
 Int_t rp = 0; // RP or POI
 Int_t pe = 0; // pt or eta

 if(rpPoi == "RP")
 {
  rp = 0;
 } else if(rpPoi == "POI")
   {
    rp = 1;
   } 
 if(ptEta == "pt")
 {
  pe = 0;
 } else if(ptEta == "eta")
   {
    pe = 1;
   } 
         
 // [nBins][pMax][qMax]:
 Int_t nBins = fDiffFlowGenFun[0][rp][pe]->GetXaxis()->GetNbins();
 Int_t pMax  = fDiffFlowGenFun[0][rp][pe]->GetYaxis()->GetNbins();
 Int_t qMax  = fDiffFlowGenFun[0][rp][pe]->GetZaxis()->GetNbins();
 // <G[p][q]>
 TMatrixD dAvG(pMax,qMax); 
 dAvG.Zero();
 for(Int_t p=0;p<pMax;p++)
 {
  for(Int_t q=0;q<qMax;q++)
  {
   dAvG(p,q) = fReferenceFlowGenFun->GetBinContent(fReferenceFlowGenFun->GetBin(p+1,q+1));
  }  
 } 
 // Loop over pt/eta bins and calculate differential cumulants:
 for(Int_t b=0;b<nBins;b++)
 {
  Double_t gfc[5] = {0.}; // to be improved (hardwired 5)
  Double_t dD[5] = {0.}; // D_{p} in Eq. (11) in Practical guide // to be improved (hardwired 5)
  // ptBinRPNoOfParticles[b]=fPtBinRPNoOfParticles->GetBinEntries(b+1); 
  for(Int_t p=0;p<pMax;p++)
  {
   Double_t tempSum = 0.;
   for(Int_t q=0;q<qMax;q++)
   {
    if(TMath::Abs(dAvG(p,q))>1.e-44)
    {   
     Double_t dX = fDiffFlowGenFun[0][rp][pe]->GetBinContent(fDiffFlowGenFun[0][rp][pe]->GetBin(b+1,p+1,q+1))/dAvG(p,q); // see Ollitrault's Practical guide (Eq. 11)
     Double_t dY = fDiffFlowGenFun[1][rp][pe]->GetBinContent(fDiffFlowGenFun[0][rp][pe]->GetBin(b+1,p+1,q+1))/dAvG(p,q); // see Ollitrault's Practical guide (Eq. 11)
     tempSum += cos(fMultiple*2.*q*TMath::Pi()/qMax)*dX 
              + sin(fMultiple*2.*q*TMath::Pi()/qMax)*dY;
    }
   }   
   dD[p] = (pow(fR0*pow(p+1.0,0.5),fMultiple)/qMax)*tempSum;   
  }   
  gfc[0] = (1./(fR0*fR0))*(5.*dD[0]-5.*dD[1]+(10./3.)*dD[2]-(5./4.)*dD[3]+(1./5.)*dD[4]); 
  gfc[1] = (1./pow(fR0,4.))*((-77./6.)*dD[0]+(107./6.)*dD[1]-(13./1.)*dD[2]+(61./12.)*dD[3]-(5./6.)*dD[4]);
  gfc[2] = (1./pow(fR0,6.))*((71./2.)*dD[0]-59.*dD[1]+49.*dD[2]-(41./2.)*dD[3]+(7./2.)*dD[4]);
  gfc[3] = (1./pow(fR0,8.))*(-84.*dD[0]+156.*dD[1]-144.*dD[2]+66.*dD[3]-12.*dD[4]);
  // gfc[4] = (1./pow(fR0,10.))*(120.*dD[0]-240.*dD[1]+240.*dD[2]-120.*dD[3]+24.*dD[4]); // 10th order cumulant (to be improved - where to store it?)
  // Store cumulants:
  for(Int_t co=0;co<4;co++)
  {
   fDiffFlowCumulants[rp][pe][co]->SetBinContent(b+1,gfc[co]);
  } 
 }   
 
} // end of void AliFlowAnalysisWithCumulants::CalculateCumulantsForDiffFlow(TString rpPoi, TString ptEta)

//================================================================================================================

void AliFlowAnalysisWithCumulants::PrintFinalResults(TString type)
{
 // Printing on the screen the final results for reference flow and for integrated flow of RPs and POIs.
  
 Int_t n = fHarmonic; 
  
 Double_t dVn[4] = {0.}; // array to hold Vn{2}, Vn{4}, Vn{6} and Vn{8}   
 Double_t dVnErr[4] = {0.}; // array to hold errors of Vn{2}, Vn{4}, Vn{6} and Vn{8}   
 
 if(type == "RF")
 {
  dVn[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinContent(1); 
  dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlow())->GetBinError(1); 
  dVn[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinContent(1); 
  dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlow())->GetBinError(1); 
  dVn[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinContent(1); 
  dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlow())->GetBinError(1); 
  dVn[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinContent(1); 
  dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlow())->GetBinError(1); 
 } else if(type == "RP")
   {
    dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinContent(1); 
    dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowRP())->GetBinError(1); 
    dVn[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinContent(1); 
    dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowRP())->GetBinError(1); 
    dVn[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinContent(1); 
    dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowRP())->GetBinError(1); 
    dVn[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinContent(1); 
    dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowRP())->GetBinError(1); 
   } else if(type == "POI")
     {
      dVn[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinContent(1); 
      dVnErr[0] = (fCommonHistsResults2nd->GetHistIntFlowPOI())->GetBinError(1); 
      dVn[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinContent(1); 
      dVnErr[1] = (fCommonHistsResults4th->GetHistIntFlowPOI())->GetBinError(1); 
      dVn[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinContent(1); 
      dVnErr[2] = (fCommonHistsResults6th->GetHistIntFlowPOI())->GetBinError(1); 
      dVn[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinContent(1); 
      dVnErr[3] = (fCommonHistsResults8th->GetHistIntFlowPOI())->GetBinError(1); 
     } else
       {
        cout<<endl;
        cout<<" WARNING: Impossible type (can be RF, RP or POI) !!!!"<<endl;
        cout<<"          Results will not be printed on the screen."<<endl;
        cout<<endl;
        exit(0);
       }
 
 TString title = " flow estimates from GF-cumulants"; 
 TString subtitle = "      ("; 
 
 if(!(fUsePhiWeights||fUsePtWeights||fUseEtaWeights))
 {
  subtitle.Append(type);
  subtitle.Append(", without weights)");
 } else  
   {
    subtitle.Append(type);
    subtitle.Append(", with weights)");
   }
  
 cout<<endl;
 cout<<"*************************************"<<endl;
 cout<<"*************************************"<<endl;
 cout<<title.Data()<<endl; 
 cout<<subtitle.Data()<<endl; 
 cout<<endl;
  
 for(Int_t i=0;i<4;i++)
 {
  cout<<"  v_"<<n<<"{"<<2*(i+1)<<"} = "<<dVn[i]<<" +/- "<<dVnErr[i]<<endl;
 }
  
 cout<<endl;
 if(type == "RF")
 {
  cout<<"     nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl; 
 }
 else if (type == "RP")
 {
  cout<<"     nEvts = "<<(Int_t)fCommonHists->GetHistMultRP()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultRP()->GetMean()<<endl;  
 } 
 else if (type == "POI")
 {
  cout<<"     nEvts = "<<(Int_t)fCommonHists->GetHistMultPOI()->GetEntries()<<", <M> = "<<(Double_t)fCommonHists->GetHistMultPOI()->GetMean()<<endl;
 } 
 cout<<"*************************************"<<endl;
 cout<<"*************************************"<<endl;
 cout<<endl; 
  
} // end of AliFlowAnalysisWithCumulants::PrintFinalResults(TString type);

//================================================================================================================

void AliFlowAnalysisWithCumulants::FillCommonHistResultsForReferenceFlow()
{
 // Fill in AliFlowCommonHistResults dedicated histograms for reference flow. 
 
 // Results: 
 Double_t v2 = fReferenceFlow->GetBinContent(1);
 Double_t v4 = fReferenceFlow->GetBinContent(2);
 Double_t v6 = fReferenceFlow->GetBinContent(3);
 Double_t v8 = fReferenceFlow->GetBinContent(4);
 // Errors: 
 Double_t v2Error = fReferenceFlow->GetBinError(1);
 Double_t v4Error = fReferenceFlow->GetBinError(2);
 Double_t v6Error = fReferenceFlow->GetBinError(3);
 Double_t v8Error = fReferenceFlow->GetBinError(4);
 // Fill results end errors in common hist results:
 fCommonHistsResults2nd->FillIntegratedFlow(v2,v2Error);  
 fCommonHistsResults4th->FillIntegratedFlow(v4,v4Error); 
 fCommonHistsResults6th->FillIntegratedFlow(v6,v6Error); 
 fCommonHistsResults8th->FillIntegratedFlow(v8,v8Error); 
 // Chi:
 Double_t chi2 = fChi->GetBinContent(1);
 Double_t chi4 = fChi->GetBinContent(2);
 Double_t chi6 = fChi->GetBinContent(3);
 Double_t chi8 = fChi->GetBinContent(4);
 // Fill resolution chi in common hist results:
 fCommonHistsResults2nd->FillChi(chi2);
 fCommonHistsResults4th->FillChi(chi4);
 fCommonHistsResults6th->FillChi(chi6);
 fCommonHistsResults8th->FillChi(chi8); 
  
} // end of AliFlowAnalysisWithCumulants::FillCommonHistResultsForReferenceFlow()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateReferenceFlowError()
{
 // Calculate error of reference flow harmonics.
  
 // Generating Function Cumulants:
 Double_t gfc2 = fReferenceFlowCumulants->GetBinContent(1); // GFC{2}  
 Double_t gfc4 = fReferenceFlowCumulants->GetBinContent(2); // GFC{4}  
 Double_t gfc6 = fReferenceFlowCumulants->GetBinContent(3); // GFC{6}  
 Double_t gfc8 = fReferenceFlowCumulants->GetBinContent(4); // GFC{8}
 // Reference flow estimates:
 Double_t v2 = fReferenceFlow->GetBinContent(1); // v{2,GFC}  
 Double_t v4 = fReferenceFlow->GetBinContent(2); // v{4,GFC}  
 Double_t v6 = fReferenceFlow->GetBinContent(3); // v{6,GFC}  
 Double_t v8 = fReferenceFlow->GetBinContent(4); // v{8,GFC}
 // Statistical errors of reference flow estimates:
 Double_t v2Error = 0.; // statistical error of v{2,GFC}  
 Double_t v4Error = 0.; // statistical error of v{4,GFC}  
 Double_t v6Error = 0.; // statistical error of v{6,GFC}  
 Double_t v8Error = 0.; // statistical error of v{8,GFC}
 // Chi:
 Double_t chi2 = 0.;
 Double_t chi4 = 0.;
 Double_t chi6 = 0.;
 Double_t chi8 = 0.;
 // <Q-vector stuff>:
 Double_t dAvQx  = fQvectorComponents->GetBinContent(1); // <Q_x>
 Double_t dAvQy  = fQvectorComponents->GetBinContent(2); // <Q_y>
 Double_t dAvQ2x = fQvectorComponents->GetBinContent(3); // <(Q_x)^2>
 Double_t dAvQ2y = fQvectorComponents->GetBinContent(4); // <(Q_y)^2>
 // <w^2>:
 Double_t dAvw2 = 1.;
 if(fnEvts>0)
 { 
  dAvw2 = fAverageOfSquaredWeight->GetBinContent(1); 
  if(TMath::Abs(dAvw2)<1.e-44) 
  {
   cout<<endl;
   cout<<" WARNING (GFC): Average of squared weight is 0 in GFC. Most probably one of the histograms"<<endl; 
   cout<<"                in the file \"weights.root\" was empty. Nothing will be calculated !!!!"<<endl;
   cout<<endl;
  }
 } 
 // Calculating statistical error of v{2,GFC}:
 if(fnEvts>0. && fAvM>0. && dAvw2>0. && gfc2>=0.)
 { 
  if((dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(pow(gfc2,(1./2.))*(fAvM/dAvw2),2.)>0.))       
  {
   chi2 = (fAvM*v2)/pow(dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(v2*fAvM/dAvw2,2.),0.5); 
  } 
  if(TMath::Abs(chi2)>1.e-44)
  {  
   v2Error = pow(((1./(2.*fAvM*fnEvts))*((1.+2.*pow(chi2,2))/(2.*pow(chi2,2)))),0.5);
  }
 } 
 // Calculating statistical error of v{4,GFC}:
 if(fnEvts>0 && fAvM>0 && dAvw2>0 && gfc4<=0.)
 {
  if((dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(pow(-gfc4,(1./4.))*(fAvM/dAvw2),2.)>0.))
  {
   chi4 = (fAvM*v4)/pow(dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(v4*fAvM/dAvw2,2.),0.5);
  } 
  if(TMath::Abs(chi4)>1.e-44)
  {
   v4Error = (1./(pow(2.*fAvM*fnEvts,0.5)))*pow((1.+4.*pow(chi4,2)+1.*pow(chi4,4.)+2.*pow(chi4,6.))/(2.*pow(chi4,6.)),0.5);
  }
 } 
 // Calculating statistical error of v{6,GFC}:
 if(fnEvts>0 && fAvM>0 && dAvw2>0 && gfc6>=0.)
 {
  if((dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(pow((1./4.)*gfc6,(1./6.))*(fAvM/dAvw2),2.)>0.))
  {
   chi6 = (fAvM*v6)/pow(dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(v6*fAvM/dAvw2,2.),0.5);
  } 
  if(TMath::Abs(chi6)>1.e-44)
  {
   v6Error = (1./(pow(2.*fAvM*fnEvts,0.5)))*pow((3.+18.*pow(chi6,2)+9.*pow(chi6,4.)+28.*pow(chi6,6.)
              +12.*pow(chi6,8.)+24.*pow(chi6,10.))/(24.*pow(chi6,10.)),0.5);
  } 
 } 
 // Calculating statistical error of v{8,GFC}:
 if(fnEvts>0 && fAvM>0 && dAvw2>0 && gfc8<=0.)
 { 
  if((dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(pow(-(1./33.)*gfc8,(1./8.))*(fAvM/dAvw2),2.)>0.))
  { 
   chi8=(fAvM*v8)/pow(dAvQ2x+dAvQ2y-pow(dAvQx,2.)-pow(dAvQy,2.)-pow(v8*fAvM/dAvw2,2.),0.5);
  }
  if(TMath::Abs(chi8)>1.e-44)
  {
   v8Error = (1./(pow(2.*fAvM*fnEvts,0.5)))*pow((12.+96.*pow(chi8,2.)+72.*pow(chi8,4.)+304.*pow(chi8,6.)
              +257.*pow(chi8,8.)+804.*pow(chi8,10.)+363.*pow(chi8,12.)+726.*pow(chi8,14.))/(726.*pow(chi8,14.)),0.5);
  } 
 } 
  
 // Store errors for reference flow:
 fReferenceFlow->SetBinError(1,v2Error);
 fReferenceFlow->SetBinError(2,v4Error);
 fReferenceFlow->SetBinError(3,v6Error);
 fReferenceFlow->SetBinError(4,v8Error);
 // Store resolution chi:
 fChi->SetBinContent(1,chi2);
 fChi->SetBinContent(2,chi4);
 fChi->SetBinContent(3,chi6);
 fChi->SetBinContent(4,chi8);

} // end of void AliFlowAnalysisWithCumulants::CalculateReferenceFlowError()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateReferenceFlow()
{
 // Calculate from isotropic cumulants reference flow.

 // Generating Function Cumulants:
 Double_t gfc2 = fReferenceFlowCumulants->GetBinContent(1); // GFC{2}  
 Double_t gfc4 = fReferenceFlowCumulants->GetBinContent(2); // GFC{4}  
 Double_t gfc6 = fReferenceFlowCumulants->GetBinContent(3); // GFC{6}  
 Double_t gfc8 = fReferenceFlowCumulants->GetBinContent(4); // GFC{8}
 // Reference flow estimates:
 Double_t v2 = 0.; // v{2,GFC}  
 Double_t v4 = 0.; // v{4,GFC}  
 Double_t v6 = 0.; // v{6,GFC}  
 Double_t v8 = 0.; // v{8,GFC}
 // Calculate reference flow estimates from Q-cumulants: 
 if(gfc2>=0.) v2 = pow(gfc2,1./2.); 
 if(gfc4<=0.) v4 = pow(-1.*gfc4,1./4.); 
 if(gfc6>=0.) v6 = pow((1./4.)*gfc6,1./6.); 
 if(gfc8<=0.) v8 = pow((-1./33.)*gfc8,1./8.); 
 // Store results for reference flow:
 fReferenceFlow->SetBinContent(1,v2);
 fReferenceFlow->SetBinContent(2,v4);
 fReferenceFlow->SetBinContent(3,v6);
 fReferenceFlow->SetBinContent(4,v8);
 
} // end of void AliFlowAnalysisWithCumulants::CalculateReferenceFlow()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CalculateCumulantsForReferenceFlow()
{
 // Calculate cumulants for reference flow.

 Int_t pMax = fReferenceFlowGenFun->GetXaxis()->GetNbins();
 Int_t qMax = fReferenceFlowGenFun->GetYaxis()->GetNbins();
 
 // <G[p][q]>
 TMatrixD dAvG(pMax,qMax); 
 dAvG.Zero();
 Bool_t someAvGEntryIsNegative = kFALSE;
 for(Int_t p=0;p<pMax;p++)
 {
  for(Int_t q=0;q<qMax;q++)
  {
   dAvG(p,q) = fReferenceFlowGenFun->GetBinContent(fReferenceFlowGenFun->GetBin(p+1,q+1));
   if(dAvG(p,q)<0.)
   {
    someAvGEntryIsNegative = kTRUE;
    cout<<endl; 
    cout<<" WARNING: "<<Form("<G[%d][%d]> is negative !!!! GFC results are meaningless.",p,q)<<endl; 
    cout<<endl; 
   }
  }  
 } 
      
 // C[p][q] (generating function for the cumulants)    
 TMatrixD dC(pMax,qMax);
 dC.Zero();
 if(fAvM>0. && !someAvGEntryIsNegative)
 {
  for(Int_t p=0;p<pMax;p++)
  {
   for(Int_t q=0;q<qMax;q++)
   {
    dC(p,q) = fAvM*(pow(dAvG(p,q),(1./fAvM))-1.); 
   }
  }
 }
    
 // Averaging the generating function for cumulants over azimuth
 // in order to eliminate detector effects.
 // <C[p][q]> (Remark: here <> stands for average over azimuth):
 TVectorD dAvC(pMax);
 dAvC.Zero();
 for(Int_t p=0;p<pMax;p++)
 {
  Double_t temp = 0.; 
  for(Int_t q=0;q<qMax;q++)
  {
   temp += 1.*dC(p,q);
  } 
  dAvC[p] = temp/qMax;
 }
 
 // Finally, the isotropic cumulants for reference flow:
 TVectorD cumulant(pMax);
 cumulant.Zero(); 
 cumulant[0] = (-1./(60*fR0*fR0))*((-300.)*dAvC[0]+300.*dAvC[1]-200.*dAvC[2]+75.*dAvC[3]-12.*dAvC[4]);
 cumulant[1] = (-1./(6.*pow(fR0,4.)))*(154.*dAvC[0]-214.*dAvC[1]+156.*dAvC[2]-61.*dAvC[3]+10.*dAvC[4]);
 cumulant[2] = (3./(2.*pow(fR0,6.)))*(71.*dAvC[0]-118.*dAvC[1]+98.*dAvC[2]-41.*dAvC[3]+7.*dAvC[4]);
 cumulant[3] = (-24./pow(fR0,8.))*(14.*dAvC[0]-26.*dAvC[1]+24.*dAvC[2]-11.*dAvC[3]+2.*dAvC[4]);
 cumulant[4] = (120./pow(fR0,10.))*(5.*dAvC[0]-10.*dAvC[1]+10.*dAvC[2]-5.*dAvC[3]+1.*dAvC[4]);
 
 // Store cumulants:
 // Remark: the highest order cumulant is on purpose in the overflow.
 for(Int_t co=0;co<pMax;co++) // cumulant order
 {
  fReferenceFlowCumulants->SetBinContent(co+1,cumulant[co]);
 }
 
 // Calculation versus multiplicity:
 if(!fCalculateVsMultiplicity){return;}
 for(Int_t b=0;b<fnBinsMult;b++)
 {
  fAvM = fAvMVsM->GetBinContent(b+1);
  // <G[p][q]>
  TMatrixD dAvGVsM(pMax,qMax); 
  dAvGVsM.Zero();
  Bool_t someAvGEntryIsNegativeVsM = kFALSE;
  for(Int_t p=0;p<pMax;p++)
  {
   for(Int_t q=0;q<qMax;q++)
   {
    dAvGVsM(p,q) = fReferenceFlowGenFunVsM->GetBinContent(fReferenceFlowGenFunVsM->GetBin(b+1,p+1,q+1));
    if(dAvGVsM(p,q)<0.)
    {
     someAvGEntryIsNegativeVsM = kTRUE;
     cout<<endl; 
     cout<<" WARNING: "<<Form("<G[%d][%d]> is negative !!!! GFC vs multiplicity results are meaningless.",p,q)<<endl; 
     cout<<endl; 
    }
   }  
  } 
      
  // C[p][q] (generating function for the cumulants)    
  TMatrixD dCVsM(pMax,qMax);
  dCVsM.Zero();
  if(fAvM>0. && !someAvGEntryIsNegativeVsM)
  {
   for(Int_t p=0;p<pMax;p++)
   {
    for(Int_t q=0;q<qMax;q++)
    {
     dCVsM(p,q) = fAvM*(pow(dAvGVsM(p,q),(1./fAvM))-1.); 
    }
   }
  }
    
  // Averaging the generating function for cumulants over azimuth
  // in order to eliminate detector effects.
  // <C[p][q]> (Remark: here <> stands for average over azimuth):
  TVectorD dAvCVsM(pMax);
  dAvCVsM.Zero();
  for(Int_t p=0;p<pMax;p++)
  {
   Double_t tempVsM = 0.; 
   for(Int_t q=0;q<qMax;q++)
   {
    tempVsM += 1.*dCVsM(p,q);
   } 
   dAvCVsM[p] = tempVsM/qMax;
  }
  
  // Finally, the isotropic cumulants for reference flow:
  TVectorD cumulantVsM(pMax);
  cumulantVsM.Zero(); 
  cumulantVsM[0] = (-1./(60*fR0*fR0))*((-300.)*dAvCVsM[0]+300.*dAvCVsM[1]-200.*dAvCVsM[2]+75.*dAvCVsM[3]-12.*dAvCVsM[4]);
  cumulantVsM[1] = (-1./(6.*pow(fR0,4.)))*(154.*dAvCVsM[0]-214.*dAvCVsM[1]+156.*dAvCVsM[2]-61.*dAvCVsM[3]+10.*dAvCVsM[4]);
  cumulantVsM[2] = (3./(2.*pow(fR0,6.)))*(71.*dAvCVsM[0]-118.*dAvCVsM[1]+98.*dAvCVsM[2]-41.*dAvCVsM[3]+7.*dAvCVsM[4]);
  cumulantVsM[3] = (-24./pow(fR0,8.))*(14.*dAvCVsM[0]-26.*dAvCVsM[1]+24.*dAvCVsM[2]-11.*dAvCVsM[3]+2.*dAvCVsM[4]);
  cumulantVsM[4] = (120./pow(fR0,10.))*(5.*dAvCVsM[0]-10.*dAvCVsM[1]+10.*dAvCVsM[2]-5.*dAvCVsM[3]+1.*dAvCVsM[4]);
  
  // Store cumulants:
  for(Int_t co=0;co<pMax-1;co++) // cumulant order
  {
   fReferenceFlowCumulantsVsM[co]->SetBinContent(b+1,cumulantVsM[co]);
  } 
 } // end of for(Int_t b=0;b<fnBinsMult;b++)

} // end of void AliFlowAnalysisWithCumulants::CalculateCumulantsForReferenceFlow()

//================================================================================================================

void AliFlowAnalysisWithCumulants::GetAvMultAndNoOfEvts()
{
 // From relevant common control histogram get average multiplicity of RPs and number of events.
 
 fAvM = (Double_t)fCommonHists->GetHistMultRP()->GetMean(); 
 fnEvts = (Int_t)fCommonHists->GetHistMultRP()->GetEntries(); 
 
} // end of void AliFlowAnalysisWithCumulants::GetAvMultAndNoOfEvts()

//================================================================================================================

void AliFlowAnalysisWithCumulants::InitializeArrays()
{
 // Initialize all arrays.
 
 for(Int_t ri=0;ri<2;ri++)
 {
  for(Int_t rp=0;rp<2;rp++)
  {
   for(Int_t pe=0;pe<2;pe++)
   {
    fDiffFlowGenFun[ri][rp][pe] = NULL;
   }
  }   
 } 
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   fNoOfParticlesInBin[rp][pe] = NULL;
  }
 }   
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    fDiffFlowCumulants[rp][pe][co] = NULL;
    fDiffFlow[rp][pe][co] = NULL;
   }
  }
 }   
 for(Int_t i=0;i<3;i++)
 {
  fPrintFinalResults[i] = kTRUE;
 }
 for(Int_t r=0;r<10;r++)
 {
  fTuningR0[r] = 0.;
  for(Int_t pq=0;pq<5;pq++)
  {
   fTuningGenFun[r][pq] = NULL;
   fTuningCumulants[r][pq] = NULL;
   fTuningFlow[r][pq] = NULL;
  }
 }
 for(Int_t co=0;co<4;co++)
 {
  fReferenceFlowCumulantsVsM[co] = NULL;
 }
 
} // end of void AliFlowAnalysisWithCumulants::InitializeArrays()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CrossCheckSettings()
{
 // Cross-check the user settings before starting.
 
 // a) Cross check if the choice for multiplicity weight make sense.
 
 // a) Cross check if the choice for multiplicity weight make sense:
 if(strcmp(fMultiplicityWeight->Data(),"unit") &&
    strcmp(fMultiplicityWeight->Data(),"multiplicity"))
 {
  cout<<endl;
  cout<<"WARNING (GFC): Multiplicity weight can be either \"unit\" or \"multiplicity\"."<<endl;
  cout<<"               Certainly not \""<<fMultiplicityWeight->Data()<<"\"."<<endl;
  cout<<endl;
  exit(0);
 }   

 
 
} // end of void AliFlowAnalysisWithCumulants::CrossCheckSettings()

//================================================================================================================

void AliFlowAnalysisWithCumulants::AccessConstants()
{
 // Access needed common constants from AliFlowCommonConstants.
 
 fnBinsPhi = AliFlowCommonConstants::GetMaster()->GetNbinsPhi();
 fPhiMin = AliFlowCommonConstants::GetMaster()->GetPhiMin();	     
 fPhiMax = AliFlowCommonConstants::GetMaster()->GetPhiMax();
 if(fnBinsPhi) fPhiBinWidth = (fPhiMax-fPhiMin)/fnBinsPhi;   
 fnBinsPt = AliFlowCommonConstants::GetMaster()->GetNbinsPt();
 fPtMin = AliFlowCommonConstants::GetMaster()->GetPtMin();	     
 fPtMax = AliFlowCommonConstants::GetMaster()->GetPtMax();
 if(fnBinsPt) fPtBinWidth = (fPtMax-fPtMin)/fnBinsPt;  
 fnBinsEta = AliFlowCommonConstants::GetMaster()->GetNbinsEta();
 fEtaMin = AliFlowCommonConstants::GetMaster()->GetEtaMin();	     
 fEtaMax = AliFlowCommonConstants::GetMaster()->GetEtaMax();
 if(fnBinsEta) fEtaBinWidth = (fEtaMax-fEtaMin)/fnBinsEta;  
  
} // end of void AliFlowAnalysisWithCumulants::AccessConstants()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookAndFillWeightsHistograms()
{
 // Book and fill histograms which hold phi, pt and eta weights.

 if(!fWeightsList)
 {
  cout<<"WARNING (GFC): fWeightsList is NULL in AFAWGFC::BAFWH() !!!!"<<endl;
  exit(0);  
 }
    
 if(fUsePhiWeights)
 {
  if(fWeightsList->FindObject("phi_weights"))
  {
   fPhiWeights = dynamic_cast<TH1F*>(fWeightsList->FindObject("phi_weights"));
   if(!fPhiWeights){printf("\n WARNING (GFC): !fPhiWeights !!!!\n");exit(0);}
   if(TMath::Abs(fPhiWeights->GetBinWidth(1)-fPhiBinWidth)>pow(10.,-6.))
   {
    cout<<endl;
    cout<<"WARNING (GFC): Inconsistent binning in histograms for phi-weights throughout the code."<<endl;
    cout<<endl;
    //exit(0);
   }
  } else 
    {
     cout<<endl;
     cout<<"WARNING (GFC): fWeightsList->FindObject(\"phi_weights\") is NULL in AFAWGFC::BAFWH() !!!!"<<endl;
     cout<<endl;
     exit(0);
    }
 } // end of if(fUsePhiWeights)
 
 if(fUsePtWeights) 
 {
  if(fWeightsList->FindObject("pt_weights"))
  {
   fPtWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("pt_weights"));
   if(!fPtWeights){printf("\n WARNING (GFC): !fPtWeights !!!!\n");exit(0);}
   if(TMath::Abs(fPtWeights->GetBinWidth(1)-fPtBinWidth)>pow(10.,-6.))
   {
    cout<<endl;
    cout<<"WARNING (GFC): Inconsistent binning in histograms for pt-weights throughout the code."<<endl;
    cout<<endl;
    //exit(0);
   }
  } else 
    {
     cout<<endl;
     cout<<"WARNING (GFC): fWeightsList->FindObject(\"pt_weights\") is NULL in AFAWGFC::BAFWH() !!!!"<<endl;
     cout<<endl;
     exit(0);
    }
 } // end of if(fUsePtWeights)    
 
 if(fUseEtaWeights) 
 {
  if(fWeightsList->FindObject("eta_weights"))
  {
   fEtaWeights = dynamic_cast<TH1D*>(fWeightsList->FindObject("eta_weights"));
   if(!fEtaWeights){printf("\n WARNING (GFC): !fEtaWeights !!!!\n");exit(0);}
   if(TMath::Abs(fEtaWeights->GetBinWidth(1)-fEtaBinWidth)>pow(10.,-6.))
   {
    cout<<endl;
    cout<<"WARNING (GFC): Inconsistent binning in histograms for eta-weights throughout the code."<<endl;
    cout<<endl;
    //exit(0);
   }
  } else 
    {
     cout<<endl;
     cout<<"WARNING (GFC): fUseEtaWeights && fWeightsList->FindObject(\"eta_weights\") is NULL in AFAWGFC::BAFWH() !!!!"<<endl;
     cout<<endl;
     exit(0);
    }
 } // end of if(fUseEtaWeights)
 
} // end of AliFlowAnalysisWithCumulants::BookAndFillWeightsHistograms()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookEverythingForCalculationVsMultiplicity()
{
 // Book all objects relevant for flow analysis versus multiplicity.
 
 // a) Define constants;
 // b) Book all profiles;
 // c) Book all results.
 
 // a) Define constants and local flags:
 Int_t pMax = 5;     
 Int_t qMax = 11;  
 TString cumulantFlag[4] = {"GFC{2}","GFC{4}","GFC{6}","GFC{8}"};

 // b) Book all profiles:
 // Average of the generating function for reference flow <G[p][q]> versus multiplicity:
 fReferenceFlowGenFunVsM = new TProfile3D("fReferenceFlowGenFunVsM","#LTG[p][q]#GT vs M",fnBinsMult,fMinMult,fMaxMult,pMax,0.,(Double_t)pMax,qMax,0.,(Double_t)qMax);
 fReferenceFlowGenFunVsM->SetXTitle("M");
 fReferenceFlowGenFunVsM->SetYTitle("p");
 fReferenceFlowGenFunVsM->SetZTitle("q");
 fReferenceFlowProfiles->Add(fReferenceFlowGenFunVsM);
 // Averages of Q-vector components versus multiplicity:
 fQvectorComponentsVsM = new TProfile2D("fQvectorComponentsVsM","Averages of Q-vector components",fnBinsMult,fMinMult,fMaxMult,4,0.,4.);
 //fQvectorComponentsVsM->SetLabelSize(0.06);
 fQvectorComponentsVsM->SetMarkerStyle(25);
 fQvectorComponentsVsM->SetXTitle("M");
 fQvectorComponentsVsM->GetYaxis()->SetBinLabel(1,"#LTQ_{x}#GT"); // Q_{x}
 fQvectorComponentsVsM->GetYaxis()->SetBinLabel(2,"#LTQ_{y}#GT"); // Q_{y}
 fQvectorComponentsVsM->GetYaxis()->SetBinLabel(3,"#LTQ_{x}^{2}#GT"); // Q_{x}^{2}
 fQvectorComponentsVsM->GetYaxis()->SetBinLabel(4,"#LTQ_{y}^{2}#GT"); // Q_{y}^{2}
 fReferenceFlowProfiles->Add(fQvectorComponentsVsM);
 // <<w^2>>, where w = wPhi*wPt*wEta versus multiplicity:
 fAverageOfSquaredWeightVsM = new TProfile2D("fAverageOfSquaredWeightVsM","#LT#LTw^{2}#GT#GT",fnBinsMult,fMinMult,fMaxMult,1,0,1);
 fAverageOfSquaredWeightVsM->SetLabelSize(0.06);
 fAverageOfSquaredWeightVsM->SetMarkerStyle(25);
 fAverageOfSquaredWeightVsM->SetLabelOffset(0.01);
 fAverageOfSquaredWeightVsM->GetXaxis()->SetBinLabel(1,"#LT#LTw^{2}#GT#GT");
 fReferenceFlowProfiles->Add(fAverageOfSquaredWeightVsM); 
 // <M> vs multiplicity bin: 
 fAvMVsM = new TProfile("fAvMVsM","#LTM#GT vs M",fnBinsMult,fMinMult,fMaxMult);
 //fAvMVsM->SetLabelSize(0.06);
 fAvMVsM->SetMarkerStyle(25);
 fAvMVsM->SetLabelOffset(0.01);
 fAvMVsM->SetXTitle("M");
 fAvMVsM->SetYTitle("#LTM#GT");
 fReferenceFlowProfiles->Add(fAvMVsM); 

 // c) Book all results:
 // Final results for reference GF-cumulants versus multiplicity:
 TString referenceFlowCumulantsVsMName = "fReferenceFlowCumulantsVsM";
 for(Int_t co=0;co<4;co++) // cumulant order
 {
  fReferenceFlowCumulantsVsM[co] = new TH1D(Form("%s, %s",referenceFlowCumulantsVsMName.Data(),cumulantFlag[co].Data()),
                                            Form("%s vs multipicity",cumulantFlag[co].Data()),
                                            fnBinsMult,fMinMult,fMaxMult);
  fReferenceFlowCumulantsVsM[co]->SetMarkerStyle(25);              
  fReferenceFlowCumulantsVsM[co]->GetXaxis()->SetTitle("M");                                     
  fReferenceFlowCumulantsVsM[co]->GetYaxis()->SetTitle(cumulantFlag[co].Data());  
  fReferenceFlowResults->Add(fReferenceFlowCumulantsVsM[co]);                                    
 } // end of for(Int_t co=0;co<4;co++) // cumulant order
 
} // end of void AliFlowAnalysisWithCumulants::BookEverythingForCalculationVsMultiplicity()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookEverythingForReferenceFlow()
{
 // Book all objects relevant for calculation of reference flow.
 
 // a) Define static constants for array's boundaries;
 // b) Book profile to hold all flags for reference flow;
 // c) Book all event-by-event quantities;
 // d) Book all profiles;
 // e) Book all histograms.
 
 // a) Define static constants for array's boundaries:
 static const Int_t pMax = 5;     
 static const Int_t qMax = 11;  
 
 // b) Book profile to hold all flags for reference flow:
 TString referenceFlowFlagsName = "fReferenceFlowFlags";
 fReferenceFlowFlags = new TProfile(referenceFlowFlagsName.Data(),"Flags for Reference Flow",2,0,2);
 fReferenceFlowFlags->SetTickLength(-0.01,"Y");
 fReferenceFlowFlags->SetMarkerStyle(25);
 fReferenceFlowFlags->SetLabelSize(0.05);
 fReferenceFlowFlags->SetLabelOffset(0.02,"Y");
 fReferenceFlowFlags->GetXaxis()->SetBinLabel(1,"Particle weights");
 fReferenceFlowFlags->GetXaxis()->SetBinLabel(2,"Event weights");
 fReferenceFlowList->Add(fReferenceFlowFlags);
 
 // c) Book all event-by-event quantities: 
 fGEBE = new TMatrixD(pMax,qMax);

 // d) Book all profiles:
 // Average of the generating function for reference flow <G[p][q]>:
 fReferenceFlowGenFun = new TProfile2D("fReferenceFlowGenFun","#LTG[p][q]#GT",pMax,0.,(Double_t)pMax,qMax,0.,(Double_t)qMax);
 fReferenceFlowGenFun->SetXTitle("p");
 fReferenceFlowGenFun->SetYTitle("q");
 fReferenceFlowProfiles->Add(fReferenceFlowGenFun);
 // Averages of Q-vector components:
 fQvectorComponents = new TProfile("fQvectorComponents","Averages of Q-vector components",4,0.,4.);
 fQvectorComponents->SetLabelSize(0.06);
 fQvectorComponents->SetMarkerStyle(25);
 fQvectorComponents->GetXaxis()->SetBinLabel(1,"#LTQ_{x}#GT"); // Q_{x}
 fQvectorComponents->GetXaxis()->SetBinLabel(2,"#LTQ_{y}#GT"); // Q_{y}
 fQvectorComponents->GetXaxis()->SetBinLabel(3,"#LTQ_{x}^{2}#GT"); // Q_{x}^{2}
 fQvectorComponents->GetXaxis()->SetBinLabel(4,"#LTQ_{y}^{2}#GT"); // Q_{y}^{2}
 fReferenceFlowProfiles->Add(fQvectorComponents);
 // <<w^2>>, where w = wPhi*wPt*wEta:
 fAverageOfSquaredWeight = new TProfile("fAverageOfSquaredWeight","#LT#LTw^{2}#GT#GT",1,0,1);
 fAverageOfSquaredWeight->SetLabelSize(0.06);
 fAverageOfSquaredWeight->SetMarkerStyle(25);
 fAverageOfSquaredWeight->SetLabelOffset(0.01);
 fAverageOfSquaredWeight->GetXaxis()->SetBinLabel(1,"#LT#LTw^{2}#GT#GT");
 fReferenceFlowProfiles->Add(fAverageOfSquaredWeight);
 
 // e) Book all histograms:
 // Final results for isotropic cumulants for reference flow:
 TString referenceFlowCumulantsName = "fReferenceFlowCumulants";
 fReferenceFlowCumulants = new TH1D(referenceFlowCumulantsName.Data(),"Isotropic Generating Function Cumulants for reference flow",4,0,4); // to be improved (hw 4)
 fReferenceFlowCumulants->SetLabelSize(0.05);
 fReferenceFlowCumulants->SetMarkerStyle(25);
 fReferenceFlowCumulants->GetXaxis()->SetBinLabel(1,"GFC{2}");
 fReferenceFlowCumulants->GetXaxis()->SetBinLabel(2,"GFC{4}");
 fReferenceFlowCumulants->GetXaxis()->SetBinLabel(3,"GFC{6}");
 fReferenceFlowCumulants->GetXaxis()->SetBinLabel(4,"GFC{8}");
 fReferenceFlowResults->Add(fReferenceFlowCumulants); 
 // Final results for reference flow:  
 fReferenceFlow = new TH1D("fReferenceFlow","Reference flow",4,0,4); // to be improved (hardwired 4)
 fReferenceFlow->SetLabelSize(0.05);
 fReferenceFlow->SetMarkerStyle(25);
 fReferenceFlow->GetXaxis()->SetBinLabel(1,"v_{n}{2,GFC}");
 fReferenceFlow->GetXaxis()->SetBinLabel(2,"v_{n}{4,GFC}");
 fReferenceFlow->GetXaxis()->SetBinLabel(3,"v_{n}{6,GFC}");
 fReferenceFlow->GetXaxis()->SetBinLabel(4,"v_{n}{8,GFC}");
 fReferenceFlowResults->Add(fReferenceFlow);
 // Final results for resolution:  
 fChi = new TH1D("fChi","Resolution",4,0,4); // to be improved (hardwired 4)
 fChi->SetLabelSize(0.06);
 fChi->SetMarkerStyle(25);
 fChi->GetXaxis()->SetBinLabel(1,"#chi_{2}");
 fChi->GetXaxis()->SetBinLabel(2,"#chi_{4}");
 fChi->GetXaxis()->SetBinLabel(3,"#chi_{6}");
 fChi->GetXaxis()->SetBinLabel(4,"#chi_{8}");
 fReferenceFlowResults->Add(fChi);

} // end of void AliFlowAnalysisWithCumulants::BookEverythingForReferenceFlow()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookEverythingForTuning()
{
 // Book all objects relevant for tuning.
 
 // a) Define pMax's and qMax's:
 // b) Book profile to hold all tuning parameters and flags;
 // c) Book all profiles;
 // d) Book all histograms.
 
 // a) Define pMax's and qMax's:
 Int_t pMax[5] = {2,3,4,5,8};      
 Int_t qMax[5] = {5,7,9,11,17};  
 
 // b) Book profile to hold all tuning parameters and flags:
 TString tuningFlagsName = "fTuningFlags";
 fTuningFlags = new TProfile(tuningFlagsName.Data(),"Tuning parameters",10,0,10);
 // fTuningFlags->SetTickLength(-0.01,"Y");
 fTuningFlags->SetMarkerStyle(25);
 fTuningFlags->SetLabelSize(0.05);
 fTuningFlags->SetLabelOffset(0.02,"X");
 for(Int_t r=1;r<=10;r++)
 {
  fTuningFlags->GetXaxis()->SetBinLabel(r,Form("r_{0,%d}",r-1));
  fTuningFlags->Fill(r-0.5,fTuningR0[r-1],1.);
 }
 fTuningList->Add(fTuningFlags);
  
 // c) Book all profiles:
 // Average of the generating function for reference flow <G[p][q]> for different tuning parameters:
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   fTuningGenFun[r][pq] = new TProfile2D(Form("fTuningGenFun (r_{0,%i}, pq set %i)",r,pq),
                                         Form("#LTG[p][q]#GT for r_{0} = %f, p_{max} = %i, q_{max} = %i",fTuningR0[r],pMax[pq],qMax[pq]),
                                         pMax[pq],0.,(Double_t)pMax[pq],qMax[pq],0.,(Double_t)qMax[pq]);
   fTuningGenFun[r][pq]->SetXTitle("p");
   fTuningGenFun[r][pq]->SetYTitle("q");
   fTuningProfiles->Add(fTuningGenFun[r][pq]);
  }
 }
 // Average multiplicities for events with nRPs >= cuttof:
 fTuningAvM = new TProfile("fTuningAvM","Average multiplicity",5,0,5);
 fTuningAvM->SetMarkerStyle(25);
 for(Int_t b=1;b<=5;b++)
 {
  fTuningAvM->GetXaxis()->SetBinLabel(b,Form("nRP #geq %i",2*pMax[b-1]));
 }
 fTuningProfiles->Add(fTuningAvM); 

 // d) Book all histograms:
 // Final results for isotropic cumulants for reference flow for different tuning parameters:
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   fTuningCumulants[r][pq] = new TH1D(Form("fTuningCumulants (r_{0,%i}, pq set %i)",r,pq),
                                      Form("GFC for r_{0} = %f, p_{max} = %i, q_{max} = %i",fTuningR0[r],pMax[pq],qMax[pq]),
                                      pMax[pq],0,pMax[pq]);
   // fTuningCumulants[r][pq]->SetLabelSize(0.05);
   fTuningCumulants[r][pq]->SetMarkerStyle(25);
   for(Int_t b=1;b<=pMax[pq];b++)
   {
    fTuningCumulants[r][pq]->GetXaxis()->SetBinLabel(b,Form("GFC{%i}",2*b));
   }
   fTuningResults->Add(fTuningCumulants[r][pq]); 
  }
 } 
 // Final results for reference flow for different tuning parameters: 
 for(Int_t r=0;r<10;r++)
 { 
  for(Int_t pq=0;pq<5;pq++)
  {
   fTuningFlow[r][pq] = new TH1D(Form("fTuningFlow (r_{0,%i}, pq set %i)",r,pq),
                                 Form("Reference flow for r_{0} = %f, p_{max} = %i, q_{max} = %i",fTuningR0[r],pMax[pq],qMax[pq]),
                                 pMax[pq],0,pMax[pq]);
   // fTuningFlow[r][pq]->SetLabelSize(0.06);
   fTuningFlow[r][pq]->SetMarkerStyle(25);
   for(Int_t b=1;b<=pMax[pq];b++)
   {
    fTuningFlow[r][pq]->GetXaxis()->SetBinLabel(b,Form("v{%i,GFC}",2*b));
   }
   fTuningResults->Add(fTuningFlow[r][pq]); 
  }
 }  
   
} // end of void AliFlowAnalysisWithCumulants::BookEverythingForTuning()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookEverythingForDiffFlow()
{
 // Book all objects relevant for calculation of differential flow.
 
 // a) Define static constants for array's boundaries;
 // b) Define local variables and local flags for booking;
 // c) Book profile to hold all flags for differential flow;
 // d) Book all event-by-event quantities;
 // e) Book all profiles;
 // f) Book all histograms.
 
 // a) Define static constants for array's boundaries:
 static const Int_t pMax = 5;     
 static const Int_t qMax = 11;  
 
 // b) Define local variables and local flags for booking:
 Int_t nBinsPtEta[2] = {fnBinsPt,fnBinsEta};
 Double_t minPtEta[2] = {fPtMin,fEtaMin};
 Double_t maxPtEta[2] = {fPtMax,fEtaMax};
 TString reIm[2] = {"Re","Im"};
 TString rpPoi[2] = {"RP","POI"};
 TString ptEta[2] = {"p_{t}","#eta"}; 
 TString order[4] = {"2nd order","4th order","6th order","8th order"}; 
 
 // c) Book profile to hold all flags for differential flow:
 TString diffFlowFlagsName = "fDiffFlowFlags";
 fDiffFlowFlags = new TProfile(diffFlowFlagsName.Data(),"Flags for Differential Flow",1,0,1);
 fDiffFlowFlags->SetTickLength(-0.01,"Y");
 fDiffFlowFlags->SetMarkerStyle(25);
 fDiffFlowFlags->SetLabelSize(0.05);
 fDiffFlowFlags->SetLabelOffset(0.02,"Y");
 fDiffFlowFlags->GetXaxis()->SetBinLabel(1,"...");
 fDiffFlowList->Add(fDiffFlowFlags);
 
 // d) Book all event-by-event quantities:
 // ... (to be improved - perhaps not needed)
 
 // e) Book all profiles:
 // Generating functions for differential flow:
 for(Int_t ri=0;ri<2;ri++)
 {
  for(Int_t rp=0;rp<2;rp++)
  {
   for(Int_t pe=0;pe<2;pe++)
   {
    fDiffFlowGenFun[ri][rp][pe] = new TProfile3D(Form("fDiffFlowGenFun (%s, %s, %s)",reIm[ri].Data(),rpPoi[rp].Data(),ptEta[pe].Data()),
                                                 Form("#LT%s[D[%s-bin][p][q]]#GT for %ss",reIm[ri].Data(),ptEta[pe].Data(),rpPoi[rp].Data()),
                                                 nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe],pMax,0.,(Double_t)pMax,qMax,0.,(Double_t)qMax);
    fDiffFlowGenFun[ri][rp][pe]->SetXTitle(ptEta[pe].Data());
    fDiffFlowGenFun[ri][rp][pe]->SetYTitle("p");
    fDiffFlowGenFun[ri][rp][pe]->SetZTitle("q");
    fDiffFlowGenFun[ri][rp][pe]->SetTitleOffset(1.44,"X");
    fDiffFlowGenFun[ri][rp][pe]->SetTitleOffset(1.44,"Y");
    fDiffFlowProfiles->Add(fDiffFlowGenFun[ri][rp][pe]);
    // to be improved - alternative // nBinsPtEta[pe],(Double_t)(fPtMin/fPtBinWidth),(Double_t)(fPtMax/fPtBinWidth),pMax,0.,(Double_t)pMax,qMax,0.,(Double_t)qMax);                                                 
   }
  }   
 } 
 // Number of particles in pt/eta bin for RPs/POIs:
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   fNoOfParticlesInBin[rp][pe] = new TProfile(Form("fNoOfParticlesInBin (%s, %s)",rpPoi[rp].Data(),ptEta[pe].Data()),
                                              Form("Number of %ss per %s bin",rpPoi[rp].Data(),ptEta[pe].Data()),
                                              nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
   fNoOfParticlesInBin[rp][pe]->SetXTitle(ptEta[pe].Data());
   fDiffFlowProfiles->Add(fNoOfParticlesInBin[rp][pe]);
  }
 }   
 // Differential cumulants per pt/eta bin for RPs/POIs:
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    fDiffFlowCumulants[rp][pe][co] = new TH1D(Form("fDiffFlowCumulants (%s, %s, %s)",rpPoi[rp].Data(),ptEta[pe].Data(),order[co].Data()),
                                              Form("Differential %s cumulant for %ss vs %s",order[co].Data(),rpPoi[rp].Data(),ptEta[pe].Data()),
                                              nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
    fDiffFlowCumulants[rp][pe][co]->SetXTitle(ptEta[pe].Data());
    fDiffFlowResults->Add(fDiffFlowCumulants[rp][pe][co]);
   }
  }
 }   
 // Differential flow per pt/eta bin for RPs/POIs:
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    fDiffFlow[rp][pe][co] = new TH1D(Form("fDiffFlow (%s, %s, %s)",rpPoi[rp].Data(),ptEta[pe].Data(),order[co].Data()),
                                     Form("Differential flow from %s cumulant for %ss vs %s",order[co].Data(),rpPoi[rp].Data(),ptEta[pe].Data()),
                                     nBinsPtEta[pe],minPtEta[pe],maxPtEta[pe]);
    fDiffFlow[rp][pe][co]->SetXTitle(ptEta[pe].Data());
    fDiffFlowResults->Add(fDiffFlow[rp][pe][co]);
   }
  }
 }   

}// end of void AliFlowAnalysisWithCumulants::BookEverythingForDiffFlow()

//================================================================================================================

void AliFlowAnalysisWithCumulants::StoreReferenceFlowFlags()
{
 // Store all flags for reference flow in profile fReferenceFlowFlags.
 
 if(!fReferenceFlowFlags)
 {
  cout<<endl;
  cout<<"WARNING: !fReferenceFlowFlags is NULL in AFAWC::SRFF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 

 // Particle weights used or not:
 fReferenceFlowFlags->Fill(0.5,(Double_t)fUsePhiWeights||fUsePtWeights||fUseEtaWeights);
 // Which event weight was used to weight generating function event-by-event:
 if(strcmp(fMultiplicityWeight->Data(),"unit"))
 {
  fReferenceFlowFlags->Fill(1.5,0.); // 0 = "unit" (default)
 } else if(strcmp(fMultiplicityWeight->Data(),"multiplicity"))
   {
    fReferenceFlowFlags->Fill(1.5,1.); // 1 = "multiplicity"        
   } 
 fReferenceFlowFlags->Fill(2.5,fCalculateVsMultiplicity); // evaluate vs M?          

} // end of void AliFlowAnalysisWithCumulants::StoreReferenceFlowFlags()

//================================================================================================================

void AliFlowAnalysisWithCumulants::StoreDiffFlowFlags()
{
 // Store all flags for differential flow in profile fDiffFlowFlags.
 
 if(!fDiffFlowFlags)
 {
  cout<<endl;
  cout<<"WARNING: !fDiffFlowFlags is NULL in AFAWC::SRFF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 

 // fDiffFlags->Fill(0.5,(Double_t) ... );

} // end of void AliFlowAnalysisWithCumulants::StoreDiffFlowFlags()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookAndNestAllLists()
{
 // Book and nest all list in base list fHistList.
 
 // a) Book and nest lists for reference flow;
 // b) Book and nest lists for differential flow;
 // c) Book and nest lists for tuning;
 // d) If used, nest list for particle weights.   
  
 // a) Book and nest all lists for reference flow:
 fReferenceFlowList = new TList();
 fReferenceFlowList->SetName("Reference Flow");
 fReferenceFlowList->SetOwner(kTRUE);
 fHistList->Add(fReferenceFlowList);
 fReferenceFlowProfiles = new TList();
 fReferenceFlowProfiles->SetName("Profiles");
 fReferenceFlowProfiles->SetOwner(kTRUE);
 fReferenceFlowList->Add(fReferenceFlowProfiles);
 fReferenceFlowResults = new TList();
 fReferenceFlowResults->SetName("Results");
 fReferenceFlowResults->SetOwner(kTRUE);
 fReferenceFlowList->Add(fReferenceFlowResults);
 // b) Book and nest lists for differential flow:
 fDiffFlowList = new TList();
 fDiffFlowList->SetName("Differential Flow");
 fDiffFlowList->SetOwner(kTRUE); 
 fHistList->Add(fDiffFlowList);
 fDiffFlowProfiles = new TList(); 
 fDiffFlowProfiles->SetName("Profiles");
 fDiffFlowProfiles->SetOwner(kTRUE);
 fDiffFlowList->Add(fDiffFlowProfiles);
 fDiffFlowResults = new TList();
 fDiffFlowResults->SetName("Results");
 fDiffFlowResults->SetOwner(kTRUE);
 fDiffFlowList->Add(fDiffFlowResults);
 // c) Book and nest lists for tuning:
 if(fTuneParameters)
 {
  fTuningList = new TList();
  fTuningList->SetName("Tuning");
  fTuningList->SetOwner(kTRUE);
  fHistList->Add(fTuningList);
  fTuningProfiles = new TList();
  fTuningProfiles->SetName("Profiles");
  fTuningProfiles->SetOwner(kTRUE);
  fTuningList->Add(fTuningProfiles);
  fTuningResults = new TList();
  fTuningResults->SetName("Results");
  fTuningResults->SetOwner(kTRUE);
  fTuningList->Add(fTuningResults);
 } 
  
 // d) If used, nest list for particle weights.   
 if(fUsePhiWeights||fUsePtWeights||fUseEtaWeights)
 {
  // Remark: pointer to this list is coming from the macro, no need to "new" it. 
  fWeightsList->SetName("Weights");
  fWeightsList->SetOwner(kTRUE);
  fHistList->Add(fWeightsList); 
 }

} // end of void AliFlowAnalysisWithCumulants::BookAndNestAllLists()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookProfileHoldingSettings()
{
 // Book profile to hold all analysis settings.

 TString analysisSettingsName = "fAnalysisSettings";
 fAnalysisSettings = new TProfile(analysisSettingsName.Data(),"Settings for analysis with Generating Function Cumulants",11,0.,11.);
 fAnalysisSettings->GetXaxis()->SetLabelSize(0.035);
 fAnalysisSettings->GetXaxis()->SetBinLabel(1,"Harmonic");
 fAnalysisSettings->Fill(0.5,fHarmonic);
 fAnalysisSettings->GetXaxis()->SetBinLabel(2,"Multiple");
 fAnalysisSettings->Fill(1.5,fMultiple); 
 fAnalysisSettings->GetXaxis()->SetBinLabel(3,"r_{0}");
 fAnalysisSettings->Fill(2.5,fR0);   
 fAnalysisSettings->GetXaxis()->SetBinLabel(4,"Use w_{#phi}?");
 fAnalysisSettings->Fill(3.5,fUsePhiWeights);
 fAnalysisSettings->GetXaxis()->SetBinLabel(5,"Use w_{p_{t}}?");
 fAnalysisSettings->Fill(4.5,fUsePtWeights);
 fAnalysisSettings->GetXaxis()->SetBinLabel(6,"Use w_{#eta}?");
 fAnalysisSettings->Fill(5.5,fUsePhiWeights);
 fAnalysisSettings->GetXaxis()->SetBinLabel(7,"Tune parameters?");
 fAnalysisSettings->Fill(6.5,fTuneParameters); 
 fAnalysisSettings->GetXaxis()->SetBinLabel(8,"Print RF results");
 fAnalysisSettings->Fill(7.5,fPrintFinalResults[0]); 
 fAnalysisSettings->GetXaxis()->SetBinLabel(9,"Print RP results");
 fAnalysisSettings->Fill(8.5,fPrintFinalResults[1]); 
 fAnalysisSettings->GetXaxis()->SetBinLabel(10,"Print POI results");
 fAnalysisSettings->Fill(9.5,fPrintFinalResults[2]);
 fAnalysisSettings->GetXaxis()->SetBinLabel(11,"Evaluate vs M?");
 fAnalysisSettings->Fill(10.5,fCalculateVsMultiplicity);
 fHistList->Add(fAnalysisSettings);

} // end of void AliFlowAnalysisWithCumulants::BookProfileHoldingSettings()

//================================================================================================================

void AliFlowAnalysisWithCumulants::BookCommonHistograms()
{
 // Book common control histograms and common histograms for final results.
 
 // Common control histogram:
 TString commonHistsName = "AliFlowCommonHistGFC";
 fCommonHists = new AliFlowCommonHist(commonHistsName.Data());
 fHistList->Add(fCommonHists);  
 // Common histograms for final results from 2nd order GFC:
 TString commonHistResults2ndOrderName = "AliFlowCommonHistResults2ndOrderGFC";
 fCommonHistsResults2nd = new AliFlowCommonHistResults(commonHistResults2ndOrderName.Data(),"",fHarmonic);
 fHistList->Add(fCommonHistsResults2nd);  
 // Common histograms for final results from 4th order GFC:
 TString commonHistResults4thOrderName = "AliFlowCommonHistResults4thOrderGFC";
 fCommonHistsResults4th = new AliFlowCommonHistResults(commonHistResults4thOrderName.Data(),"",fHarmonic);
 fHistList->Add(fCommonHistsResults4th); 
 // Common histograms for final results from 6th order GFC:
 TString commonHistResults6thOrderName = "AliFlowCommonHistResults6thOrderGFC";
 fCommonHistsResults6th = new AliFlowCommonHistResults(commonHistResults6thOrderName.Data(),"",fHarmonic);
 fHistList->Add(fCommonHistsResults6th);  
 // Common histograms for final results from 8th order GFC:
 TString commonHistResults8thOrderName = "AliFlowCommonHistResults8thOrderGFC";
 fCommonHistsResults8th = new AliFlowCommonHistResults(commonHistResults8thOrderName.Data(),"",fHarmonic);
 fHistList->Add(fCommonHistsResults8th);
 
} // end of void AliFlowAnalysisWithCumulants::BookCommonHistograms()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CheckPointersUsedInMake()
{
 // Check pointers used in method Make().
 
 if(!fCommonHists)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fCommonHists is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(fUsePhiWeights && !fPhiWeights)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fPhiWeights is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(fUsePtWeights && !fPtWeights)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fPtWeights is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(fUseEtaWeights && !fEtaWeights)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fEtaWeights is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(!fAverageOfSquaredWeight)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fAverageOfSquaredWeight is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(!fReferenceFlowGenFun)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fReferenceFlowGenFun is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(!fQvectorComponents)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fQvectorComponents is NULL in CPUIM() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(!fGEBE)
 {
  cout<<endl; 
  cout<<"WARNING (GFC): fGEBE is NULL in CPUIM() !!!!"<<endl;
  cout<<endl; 
  exit(0);
 }
 // Checking pointers for vs multiplicity calculation: 
 if(fCalculateVsMultiplicity)
 {
  if(!fReferenceFlowGenFunVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fReferenceFlowGenFunVsM is NULL in CPUIM() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fQvectorComponentsVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fQvectorComponentsVsM is NULL in CPUIM() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fAverageOfSquaredWeightVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fAverageOfSquaredWeightVsM is NULL in CPUIM() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fAvMVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fAvMVsM is NULL in CPUIM() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
 } // end of if(fCalculateVsMultiplicity) 
 
} // end of void AliFlowAnalysisWithCumulants::CheckPointersUsedInMake()

//================================================================================================================

void AliFlowAnalysisWithCumulants::CheckPointersUsedInFinish()
{
 // Check pointers used in method Finish().
 
 if(!fAnalysisSettings)
 {                        
  cout<<endl;
  cout<<" WARNING (GFC): fAnalysisSettings is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }
 if(!(fCommonHists && fCommonHists->GetHistMultRP()))
 { 
  cout<<endl;
  cout<<" WARNING (GFC): (fCommonHists && fCommonHists->GetHistMultRP) is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 
 if(!fReferenceFlowGenFun)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fReferenceFlowGenFun is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }  
 if(!fReferenceFlowCumulants)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fReferenceFlowCumulants is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 
 if(!fQvectorComponents)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fQvectorComponents is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 
 if(!fAverageOfSquaredWeight)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fAverageOfSquaredWeight is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 } 
 if(!(fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && fCommonHistsResults8th))
 {
  cout<<endl;
  cout<<" WARNING (GFC): fCommonHistsResults2nd && fCommonHistsResults4th && fCommonHistsResults6th && "<<endl;
  cout<<"                fCommonHistsResults8th is NULL in CPUIF() !!!!"<<endl; 
  cout<<endl;
  exit(0);
 }
 if(!fReferenceFlow)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fReferenceFlow is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }  
 if(!fChi)
 { 
  cout<<endl;
  cout<<" WARNING (GFC): fChi is NULL in CPUIF() !!!!"<<endl;
  cout<<endl;
  exit(0);
 }  
 for(Int_t ri=0;ri<2;ri++)
 {
  for(Int_t rp=0;rp<2;rp++)
  {
   for(Int_t pe=0;pe<2;pe++)
   {
    if(!fDiffFlowGenFun[ri][rp][pe])
    {
     cout<<endl;
     cout<<" WARNING (GFC): "<<Form("fDiffFlowGenFun[%d][%d][%d]",ri,rp,pe)<<" is NULL in CPUIF() !!!!"<<endl;
     cout<<endl;
     exit(0);    
    }
   }
  }
 }
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   for(Int_t co=0;co<4;co++)
   {
    if(!fDiffFlowCumulants[rp][pe][co])
    {
     cout<<endl;
     cout<<" WARNING (GFC): "<<Form("fDiffFlowCumulants[%d][%d][%d]",rp,pe,co)<<" is NULL in CPUIF() !!!!"<<endl;
     cout<<endl;
     exit(0);    
    }
    if(!fDiffFlow[rp][pe][co])
    {
     cout<<endl;
     cout<<" WARNING (GFC): "<<Form("fDiffFlow[%d][%d][%d]",rp,pe,co)<<" is NULL in CPUIF() !!!!"<<endl;
     cout<<endl;
     exit(0);    
    }
   }
  }
 }
 for(Int_t rp=0;rp<2;rp++)
 {
  for(Int_t pe=0;pe<2;pe++)
  {
   if(!fNoOfParticlesInBin[rp][pe])
   {
    cout<<endl;
    cout<<" WARNING (GFC): "<<Form("fNoOfParticlesInBin[%d][%d]",rp,pe)<<" is NULL in CPUIF() !!!!"<<endl;
    cout<<endl;
    exit(0);    
   } 
  }
 }  
 // Checking pointers for vs multiplicity calculation: 
 if(fCalculateVsMultiplicity)
 {
  if(!fReferenceFlowGenFunVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fReferenceFlowGenFunVsM is NULL in CPUIF() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fQvectorComponentsVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fQvectorComponentsVsM is NULL in CPUIF() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fAverageOfSquaredWeightVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fAverageOfSquaredWeightVsM is NULL in CPUIF() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
  if(!fAvMVsM)
  {
   cout<<endl; 
   cout<<"WARNING (GFC): fAvMVsM is NULL in CPUIF() !!!!"<<endl;
   cout<<endl; 
   exit(0);
  }
 } // end of if(fCalculateVsMultiplicity) 
 
} // end of void AliFlowAnalysisWithCumulants::CheckPointersUsedInFinish()

//================================================================================================================

void AliFlowAnalysisWithCumulants::AccessSettings()
{
 // Access the settings for analysis with Generating Function Cumulants.
 
 fHarmonic = (Int_t)fAnalysisSettings->GetBinContent(1); 
 fMultiple = (Int_t)fAnalysisSettings->GetBinContent(2); 
 fR0 = (Double_t)fAnalysisSettings->GetBinContent(3); 
 fUsePhiWeights = (Bool_t)fAnalysisSettings->GetBinContent(4);
 fUsePtWeights = (Bool_t)fAnalysisSettings->GetBinContent(5);
 fUseEtaWeights = (Bool_t)fAnalysisSettings->GetBinContent(6);
 fTuneParameters = (Bool_t)fAnalysisSettings->GetBinContent(7);
 fPrintFinalResults[0] = (Bool_t)fAnalysisSettings->GetBinContent(8);
 fPrintFinalResults[1] = (Bool_t)fAnalysisSettings->GetBinContent(9);
 fPrintFinalResults[2] = (Bool_t)fAnalysisSettings->GetBinContent(10);
 fCalculateVsMultiplicity = (Bool_t)fAnalysisSettings->GetBinContent(11);
 
} // end of AliFlowAnalysisWithCumulants::AccessSettings()

//================================================================================================================

void AliFlowAnalysisWithCumulants::WriteHistograms(TString* outputFileName)
{
 // Store the final results in output .root file.
 
 TFile *output = new TFile(outputFileName->Data(),"RECREATE");
 //output->WriteObject(fHistList, "cobjGFC","SingleKey");
 fHistList->SetName("cobjGFC");
 fHistList->SetOwner(kTRUE);
 fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
 delete output;

} // end of void AliFlowAnalysisWithCumulants::WriteHistograms(TString* outputFileName)

//================================================================================================================

void AliFlowAnalysisWithCumulants::WriteHistograms(TString outputFileName)
{
 // Store the final results in output .root file.
 
 TFile *output = new TFile(outputFileName.Data(),"RECREATE");
 //output->WriteObject(fHistList, "cobjGFC","SingleKey");
 fHistList->SetName("cobjGFC");
 fHistList->SetOwner(kTRUE);
 fHistList->Write(fHistList->GetName(), TObject::kSingleKey);
 delete output;

} // end of void AliFlowAnalysisWithCumulants::WriteHistograms(TString outputFileName)

//================================================================================================================

void AliFlowAnalysisWithCumulants::WriteHistograms(TDirectoryFile *outputFileName)
{
 // Store the final results in output .root file.
 
 fHistList->SetName("cobjGFC");
 fHistList->SetOwner(kTRUE);
 outputFileName->Add(fHistList);
 outputFileName->Write(outputFileName->GetName(), TObject::kSingleKey);

} // end of void AliFlowAnalysisWithCumulants::WriteHistograms(TDirectoryFile *outputFileName)

//================================================================================================================




 AliFlowAnalysisWithCumulants.cxx:1
 AliFlowAnalysisWithCumulants.cxx:2
 AliFlowAnalysisWithCumulants.cxx:3
 AliFlowAnalysisWithCumulants.cxx:4
 AliFlowAnalysisWithCumulants.cxx:5
 AliFlowAnalysisWithCumulants.cxx:6
 AliFlowAnalysisWithCumulants.cxx:7
 AliFlowAnalysisWithCumulants.cxx:8
 AliFlowAnalysisWithCumulants.cxx:9
 AliFlowAnalysisWithCumulants.cxx:10
 AliFlowAnalysisWithCumulants.cxx:11
 AliFlowAnalysisWithCumulants.cxx:12
 AliFlowAnalysisWithCumulants.cxx:13
 AliFlowAnalysisWithCumulants.cxx:14
 AliFlowAnalysisWithCumulants.cxx:15
 AliFlowAnalysisWithCumulants.cxx:16
 AliFlowAnalysisWithCumulants.cxx:17
 AliFlowAnalysisWithCumulants.cxx:18
 AliFlowAnalysisWithCumulants.cxx:19
 AliFlowAnalysisWithCumulants.cxx:20
 AliFlowAnalysisWithCumulants.cxx:21
 AliFlowAnalysisWithCumulants.cxx:22
 AliFlowAnalysisWithCumulants.cxx:23
 AliFlowAnalysisWithCumulants.cxx:24
 AliFlowAnalysisWithCumulants.cxx:25
 AliFlowAnalysisWithCumulants.cxx:26
 AliFlowAnalysisWithCumulants.cxx:27
 AliFlowAnalysisWithCumulants.cxx:28
 AliFlowAnalysisWithCumulants.cxx:29
 AliFlowAnalysisWithCumulants.cxx:30
 AliFlowAnalysisWithCumulants.cxx:31
 AliFlowAnalysisWithCumulants.cxx:32
 AliFlowAnalysisWithCumulants.cxx:33
 AliFlowAnalysisWithCumulants.cxx:34
 AliFlowAnalysisWithCumulants.cxx:35
 AliFlowAnalysisWithCumulants.cxx:36
 AliFlowAnalysisWithCumulants.cxx:37
 AliFlowAnalysisWithCumulants.cxx:38
 AliFlowAnalysisWithCumulants.cxx:39
 AliFlowAnalysisWithCumulants.cxx:40
 AliFlowAnalysisWithCumulants.cxx:41
 AliFlowAnalysisWithCumulants.cxx:42
 AliFlowAnalysisWithCumulants.cxx:43
 AliFlowAnalysisWithCumulants.cxx:44
 AliFlowAnalysisWithCumulants.cxx:45
 AliFlowAnalysisWithCumulants.cxx:46
 AliFlowAnalysisWithCumulants.cxx:47
 AliFlowAnalysisWithCumulants.cxx:48
 AliFlowAnalysisWithCumulants.cxx:49
 AliFlowAnalysisWithCumulants.cxx:50
 AliFlowAnalysisWithCumulants.cxx:51
 AliFlowAnalysisWithCumulants.cxx:52
 AliFlowAnalysisWithCumulants.cxx:53
 AliFlowAnalysisWithCumulants.cxx:54
 AliFlowAnalysisWithCumulants.cxx:55
 AliFlowAnalysisWithCumulants.cxx:56
 AliFlowAnalysisWithCumulants.cxx:57
 AliFlowAnalysisWithCumulants.cxx:58
 AliFlowAnalysisWithCumulants.cxx:59
 AliFlowAnalysisWithCumulants.cxx:60
 AliFlowAnalysisWithCumulants.cxx:61
 AliFlowAnalysisWithCumulants.cxx:62
 AliFlowAnalysisWithCumulants.cxx:63
 AliFlowAnalysisWithCumulants.cxx:64
 AliFlowAnalysisWithCumulants.cxx:65
 AliFlowAnalysisWithCumulants.cxx:66
 AliFlowAnalysisWithCumulants.cxx:67
 AliFlowAnalysisWithCumulants.cxx:68
 AliFlowAnalysisWithCumulants.cxx:69
 AliFlowAnalysisWithCumulants.cxx:70
 AliFlowAnalysisWithCumulants.cxx:71
 AliFlowAnalysisWithCumulants.cxx:72
 AliFlowAnalysisWithCumulants.cxx:73
 AliFlowAnalysisWithCumulants.cxx:74
 AliFlowAnalysisWithCumulants.cxx:75
 AliFlowAnalysisWithCumulants.cxx:76
 AliFlowAnalysisWithCumulants.cxx:77
 AliFlowAnalysisWithCumulants.cxx:78
 AliFlowAnalysisWithCumulants.cxx:79
 AliFlowAnalysisWithCumulants.cxx:80
 AliFlowAnalysisWithCumulants.cxx:81
 AliFlowAnalysisWithCumulants.cxx:82
 AliFlowAnalysisWithCumulants.cxx:83
 AliFlowAnalysisWithCumulants.cxx:84
 AliFlowAnalysisWithCumulants.cxx:85
 AliFlowAnalysisWithCumulants.cxx:86
 AliFlowAnalysisWithCumulants.cxx:87
 AliFlowAnalysisWithCumulants.cxx:88
 AliFlowAnalysisWithCumulants.cxx:89
 AliFlowAnalysisWithCumulants.cxx:90
 AliFlowAnalysisWithCumulants.cxx:91
 AliFlowAnalysisWithCumulants.cxx:92
 AliFlowAnalysisWithCumulants.cxx:93
 AliFlowAnalysisWithCumulants.cxx:94
 AliFlowAnalysisWithCumulants.cxx:95
 AliFlowAnalysisWithCumulants.cxx:96
 AliFlowAnalysisWithCumulants.cxx:97
 AliFlowAnalysisWithCumulants.cxx:98
 AliFlowAnalysisWithCumulants.cxx:99
 AliFlowAnalysisWithCumulants.cxx:100
 AliFlowAnalysisWithCumulants.cxx:101
 AliFlowAnalysisWithCumulants.cxx:102
 AliFlowAnalysisWithCumulants.cxx:103
 AliFlowAnalysisWithCumulants.cxx:104
 AliFlowAnalysisWithCumulants.cxx:105
 AliFlowAnalysisWithCumulants.cxx:106
 AliFlowAnalysisWithCumulants.cxx:107
 AliFlowAnalysisWithCumulants.cxx:108
 AliFlowAnalysisWithCumulants.cxx:109
 AliFlowAnalysisWithCumulants.cxx:110
 AliFlowAnalysisWithCumulants.cxx:111
 AliFlowAnalysisWithCumulants.cxx:112
 AliFlowAnalysisWithCumulants.cxx:113
 AliFlowAnalysisWithCumulants.cxx:114
 AliFlowAnalysisWithCumulants.cxx:115
 AliFlowAnalysisWithCumulants.cxx:116
 AliFlowAnalysisWithCumulants.cxx:117
 AliFlowAnalysisWithCumulants.cxx:118
 AliFlowAnalysisWithCumulants.cxx:119
 AliFlowAnalysisWithCumulants.cxx:120
 AliFlowAnalysisWithCumulants.cxx:121
 AliFlowAnalysisWithCumulants.cxx:122
 AliFlowAnalysisWithCumulants.cxx:123
 AliFlowAnalysisWithCumulants.cxx:124
 AliFlowAnalysisWithCumulants.cxx:125
 AliFlowAnalysisWithCumulants.cxx:126
 AliFlowAnalysisWithCumulants.cxx:127
 AliFlowAnalysisWithCumulants.cxx:128
 AliFlowAnalysisWithCumulants.cxx:129
 AliFlowAnalysisWithCumulants.cxx:130
 AliFlowAnalysisWithCumulants.cxx:131
 AliFlowAnalysisWithCumulants.cxx:132
 AliFlowAnalysisWithCumulants.cxx:133
 AliFlowAnalysisWithCumulants.cxx:134
 AliFlowAnalysisWithCumulants.cxx:135
 AliFlowAnalysisWithCumulants.cxx:136
 AliFlowAnalysisWithCumulants.cxx:137
 AliFlowAnalysisWithCumulants.cxx:138
 AliFlowAnalysisWithCumulants.cxx:139
 AliFlowAnalysisWithCumulants.cxx:140
 AliFlowAnalysisWithCumulants.cxx:141
 AliFlowAnalysisWithCumulants.cxx:142
 AliFlowAnalysisWithCumulants.cxx:143
 AliFlowAnalysisWithCumulants.cxx:144
 AliFlowAnalysisWithCumulants.cxx:145
 AliFlowAnalysisWithCumulants.cxx:146
 AliFlowAnalysisWithCumulants.cxx:147
 AliFlowAnalysisWithCumulants.cxx:148
 AliFlowAnalysisWithCumulants.cxx:149
 AliFlowAnalysisWithCumulants.cxx:150
 AliFlowAnalysisWithCumulants.cxx:151
 AliFlowAnalysisWithCumulants.cxx:152
 AliFlowAnalysisWithCumulants.cxx:153
 AliFlowAnalysisWithCumulants.cxx:154
 AliFlowAnalysisWithCumulants.cxx:155
 AliFlowAnalysisWithCumulants.cxx:156
 AliFlowAnalysisWithCumulants.cxx:157
 AliFlowAnalysisWithCumulants.cxx:158
 AliFlowAnalysisWithCumulants.cxx:159
 AliFlowAnalysisWithCumulants.cxx:160
 AliFlowAnalysisWithCumulants.cxx:161
 AliFlowAnalysisWithCumulants.cxx:162
 AliFlowAnalysisWithCumulants.cxx:163
 AliFlowAnalysisWithCumulants.cxx:164
 AliFlowAnalysisWithCumulants.cxx:165
 AliFlowAnalysisWithCumulants.cxx:166
 AliFlowAnalysisWithCumulants.cxx:167
 AliFlowAnalysisWithCumulants.cxx:168
 AliFlowAnalysisWithCumulants.cxx:169
 AliFlowAnalysisWithCumulants.cxx:170
 AliFlowAnalysisWithCumulants.cxx:171
 AliFlowAnalysisWithCumulants.cxx:172
 AliFlowAnalysisWithCumulants.cxx:173
 AliFlowAnalysisWithCumulants.cxx:174
 AliFlowAnalysisWithCumulants.cxx:175
 AliFlowAnalysisWithCumulants.cxx:176
 AliFlowAnalysisWithCumulants.cxx:177
 AliFlowAnalysisWithCumulants.cxx:178
 AliFlowAnalysisWithCumulants.cxx:179
 AliFlowAnalysisWithCumulants.cxx:180
 AliFlowAnalysisWithCumulants.cxx:181
 AliFlowAnalysisWithCumulants.cxx:182
 AliFlowAnalysisWithCumulants.cxx:183
 AliFlowAnalysisWithCumulants.cxx:184
 AliFlowAnalysisWithCumulants.cxx:185
 AliFlowAnalysisWithCumulants.cxx:186
 AliFlowAnalysisWithCumulants.cxx:187
 AliFlowAnalysisWithCumulants.cxx:188
 AliFlowAnalysisWithCumulants.cxx:189
 AliFlowAnalysisWithCumulants.cxx:190
 AliFlowAnalysisWithCumulants.cxx:191
 AliFlowAnalysisWithCumulants.cxx:192
 AliFlowAnalysisWithCumulants.cxx:193
 AliFlowAnalysisWithCumulants.cxx:194
 AliFlowAnalysisWithCumulants.cxx:195
 AliFlowAnalysisWithCumulants.cxx:196
 AliFlowAnalysisWithCumulants.cxx:197
 AliFlowAnalysisWithCumulants.cxx:198
 AliFlowAnalysisWithCumulants.cxx:199
 AliFlowAnalysisWithCumulants.cxx:200
 AliFlowAnalysisWithCumulants.cxx:201
 AliFlowAnalysisWithCumulants.cxx:202
 AliFlowAnalysisWithCumulants.cxx:203
 AliFlowAnalysisWithCumulants.cxx:204
 AliFlowAnalysisWithCumulants.cxx:205
 AliFlowAnalysisWithCumulants.cxx:206
 AliFlowAnalysisWithCumulants.cxx:207
 AliFlowAnalysisWithCumulants.cxx:208
 AliFlowAnalysisWithCumulants.cxx:209
 AliFlowAnalysisWithCumulants.cxx:210
 AliFlowAnalysisWithCumulants.cxx:211
 AliFlowAnalysisWithCumulants.cxx:212
 AliFlowAnalysisWithCumulants.cxx:213
 AliFlowAnalysisWithCumulants.cxx:214
 AliFlowAnalysisWithCumulants.cxx:215
 AliFlowAnalysisWithCumulants.cxx:216
 AliFlowAnalysisWithCumulants.cxx:217
 AliFlowAnalysisWithCumulants.cxx:218
 AliFlowAnalysisWithCumulants.cxx:219
 AliFlowAnalysisWithCumulants.cxx:220
 AliFlowAnalysisWithCumulants.cxx:221
 AliFlowAnalysisWithCumulants.cxx:222
 AliFlowAnalysisWithCumulants.cxx:223
 AliFlowAnalysisWithCumulants.cxx:224
 AliFlowAnalysisWithCumulants.cxx:225
 AliFlowAnalysisWithCumulants.cxx:226
 AliFlowAnalysisWithCumulants.cxx:227
 AliFlowAnalysisWithCumulants.cxx:228
 AliFlowAnalysisWithCumulants.cxx:229
 AliFlowAnalysisWithCumulants.cxx:230
 AliFlowAnalysisWithCumulants.cxx:231
 AliFlowAnalysisWithCumulants.cxx:232
 AliFlowAnalysisWithCumulants.cxx:233
 AliFlowAnalysisWithCumulants.cxx:234
 AliFlowAnalysisWithCumulants.cxx:235
 AliFlowAnalysisWithCumulants.cxx:236
 AliFlowAnalysisWithCumulants.cxx:237
 AliFlowAnalysisWithCumulants.cxx:238
 AliFlowAnalysisWithCumulants.cxx:239
 AliFlowAnalysisWithCumulants.cxx:240
 AliFlowAnalysisWithCumulants.cxx:241
 AliFlowAnalysisWithCumulants.cxx:242
 AliFlowAnalysisWithCumulants.cxx:243
 AliFlowAnalysisWithCumulants.cxx:244
 AliFlowAnalysisWithCumulants.cxx:245
 AliFlowAnalysisWithCumulants.cxx:246
 AliFlowAnalysisWithCumulants.cxx:247
 AliFlowAnalysisWithCumulants.cxx:248
 AliFlowAnalysisWithCumulants.cxx:249
 AliFlowAnalysisWithCumulants.cxx:250
 AliFlowAnalysisWithCumulants.cxx:251
 AliFlowAnalysisWithCumulants.cxx:252
 AliFlowAnalysisWithCumulants.cxx:253
 AliFlowAnalysisWithCumulants.cxx:254
 AliFlowAnalysisWithCumulants.cxx:255
 AliFlowAnalysisWithCumulants.cxx:256
 AliFlowAnalysisWithCumulants.cxx:257
 AliFlowAnalysisWithCumulants.cxx:258
 AliFlowAnalysisWithCumulants.cxx:259
 AliFlowAnalysisWithCumulants.cxx:260
 AliFlowAnalysisWithCumulants.cxx:261
 AliFlowAnalysisWithCumulants.cxx:262
 AliFlowAnalysisWithCumulants.cxx:263
 AliFlowAnalysisWithCumulants.cxx:264
 AliFlowAnalysisWithCumulants.cxx:265
 AliFlowAnalysisWithCumulants.cxx:266
 AliFlowAnalysisWithCumulants.cxx:267
 AliFlowAnalysisWithCumulants.cxx:268
 AliFlowAnalysisWithCumulants.cxx:269
 AliFlowAnalysisWithCumulants.cxx:270
 AliFlowAnalysisWithCumulants.cxx:271
 AliFlowAnalysisWithCumulants.cxx:272
 AliFlowAnalysisWithCumulants.cxx:273
 AliFlowAnalysisWithCumulants.cxx:274
 AliFlowAnalysisWithCumulants.cxx:275
 AliFlowAnalysisWithCumulants.cxx:276
 AliFlowAnalysisWithCumulants.cxx:277
 AliFlowAnalysisWithCumulants.cxx:278
 AliFlowAnalysisWithCumulants.cxx:279
 AliFlowAnalysisWithCumulants.cxx:280
 AliFlowAnalysisWithCumulants.cxx:281
 AliFlowAnalysisWithCumulants.cxx:282
 AliFlowAnalysisWithCumulants.cxx:283
 AliFlowAnalysisWithCumulants.cxx:284
 AliFlowAnalysisWithCumulants.cxx:285
 AliFlowAnalysisWithCumulants.cxx:286
 AliFlowAnalysisWithCumulants.cxx:287
 AliFlowAnalysisWithCumulants.cxx:288
 AliFlowAnalysisWithCumulants.cxx:289
 AliFlowAnalysisWithCumulants.cxx:290
 AliFlowAnalysisWithCumulants.cxx:291
 AliFlowAnalysisWithCumulants.cxx:292
 AliFlowAnalysisWithCumulants.cxx:293
 AliFlowAnalysisWithCumulants.cxx:294
 AliFlowAnalysisWithCumulants.cxx:295
 AliFlowAnalysisWithCumulants.cxx:296
 AliFlowAnalysisWithCumulants.cxx:297
 AliFlowAnalysisWithCumulants.cxx:298
 AliFlowAnalysisWithCumulants.cxx:299
 AliFlowAnalysisWithCumulants.cxx:300
 AliFlowAnalysisWithCumulants.cxx:301
 AliFlowAnalysisWithCumulants.cxx:302
 AliFlowAnalysisWithCumulants.cxx:303
 AliFlowAnalysisWithCumulants.cxx:304
 AliFlowAnalysisWithCumulants.cxx:305
 AliFlowAnalysisWithCumulants.cxx:306
 AliFlowAnalysisWithCumulants.cxx:307
 AliFlowAnalysisWithCumulants.cxx:308
 AliFlowAnalysisWithCumulants.cxx:309
 AliFlowAnalysisWithCumulants.cxx:310
 AliFlowAnalysisWithCumulants.cxx:311
 AliFlowAnalysisWithCumulants.cxx:312
 AliFlowAnalysisWithCumulants.cxx:313
 AliFlowAnalysisWithCumulants.cxx:314
 AliFlowAnalysisWithCumulants.cxx:315
 AliFlowAnalysisWithCumulants.cxx:316
 AliFlowAnalysisWithCumulants.cxx:317
 AliFlowAnalysisWithCumulants.cxx:318
 AliFlowAnalysisWithCumulants.cxx:319
 AliFlowAnalysisWithCumulants.cxx:320
 AliFlowAnalysisWithCumulants.cxx:321
 AliFlowAnalysisWithCumulants.cxx:322
 AliFlowAnalysisWithCumulants.cxx:323
 AliFlowAnalysisWithCumulants.cxx:324
 AliFlowAnalysisWithCumulants.cxx:325
 AliFlowAnalysisWithCumulants.cxx:326
 AliFlowAnalysisWithCumulants.cxx:327
 AliFlowAnalysisWithCumulants.cxx:328
 AliFlowAnalysisWithCumulants.cxx:329
 AliFlowAnalysisWithCumulants.cxx:330
 AliFlowAnalysisWithCumulants.cxx:331
 AliFlowAnalysisWithCumulants.cxx:332
 AliFlowAnalysisWithCumulants.cxx:333
 AliFlowAnalysisWithCumulants.cxx:334
 AliFlowAnalysisWithCumulants.cxx:335
 AliFlowAnalysisWithCumulants.cxx:336
 AliFlowAnalysisWithCumulants.cxx:337
 AliFlowAnalysisWithCumulants.cxx:338
 AliFlowAnalysisWithCumulants.cxx:339
 AliFlowAnalysisWithCumulants.cxx:340
 AliFlowAnalysisWithCumulants.cxx:341
 AliFlowAnalysisWithCumulants.cxx:342
 AliFlowAnalysisWithCumulants.cxx:343
 AliFlowAnalysisWithCumulants.cxx:344
 AliFlowAnalysisWithCumulants.cxx:345
 AliFlowAnalysisWithCumulants.cxx:346
 AliFlowAnalysisWithCumulants.cxx:347
 AliFlowAnalysisWithCumulants.cxx:348
 AliFlowAnalysisWithCumulants.cxx:349
 AliFlowAnalysisWithCumulants.cxx:350
 AliFlowAnalysisWithCumulants.cxx:351
 AliFlowAnalysisWithCumulants.cxx:352
 AliFlowAnalysisWithCumulants.cxx:353
 AliFlowAnalysisWithCumulants.cxx:354
 AliFlowAnalysisWithCumulants.cxx:355
 AliFlowAnalysisWithCumulants.cxx:356
 AliFlowAnalysisWithCumulants.cxx:357
 AliFlowAnalysisWithCumulants.cxx:358
 AliFlowAnalysisWithCumulants.cxx:359
 AliFlowAnalysisWithCumulants.cxx:360
 AliFlowAnalysisWithCumulants.cxx:361
 AliFlowAnalysisWithCumulants.cxx:362
 AliFlowAnalysisWithCumulants.cxx:363
 AliFlowAnalysisWithCumulants.cxx:364
 AliFlowAnalysisWithCumulants.cxx:365
 AliFlowAnalysisWithCumulants.cxx:366
 AliFlowAnalysisWithCumulants.cxx:367
 AliFlowAnalysisWithCumulants.cxx:368
 AliFlowAnalysisWithCumulants.cxx:369
 AliFlowAnalysisWithCumulants.cxx:370
 AliFlowAnalysisWithCumulants.cxx:371
 AliFlowAnalysisWithCumulants.cxx:372
 AliFlowAnalysisWithCumulants.cxx:373
 AliFlowAnalysisWithCumulants.cxx:374
 AliFlowAnalysisWithCumulants.cxx:375
 AliFlowAnalysisWithCumulants.cxx:376
 AliFlowAnalysisWithCumulants.cxx:377
 AliFlowAnalysisWithCumulants.cxx:378
 AliFlowAnalysisWithCumulants.cxx:379
 AliFlowAnalysisWithCumulants.cxx:380
 AliFlowAnalysisWithCumulants.cxx:381
 AliFlowAnalysisWithCumulants.cxx:382
 AliFlowAnalysisWithCumulants.cxx:383
 AliFlowAnalysisWithCumulants.cxx:384
 AliFlowAnalysisWithCumulants.cxx:385
 AliFlowAnalysisWithCumulants.cxx:386
 AliFlowAnalysisWithCumulants.cxx:387
 AliFlowAnalysisWithCumulants.cxx:388
 AliFlowAnalysisWithCumulants.cxx:389
 AliFlowAnalysisWithCumulants.cxx:390
 AliFlowAnalysisWithCumulants.cxx:391
 AliFlowAnalysisWithCumulants.cxx:392
 AliFlowAnalysisWithCumulants.cxx:393
 AliFlowAnalysisWithCumulants.cxx:394
 AliFlowAnalysisWithCumulants.cxx:395
 AliFlowAnalysisWithCumulants.cxx:396
 AliFlowAnalysisWithCumulants.cxx:397
 AliFlowAnalysisWithCumulants.cxx:398
 AliFlowAnalysisWithCumulants.cxx:399
 AliFlowAnalysisWithCumulants.cxx:400
 AliFlowAnalysisWithCumulants.cxx:401
 AliFlowAnalysisWithCumulants.cxx:402
 AliFlowAnalysisWithCumulants.cxx:403
 AliFlowAnalysisWithCumulants.cxx:404
 AliFlowAnalysisWithCumulants.cxx:405
 AliFlowAnalysisWithCumulants.cxx:406
 AliFlowAnalysisWithCumulants.cxx:407
 AliFlowAnalysisWithCumulants.cxx:408
 AliFlowAnalysisWithCumulants.cxx:409
 AliFlowAnalysisWithCumulants.cxx:410
 AliFlowAnalysisWithCumulants.cxx:411
 AliFlowAnalysisWithCumulants.cxx:412
 AliFlowAnalysisWithCumulants.cxx:413
 AliFlowAnalysisWithCumulants.cxx:414
 AliFlowAnalysisWithCumulants.cxx:415
 AliFlowAnalysisWithCumulants.cxx:416
 AliFlowAnalysisWithCumulants.cxx:417
 AliFlowAnalysisWithCumulants.cxx:418
 AliFlowAnalysisWithCumulants.cxx:419
 AliFlowAnalysisWithCumulants.cxx:420
 AliFlowAnalysisWithCumulants.cxx:421
 AliFlowAnalysisWithCumulants.cxx:422
 AliFlowAnalysisWithCumulants.cxx:423
 AliFlowAnalysisWithCumulants.cxx:424
 AliFlowAnalysisWithCumulants.cxx:425
 AliFlowAnalysisWithCumulants.cxx:426
 AliFlowAnalysisWithCumulants.cxx:427
 AliFlowAnalysisWithCumulants.cxx:428
 AliFlowAnalysisWithCumulants.cxx:429
 AliFlowAnalysisWithCumulants.cxx:430
 AliFlowAnalysisWithCumulants.cxx:431
 AliFlowAnalysisWithCumulants.cxx:432
 AliFlowAnalysisWithCumulants.cxx:433
 AliFlowAnalysisWithCumulants.cxx:434
 AliFlowAnalysisWithCumulants.cxx:435
 AliFlowAnalysisWithCumulants.cxx:436
 AliFlowAnalysisWithCumulants.cxx:437
 AliFlowAnalysisWithCumulants.cxx:438
 AliFlowAnalysisWithCumulants.cxx:439
 AliFlowAnalysisWithCumulants.cxx:440
 AliFlowAnalysisWithCumulants.cxx:441
 AliFlowAnalysisWithCumulants.cxx:442
 AliFlowAnalysisWithCumulants.cxx:443
 AliFlowAnalysisWithCumulants.cxx:444
 AliFlowAnalysisWithCumulants.cxx:445
 AliFlowAnalysisWithCumulants.cxx:446
 AliFlowAnalysisWithCumulants.cxx:447
 AliFlowAnalysisWithCumulants.cxx:448
 AliFlowAnalysisWithCumulants.cxx:449
 AliFlowAnalysisWithCumulants.cxx:450
 AliFlowAnalysisWithCumulants.cxx:451
 AliFlowAnalysisWithCumulants.cxx:452
 AliFlowAnalysisWithCumulants.cxx:453
 AliFlowAnalysisWithCumulants.cxx:454
 AliFlowAnalysisWithCumulants.cxx:455
 AliFlowAnalysisWithCumulants.cxx:456
 AliFlowAnalysisWithCumulants.cxx:457
 AliFlowAnalysisWithCumulants.cxx:458
 AliFlowAnalysisWithCumulants.cxx:459
 AliFlowAnalysisWithCumulants.cxx:460
 AliFlowAnalysisWithCumulants.cxx:461
 AliFlowAnalysisWithCumulants.cxx:462
 AliFlowAnalysisWithCumulants.cxx:463
 AliFlowAnalysisWithCumulants.cxx:464
 AliFlowAnalysisWithCumulants.cxx:465
 AliFlowAnalysisWithCumulants.cxx:466
 AliFlowAnalysisWithCumulants.cxx:467
 AliFlowAnalysisWithCumulants.cxx:468
 AliFlowAnalysisWithCumulants.cxx:469
 AliFlowAnalysisWithCumulants.cxx:470
 AliFlowAnalysisWithCumulants.cxx:471
 AliFlowAnalysisWithCumulants.cxx:472
 AliFlowAnalysisWithCumulants.cxx:473
 AliFlowAnalysisWithCumulants.cxx:474
 AliFlowAnalysisWithCumulants.cxx:475
 AliFlowAnalysisWithCumulants.cxx:476
 AliFlowAnalysisWithCumulants.cxx:477
 AliFlowAnalysisWithCumulants.cxx:478
 AliFlowAnalysisWithCumulants.cxx:479
 AliFlowAnalysisWithCumulants.cxx:480
 AliFlowAnalysisWithCumulants.cxx:481
 AliFlowAnalysisWithCumulants.cxx:482
 AliFlowAnalysisWithCumulants.cxx:483
 AliFlowAnalysisWithCumulants.cxx:484
 AliFlowAnalysisWithCumulants.cxx:485
 AliFlowAnalysisWithCumulants.cxx:486
 AliFlowAnalysisWithCumulants.cxx:487
 AliFlowAnalysisWithCumulants.cxx:488
 AliFlowAnalysisWithCumulants.cxx:489
 AliFlowAnalysisWithCumulants.cxx:490
 AliFlowAnalysisWithCumulants.cxx:491
 AliFlowAnalysisWithCumulants.cxx:492
 AliFlowAnalysisWithCumulants.cxx:493
 AliFlowAnalysisWithCumulants.cxx:494
 AliFlowAnalysisWithCumulants.cxx:495
 AliFlowAnalysisWithCumulants.cxx:496
 AliFlowAnalysisWithCumulants.cxx:497
 AliFlowAnalysisWithCumulants.cxx:498
 AliFlowAnalysisWithCumulants.cxx:499
 AliFlowAnalysisWithCumulants.cxx:500
 AliFlowAnalysisWithCumulants.cxx:501
 AliFlowAnalysisWithCumulants.cxx:502
 AliFlowAnalysisWithCumulants.cxx:503
 AliFlowAnalysisWithCumulants.cxx:504
 AliFlowAnalysisWithCumulants.cxx:505
 AliFlowAnalysisWithCumulants.cxx:506
 AliFlowAnalysisWithCumulants.cxx:507
 AliFlowAnalysisWithCumulants.cxx:508
 AliFlowAnalysisWithCumulants.cxx:509
 AliFlowAnalysisWithCumulants.cxx:510
 AliFlowAnalysisWithCumulants.cxx:511
 AliFlowAnalysisWithCumulants.cxx:512
 AliFlowAnalysisWithCumulants.cxx:513
 AliFlowAnalysisWithCumulants.cxx:514
 AliFlowAnalysisWithCumulants.cxx:515
 AliFlowAnalysisWithCumulants.cxx:516
 AliFlowAnalysisWithCumulants.cxx:517
 AliFlowAnalysisWithCumulants.cxx:518
 AliFlowAnalysisWithCumulants.cxx:519
 AliFlowAnalysisWithCumulants.cxx:520
 AliFlowAnalysisWithCumulants.cxx:521
 AliFlowAnalysisWithCumulants.cxx:522
 AliFlowAnalysisWithCumulants.cxx:523
 AliFlowAnalysisWithCumulants.cxx:524
 AliFlowAnalysisWithCumulants.cxx:525
 AliFlowAnalysisWithCumulants.cxx:526
 AliFlowAnalysisWithCumulants.cxx:527
 AliFlowAnalysisWithCumulants.cxx:528
 AliFlowAnalysisWithCumulants.cxx:529
 AliFlowAnalysisWithCumulants.cxx:530
 AliFlowAnalysisWithCumulants.cxx:531
 AliFlowAnalysisWithCumulants.cxx:532
 AliFlowAnalysisWithCumulants.cxx:533
 AliFlowAnalysisWithCumulants.cxx:534
 AliFlowAnalysisWithCumulants.cxx:535
 AliFlowAnalysisWithCumulants.cxx:536
 AliFlowAnalysisWithCumulants.cxx:537
 AliFlowAnalysisWithCumulants.cxx:538
 AliFlowAnalysisWithCumulants.cxx:539
 AliFlowAnalysisWithCumulants.cxx:540
 AliFlowAnalysisWithCumulants.cxx:541
 AliFlowAnalysisWithCumulants.cxx:542
 AliFlowAnalysisWithCumulants.cxx:543
 AliFlowAnalysisWithCumulants.cxx:544
 AliFlowAnalysisWithCumulants.cxx:545
 AliFlowAnalysisWithCumulants.cxx:546
 AliFlowAnalysisWithCumulants.cxx:547
 AliFlowAnalysisWithCumulants.cxx:548
 AliFlowAnalysisWithCumulants.cxx:549
 AliFlowAnalysisWithCumulants.cxx:550
 AliFlowAnalysisWithCumulants.cxx:551
 AliFlowAnalysisWithCumulants.cxx:552
 AliFlowAnalysisWithCumulants.cxx:553
 AliFlowAnalysisWithCumulants.cxx:554
 AliFlowAnalysisWithCumulants.cxx:555
 AliFlowAnalysisWithCumulants.cxx:556
 AliFlowAnalysisWithCumulants.cxx:557
 AliFlowAnalysisWithCumulants.cxx:558
 AliFlowAnalysisWithCumulants.cxx:559
 AliFlowAnalysisWithCumulants.cxx:560
 AliFlowAnalysisWithCumulants.cxx:561
 AliFlowAnalysisWithCumulants.cxx:562
 AliFlowAnalysisWithCumulants.cxx:563
 AliFlowAnalysisWithCumulants.cxx:564
 AliFlowAnalysisWithCumulants.cxx:565
 AliFlowAnalysisWithCumulants.cxx:566
 AliFlowAnalysisWithCumulants.cxx:567
 AliFlowAnalysisWithCumulants.cxx:568
 AliFlowAnalysisWithCumulants.cxx:569
 AliFlowAnalysisWithCumulants.cxx:570
 AliFlowAnalysisWithCumulants.cxx:571
 AliFlowAnalysisWithCumulants.cxx:572
 AliFlowAnalysisWithCumulants.cxx:573
 AliFlowAnalysisWithCumulants.cxx:574
 AliFlowAnalysisWithCumulants.cxx:575
 AliFlowAnalysisWithCumulants.cxx:576
 AliFlowAnalysisWithCumulants.cxx:577
 AliFlowAnalysisWithCumulants.cxx:578
 AliFlowAnalysisWithCumulants.cxx:579
 AliFlowAnalysisWithCumulants.cxx:580
 AliFlowAnalysisWithCumulants.cxx:581
 AliFlowAnalysisWithCumulants.cxx:582
 AliFlowAnalysisWithCumulants.cxx:583
 AliFlowAnalysisWithCumulants.cxx:584
 AliFlowAnalysisWithCumulants.cxx:585
 AliFlowAnalysisWithCumulants.cxx:586
 AliFlowAnalysisWithCumulants.cxx:587
 AliFlowAnalysisWithCumulants.cxx:588
 AliFlowAnalysisWithCumulants.cxx:589
 AliFlowAnalysisWithCumulants.cxx:590
 AliFlowAnalysisWithCumulants.cxx:591
 AliFlowAnalysisWithCumulants.cxx:592
 AliFlowAnalysisWithCumulants.cxx:593
 AliFlowAnalysisWithCumulants.cxx:594
 AliFlowAnalysisWithCumulants.cxx:595
 AliFlowAnalysisWithCumulants.cxx:596
 AliFlowAnalysisWithCumulants.cxx:597
 AliFlowAnalysisWithCumulants.cxx:598
 AliFlowAnalysisWithCumulants.cxx:599
 AliFlowAnalysisWithCumulants.cxx:600
 AliFlowAnalysisWithCumulants.cxx:601
 AliFlowAnalysisWithCumulants.cxx:602
 AliFlowAnalysisWithCumulants.cxx:603
 AliFlowAnalysisWithCumulants.cxx:604
 AliFlowAnalysisWithCumulants.cxx:605
 AliFlowAnalysisWithCumulants.cxx:606
 AliFlowAnalysisWithCumulants.cxx:607
 AliFlowAnalysisWithCumulants.cxx:608
 AliFlowAnalysisWithCumulants.cxx:609
 AliFlowAnalysisWithCumulants.cxx:610
 AliFlowAnalysisWithCumulants.cxx:611
 AliFlowAnalysisWithCumulants.cxx:612
 AliFlowAnalysisWithCumulants.cxx:613
 AliFlowAnalysisWithCumulants.cxx:614
 AliFlowAnalysisWithCumulants.cxx:615
 AliFlowAnalysisWithCumulants.cxx:616
 AliFlowAnalysisWithCumulants.cxx:617
 AliFlowAnalysisWithCumulants.cxx:618
 AliFlowAnalysisWithCumulants.cxx:619
 AliFlowAnalysisWithCumulants.cxx:620
 AliFlowAnalysisWithCumulants.cxx:621
 AliFlowAnalysisWithCumulants.cxx:622
 AliFlowAnalysisWithCumulants.cxx:623
 AliFlowAnalysisWithCumulants.cxx:624
 AliFlowAnalysisWithCumulants.cxx:625
 AliFlowAnalysisWithCumulants.cxx:626
 AliFlowAnalysisWithCumulants.cxx:627
 AliFlowAnalysisWithCumulants.cxx:628
 AliFlowAnalysisWithCumulants.cxx:629
 AliFlowAnalysisWithCumulants.cxx:630
 AliFlowAnalysisWithCumulants.cxx:631
 AliFlowAnalysisWithCumulants.cxx:632
 AliFlowAnalysisWithCumulants.cxx:633
 AliFlowAnalysisWithCumulants.cxx:634
 AliFlowAnalysisWithCumulants.cxx:635
 AliFlowAnalysisWithCumulants.cxx:636
 AliFlowAnalysisWithCumulants.cxx:637
 AliFlowAnalysisWithCumulants.cxx:638
 AliFlowAnalysisWithCumulants.cxx:639
 AliFlowAnalysisWithCumulants.cxx:640
 AliFlowAnalysisWithCumulants.cxx:641
 AliFlowAnalysisWithCumulants.cxx:642
 AliFlowAnalysisWithCumulants.cxx:643
 AliFlowAnalysisWithCumulants.cxx:644
 AliFlowAnalysisWithCumulants.cxx:645
 AliFlowAnalysisWithCumulants.cxx:646
 AliFlowAnalysisWithCumulants.cxx:647
 AliFlowAnalysisWithCumulants.cxx:648
 AliFlowAnalysisWithCumulants.cxx:649
 AliFlowAnalysisWithCumulants.cxx:650
 AliFlowAnalysisWithCumulants.cxx:651
 AliFlowAnalysisWithCumulants.cxx:652
 AliFlowAnalysisWithCumulants.cxx:653
 AliFlowAnalysisWithCumulants.cxx:654
 AliFlowAnalysisWithCumulants.cxx:655
 AliFlowAnalysisWithCumulants.cxx:656
 AliFlowAnalysisWithCumulants.cxx:657
 AliFlowAnalysisWithCumulants.cxx:658
 AliFlowAnalysisWithCumulants.cxx:659
 AliFlowAnalysisWithCumulants.cxx:660
 AliFlowAnalysisWithCumulants.cxx:661
 AliFlowAnalysisWithCumulants.cxx:662
 AliFlowAnalysisWithCumulants.cxx:663
 AliFlowAnalysisWithCumulants.cxx:664
 AliFlowAnalysisWithCumulants.cxx:665
 AliFlowAnalysisWithCumulants.cxx:666
 AliFlowAnalysisWithCumulants.cxx:667
 AliFlowAnalysisWithCumulants.cxx:668
 AliFlowAnalysisWithCumulants.cxx:669
 AliFlowAnalysisWithCumulants.cxx:670
 AliFlowAnalysisWithCumulants.cxx:671
 AliFlowAnalysisWithCumulants.cxx:672
 AliFlowAnalysisWithCumulants.cxx:673
 AliFlowAnalysisWithCumulants.cxx:674
 AliFlowAnalysisWithCumulants.cxx:675
 AliFlowAnalysisWithCumulants.cxx:676
 AliFlowAnalysisWithCumulants.cxx:677
 AliFlowAnalysisWithCumulants.cxx:678
 AliFlowAnalysisWithCumulants.cxx:679
 AliFlowAnalysisWithCumulants.cxx:680
 AliFlowAnalysisWithCumulants.cxx:681
 AliFlowAnalysisWithCumulants.cxx:682
 AliFlowAnalysisWithCumulants.cxx:683
 AliFlowAnalysisWithCumulants.cxx:684
 AliFlowAnalysisWithCumulants.cxx:685
 AliFlowAnalysisWithCumulants.cxx:686
 AliFlowAnalysisWithCumulants.cxx:687
 AliFlowAnalysisWithCumulants.cxx:688
 AliFlowAnalysisWithCumulants.cxx:689
 AliFlowAnalysisWithCumulants.cxx:690
 AliFlowAnalysisWithCumulants.cxx:691
 AliFlowAnalysisWithCumulants.cxx:692
 AliFlowAnalysisWithCumulants.cxx:693
 AliFlowAnalysisWithCumulants.cxx:694
 AliFlowAnalysisWithCumulants.cxx:695
 AliFlowAnalysisWithCumulants.cxx:696
 AliFlowAnalysisWithCumulants.cxx:697
 AliFlowAnalysisWithCumulants.cxx:698
 AliFlowAnalysisWithCumulants.cxx:699
 AliFlowAnalysisWithCumulants.cxx:700
 AliFlowAnalysisWithCumulants.cxx:701
 AliFlowAnalysisWithCumulants.cxx:702
 AliFlowAnalysisWithCumulants.cxx:703
 AliFlowAnalysisWithCumulants.cxx:704
 AliFlowAnalysisWithCumulants.cxx:705
 AliFlowAnalysisWithCumulants.cxx:706
 AliFlowAnalysisWithCumulants.cxx:707
 AliFlowAnalysisWithCumulants.cxx:708
 AliFlowAnalysisWithCumulants.cxx:709
 AliFlowAnalysisWithCumulants.cxx:710
 AliFlowAnalysisWithCumulants.cxx:711
 AliFlowAnalysisWithCumulants.cxx:712
 AliFlowAnalysisWithCumulants.cxx:713
 AliFlowAnalysisWithCumulants.cxx:714
 AliFlowAnalysisWithCumulants.cxx:715
 AliFlowAnalysisWithCumulants.cxx:716
 AliFlowAnalysisWithCumulants.cxx:717
 AliFlowAnalysisWithCumulants.cxx:718
 AliFlowAnalysisWithCumulants.cxx:719
 AliFlowAnalysisWithCumulants.cxx:720
 AliFlowAnalysisWithCumulants.cxx:721
 AliFlowAnalysisWithCumulants.cxx:722
 AliFlowAnalysisWithCumulants.cxx:723
 AliFlowAnalysisWithCumulants.cxx:724
 AliFlowAnalysisWithCumulants.cxx:725
 AliFlowAnalysisWithCumulants.cxx:726
 AliFlowAnalysisWithCumulants.cxx:727
 AliFlowAnalysisWithCumulants.cxx:728
 AliFlowAnalysisWithCumulants.cxx:729
 AliFlowAnalysisWithCumulants.cxx:730
 AliFlowAnalysisWithCumulants.cxx:731
 AliFlowAnalysisWithCumulants.cxx:732
 AliFlowAnalysisWithCumulants.cxx:733
 AliFlowAnalysisWithCumulants.cxx:734
 AliFlowAnalysisWithCumulants.cxx:735
 AliFlowAnalysisWithCumulants.cxx:736
 AliFlowAnalysisWithCumulants.cxx:737
 AliFlowAnalysisWithCumulants.cxx:738
 AliFlowAnalysisWithCumulants.cxx:739
 AliFlowAnalysisWithCumulants.cxx:740
 AliFlowAnalysisWithCumulants.cxx:741
 AliFlowAnalysisWithCumulants.cxx:742
 AliFlowAnalysisWithCumulants.cxx:743
 AliFlowAnalysisWithCumulants.cxx:744
 AliFlowAnalysisWithCumulants.cxx:745
 AliFlowAnalysisWithCumulants.cxx:746
 AliFlowAnalysisWithCumulants.cxx:747
 AliFlowAnalysisWithCumulants.cxx:748
 AliFlowAnalysisWithCumulants.cxx:749
 AliFlowAnalysisWithCumulants.cxx:750
 AliFlowAnalysisWithCumulants.cxx:751
 AliFlowAnalysisWithCumulants.cxx:752
 AliFlowAnalysisWithCumulants.cxx:753
 AliFlowAnalysisWithCumulants.cxx:754
 AliFlowAnalysisWithCumulants.cxx:755
 AliFlowAnalysisWithCumulants.cxx:756
 AliFlowAnalysisWithCumulants.cxx:757
 AliFlowAnalysisWithCumulants.cxx:758
 AliFlowAnalysisWithCumulants.cxx:759
 AliFlowAnalysisWithCumulants.cxx:760
 AliFlowAnalysisWithCumulants.cxx:761
 AliFlowAnalysisWithCumulants.cxx:762
 AliFlowAnalysisWithCumulants.cxx:763
 AliFlowAnalysisWithCumulants.cxx:764
 AliFlowAnalysisWithCumulants.cxx:765
 AliFlowAnalysisWithCumulants.cxx:766
 AliFlowAnalysisWithCumulants.cxx:767
 AliFlowAnalysisWithCumulants.cxx:768
 AliFlowAnalysisWithCumulants.cxx:769
 AliFlowAnalysisWithCumulants.cxx:770
 AliFlowAnalysisWithCumulants.cxx:771
 AliFlowAnalysisWithCumulants.cxx:772
 AliFlowAnalysisWithCumulants.cxx:773
 AliFlowAnalysisWithCumulants.cxx:774
 AliFlowAnalysisWithCumulants.cxx:775
 AliFlowAnalysisWithCumulants.cxx:776
 AliFlowAnalysisWithCumulants.cxx:777
 AliFlowAnalysisWithCumulants.cxx:778
 AliFlowAnalysisWithCumulants.cxx:779
 AliFlowAnalysisWithCumulants.cxx:780
 AliFlowAnalysisWithCumulants.cxx:781
 AliFlowAnalysisWithCumulants.cxx:782
 AliFlowAnalysisWithCumulants.cxx:783
 AliFlowAnalysisWithCumulants.cxx:784
 AliFlowAnalysisWithCumulants.cxx:785
 AliFlowAnalysisWithCumulants.cxx:786
 AliFlowAnalysisWithCumulants.cxx:787
 AliFlowAnalysisWithCumulants.cxx:788
 AliFlowAnalysisWithCumulants.cxx:789
 AliFlowAnalysisWithCumulants.cxx:790
 AliFlowAnalysisWithCumulants.cxx:791
 AliFlowAnalysisWithCumulants.cxx:792
 AliFlowAnalysisWithCumulants.cxx:793
 AliFlowAnalysisWithCumulants.cxx:794
 AliFlowAnalysisWithCumulants.cxx:795
 AliFlowAnalysisWithCumulants.cxx:796
 AliFlowAnalysisWithCumulants.cxx:797
 AliFlowAnalysisWithCumulants.cxx:798
 AliFlowAnalysisWithCumulants.cxx:799
 AliFlowAnalysisWithCumulants.cxx:800
 AliFlowAnalysisWithCumulants.cxx:801
 AliFlowAnalysisWithCumulants.cxx:802
 AliFlowAnalysisWithCumulants.cxx:803
 AliFlowAnalysisWithCumulants.cxx:804
 AliFlowAnalysisWithCumulants.cxx:805
 AliFlowAnalysisWithCumulants.cxx:806
 AliFlowAnalysisWithCumulants.cxx:807
 AliFlowAnalysisWithCumulants.cxx:808
 AliFlowAnalysisWithCumulants.cxx:809
 AliFlowAnalysisWithCumulants.cxx:810
 AliFlowAnalysisWithCumulants.cxx:811
 AliFlowAnalysisWithCumulants.cxx:812
 AliFlowAnalysisWithCumulants.cxx:813
 AliFlowAnalysisWithCumulants.cxx:814
 AliFlowAnalysisWithCumulants.cxx:815
 AliFlowAnalysisWithCumulants.cxx:816
 AliFlowAnalysisWithCumulants.cxx:817
 AliFlowAnalysisWithCumulants.cxx:818
 AliFlowAnalysisWithCumulants.cxx:819
 AliFlowAnalysisWithCumulants.cxx:820
 AliFlowAnalysisWithCumulants.cxx:821
 AliFlowAnalysisWithCumulants.cxx:822
 AliFlowAnalysisWithCumulants.cxx:823
 AliFlowAnalysisWithCumulants.cxx:824
 AliFlowAnalysisWithCumulants.cxx:825
 AliFlowAnalysisWithCumulants.cxx:826
 AliFlowAnalysisWithCumulants.cxx:827
 AliFlowAnalysisWithCumulants.cxx:828
 AliFlowAnalysisWithCumulants.cxx:829
 AliFlowAnalysisWithCumulants.cxx:830
 AliFlowAnalysisWithCumulants.cxx:831
 AliFlowAnalysisWithCumulants.cxx:832
 AliFlowAnalysisWithCumulants.cxx:833
 AliFlowAnalysisWithCumulants.cxx:834
 AliFlowAnalysisWithCumulants.cxx:835
 AliFlowAnalysisWithCumulants.cxx:836
 AliFlowAnalysisWithCumulants.cxx:837
 AliFlowAnalysisWithCumulants.cxx:838
 AliFlowAnalysisWithCumulants.cxx:839
 AliFlowAnalysisWithCumulants.cxx:840
 AliFlowAnalysisWithCumulants.cxx:841
 AliFlowAnalysisWithCumulants.cxx:842
 AliFlowAnalysisWithCumulants.cxx:843
 AliFlowAnalysisWithCumulants.cxx:844
 AliFlowAnalysisWithCumulants.cxx:845
 AliFlowAnalysisWithCumulants.cxx:846
 AliFlowAnalysisWithCumulants.cxx:847
 AliFlowAnalysisWithCumulants.cxx:848
 AliFlowAnalysisWithCumulants.cxx:849
 AliFlowAnalysisWithCumulants.cxx:850
 AliFlowAnalysisWithCumulants.cxx:851
 AliFlowAnalysisWithCumulants.cxx:852
 AliFlowAnalysisWithCumulants.cxx:853
 AliFlowAnalysisWithCumulants.cxx:854
 AliFlowAnalysisWithCumulants.cxx:855
 AliFlowAnalysisWithCumulants.cxx:856
 AliFlowAnalysisWithCumulants.cxx:857
 AliFlowAnalysisWithCumulants.cxx:858
 AliFlowAnalysisWithCumulants.cxx:859
 AliFlowAnalysisWithCumulants.cxx:860
 AliFlowAnalysisWithCumulants.cxx:861
 AliFlowAnalysisWithCumulants.cxx:862
 AliFlowAnalysisWithCumulants.cxx:863
 AliFlowAnalysisWithCumulants.cxx:864
 AliFlowAnalysisWithCumulants.cxx:865
 AliFlowAnalysisWithCumulants.cxx:866
 AliFlowAnalysisWithCumulants.cxx:867
 AliFlowAnalysisWithCumulants.cxx:868
 AliFlowAnalysisWithCumulants.cxx:869
 AliFlowAnalysisWithCumulants.cxx:870
 AliFlowAnalysisWithCumulants.cxx:871
 AliFlowAnalysisWithCumulants.cxx:872
 AliFlowAnalysisWithCumulants.cxx:873
 AliFlowAnalysisWithCumulants.cxx:874
 AliFlowAnalysisWithCumulants.cxx:875
 AliFlowAnalysisWithCumulants.cxx:876
 AliFlowAnalysisWithCumulants.cxx:877
 AliFlowAnalysisWithCumulants.cxx:878
 AliFlowAnalysisWithCumulants.cxx:879
 AliFlowAnalysisWithCumulants.cxx:880
 AliFlowAnalysisWithCumulants.cxx:881
 AliFlowAnalysisWithCumulants.cxx:882
 AliFlowAnalysisWithCumulants.cxx:883
 AliFlowAnalysisWithCumulants.cxx:884
 AliFlowAnalysisWithCumulants.cxx:885
 AliFlowAnalysisWithCumulants.cxx:886
 AliFlowAnalysisWithCumulants.cxx:887
 AliFlowAnalysisWithCumulants.cxx:888
 AliFlowAnalysisWithCumulants.cxx:889
 AliFlowAnalysisWithCumulants.cxx:890
 AliFlowAnalysisWithCumulants.cxx:891
 AliFlowAnalysisWithCumulants.cxx:892
 AliFlowAnalysisWithCumulants.cxx:893
 AliFlowAnalysisWithCumulants.cxx:894
 AliFlowAnalysisWithCumulants.cxx:895
 AliFlowAnalysisWithCumulants.cxx:896
 AliFlowAnalysisWithCumulants.cxx:897
 AliFlowAnalysisWithCumulants.cxx:898
 AliFlowAnalysisWithCumulants.cxx:899
 AliFlowAnalysisWithCumulants.cxx:900
 AliFlowAnalysisWithCumulants.cxx:901
 AliFlowAnalysisWithCumulants.cxx:902
 AliFlowAnalysisWithCumulants.cxx:903
 AliFlowAnalysisWithCumulants.cxx:904
 AliFlowAnalysisWithCumulants.cxx:905
 AliFlowAnalysisWithCumulants.cxx:906
 AliFlowAnalysisWithCumulants.cxx:907
 AliFlowAnalysisWithCumulants.cxx:908
 AliFlowAnalysisWithCumulants.cxx:909
 AliFlowAnalysisWithCumulants.cxx:910
 AliFlowAnalysisWithCumulants.cxx:911
 AliFlowAnalysisWithCumulants.cxx:912
 AliFlowAnalysisWithCumulants.cxx:913
 AliFlowAnalysisWithCumulants.cxx:914
 AliFlowAnalysisWithCumulants.cxx:915
 AliFlowAnalysisWithCumulants.cxx:916
 AliFlowAnalysisWithCumulants.cxx:917
 AliFlowAnalysisWithCumulants.cxx:918
 AliFlowAnalysisWithCumulants.cxx:919
 AliFlowAnalysisWithCumulants.cxx:920
 AliFlowAnalysisWithCumulants.cxx:921
 AliFlowAnalysisWithCumulants.cxx:922
 AliFlowAnalysisWithCumulants.cxx:923
 AliFlowAnalysisWithCumulants.cxx:924
 AliFlowAnalysisWithCumulants.cxx:925
 AliFlowAnalysisWithCumulants.cxx:926
 AliFlowAnalysisWithCumulants.cxx:927
 AliFlowAnalysisWithCumulants.cxx:928
 AliFlowAnalysisWithCumulants.cxx:929
 AliFlowAnalysisWithCumulants.cxx:930
 AliFlowAnalysisWithCumulants.cxx:931
 AliFlowAnalysisWithCumulants.cxx:932
 AliFlowAnalysisWithCumulants.cxx:933
 AliFlowAnalysisWithCumulants.cxx:934
 AliFlowAnalysisWithCumulants.cxx:935
 AliFlowAnalysisWithCumulants.cxx:936
 AliFlowAnalysisWithCumulants.cxx:937
 AliFlowAnalysisWithCumulants.cxx:938
 AliFlowAnalysisWithCumulants.cxx:939
 AliFlowAnalysisWithCumulants.cxx:940
 AliFlowAnalysisWithCumulants.cxx:941
 AliFlowAnalysisWithCumulants.cxx:942
 AliFlowAnalysisWithCumulants.cxx:943
 AliFlowAnalysisWithCumulants.cxx:944
 AliFlowAnalysisWithCumulants.cxx:945
 AliFlowAnalysisWithCumulants.cxx:946
 AliFlowAnalysisWithCumulants.cxx:947
 AliFlowAnalysisWithCumulants.cxx:948
 AliFlowAnalysisWithCumulants.cxx:949
 AliFlowAnalysisWithCumulants.cxx:950
 AliFlowAnalysisWithCumulants.cxx:951
 AliFlowAnalysisWithCumulants.cxx:952
 AliFlowAnalysisWithCumulants.cxx:953
 AliFlowAnalysisWithCumulants.cxx:954
 AliFlowAnalysisWithCumulants.cxx:955
 AliFlowAnalysisWithCumulants.cxx:956
 AliFlowAnalysisWithCumulants.cxx:957
 AliFlowAnalysisWithCumulants.cxx:958
 AliFlowAnalysisWithCumulants.cxx:959
 AliFlowAnalysisWithCumulants.cxx:960
 AliFlowAnalysisWithCumulants.cxx:961
 AliFlowAnalysisWithCumulants.cxx:962
 AliFlowAnalysisWithCumulants.cxx:963
 AliFlowAnalysisWithCumulants.cxx:964
 AliFlowAnalysisWithCumulants.cxx:965
 AliFlowAnalysisWithCumulants.cxx:966
 AliFlowAnalysisWithCumulants.cxx:967
 AliFlowAnalysisWithCumulants.cxx:968
 AliFlowAnalysisWithCumulants.cxx:969
 AliFlowAnalysisWithCumulants.cxx:970
 AliFlowAnalysisWithCumulants.cxx:971
 AliFlowAnalysisWithCumulants.cxx:972
 AliFlowAnalysisWithCumulants.cxx:973
 AliFlowAnalysisWithCumulants.cxx:974
 AliFlowAnalysisWithCumulants.cxx:975
 AliFlowAnalysisWithCumulants.cxx:976
 AliFlowAnalysisWithCumulants.cxx:977
 AliFlowAnalysisWithCumulants.cxx:978
 AliFlowAnalysisWithCumulants.cxx:979
 AliFlowAnalysisWithCumulants.cxx:980
 AliFlowAnalysisWithCumulants.cxx:981
 AliFlowAnalysisWithCumulants.cxx:982
 AliFlowAnalysisWithCumulants.cxx:983
 AliFlowAnalysisWithCumulants.cxx:984
 AliFlowAnalysisWithCumulants.cxx:985
 AliFlowAnalysisWithCumulants.cxx:986
 AliFlowAnalysisWithCumulants.cxx:987
 AliFlowAnalysisWithCumulants.cxx:988
 AliFlowAnalysisWithCumulants.cxx:989
 AliFlowAnalysisWithCumulants.cxx:990
 AliFlowAnalysisWithCumulants.cxx:991
 AliFlowAnalysisWithCumulants.cxx:992
 AliFlowAnalysisWithCumulants.cxx:993
 AliFlowAnalysisWithCumulants.cxx:994
 AliFlowAnalysisWithCumulants.cxx:995
 AliFlowAnalysisWithCumulants.cxx:996
 AliFlowAnalysisWithCumulants.cxx:997
 AliFlowAnalysisWithCumulants.cxx:998
 AliFlowAnalysisWithCumulants.cxx:999
 AliFlowAnalysisWithCumulants.cxx:1000
 AliFlowAnalysisWithCumulants.cxx:1001
 AliFlowAnalysisWithCumulants.cxx:1002
 AliFlowAnalysisWithCumulants.cxx:1003
 AliFlowAnalysisWithCumulants.cxx:1004
 AliFlowAnalysisWithCumulants.cxx:1005
 AliFlowAnalysisWithCumulants.cxx:1006
 AliFlowAnalysisWithCumulants.cxx:1007
 AliFlowAnalysisWithCumulants.cxx:1008
 AliFlowAnalysisWithCumulants.cxx:1009
 AliFlowAnalysisWithCumulants.cxx:1010
 AliFlowAnalysisWithCumulants.cxx:1011
 AliFlowAnalysisWithCumulants.cxx:1012
 AliFlowAnalysisWithCumulants.cxx:1013
 AliFlowAnalysisWithCumulants.cxx:1014
 AliFlowAnalysisWithCumulants.cxx:1015
 AliFlowAnalysisWithCumulants.cxx:1016
 AliFlowAnalysisWithCumulants.cxx:1017
 AliFlowAnalysisWithCumulants.cxx:1018
 AliFlowAnalysisWithCumulants.cxx:1019
 AliFlowAnalysisWithCumulants.cxx:1020
 AliFlowAnalysisWithCumulants.cxx:1021
 AliFlowAnalysisWithCumulants.cxx:1022
 AliFlowAnalysisWithCumulants.cxx:1023
 AliFlowAnalysisWithCumulants.cxx:1024
 AliFlowAnalysisWithCumulants.cxx:1025
 AliFlowAnalysisWithCumulants.cxx:1026
 AliFlowAnalysisWithCumulants.cxx:1027
 AliFlowAnalysisWithCumulants.cxx:1028
 AliFlowAnalysisWithCumulants.cxx:1029
 AliFlowAnalysisWithCumulants.cxx:1030
 AliFlowAnalysisWithCumulants.cxx:1031
 AliFlowAnalysisWithCumulants.cxx:1032
 AliFlowAnalysisWithCumulants.cxx:1033
 AliFlowAnalysisWithCumulants.cxx:1034
 AliFlowAnalysisWithCumulants.cxx:1035
 AliFlowAnalysisWithCumulants.cxx:1036
 AliFlowAnalysisWithCumulants.cxx:1037
 AliFlowAnalysisWithCumulants.cxx:1038
 AliFlowAnalysisWithCumulants.cxx:1039
 AliFlowAnalysisWithCumulants.cxx:1040
 AliFlowAnalysisWithCumulants.cxx:1041
 AliFlowAnalysisWithCumulants.cxx:1042
 AliFlowAnalysisWithCumulants.cxx:1043
 AliFlowAnalysisWithCumulants.cxx:1044
 AliFlowAnalysisWithCumulants.cxx:1045
 AliFlowAnalysisWithCumulants.cxx:1046
 AliFlowAnalysisWithCumulants.cxx:1047
 AliFlowAnalysisWithCumulants.cxx:1048
 AliFlowAnalysisWithCumulants.cxx:1049
 AliFlowAnalysisWithCumulants.cxx:1050
 AliFlowAnalysisWithCumulants.cxx:1051
 AliFlowAnalysisWithCumulants.cxx:1052
 AliFlowAnalysisWithCumulants.cxx:1053
 AliFlowAnalysisWithCumulants.cxx:1054
 AliFlowAnalysisWithCumulants.cxx:1055
 AliFlowAnalysisWithCumulants.cxx:1056
 AliFlowAnalysisWithCumulants.cxx:1057
 AliFlowAnalysisWithCumulants.cxx:1058
 AliFlowAnalysisWithCumulants.cxx:1059
 AliFlowAnalysisWithCumulants.cxx:1060
 AliFlowAnalysisWithCumulants.cxx:1061
 AliFlowAnalysisWithCumulants.cxx:1062
 AliFlowAnalysisWithCumulants.cxx:1063
 AliFlowAnalysisWithCumulants.cxx:1064
 AliFlowAnalysisWithCumulants.cxx:1065
 AliFlowAnalysisWithCumulants.cxx:1066
 AliFlowAnalysisWithCumulants.cxx:1067
 AliFlowAnalysisWithCumulants.cxx:1068
 AliFlowAnalysisWithCumulants.cxx:1069
 AliFlowAnalysisWithCumulants.cxx:1070
 AliFlowAnalysisWithCumulants.cxx:1071
 AliFlowAnalysisWithCumulants.cxx:1072
 AliFlowAnalysisWithCumulants.cxx:1073
 AliFlowAnalysisWithCumulants.cxx:1074
 AliFlowAnalysisWithCumulants.cxx:1075
 AliFlowAnalysisWithCumulants.cxx:1076
 AliFlowAnalysisWithCumulants.cxx:1077
 AliFlowAnalysisWithCumulants.cxx:1078
 AliFlowAnalysisWithCumulants.cxx:1079
 AliFlowAnalysisWithCumulants.cxx:1080
 AliFlowAnalysisWithCumulants.cxx:1081
 AliFlowAnalysisWithCumulants.cxx:1082
 AliFlowAnalysisWithCumulants.cxx:1083
 AliFlowAnalysisWithCumulants.cxx:1084
 AliFlowAnalysisWithCumulants.cxx:1085
 AliFlowAnalysisWithCumulants.cxx:1086
 AliFlowAnalysisWithCumulants.cxx:1087
 AliFlowAnalysisWithCumulants.cxx:1088
 AliFlowAnalysisWithCumulants.cxx:1089
 AliFlowAnalysisWithCumulants.cxx:1090
 AliFlowAnalysisWithCumulants.cxx:1091
 AliFlowAnalysisWithCumulants.cxx:1092
 AliFlowAnalysisWithCumulants.cxx:1093
 AliFlowAnalysisWithCumulants.cxx:1094
 AliFlowAnalysisWithCumulants.cxx:1095
 AliFlowAnalysisWithCumulants.cxx:1096
 AliFlowAnalysisWithCumulants.cxx:1097
 AliFlowAnalysisWithCumulants.cxx:1098
 AliFlowAnalysisWithCumulants.cxx:1099
 AliFlowAnalysisWithCumulants.cxx:1100
 AliFlowAnalysisWithCumulants.cxx:1101
 AliFlowAnalysisWithCumulants.cxx:1102
 AliFlowAnalysisWithCumulants.cxx:1103
 AliFlowAnalysisWithCumulants.cxx:1104
 AliFlowAnalysisWithCumulants.cxx:1105
 AliFlowAnalysisWithCumulants.cxx:1106
 AliFlowAnalysisWithCumulants.cxx:1107
 AliFlowAnalysisWithCumulants.cxx:1108
 AliFlowAnalysisWithCumulants.cxx:1109
 AliFlowAnalysisWithCumulants.cxx:1110
 AliFlowAnalysisWithCumulants.cxx:1111
 AliFlowAnalysisWithCumulants.cxx:1112
 AliFlowAnalysisWithCumulants.cxx:1113
 AliFlowAnalysisWithCumulants.cxx:1114
 AliFlowAnalysisWithCumulants.cxx:1115
 AliFlowAnalysisWithCumulants.cxx:1116
 AliFlowAnalysisWithCumulants.cxx:1117
 AliFlowAnalysisWithCumulants.cxx:1118
 AliFlowAnalysisWithCumulants.cxx:1119
 AliFlowAnalysisWithCumulants.cxx:1120
 AliFlowAnalysisWithCumulants.cxx:1121
 AliFlowAnalysisWithCumulants.cxx:1122
 AliFlowAnalysisWithCumulants.cxx:1123
 AliFlowAnalysisWithCumulants.cxx:1124
 AliFlowAnalysisWithCumulants.cxx:1125
 AliFlowAnalysisWithCumulants.cxx:1126
 AliFlowAnalysisWithCumulants.cxx:1127
 AliFlowAnalysisWithCumulants.cxx:1128
 AliFlowAnalysisWithCumulants.cxx:1129
 AliFlowAnalysisWithCumulants.cxx:1130
 AliFlowAnalysisWithCumulants.cxx:1131
 AliFlowAnalysisWithCumulants.cxx:1132
 AliFlowAnalysisWithCumulants.cxx:1133
 AliFlowAnalysisWithCumulants.cxx:1134
 AliFlowAnalysisWithCumulants.cxx:1135
 AliFlowAnalysisWithCumulants.cxx:1136
 AliFlowAnalysisWithCumulants.cxx:1137
 AliFlowAnalysisWithCumulants.cxx:1138
 AliFlowAnalysisWithCumulants.cxx:1139
 AliFlowAnalysisWithCumulants.cxx:1140
 AliFlowAnalysisWithCumulants.cxx:1141
 AliFlowAnalysisWithCumulants.cxx:1142
 AliFlowAnalysisWithCumulants.cxx:1143
 AliFlowAnalysisWithCumulants.cxx:1144
 AliFlowAnalysisWithCumulants.cxx:1145
 AliFlowAnalysisWithCumulants.cxx:1146
 AliFlowAnalysisWithCumulants.cxx:1147
 AliFlowAnalysisWithCumulants.cxx:1148
 AliFlowAnalysisWithCumulants.cxx:1149
 AliFlowAnalysisWithCumulants.cxx:1150
 AliFlowAnalysisWithCumulants.cxx:1151
 AliFlowAnalysisWithCumulants.cxx:1152
 AliFlowAnalysisWithCumulants.cxx:1153
 AliFlowAnalysisWithCumulants.cxx:1154
 AliFlowAnalysisWithCumulants.cxx:1155
 AliFlowAnalysisWithCumulants.cxx:1156
 AliFlowAnalysisWithCumulants.cxx:1157
 AliFlowAnalysisWithCumulants.cxx:1158
 AliFlowAnalysisWithCumulants.cxx:1159
 AliFlowAnalysisWithCumulants.cxx:1160
 AliFlowAnalysisWithCumulants.cxx:1161
 AliFlowAnalysisWithCumulants.cxx:1162
 AliFlowAnalysisWithCumulants.cxx:1163
 AliFlowAnalysisWithCumulants.cxx:1164
 AliFlowAnalysisWithCumulants.cxx:1165
 AliFlowAnalysisWithCumulants.cxx:1166
 AliFlowAnalysisWithCumulants.cxx:1167
 AliFlowAnalysisWithCumulants.cxx:1168
 AliFlowAnalysisWithCumulants.cxx:1169
 AliFlowAnalysisWithCumulants.cxx:1170
 AliFlowAnalysisWithCumulants.cxx:1171
 AliFlowAnalysisWithCumulants.cxx:1172
 AliFlowAnalysisWithCumulants.cxx:1173
 AliFlowAnalysisWithCumulants.cxx:1174
 AliFlowAnalysisWithCumulants.cxx:1175
 AliFlowAnalysisWithCumulants.cxx:1176
 AliFlowAnalysisWithCumulants.cxx:1177
 AliFlowAnalysisWithCumulants.cxx:1178
 AliFlowAnalysisWithCumulants.cxx:1179
 AliFlowAnalysisWithCumulants.cxx:1180
 AliFlowAnalysisWithCumulants.cxx:1181
 AliFlowAnalysisWithCumulants.cxx:1182
 AliFlowAnalysisWithCumulants.cxx:1183
 AliFlowAnalysisWithCumulants.cxx:1184
 AliFlowAnalysisWithCumulants.cxx:1185
 AliFlowAnalysisWithCumulants.cxx:1186
 AliFlowAnalysisWithCumulants.cxx:1187
 AliFlowAnalysisWithCumulants.cxx:1188
 AliFlowAnalysisWithCumulants.cxx:1189
 AliFlowAnalysisWithCumulants.cxx:1190
 AliFlowAnalysisWithCumulants.cxx:1191
 AliFlowAnalysisWithCumulants.cxx:1192
 AliFlowAnalysisWithCumulants.cxx:1193
 AliFlowAnalysisWithCumulants.cxx:1194
 AliFlowAnalysisWithCumulants.cxx:1195
 AliFlowAnalysisWithCumulants.cxx:1196
 AliFlowAnalysisWithCumulants.cxx:1197
 AliFlowAnalysisWithCumulants.cxx:1198
 AliFlowAnalysisWithCumulants.cxx:1199
 AliFlowAnalysisWithCumulants.cxx:1200
 AliFlowAnalysisWithCumulants.cxx:1201
 AliFlowAnalysisWithCumulants.cxx:1202
 AliFlowAnalysisWithCumulants.cxx:1203
 AliFlowAnalysisWithCumulants.cxx:1204
 AliFlowAnalysisWithCumulants.cxx:1205
 AliFlowAnalysisWithCumulants.cxx:1206
 AliFlowAnalysisWithCumulants.cxx:1207
 AliFlowAnalysisWithCumulants.cxx:1208
 AliFlowAnalysisWithCumulants.cxx:1209
 AliFlowAnalysisWithCumulants.cxx:1210
 AliFlowAnalysisWithCumulants.cxx:1211
 AliFlowAnalysisWithCumulants.cxx:1212
 AliFlowAnalysisWithCumulants.cxx:1213
 AliFlowAnalysisWithCumulants.cxx:1214
 AliFlowAnalysisWithCumulants.cxx:1215
 AliFlowAnalysisWithCumulants.cxx:1216
 AliFlowAnalysisWithCumulants.cxx:1217
 AliFlowAnalysisWithCumulants.cxx:1218
 AliFlowAnalysisWithCumulants.cxx:1219
 AliFlowAnalysisWithCumulants.cxx:1220
 AliFlowAnalysisWithCumulants.cxx:1221
 AliFlowAnalysisWithCumulants.cxx:1222
 AliFlowAnalysisWithCumulants.cxx:1223
 AliFlowAnalysisWithCumulants.cxx:1224
 AliFlowAnalysisWithCumulants.cxx:1225
 AliFlowAnalysisWithCumulants.cxx:1226
 AliFlowAnalysisWithCumulants.cxx:1227
 AliFlowAnalysisWithCumulants.cxx:1228
 AliFlowAnalysisWithCumulants.cxx:1229
 AliFlowAnalysisWithCumulants.cxx:1230
 AliFlowAnalysisWithCumulants.cxx:1231
 AliFlowAnalysisWithCumulants.cxx:1232
 AliFlowAnalysisWithCumulants.cxx:1233
 AliFlowAnalysisWithCumulants.cxx:1234
 AliFlowAnalysisWithCumulants.cxx:1235
 AliFlowAnalysisWithCumulants.cxx:1236
 AliFlowAnalysisWithCumulants.cxx:1237
 AliFlowAnalysisWithCumulants.cxx:1238
 AliFlowAnalysisWithCumulants.cxx:1239
 AliFlowAnalysisWithCumulants.cxx:1240
 AliFlowAnalysisWithCumulants.cxx:1241
 AliFlowAnalysisWithCumulants.cxx:1242
 AliFlowAnalysisWithCumulants.cxx:1243
 AliFlowAnalysisWithCumulants.cxx:1244
 AliFlowAnalysisWithCumulants.cxx:1245
 AliFlowAnalysisWithCumulants.cxx:1246
 AliFlowAnalysisWithCumulants.cxx:1247
 AliFlowAnalysisWithCumulants.cxx:1248
 AliFlowAnalysisWithCumulants.cxx:1249
 AliFlowAnalysisWithCumulants.cxx:1250
 AliFlowAnalysisWithCumulants.cxx:1251
 AliFlowAnalysisWithCumulants.cxx:1252
 AliFlowAnalysisWithCumulants.cxx:1253
 AliFlowAnalysisWithCumulants.cxx:1254
 AliFlowAnalysisWithCumulants.cxx:1255
 AliFlowAnalysisWithCumulants.cxx:1256
 AliFlowAnalysisWithCumulants.cxx:1257
 AliFlowAnalysisWithCumulants.cxx:1258
 AliFlowAnalysisWithCumulants.cxx:1259
 AliFlowAnalysisWithCumulants.cxx:1260
 AliFlowAnalysisWithCumulants.cxx:1261
 AliFlowAnalysisWithCumulants.cxx:1262
 AliFlowAnalysisWithCumulants.cxx:1263
 AliFlowAnalysisWithCumulants.cxx:1264
 AliFlowAnalysisWithCumulants.cxx:1265
 AliFlowAnalysisWithCumulants.cxx:1266
 AliFlowAnalysisWithCumulants.cxx:1267
 AliFlowAnalysisWithCumulants.cxx:1268
 AliFlowAnalysisWithCumulants.cxx:1269
 AliFlowAnalysisWithCumulants.cxx:1270
 AliFlowAnalysisWithCumulants.cxx:1271
 AliFlowAnalysisWithCumulants.cxx:1272
 AliFlowAnalysisWithCumulants.cxx:1273
 AliFlowAnalysisWithCumulants.cxx:1274
 AliFlowAnalysisWithCumulants.cxx:1275
 AliFlowAnalysisWithCumulants.cxx:1276
 AliFlowAnalysisWithCumulants.cxx:1277
 AliFlowAnalysisWithCumulants.cxx:1278
 AliFlowAnalysisWithCumulants.cxx:1279
 AliFlowAnalysisWithCumulants.cxx:1280
 AliFlowAnalysisWithCumulants.cxx:1281
 AliFlowAnalysisWithCumulants.cxx:1282
 AliFlowAnalysisWithCumulants.cxx:1283
 AliFlowAnalysisWithCumulants.cxx:1284
 AliFlowAnalysisWithCumulants.cxx:1285
 AliFlowAnalysisWithCumulants.cxx:1286
 AliFlowAnalysisWithCumulants.cxx:1287
 AliFlowAnalysisWithCumulants.cxx:1288
 AliFlowAnalysisWithCumulants.cxx:1289
 AliFlowAnalysisWithCumulants.cxx:1290
 AliFlowAnalysisWithCumulants.cxx:1291
 AliFlowAnalysisWithCumulants.cxx:1292
 AliFlowAnalysisWithCumulants.cxx:1293
 AliFlowAnalysisWithCumulants.cxx:1294
 AliFlowAnalysisWithCumulants.cxx:1295
 AliFlowAnalysisWithCumulants.cxx:1296
 AliFlowAnalysisWithCumulants.cxx:1297
 AliFlowAnalysisWithCumulants.cxx:1298
 AliFlowAnalysisWithCumulants.cxx:1299
 AliFlowAnalysisWithCumulants.cxx:1300
 AliFlowAnalysisWithCumulants.cxx:1301
 AliFlowAnalysisWithCumulants.cxx:1302
 AliFlowAnalysisWithCumulants.cxx:1303
 AliFlowAnalysisWithCumulants.cxx:1304
 AliFlowAnalysisWithCumulants.cxx:1305
 AliFlowAnalysisWithCumulants.cxx:1306
 AliFlowAnalysisWithCumulants.cxx:1307
 AliFlowAnalysisWithCumulants.cxx:1308
 AliFlowAnalysisWithCumulants.cxx:1309
 AliFlowAnalysisWithCumulants.cxx:1310
 AliFlowAnalysisWithCumulants.cxx:1311
 AliFlowAnalysisWithCumulants.cxx:1312
 AliFlowAnalysisWithCumulants.cxx:1313
 AliFlowAnalysisWithCumulants.cxx:1314
 AliFlowAnalysisWithCumulants.cxx:1315
 AliFlowAnalysisWithCumulants.cxx:1316
 AliFlowAnalysisWithCumulants.cxx:1317
 AliFlowAnalysisWithCumulants.cxx:1318
 AliFlowAnalysisWithCumulants.cxx:1319
 AliFlowAnalysisWithCumulants.cxx:1320
 AliFlowAnalysisWithCumulants.cxx:1321
 AliFlowAnalysisWithCumulants.cxx:1322
 AliFlowAnalysisWithCumulants.cxx:1323
 AliFlowAnalysisWithCumulants.cxx:1324
 AliFlowAnalysisWithCumulants.cxx:1325
 AliFlowAnalysisWithCumulants.cxx:1326
 AliFlowAnalysisWithCumulants.cxx:1327
 AliFlowAnalysisWithCumulants.cxx:1328
 AliFlowAnalysisWithCumulants.cxx:1329
 AliFlowAnalysisWithCumulants.cxx:1330
 AliFlowAnalysisWithCumulants.cxx:1331
 AliFlowAnalysisWithCumulants.cxx:1332
 AliFlowAnalysisWithCumulants.cxx:1333
 AliFlowAnalysisWithCumulants.cxx:1334
 AliFlowAnalysisWithCumulants.cxx:1335
 AliFlowAnalysisWithCumulants.cxx:1336
 AliFlowAnalysisWithCumulants.cxx:1337
 AliFlowAnalysisWithCumulants.cxx:1338
 AliFlowAnalysisWithCumulants.cxx:1339
 AliFlowAnalysisWithCumulants.cxx:1340
 AliFlowAnalysisWithCumulants.cxx:1341
 AliFlowAnalysisWithCumulants.cxx:1342
 AliFlowAnalysisWithCumulants.cxx:1343
 AliFlowAnalysisWithCumulants.cxx:1344
 AliFlowAnalysisWithCumulants.cxx:1345
 AliFlowAnalysisWithCumulants.cxx:1346
 AliFlowAnalysisWithCumulants.cxx:1347
 AliFlowAnalysisWithCumulants.cxx:1348
 AliFlowAnalysisWithCumulants.cxx:1349
 AliFlowAnalysisWithCumulants.cxx:1350
 AliFlowAnalysisWithCumulants.cxx:1351
 AliFlowAnalysisWithCumulants.cxx:1352
 AliFlowAnalysisWithCumulants.cxx:1353
 AliFlowAnalysisWithCumulants.cxx:1354
 AliFlowAnalysisWithCumulants.cxx:1355
 AliFlowAnalysisWithCumulants.cxx:1356
 AliFlowAnalysisWithCumulants.cxx:1357
 AliFlowAnalysisWithCumulants.cxx:1358
 AliFlowAnalysisWithCumulants.cxx:1359
 AliFlowAnalysisWithCumulants.cxx:1360
 AliFlowAnalysisWithCumulants.cxx:1361
 AliFlowAnalysisWithCumulants.cxx:1362
 AliFlowAnalysisWithCumulants.cxx:1363
 AliFlowAnalysisWithCumulants.cxx:1364
 AliFlowAnalysisWithCumulants.cxx:1365
 AliFlowAnalysisWithCumulants.cxx:1366
 AliFlowAnalysisWithCumulants.cxx:1367
 AliFlowAnalysisWithCumulants.cxx:1368
 AliFlowAnalysisWithCumulants.cxx:1369
 AliFlowAnalysisWithCumulants.cxx:1370
 AliFlowAnalysisWithCumulants.cxx:1371
 AliFlowAnalysisWithCumulants.cxx:1372
 AliFlowAnalysisWithCumulants.cxx:1373
 AliFlowAnalysisWithCumulants.cxx:1374
 AliFlowAnalysisWithCumulants.cxx:1375
 AliFlowAnalysisWithCumulants.cxx:1376
 AliFlowAnalysisWithCumulants.cxx:1377
 AliFlowAnalysisWithCumulants.cxx:1378
 AliFlowAnalysisWithCumulants.cxx:1379
 AliFlowAnalysisWithCumulants.cxx:1380
 AliFlowAnalysisWithCumulants.cxx:1381
 AliFlowAnalysisWithCumulants.cxx:1382
 AliFlowAnalysisWithCumulants.cxx:1383
 AliFlowAnalysisWithCumulants.cxx:1384
 AliFlowAnalysisWithCumulants.cxx:1385
 AliFlowAnalysisWithCumulants.cxx:1386
 AliFlowAnalysisWithCumulants.cxx:1387
 AliFlowAnalysisWithCumulants.cxx:1388
 AliFlowAnalysisWithCumulants.cxx:1389
 AliFlowAnalysisWithCumulants.cxx:1390
 AliFlowAnalysisWithCumulants.cxx:1391
 AliFlowAnalysisWithCumulants.cxx:1392
 AliFlowAnalysisWithCumulants.cxx:1393
 AliFlowAnalysisWithCumulants.cxx:1394
 AliFlowAnalysisWithCumulants.cxx:1395
 AliFlowAnalysisWithCumulants.cxx:1396
 AliFlowAnalysisWithCumulants.cxx:1397
 AliFlowAnalysisWithCumulants.cxx:1398
 AliFlowAnalysisWithCumulants.cxx:1399
 AliFlowAnalysisWithCumulants.cxx:1400
 AliFlowAnalysisWithCumulants.cxx:1401
 AliFlowAnalysisWithCumulants.cxx:1402
 AliFlowAnalysisWithCumulants.cxx:1403
 AliFlowAnalysisWithCumulants.cxx:1404
 AliFlowAnalysisWithCumulants.cxx:1405
 AliFlowAnalysisWithCumulants.cxx:1406
 AliFlowAnalysisWithCumulants.cxx:1407
 AliFlowAnalysisWithCumulants.cxx:1408
 AliFlowAnalysisWithCumulants.cxx:1409
 AliFlowAnalysisWithCumulants.cxx:1410
 AliFlowAnalysisWithCumulants.cxx:1411
 AliFlowAnalysisWithCumulants.cxx:1412
 AliFlowAnalysisWithCumulants.cxx:1413
 AliFlowAnalysisWithCumulants.cxx:1414
 AliFlowAnalysisWithCumulants.cxx:1415
 AliFlowAnalysisWithCumulants.cxx:1416
 AliFlowAnalysisWithCumulants.cxx:1417
 AliFlowAnalysisWithCumulants.cxx:1418
 AliFlowAnalysisWithCumulants.cxx:1419
 AliFlowAnalysisWithCumulants.cxx:1420
 AliFlowAnalysisWithCumulants.cxx:1421
 AliFlowAnalysisWithCumulants.cxx:1422
 AliFlowAnalysisWithCumulants.cxx:1423
 AliFlowAnalysisWithCumulants.cxx:1424
 AliFlowAnalysisWithCumulants.cxx:1425
 AliFlowAnalysisWithCumulants.cxx:1426
 AliFlowAnalysisWithCumulants.cxx:1427
 AliFlowAnalysisWithCumulants.cxx:1428
 AliFlowAnalysisWithCumulants.cxx:1429
 AliFlowAnalysisWithCumulants.cxx:1430
 AliFlowAnalysisWithCumulants.cxx:1431
 AliFlowAnalysisWithCumulants.cxx:1432
 AliFlowAnalysisWithCumulants.cxx:1433
 AliFlowAnalysisWithCumulants.cxx:1434
 AliFlowAnalysisWithCumulants.cxx:1435
 AliFlowAnalysisWithCumulants.cxx:1436
 AliFlowAnalysisWithCumulants.cxx:1437
 AliFlowAnalysisWithCumulants.cxx:1438
 AliFlowAnalysisWithCumulants.cxx:1439
 AliFlowAnalysisWithCumulants.cxx:1440
 AliFlowAnalysisWithCumulants.cxx:1441
 AliFlowAnalysisWithCumulants.cxx:1442
 AliFlowAnalysisWithCumulants.cxx:1443
 AliFlowAnalysisWithCumulants.cxx:1444
 AliFlowAnalysisWithCumulants.cxx:1445
 AliFlowAnalysisWithCumulants.cxx:1446
 AliFlowAnalysisWithCumulants.cxx:1447
 AliFlowAnalysisWithCumulants.cxx:1448
 AliFlowAnalysisWithCumulants.cxx:1449
 AliFlowAnalysisWithCumulants.cxx:1450
 AliFlowAnalysisWithCumulants.cxx:1451
 AliFlowAnalysisWithCumulants.cxx:1452
 AliFlowAnalysisWithCumulants.cxx:1453
 AliFlowAnalysisWithCumulants.cxx:1454
 AliFlowAnalysisWithCumulants.cxx:1455
 AliFlowAnalysisWithCumulants.cxx:1456
 AliFlowAnalysisWithCumulants.cxx:1457
 AliFlowAnalysisWithCumulants.cxx:1458
 AliFlowAnalysisWithCumulants.cxx:1459
 AliFlowAnalysisWithCumulants.cxx:1460
 AliFlowAnalysisWithCumulants.cxx:1461
 AliFlowAnalysisWithCumulants.cxx:1462
 AliFlowAnalysisWithCumulants.cxx:1463
 AliFlowAnalysisWithCumulants.cxx:1464
 AliFlowAnalysisWithCumulants.cxx:1465
 AliFlowAnalysisWithCumulants.cxx:1466
 AliFlowAnalysisWithCumulants.cxx:1467
 AliFlowAnalysisWithCumulants.cxx:1468
 AliFlowAnalysisWithCumulants.cxx:1469
 AliFlowAnalysisWithCumulants.cxx:1470
 AliFlowAnalysisWithCumulants.cxx:1471
 AliFlowAnalysisWithCumulants.cxx:1472
 AliFlowAnalysisWithCumulants.cxx:1473
 AliFlowAnalysisWithCumulants.cxx:1474
 AliFlowAnalysisWithCumulants.cxx:1475
 AliFlowAnalysisWithCumulants.cxx:1476
 AliFlowAnalysisWithCumulants.cxx:1477
 AliFlowAnalysisWithCumulants.cxx:1478
 AliFlowAnalysisWithCumulants.cxx:1479
 AliFlowAnalysisWithCumulants.cxx:1480
 AliFlowAnalysisWithCumulants.cxx:1481
 AliFlowAnalysisWithCumulants.cxx:1482
 AliFlowAnalysisWithCumulants.cxx:1483
 AliFlowAnalysisWithCumulants.cxx:1484
 AliFlowAnalysisWithCumulants.cxx:1485
 AliFlowAnalysisWithCumulants.cxx:1486
 AliFlowAnalysisWithCumulants.cxx:1487
 AliFlowAnalysisWithCumulants.cxx:1488
 AliFlowAnalysisWithCumulants.cxx:1489
 AliFlowAnalysisWithCumulants.cxx:1490
 AliFlowAnalysisWithCumulants.cxx:1491
 AliFlowAnalysisWithCumulants.cxx:1492
 AliFlowAnalysisWithCumulants.cxx:1493
 AliFlowAnalysisWithCumulants.cxx:1494
 AliFlowAnalysisWithCumulants.cxx:1495
 AliFlowAnalysisWithCumulants.cxx:1496
 AliFlowAnalysisWithCumulants.cxx:1497
 AliFlowAnalysisWithCumulants.cxx:1498
 AliFlowAnalysisWithCumulants.cxx:1499
 AliFlowAnalysisWithCumulants.cxx:1500
 AliFlowAnalysisWithCumulants.cxx:1501
 AliFlowAnalysisWithCumulants.cxx:1502
 AliFlowAnalysisWithCumulants.cxx:1503
 AliFlowAnalysisWithCumulants.cxx:1504
 AliFlowAnalysisWithCumulants.cxx:1505
 AliFlowAnalysisWithCumulants.cxx:1506
 AliFlowAnalysisWithCumulants.cxx:1507
 AliFlowAnalysisWithCumulants.cxx:1508
 AliFlowAnalysisWithCumulants.cxx:1509
 AliFlowAnalysisWithCumulants.cxx:1510
 AliFlowAnalysisWithCumulants.cxx:1511
 AliFlowAnalysisWithCumulants.cxx:1512
 AliFlowAnalysisWithCumulants.cxx:1513
 AliFlowAnalysisWithCumulants.cxx:1514
 AliFlowAnalysisWithCumulants.cxx:1515
 AliFlowAnalysisWithCumulants.cxx:1516
 AliFlowAnalysisWithCumulants.cxx:1517
 AliFlowAnalysisWithCumulants.cxx:1518
 AliFlowAnalysisWithCumulants.cxx:1519
 AliFlowAnalysisWithCumulants.cxx:1520
 AliFlowAnalysisWithCumulants.cxx:1521
 AliFlowAnalysisWithCumulants.cxx:1522
 AliFlowAnalysisWithCumulants.cxx:1523
 AliFlowAnalysisWithCumulants.cxx:1524
 AliFlowAnalysisWithCumulants.cxx:1525
 AliFlowAnalysisWithCumulants.cxx:1526
 AliFlowAnalysisWithCumulants.cxx:1527
 AliFlowAnalysisWithCumulants.cxx:1528
 AliFlowAnalysisWithCumulants.cxx:1529
 AliFlowAnalysisWithCumulants.cxx:1530
 AliFlowAnalysisWithCumulants.cxx:1531
 AliFlowAnalysisWithCumulants.cxx:1532
 AliFlowAnalysisWithCumulants.cxx:1533
 AliFlowAnalysisWithCumulants.cxx:1534
 AliFlowAnalysisWithCumulants.cxx:1535
 AliFlowAnalysisWithCumulants.cxx:1536
 AliFlowAnalysisWithCumulants.cxx:1537
 AliFlowAnalysisWithCumulants.cxx:1538
 AliFlowAnalysisWithCumulants.cxx:1539
 AliFlowAnalysisWithCumulants.cxx:1540
 AliFlowAnalysisWithCumulants.cxx:1541
 AliFlowAnalysisWithCumulants.cxx:1542
 AliFlowAnalysisWithCumulants.cxx:1543
 AliFlowAnalysisWithCumulants.cxx:1544
 AliFlowAnalysisWithCumulants.cxx:1545
 AliFlowAnalysisWithCumulants.cxx:1546
 AliFlowAnalysisWithCumulants.cxx:1547
 AliFlowAnalysisWithCumulants.cxx:1548
 AliFlowAnalysisWithCumulants.cxx:1549
 AliFlowAnalysisWithCumulants.cxx:1550
 AliFlowAnalysisWithCumulants.cxx:1551
 AliFlowAnalysisWithCumulants.cxx:1552
 AliFlowAnalysisWithCumulants.cxx:1553
 AliFlowAnalysisWithCumulants.cxx:1554
 AliFlowAnalysisWithCumulants.cxx:1555
 AliFlowAnalysisWithCumulants.cxx:1556
 AliFlowAnalysisWithCumulants.cxx:1557
 AliFlowAnalysisWithCumulants.cxx:1558
 AliFlowAnalysisWithCumulants.cxx:1559
 AliFlowAnalysisWithCumulants.cxx:1560
 AliFlowAnalysisWithCumulants.cxx:1561
 AliFlowAnalysisWithCumulants.cxx:1562
 AliFlowAnalysisWithCumulants.cxx:1563
 AliFlowAnalysisWithCumulants.cxx:1564
 AliFlowAnalysisWithCumulants.cxx:1565
 AliFlowAnalysisWithCumulants.cxx:1566
 AliFlowAnalysisWithCumulants.cxx:1567
 AliFlowAnalysisWithCumulants.cxx:1568
 AliFlowAnalysisWithCumulants.cxx:1569
 AliFlowAnalysisWithCumulants.cxx:1570
 AliFlowAnalysisWithCumulants.cxx:1571
 AliFlowAnalysisWithCumulants.cxx:1572
 AliFlowAnalysisWithCumulants.cxx:1573
 AliFlowAnalysisWithCumulants.cxx:1574
 AliFlowAnalysisWithCumulants.cxx:1575
 AliFlowAnalysisWithCumulants.cxx:1576
 AliFlowAnalysisWithCumulants.cxx:1577
 AliFlowAnalysisWithCumulants.cxx:1578
 AliFlowAnalysisWithCumulants.cxx:1579
 AliFlowAnalysisWithCumulants.cxx:1580
 AliFlowAnalysisWithCumulants.cxx:1581
 AliFlowAnalysisWithCumulants.cxx:1582
 AliFlowAnalysisWithCumulants.cxx:1583
 AliFlowAnalysisWithCumulants.cxx:1584
 AliFlowAnalysisWithCumulants.cxx:1585
 AliFlowAnalysisWithCumulants.cxx:1586
 AliFlowAnalysisWithCumulants.cxx:1587
 AliFlowAnalysisWithCumulants.cxx:1588
 AliFlowAnalysisWithCumulants.cxx:1589
 AliFlowAnalysisWithCumulants.cxx:1590
 AliFlowAnalysisWithCumulants.cxx:1591
 AliFlowAnalysisWithCumulants.cxx:1592
 AliFlowAnalysisWithCumulants.cxx:1593
 AliFlowAnalysisWithCumulants.cxx:1594
 AliFlowAnalysisWithCumulants.cxx:1595
 AliFlowAnalysisWithCumulants.cxx:1596
 AliFlowAnalysisWithCumulants.cxx:1597
 AliFlowAnalysisWithCumulants.cxx:1598
 AliFlowAnalysisWithCumulants.cxx:1599
 AliFlowAnalysisWithCumulants.cxx:1600
 AliFlowAnalysisWithCumulants.cxx:1601
 AliFlowAnalysisWithCumulants.cxx:1602
 AliFlowAnalysisWithCumulants.cxx:1603
 AliFlowAnalysisWithCumulants.cxx:1604
 AliFlowAnalysisWithCumulants.cxx:1605
 AliFlowAnalysisWithCumulants.cxx:1606
 AliFlowAnalysisWithCumulants.cxx:1607
 AliFlowAnalysisWithCumulants.cxx:1608
 AliFlowAnalysisWithCumulants.cxx:1609
 AliFlowAnalysisWithCumulants.cxx:1610
 AliFlowAnalysisWithCumulants.cxx:1611
 AliFlowAnalysisWithCumulants.cxx:1612
 AliFlowAnalysisWithCumulants.cxx:1613
 AliFlowAnalysisWithCumulants.cxx:1614
 AliFlowAnalysisWithCumulants.cxx:1615
 AliFlowAnalysisWithCumulants.cxx:1616
 AliFlowAnalysisWithCumulants.cxx:1617
 AliFlowAnalysisWithCumulants.cxx:1618
 AliFlowAnalysisWithCumulants.cxx:1619
 AliFlowAnalysisWithCumulants.cxx:1620
 AliFlowAnalysisWithCumulants.cxx:1621
 AliFlowAnalysisWithCumulants.cxx:1622
 AliFlowAnalysisWithCumulants.cxx:1623
 AliFlowAnalysisWithCumulants.cxx:1624
 AliFlowAnalysisWithCumulants.cxx:1625
 AliFlowAnalysisWithCumulants.cxx:1626
 AliFlowAnalysisWithCumulants.cxx:1627
 AliFlowAnalysisWithCumulants.cxx:1628
 AliFlowAnalysisWithCumulants.cxx:1629
 AliFlowAnalysisWithCumulants.cxx:1630
 AliFlowAnalysisWithCumulants.cxx:1631
 AliFlowAnalysisWithCumulants.cxx:1632
 AliFlowAnalysisWithCumulants.cxx:1633
 AliFlowAnalysisWithCumulants.cxx:1634
 AliFlowAnalysisWithCumulants.cxx:1635
 AliFlowAnalysisWithCumulants.cxx:1636
 AliFlowAnalysisWithCumulants.cxx:1637
 AliFlowAnalysisWithCumulants.cxx:1638
 AliFlowAnalysisWithCumulants.cxx:1639
 AliFlowAnalysisWithCumulants.cxx:1640
 AliFlowAnalysisWithCumulants.cxx:1641
 AliFlowAnalysisWithCumulants.cxx:1642
 AliFlowAnalysisWithCumulants.cxx:1643
 AliFlowAnalysisWithCumulants.cxx:1644
 AliFlowAnalysisWithCumulants.cxx:1645
 AliFlowAnalysisWithCumulants.cxx:1646
 AliFlowAnalysisWithCumulants.cxx:1647
 AliFlowAnalysisWithCumulants.cxx:1648
 AliFlowAnalysisWithCumulants.cxx:1649
 AliFlowAnalysisWithCumulants.cxx:1650
 AliFlowAnalysisWithCumulants.cxx:1651
 AliFlowAnalysisWithCumulants.cxx:1652
 AliFlowAnalysisWithCumulants.cxx:1653
 AliFlowAnalysisWithCumulants.cxx:1654
 AliFlowAnalysisWithCumulants.cxx:1655
 AliFlowAnalysisWithCumulants.cxx:1656
 AliFlowAnalysisWithCumulants.cxx:1657
 AliFlowAnalysisWithCumulants.cxx:1658
 AliFlowAnalysisWithCumulants.cxx:1659
 AliFlowAnalysisWithCumulants.cxx:1660
 AliFlowAnalysisWithCumulants.cxx:1661
 AliFlowAnalysisWithCumulants.cxx:1662
 AliFlowAnalysisWithCumulants.cxx:1663
 AliFlowAnalysisWithCumulants.cxx:1664
 AliFlowAnalysisWithCumulants.cxx:1665
 AliFlowAnalysisWithCumulants.cxx:1666
 AliFlowAnalysisWithCumulants.cxx:1667
 AliFlowAnalysisWithCumulants.cxx:1668
 AliFlowAnalysisWithCumulants.cxx:1669
 AliFlowAnalysisWithCumulants.cxx:1670
 AliFlowAnalysisWithCumulants.cxx:1671
 AliFlowAnalysisWithCumulants.cxx:1672
 AliFlowAnalysisWithCumulants.cxx:1673
 AliFlowAnalysisWithCumulants.cxx:1674
 AliFlowAnalysisWithCumulants.cxx:1675
 AliFlowAnalysisWithCumulants.cxx:1676
 AliFlowAnalysisWithCumulants.cxx:1677
 AliFlowAnalysisWithCumulants.cxx:1678
 AliFlowAnalysisWithCumulants.cxx:1679
 AliFlowAnalysisWithCumulants.cxx:1680
 AliFlowAnalysisWithCumulants.cxx:1681
 AliFlowAnalysisWithCumulants.cxx:1682
 AliFlowAnalysisWithCumulants.cxx:1683
 AliFlowAnalysisWithCumulants.cxx:1684
 AliFlowAnalysisWithCumulants.cxx:1685
 AliFlowAnalysisWithCumulants.cxx:1686
 AliFlowAnalysisWithCumulants.cxx:1687
 AliFlowAnalysisWithCumulants.cxx:1688
 AliFlowAnalysisWithCumulants.cxx:1689
 AliFlowAnalysisWithCumulants.cxx:1690
 AliFlowAnalysisWithCumulants.cxx:1691
 AliFlowAnalysisWithCumulants.cxx:1692
 AliFlowAnalysisWithCumulants.cxx:1693
 AliFlowAnalysisWithCumulants.cxx:1694
 AliFlowAnalysisWithCumulants.cxx:1695
 AliFlowAnalysisWithCumulants.cxx:1696
 AliFlowAnalysisWithCumulants.cxx:1697
 AliFlowAnalysisWithCumulants.cxx:1698
 AliFlowAnalysisWithCumulants.cxx:1699
 AliFlowAnalysisWithCumulants.cxx:1700
 AliFlowAnalysisWithCumulants.cxx:1701
 AliFlowAnalysisWithCumulants.cxx:1702
 AliFlowAnalysisWithCumulants.cxx:1703
 AliFlowAnalysisWithCumulants.cxx:1704
 AliFlowAnalysisWithCumulants.cxx:1705
 AliFlowAnalysisWithCumulants.cxx:1706
 AliFlowAnalysisWithCumulants.cxx:1707
 AliFlowAnalysisWithCumulants.cxx:1708
 AliFlowAnalysisWithCumulants.cxx:1709
 AliFlowAnalysisWithCumulants.cxx:1710
 AliFlowAnalysisWithCumulants.cxx:1711
 AliFlowAnalysisWithCumulants.cxx:1712
 AliFlowAnalysisWithCumulants.cxx:1713
 AliFlowAnalysisWithCumulants.cxx:1714
 AliFlowAnalysisWithCumulants.cxx:1715
 AliFlowAnalysisWithCumulants.cxx:1716
 AliFlowAnalysisWithCumulants.cxx:1717
 AliFlowAnalysisWithCumulants.cxx:1718
 AliFlowAnalysisWithCumulants.cxx:1719
 AliFlowAnalysisWithCumulants.cxx:1720
 AliFlowAnalysisWithCumulants.cxx:1721
 AliFlowAnalysisWithCumulants.cxx:1722
 AliFlowAnalysisWithCumulants.cxx:1723
 AliFlowAnalysisWithCumulants.cxx:1724
 AliFlowAnalysisWithCumulants.cxx:1725
 AliFlowAnalysisWithCumulants.cxx:1726
 AliFlowAnalysisWithCumulants.cxx:1727
 AliFlowAnalysisWithCumulants.cxx:1728
 AliFlowAnalysisWithCumulants.cxx:1729
 AliFlowAnalysisWithCumulants.cxx:1730
 AliFlowAnalysisWithCumulants.cxx:1731
 AliFlowAnalysisWithCumulants.cxx:1732
 AliFlowAnalysisWithCumulants.cxx:1733
 AliFlowAnalysisWithCumulants.cxx:1734
 AliFlowAnalysisWithCumulants.cxx:1735
 AliFlowAnalysisWithCumulants.cxx:1736
 AliFlowAnalysisWithCumulants.cxx:1737
 AliFlowAnalysisWithCumulants.cxx:1738
 AliFlowAnalysisWithCumulants.cxx:1739
 AliFlowAnalysisWithCumulants.cxx:1740
 AliFlowAnalysisWithCumulants.cxx:1741
 AliFlowAnalysisWithCumulants.cxx:1742
 AliFlowAnalysisWithCumulants.cxx:1743
 AliFlowAnalysisWithCumulants.cxx:1744
 AliFlowAnalysisWithCumulants.cxx:1745
 AliFlowAnalysisWithCumulants.cxx:1746
 AliFlowAnalysisWithCumulants.cxx:1747
 AliFlowAnalysisWithCumulants.cxx:1748
 AliFlowAnalysisWithCumulants.cxx:1749
 AliFlowAnalysisWithCumulants.cxx:1750
 AliFlowAnalysisWithCumulants.cxx:1751
 AliFlowAnalysisWithCumulants.cxx:1752
 AliFlowAnalysisWithCumulants.cxx:1753
 AliFlowAnalysisWithCumulants.cxx:1754
 AliFlowAnalysisWithCumulants.cxx:1755
 AliFlowAnalysisWithCumulants.cxx:1756
 AliFlowAnalysisWithCumulants.cxx:1757
 AliFlowAnalysisWithCumulants.cxx:1758
 AliFlowAnalysisWithCumulants.cxx:1759
 AliFlowAnalysisWithCumulants.cxx:1760
 AliFlowAnalysisWithCumulants.cxx:1761
 AliFlowAnalysisWithCumulants.cxx:1762
 AliFlowAnalysisWithCumulants.cxx:1763
 AliFlowAnalysisWithCumulants.cxx:1764
 AliFlowAnalysisWithCumulants.cxx:1765
 AliFlowAnalysisWithCumulants.cxx:1766
 AliFlowAnalysisWithCumulants.cxx:1767
 AliFlowAnalysisWithCumulants.cxx:1768
 AliFlowAnalysisWithCumulants.cxx:1769
 AliFlowAnalysisWithCumulants.cxx:1770
 AliFlowAnalysisWithCumulants.cxx:1771
 AliFlowAnalysisWithCumulants.cxx:1772
 AliFlowAnalysisWithCumulants.cxx:1773
 AliFlowAnalysisWithCumulants.cxx:1774
 AliFlowAnalysisWithCumulants.cxx:1775
 AliFlowAnalysisWithCumulants.cxx:1776
 AliFlowAnalysisWithCumulants.cxx:1777
 AliFlowAnalysisWithCumulants.cxx:1778
 AliFlowAnalysisWithCumulants.cxx:1779
 AliFlowAnalysisWithCumulants.cxx:1780
 AliFlowAnalysisWithCumulants.cxx:1781
 AliFlowAnalysisWithCumulants.cxx:1782
 AliFlowAnalysisWithCumulants.cxx:1783
 AliFlowAnalysisWithCumulants.cxx:1784
 AliFlowAnalysisWithCumulants.cxx:1785
 AliFlowAnalysisWithCumulants.cxx:1786
 AliFlowAnalysisWithCumulants.cxx:1787
 AliFlowAnalysisWithCumulants.cxx:1788
 AliFlowAnalysisWithCumulants.cxx:1789
 AliFlowAnalysisWithCumulants.cxx:1790
 AliFlowAnalysisWithCumulants.cxx:1791
 AliFlowAnalysisWithCumulants.cxx:1792
 AliFlowAnalysisWithCumulants.cxx:1793
 AliFlowAnalysisWithCumulants.cxx:1794
 AliFlowAnalysisWithCumulants.cxx:1795
 AliFlowAnalysisWithCumulants.cxx:1796
 AliFlowAnalysisWithCumulants.cxx:1797
 AliFlowAnalysisWithCumulants.cxx:1798
 AliFlowAnalysisWithCumulants.cxx:1799
 AliFlowAnalysisWithCumulants.cxx:1800
 AliFlowAnalysisWithCumulants.cxx:1801
 AliFlowAnalysisWithCumulants.cxx:1802
 AliFlowAnalysisWithCumulants.cxx:1803
 AliFlowAnalysisWithCumulants.cxx:1804
 AliFlowAnalysisWithCumulants.cxx:1805
 AliFlowAnalysisWithCumulants.cxx:1806
 AliFlowAnalysisWithCumulants.cxx:1807
 AliFlowAnalysisWithCumulants.cxx:1808
 AliFlowAnalysisWithCumulants.cxx:1809
 AliFlowAnalysisWithCumulants.cxx:1810
 AliFlowAnalysisWithCumulants.cxx:1811
 AliFlowAnalysisWithCumulants.cxx:1812
 AliFlowAnalysisWithCumulants.cxx:1813
 AliFlowAnalysisWithCumulants.cxx:1814
 AliFlowAnalysisWithCumulants.cxx:1815
 AliFlowAnalysisWithCumulants.cxx:1816
 AliFlowAnalysisWithCumulants.cxx:1817
 AliFlowAnalysisWithCumulants.cxx:1818
 AliFlowAnalysisWithCumulants.cxx:1819
 AliFlowAnalysisWithCumulants.cxx:1820
 AliFlowAnalysisWithCumulants.cxx:1821
 AliFlowAnalysisWithCumulants.cxx:1822
 AliFlowAnalysisWithCumulants.cxx:1823
 AliFlowAnalysisWithCumulants.cxx:1824
 AliFlowAnalysisWithCumulants.cxx:1825
 AliFlowAnalysisWithCumulants.cxx:1826
 AliFlowAnalysisWithCumulants.cxx:1827
 AliFlowAnalysisWithCumulants.cxx:1828
 AliFlowAnalysisWithCumulants.cxx:1829
 AliFlowAnalysisWithCumulants.cxx:1830
 AliFlowAnalysisWithCumulants.cxx:1831
 AliFlowAnalysisWithCumulants.cxx:1832
 AliFlowAnalysisWithCumulants.cxx:1833
 AliFlowAnalysisWithCumulants.cxx:1834
 AliFlowAnalysisWithCumulants.cxx:1835
 AliFlowAnalysisWithCumulants.cxx:1836
 AliFlowAnalysisWithCumulants.cxx:1837
 AliFlowAnalysisWithCumulants.cxx:1838
 AliFlowAnalysisWithCumulants.cxx:1839
 AliFlowAnalysisWithCumulants.cxx:1840
 AliFlowAnalysisWithCumulants.cxx:1841
 AliFlowAnalysisWithCumulants.cxx:1842
 AliFlowAnalysisWithCumulants.cxx:1843
 AliFlowAnalysisWithCumulants.cxx:1844
 AliFlowAnalysisWithCumulants.cxx:1845
 AliFlowAnalysisWithCumulants.cxx:1846
 AliFlowAnalysisWithCumulants.cxx:1847
 AliFlowAnalysisWithCumulants.cxx:1848
 AliFlowAnalysisWithCumulants.cxx:1849
 AliFlowAnalysisWithCumulants.cxx:1850
 AliFlowAnalysisWithCumulants.cxx:1851
 AliFlowAnalysisWithCumulants.cxx:1852
 AliFlowAnalysisWithCumulants.cxx:1853
 AliFlowAnalysisWithCumulants.cxx:1854
 AliFlowAnalysisWithCumulants.cxx:1855
 AliFlowAnalysisWithCumulants.cxx:1856
 AliFlowAnalysisWithCumulants.cxx:1857
 AliFlowAnalysisWithCumulants.cxx:1858
 AliFlowAnalysisWithCumulants.cxx:1859
 AliFlowAnalysisWithCumulants.cxx:1860
 AliFlowAnalysisWithCumulants.cxx:1861
 AliFlowAnalysisWithCumulants.cxx:1862
 AliFlowAnalysisWithCumulants.cxx:1863
 AliFlowAnalysisWithCumulants.cxx:1864
 AliFlowAnalysisWithCumulants.cxx:1865
 AliFlowAnalysisWithCumulants.cxx:1866
 AliFlowAnalysisWithCumulants.cxx:1867
 AliFlowAnalysisWithCumulants.cxx:1868
 AliFlowAnalysisWithCumulants.cxx:1869
 AliFlowAnalysisWithCumulants.cxx:1870
 AliFlowAnalysisWithCumulants.cxx:1871
 AliFlowAnalysisWithCumulants.cxx:1872
 AliFlowAnalysisWithCumulants.cxx:1873
 AliFlowAnalysisWithCumulants.cxx:1874
 AliFlowAnalysisWithCumulants.cxx:1875
 AliFlowAnalysisWithCumulants.cxx:1876
 AliFlowAnalysisWithCumulants.cxx:1877
 AliFlowAnalysisWithCumulants.cxx:1878
 AliFlowAnalysisWithCumulants.cxx:1879
 AliFlowAnalysisWithCumulants.cxx:1880
 AliFlowAnalysisWithCumulants.cxx:1881
 AliFlowAnalysisWithCumulants.cxx:1882
 AliFlowAnalysisWithCumulants.cxx:1883
 AliFlowAnalysisWithCumulants.cxx:1884
 AliFlowAnalysisWithCumulants.cxx:1885
 AliFlowAnalysisWithCumulants.cxx:1886
 AliFlowAnalysisWithCumulants.cxx:1887
 AliFlowAnalysisWithCumulants.cxx:1888
 AliFlowAnalysisWithCumulants.cxx:1889
 AliFlowAnalysisWithCumulants.cxx:1890
 AliFlowAnalysisWithCumulants.cxx:1891
 AliFlowAnalysisWithCumulants.cxx:1892
 AliFlowAnalysisWithCumulants.cxx:1893
 AliFlowAnalysisWithCumulants.cxx:1894
 AliFlowAnalysisWithCumulants.cxx:1895
 AliFlowAnalysisWithCumulants.cxx:1896
 AliFlowAnalysisWithCumulants.cxx:1897
 AliFlowAnalysisWithCumulants.cxx:1898
 AliFlowAnalysisWithCumulants.cxx:1899
 AliFlowAnalysisWithCumulants.cxx:1900
 AliFlowAnalysisWithCumulants.cxx:1901
 AliFlowAnalysisWithCumulants.cxx:1902
 AliFlowAnalysisWithCumulants.cxx:1903
 AliFlowAnalysisWithCumulants.cxx:1904
 AliFlowAnalysisWithCumulants.cxx:1905
 AliFlowAnalysisWithCumulants.cxx:1906
 AliFlowAnalysisWithCumulants.cxx:1907
 AliFlowAnalysisWithCumulants.cxx:1908
 AliFlowAnalysisWithCumulants.cxx:1909
 AliFlowAnalysisWithCumulants.cxx:1910
 AliFlowAnalysisWithCumulants.cxx:1911
 AliFlowAnalysisWithCumulants.cxx:1912
 AliFlowAnalysisWithCumulants.cxx:1913
 AliFlowAnalysisWithCumulants.cxx:1914
 AliFlowAnalysisWithCumulants.cxx:1915
 AliFlowAnalysisWithCumulants.cxx:1916
 AliFlowAnalysisWithCumulants.cxx:1917
 AliFlowAnalysisWithCumulants.cxx:1918
 AliFlowAnalysisWithCumulants.cxx:1919
 AliFlowAnalysisWithCumulants.cxx:1920
 AliFlowAnalysisWithCumulants.cxx:1921
 AliFlowAnalysisWithCumulants.cxx:1922
 AliFlowAnalysisWithCumulants.cxx:1923
 AliFlowAnalysisWithCumulants.cxx:1924
 AliFlowAnalysisWithCumulants.cxx:1925
 AliFlowAnalysisWithCumulants.cxx:1926
 AliFlowAnalysisWithCumulants.cxx:1927
 AliFlowAnalysisWithCumulants.cxx:1928
 AliFlowAnalysisWithCumulants.cxx:1929
 AliFlowAnalysisWithCumulants.cxx:1930
 AliFlowAnalysisWithCumulants.cxx:1931
 AliFlowAnalysisWithCumulants.cxx:1932
 AliFlowAnalysisWithCumulants.cxx:1933
 AliFlowAnalysisWithCumulants.cxx:1934
 AliFlowAnalysisWithCumulants.cxx:1935
 AliFlowAnalysisWithCumulants.cxx:1936
 AliFlowAnalysisWithCumulants.cxx:1937
 AliFlowAnalysisWithCumulants.cxx:1938
 AliFlowAnalysisWithCumulants.cxx:1939
 AliFlowAnalysisWithCumulants.cxx:1940
 AliFlowAnalysisWithCumulants.cxx:1941
 AliFlowAnalysisWithCumulants.cxx:1942
 AliFlowAnalysisWithCumulants.cxx:1943
 AliFlowAnalysisWithCumulants.cxx:1944
 AliFlowAnalysisWithCumulants.cxx:1945
 AliFlowAnalysisWithCumulants.cxx:1946
 AliFlowAnalysisWithCumulants.cxx:1947
 AliFlowAnalysisWithCumulants.cxx:1948
 AliFlowAnalysisWithCumulants.cxx:1949
 AliFlowAnalysisWithCumulants.cxx:1950
 AliFlowAnalysisWithCumulants.cxx:1951
 AliFlowAnalysisWithCumulants.cxx:1952
 AliFlowAnalysisWithCumulants.cxx:1953
 AliFlowAnalysisWithCumulants.cxx:1954
 AliFlowAnalysisWithCumulants.cxx:1955
 AliFlowAnalysisWithCumulants.cxx:1956
 AliFlowAnalysisWithCumulants.cxx:1957
 AliFlowAnalysisWithCumulants.cxx:1958
 AliFlowAnalysisWithCumulants.cxx:1959
 AliFlowAnalysisWithCumulants.cxx:1960
 AliFlowAnalysisWithCumulants.cxx:1961
 AliFlowAnalysisWithCumulants.cxx:1962
 AliFlowAnalysisWithCumulants.cxx:1963
 AliFlowAnalysisWithCumulants.cxx:1964
 AliFlowAnalysisWithCumulants.cxx:1965
 AliFlowAnalysisWithCumulants.cxx:1966
 AliFlowAnalysisWithCumulants.cxx:1967
 AliFlowAnalysisWithCumulants.cxx:1968
 AliFlowAnalysisWithCumulants.cxx:1969
 AliFlowAnalysisWithCumulants.cxx:1970
 AliFlowAnalysisWithCumulants.cxx:1971
 AliFlowAnalysisWithCumulants.cxx:1972
 AliFlowAnalysisWithCumulants.cxx:1973
 AliFlowAnalysisWithCumulants.cxx:1974
 AliFlowAnalysisWithCumulants.cxx:1975
 AliFlowAnalysisWithCumulants.cxx:1976
 AliFlowAnalysisWithCumulants.cxx:1977
 AliFlowAnalysisWithCumulants.cxx:1978
 AliFlowAnalysisWithCumulants.cxx:1979
 AliFlowAnalysisWithCumulants.cxx:1980
 AliFlowAnalysisWithCumulants.cxx:1981
 AliFlowAnalysisWithCumulants.cxx:1982
 AliFlowAnalysisWithCumulants.cxx:1983
 AliFlowAnalysisWithCumulants.cxx:1984
 AliFlowAnalysisWithCumulants.cxx:1985
 AliFlowAnalysisWithCumulants.cxx:1986
 AliFlowAnalysisWithCumulants.cxx:1987
 AliFlowAnalysisWithCumulants.cxx:1988
 AliFlowAnalysisWithCumulants.cxx:1989
 AliFlowAnalysisWithCumulants.cxx:1990
 AliFlowAnalysisWithCumulants.cxx:1991
 AliFlowAnalysisWithCumulants.cxx:1992
 AliFlowAnalysisWithCumulants.cxx:1993
 AliFlowAnalysisWithCumulants.cxx:1994
 AliFlowAnalysisWithCumulants.cxx:1995
 AliFlowAnalysisWithCumulants.cxx:1996
 AliFlowAnalysisWithCumulants.cxx:1997
 AliFlowAnalysisWithCumulants.cxx:1998
 AliFlowAnalysisWithCumulants.cxx:1999
 AliFlowAnalysisWithCumulants.cxx:2000
 AliFlowAnalysisWithCumulants.cxx:2001
 AliFlowAnalysisWithCumulants.cxx:2002
 AliFlowAnalysisWithCumulants.cxx:2003
 AliFlowAnalysisWithCumulants.cxx:2004
 AliFlowAnalysisWithCumulants.cxx:2005
 AliFlowAnalysisWithCumulants.cxx:2006
 AliFlowAnalysisWithCumulants.cxx:2007
 AliFlowAnalysisWithCumulants.cxx:2008
 AliFlowAnalysisWithCumulants.cxx:2009
 AliFlowAnalysisWithCumulants.cxx:2010
 AliFlowAnalysisWithCumulants.cxx:2011
 AliFlowAnalysisWithCumulants.cxx:2012
 AliFlowAnalysisWithCumulants.cxx:2013
 AliFlowAnalysisWithCumulants.cxx:2014
 AliFlowAnalysisWithCumulants.cxx:2015
 AliFlowAnalysisWithCumulants.cxx:2016
 AliFlowAnalysisWithCumulants.cxx:2017
 AliFlowAnalysisWithCumulants.cxx:2018
 AliFlowAnalysisWithCumulants.cxx:2019
 AliFlowAnalysisWithCumulants.cxx:2020
 AliFlowAnalysisWithCumulants.cxx:2021
 AliFlowAnalysisWithCumulants.cxx:2022
 AliFlowAnalysisWithCumulants.cxx:2023
 AliFlowAnalysisWithCumulants.cxx:2024
 AliFlowAnalysisWithCumulants.cxx:2025
 AliFlowAnalysisWithCumulants.cxx:2026
 AliFlowAnalysisWithCumulants.cxx:2027
 AliFlowAnalysisWithCumulants.cxx:2028
 AliFlowAnalysisWithCumulants.cxx:2029
 AliFlowAnalysisWithCumulants.cxx:2030
 AliFlowAnalysisWithCumulants.cxx:2031
 AliFlowAnalysisWithCumulants.cxx:2032
 AliFlowAnalysisWithCumulants.cxx:2033
 AliFlowAnalysisWithCumulants.cxx:2034
 AliFlowAnalysisWithCumulants.cxx:2035
 AliFlowAnalysisWithCumulants.cxx:2036
 AliFlowAnalysisWithCumulants.cxx:2037
 AliFlowAnalysisWithCumulants.cxx:2038
 AliFlowAnalysisWithCumulants.cxx:2039
 AliFlowAnalysisWithCumulants.cxx:2040
 AliFlowAnalysisWithCumulants.cxx:2041
 AliFlowAnalysisWithCumulants.cxx:2042
 AliFlowAnalysisWithCumulants.cxx:2043
 AliFlowAnalysisWithCumulants.cxx:2044
 AliFlowAnalysisWithCumulants.cxx:2045
 AliFlowAnalysisWithCumulants.cxx:2046
 AliFlowAnalysisWithCumulants.cxx:2047
 AliFlowAnalysisWithCumulants.cxx:2048
 AliFlowAnalysisWithCumulants.cxx:2049
 AliFlowAnalysisWithCumulants.cxx:2050
 AliFlowAnalysisWithCumulants.cxx:2051
 AliFlowAnalysisWithCumulants.cxx:2052
 AliFlowAnalysisWithCumulants.cxx:2053
 AliFlowAnalysisWithCumulants.cxx:2054
 AliFlowAnalysisWithCumulants.cxx:2055
 AliFlowAnalysisWithCumulants.cxx:2056
 AliFlowAnalysisWithCumulants.cxx:2057
 AliFlowAnalysisWithCumulants.cxx:2058
 AliFlowAnalysisWithCumulants.cxx:2059
 AliFlowAnalysisWithCumulants.cxx:2060
 AliFlowAnalysisWithCumulants.cxx:2061
 AliFlowAnalysisWithCumulants.cxx:2062
 AliFlowAnalysisWithCumulants.cxx:2063
 AliFlowAnalysisWithCumulants.cxx:2064
 AliFlowAnalysisWithCumulants.cxx:2065
 AliFlowAnalysisWithCumulants.cxx:2066
 AliFlowAnalysisWithCumulants.cxx:2067
 AliFlowAnalysisWithCumulants.cxx:2068
 AliFlowAnalysisWithCumulants.cxx:2069
 AliFlowAnalysisWithCumulants.cxx:2070
 AliFlowAnalysisWithCumulants.cxx:2071
 AliFlowAnalysisWithCumulants.cxx:2072
 AliFlowAnalysisWithCumulants.cxx:2073
 AliFlowAnalysisWithCumulants.cxx:2074
 AliFlowAnalysisWithCumulants.cxx:2075
 AliFlowAnalysisWithCumulants.cxx:2076
 AliFlowAnalysisWithCumulants.cxx:2077
 AliFlowAnalysisWithCumulants.cxx:2078
 AliFlowAnalysisWithCumulants.cxx:2079
 AliFlowAnalysisWithCumulants.cxx:2080
 AliFlowAnalysisWithCumulants.cxx:2081
 AliFlowAnalysisWithCumulants.cxx:2082
 AliFlowAnalysisWithCumulants.cxx:2083
 AliFlowAnalysisWithCumulants.cxx:2084
 AliFlowAnalysisWithCumulants.cxx:2085
 AliFlowAnalysisWithCumulants.cxx:2086
 AliFlowAnalysisWithCumulants.cxx:2087
 AliFlowAnalysisWithCumulants.cxx:2088
 AliFlowAnalysisWithCumulants.cxx:2089
 AliFlowAnalysisWithCumulants.cxx:2090
 AliFlowAnalysisWithCumulants.cxx:2091
 AliFlowAnalysisWithCumulants.cxx:2092
 AliFlowAnalysisWithCumulants.cxx:2093
 AliFlowAnalysisWithCumulants.cxx:2094
 AliFlowAnalysisWithCumulants.cxx:2095
 AliFlowAnalysisWithCumulants.cxx:2096
 AliFlowAnalysisWithCumulants.cxx:2097
 AliFlowAnalysisWithCumulants.cxx:2098
 AliFlowAnalysisWithCumulants.cxx:2099
 AliFlowAnalysisWithCumulants.cxx:2100
 AliFlowAnalysisWithCumulants.cxx:2101
 AliFlowAnalysisWithCumulants.cxx:2102
 AliFlowAnalysisWithCumulants.cxx:2103
 AliFlowAnalysisWithCumulants.cxx:2104
 AliFlowAnalysisWithCumulants.cxx:2105
 AliFlowAnalysisWithCumulants.cxx:2106
 AliFlowAnalysisWithCumulants.cxx:2107
 AliFlowAnalysisWithCumulants.cxx:2108
 AliFlowAnalysisWithCumulants.cxx:2109
 AliFlowAnalysisWithCumulants.cxx:2110
 AliFlowAnalysisWithCumulants.cxx:2111
 AliFlowAnalysisWithCumulants.cxx:2112
 AliFlowAnalysisWithCumulants.cxx:2113
 AliFlowAnalysisWithCumulants.cxx:2114
 AliFlowAnalysisWithCumulants.cxx:2115
 AliFlowAnalysisWithCumulants.cxx:2116
 AliFlowAnalysisWithCumulants.cxx:2117
 AliFlowAnalysisWithCumulants.cxx:2118
 AliFlowAnalysisWithCumulants.cxx:2119
 AliFlowAnalysisWithCumulants.cxx:2120
 AliFlowAnalysisWithCumulants.cxx:2121
 AliFlowAnalysisWithCumulants.cxx:2122
 AliFlowAnalysisWithCumulants.cxx:2123
 AliFlowAnalysisWithCumulants.cxx:2124
 AliFlowAnalysisWithCumulants.cxx:2125
 AliFlowAnalysisWithCumulants.cxx:2126
 AliFlowAnalysisWithCumulants.cxx:2127
 AliFlowAnalysisWithCumulants.cxx:2128
 AliFlowAnalysisWithCumulants.cxx:2129
 AliFlowAnalysisWithCumulants.cxx:2130
 AliFlowAnalysisWithCumulants.cxx:2131
 AliFlowAnalysisWithCumulants.cxx:2132
 AliFlowAnalysisWithCumulants.cxx:2133
 AliFlowAnalysisWithCumulants.cxx:2134
 AliFlowAnalysisWithCumulants.cxx:2135
 AliFlowAnalysisWithCumulants.cxx:2136
 AliFlowAnalysisWithCumulants.cxx:2137
 AliFlowAnalysisWithCumulants.cxx:2138
 AliFlowAnalysisWithCumulants.cxx:2139
 AliFlowAnalysisWithCumulants.cxx:2140
 AliFlowAnalysisWithCumulants.cxx:2141
 AliFlowAnalysisWithCumulants.cxx:2142
 AliFlowAnalysisWithCumulants.cxx:2143
 AliFlowAnalysisWithCumulants.cxx:2144
 AliFlowAnalysisWithCumulants.cxx:2145
 AliFlowAnalysisWithCumulants.cxx:2146
 AliFlowAnalysisWithCumulants.cxx:2147
 AliFlowAnalysisWithCumulants.cxx:2148
 AliFlowAnalysisWithCumulants.cxx:2149
 AliFlowAnalysisWithCumulants.cxx:2150
 AliFlowAnalysisWithCumulants.cxx:2151
 AliFlowAnalysisWithCumulants.cxx:2152
 AliFlowAnalysisWithCumulants.cxx:2153
 AliFlowAnalysisWithCumulants.cxx:2154
 AliFlowAnalysisWithCumulants.cxx:2155
 AliFlowAnalysisWithCumulants.cxx:2156
 AliFlowAnalysisWithCumulants.cxx:2157
 AliFlowAnalysisWithCumulants.cxx:2158
 AliFlowAnalysisWithCumulants.cxx:2159
 AliFlowAnalysisWithCumulants.cxx:2160
 AliFlowAnalysisWithCumulants.cxx:2161
 AliFlowAnalysisWithCumulants.cxx:2162
 AliFlowAnalysisWithCumulants.cxx:2163
 AliFlowAnalysisWithCumulants.cxx:2164
 AliFlowAnalysisWithCumulants.cxx:2165
 AliFlowAnalysisWithCumulants.cxx:2166
 AliFlowAnalysisWithCumulants.cxx:2167
 AliFlowAnalysisWithCumulants.cxx:2168
 AliFlowAnalysisWithCumulants.cxx:2169
 AliFlowAnalysisWithCumulants.cxx:2170
 AliFlowAnalysisWithCumulants.cxx:2171
 AliFlowAnalysisWithCumulants.cxx:2172
 AliFlowAnalysisWithCumulants.cxx:2173
 AliFlowAnalysisWithCumulants.cxx:2174
 AliFlowAnalysisWithCumulants.cxx:2175
 AliFlowAnalysisWithCumulants.cxx:2176
 AliFlowAnalysisWithCumulants.cxx:2177
 AliFlowAnalysisWithCumulants.cxx:2178
 AliFlowAnalysisWithCumulants.cxx:2179
 AliFlowAnalysisWithCumulants.cxx:2180
 AliFlowAnalysisWithCumulants.cxx:2181
 AliFlowAnalysisWithCumulants.cxx:2182
 AliFlowAnalysisWithCumulants.cxx:2183
 AliFlowAnalysisWithCumulants.cxx:2184
 AliFlowAnalysisWithCumulants.cxx:2185
 AliFlowAnalysisWithCumulants.cxx:2186
 AliFlowAnalysisWithCumulants.cxx:2187
 AliFlowAnalysisWithCumulants.cxx:2188
 AliFlowAnalysisWithCumulants.cxx:2189
 AliFlowAnalysisWithCumulants.cxx:2190
 AliFlowAnalysisWithCumulants.cxx:2191
 AliFlowAnalysisWithCumulants.cxx:2192
 AliFlowAnalysisWithCumulants.cxx:2193
 AliFlowAnalysisWithCumulants.cxx:2194
 AliFlowAnalysisWithCumulants.cxx:2195
 AliFlowAnalysisWithCumulants.cxx:2196
 AliFlowAnalysisWithCumulants.cxx:2197
 AliFlowAnalysisWithCumulants.cxx:2198
 AliFlowAnalysisWithCumulants.cxx:2199
 AliFlowAnalysisWithCumulants.cxx:2200
 AliFlowAnalysisWithCumulants.cxx:2201
 AliFlowAnalysisWithCumulants.cxx:2202
 AliFlowAnalysisWithCumulants.cxx:2203
 AliFlowAnalysisWithCumulants.cxx:2204
 AliFlowAnalysisWithCumulants.cxx:2205
 AliFlowAnalysisWithCumulants.cxx:2206
 AliFlowAnalysisWithCumulants.cxx:2207
 AliFlowAnalysisWithCumulants.cxx:2208
 AliFlowAnalysisWithCumulants.cxx:2209
 AliFlowAnalysisWithCumulants.cxx:2210
 AliFlowAnalysisWithCumulants.cxx:2211
 AliFlowAnalysisWithCumulants.cxx:2212
 AliFlowAnalysisWithCumulants.cxx:2213
 AliFlowAnalysisWithCumulants.cxx:2214
 AliFlowAnalysisWithCumulants.cxx:2215
 AliFlowAnalysisWithCumulants.cxx:2216
 AliFlowAnalysisWithCumulants.cxx:2217
 AliFlowAnalysisWithCumulants.cxx:2218
 AliFlowAnalysisWithCumulants.cxx:2219
 AliFlowAnalysisWithCumulants.cxx:2220
 AliFlowAnalysisWithCumulants.cxx:2221
 AliFlowAnalysisWithCumulants.cxx:2222
 AliFlowAnalysisWithCumulants.cxx:2223
 AliFlowAnalysisWithCumulants.cxx:2224
 AliFlowAnalysisWithCumulants.cxx:2225
 AliFlowAnalysisWithCumulants.cxx:2226
 AliFlowAnalysisWithCumulants.cxx:2227
 AliFlowAnalysisWithCumulants.cxx:2228
 AliFlowAnalysisWithCumulants.cxx:2229
 AliFlowAnalysisWithCumulants.cxx:2230
 AliFlowAnalysisWithCumulants.cxx:2231
 AliFlowAnalysisWithCumulants.cxx:2232
 AliFlowAnalysisWithCumulants.cxx:2233
 AliFlowAnalysisWithCumulants.cxx:2234
 AliFlowAnalysisWithCumulants.cxx:2235
 AliFlowAnalysisWithCumulants.cxx:2236
 AliFlowAnalysisWithCumulants.cxx:2237
 AliFlowAnalysisWithCumulants.cxx:2238
 AliFlowAnalysisWithCumulants.cxx:2239
 AliFlowAnalysisWithCumulants.cxx:2240
 AliFlowAnalysisWithCumulants.cxx:2241
 AliFlowAnalysisWithCumulants.cxx:2242
 AliFlowAnalysisWithCumulants.cxx:2243
 AliFlowAnalysisWithCumulants.cxx:2244
 AliFlowAnalysisWithCumulants.cxx:2245
 AliFlowAnalysisWithCumulants.cxx:2246
 AliFlowAnalysisWithCumulants.cxx:2247
 AliFlowAnalysisWithCumulants.cxx:2248
 AliFlowAnalysisWithCumulants.cxx:2249
 AliFlowAnalysisWithCumulants.cxx:2250
 AliFlowAnalysisWithCumulants.cxx:2251
 AliFlowAnalysisWithCumulants.cxx:2252
 AliFlowAnalysisWithCumulants.cxx:2253
 AliFlowAnalysisWithCumulants.cxx:2254
 AliFlowAnalysisWithCumulants.cxx:2255
 AliFlowAnalysisWithCumulants.cxx:2256
 AliFlowAnalysisWithCumulants.cxx:2257
 AliFlowAnalysisWithCumulants.cxx:2258
 AliFlowAnalysisWithCumulants.cxx:2259
 AliFlowAnalysisWithCumulants.cxx:2260
 AliFlowAnalysisWithCumulants.cxx:2261
 AliFlowAnalysisWithCumulants.cxx:2262
 AliFlowAnalysisWithCumulants.cxx:2263
 AliFlowAnalysisWithCumulants.cxx:2264
 AliFlowAnalysisWithCumulants.cxx:2265
 AliFlowAnalysisWithCumulants.cxx:2266
 AliFlowAnalysisWithCumulants.cxx:2267
 AliFlowAnalysisWithCumulants.cxx:2268
 AliFlowAnalysisWithCumulants.cxx:2269
 AliFlowAnalysisWithCumulants.cxx:2270
 AliFlowAnalysisWithCumulants.cxx:2271
 AliFlowAnalysisWithCumulants.cxx:2272
 AliFlowAnalysisWithCumulants.cxx:2273
 AliFlowAnalysisWithCumulants.cxx:2274
 AliFlowAnalysisWithCumulants.cxx:2275
 AliFlowAnalysisWithCumulants.cxx:2276
 AliFlowAnalysisWithCumulants.cxx:2277
 AliFlowAnalysisWithCumulants.cxx:2278
 AliFlowAnalysisWithCumulants.cxx:2279
 AliFlowAnalysisWithCumulants.cxx:2280
 AliFlowAnalysisWithCumulants.cxx:2281
 AliFlowAnalysisWithCumulants.cxx:2282
 AliFlowAnalysisWithCumulants.cxx:2283
 AliFlowAnalysisWithCumulants.cxx:2284
 AliFlowAnalysisWithCumulants.cxx:2285
 AliFlowAnalysisWithCumulants.cxx:2286
 AliFlowAnalysisWithCumulants.cxx:2287
 AliFlowAnalysisWithCumulants.cxx:2288
 AliFlowAnalysisWithCumulants.cxx:2289
 AliFlowAnalysisWithCumulants.cxx:2290
 AliFlowAnalysisWithCumulants.cxx:2291
 AliFlowAnalysisWithCumulants.cxx:2292
 AliFlowAnalysisWithCumulants.cxx:2293
 AliFlowAnalysisWithCumulants.cxx:2294
 AliFlowAnalysisWithCumulants.cxx:2295
 AliFlowAnalysisWithCumulants.cxx:2296
 AliFlowAnalysisWithCumulants.cxx:2297
 AliFlowAnalysisWithCumulants.cxx:2298
 AliFlowAnalysisWithCumulants.cxx:2299
 AliFlowAnalysisWithCumulants.cxx:2300
 AliFlowAnalysisWithCumulants.cxx:2301
 AliFlowAnalysisWithCumulants.cxx:2302
 AliFlowAnalysisWithCumulants.cxx:2303
 AliFlowAnalysisWithCumulants.cxx:2304
 AliFlowAnalysisWithCumulants.cxx:2305
 AliFlowAnalysisWithCumulants.cxx:2306
 AliFlowAnalysisWithCumulants.cxx:2307
 AliFlowAnalysisWithCumulants.cxx:2308
 AliFlowAnalysisWithCumulants.cxx:2309
 AliFlowAnalysisWithCumulants.cxx:2310
 AliFlowAnalysisWithCumulants.cxx:2311
 AliFlowAnalysisWithCumulants.cxx:2312
 AliFlowAnalysisWithCumulants.cxx:2313
 AliFlowAnalysisWithCumulants.cxx:2314
 AliFlowAnalysisWithCumulants.cxx:2315
 AliFlowAnalysisWithCumulants.cxx:2316
 AliFlowAnalysisWithCumulants.cxx:2317
 AliFlowAnalysisWithCumulants.cxx:2318
 AliFlowAnalysisWithCumulants.cxx:2319
 AliFlowAnalysisWithCumulants.cxx:2320
 AliFlowAnalysisWithCumulants.cxx:2321
 AliFlowAnalysisWithCumulants.cxx:2322
 AliFlowAnalysisWithCumulants.cxx:2323
 AliFlowAnalysisWithCumulants.cxx:2324
 AliFlowAnalysisWithCumulants.cxx:2325
 AliFlowAnalysisWithCumulants.cxx:2326
 AliFlowAnalysisWithCumulants.cxx:2327
 AliFlowAnalysisWithCumulants.cxx:2328
 AliFlowAnalysisWithCumulants.cxx:2329
 AliFlowAnalysisWithCumulants.cxx:2330
 AliFlowAnalysisWithCumulants.cxx:2331
 AliFlowAnalysisWithCumulants.cxx:2332
 AliFlowAnalysisWithCumulants.cxx:2333
 AliFlowAnalysisWithCumulants.cxx:2334
 AliFlowAnalysisWithCumulants.cxx:2335
 AliFlowAnalysisWithCumulants.cxx:2336
 AliFlowAnalysisWithCumulants.cxx:2337
 AliFlowAnalysisWithCumulants.cxx:2338
 AliFlowAnalysisWithCumulants.cxx:2339
 AliFlowAnalysisWithCumulants.cxx:2340
 AliFlowAnalysisWithCumulants.cxx:2341
 AliFlowAnalysisWithCumulants.cxx:2342
 AliFlowAnalysisWithCumulants.cxx:2343
 AliFlowAnalysisWithCumulants.cxx:2344
 AliFlowAnalysisWithCumulants.cxx:2345
 AliFlowAnalysisWithCumulants.cxx:2346
 AliFlowAnalysisWithCumulants.cxx:2347
 AliFlowAnalysisWithCumulants.cxx:2348
 AliFlowAnalysisWithCumulants.cxx:2349
 AliFlowAnalysisWithCumulants.cxx:2350
 AliFlowAnalysisWithCumulants.cxx:2351
 AliFlowAnalysisWithCumulants.cxx:2352
 AliFlowAnalysisWithCumulants.cxx:2353
 AliFlowAnalysisWithCumulants.cxx:2354
 AliFlowAnalysisWithCumulants.cxx:2355
 AliFlowAnalysisWithCumulants.cxx:2356
 AliFlowAnalysisWithCumulants.cxx:2357
 AliFlowAnalysisWithCumulants.cxx:2358
 AliFlowAnalysisWithCumulants.cxx:2359
 AliFlowAnalysisWithCumulants.cxx:2360
 AliFlowAnalysisWithCumulants.cxx:2361
 AliFlowAnalysisWithCumulants.cxx:2362
 AliFlowAnalysisWithCumulants.cxx:2363
 AliFlowAnalysisWithCumulants.cxx:2364
 AliFlowAnalysisWithCumulants.cxx:2365
 AliFlowAnalysisWithCumulants.cxx:2366
 AliFlowAnalysisWithCumulants.cxx:2367
 AliFlowAnalysisWithCumulants.cxx:2368
 AliFlowAnalysisWithCumulants.cxx:2369
 AliFlowAnalysisWithCumulants.cxx:2370
 AliFlowAnalysisWithCumulants.cxx:2371
 AliFlowAnalysisWithCumulants.cxx:2372
 AliFlowAnalysisWithCumulants.cxx:2373
 AliFlowAnalysisWithCumulants.cxx:2374
 AliFlowAnalysisWithCumulants.cxx:2375
 AliFlowAnalysisWithCumulants.cxx:2376
 AliFlowAnalysisWithCumulants.cxx:2377
 AliFlowAnalysisWithCumulants.cxx:2378
 AliFlowAnalysisWithCumulants.cxx:2379
 AliFlowAnalysisWithCumulants.cxx:2380
 AliFlowAnalysisWithCumulants.cxx:2381
 AliFlowAnalysisWithCumulants.cxx:2382
 AliFlowAnalysisWithCumulants.cxx:2383
 AliFlowAnalysisWithCumulants.cxx:2384
 AliFlowAnalysisWithCumulants.cxx:2385
 AliFlowAnalysisWithCumulants.cxx:2386
 AliFlowAnalysisWithCumulants.cxx:2387
 AliFlowAnalysisWithCumulants.cxx:2388
 AliFlowAnalysisWithCumulants.cxx:2389
 AliFlowAnalysisWithCumulants.cxx:2390
 AliFlowAnalysisWithCumulants.cxx:2391
 AliFlowAnalysisWithCumulants.cxx:2392
 AliFlowAnalysisWithCumulants.cxx:2393
 AliFlowAnalysisWithCumulants.cxx:2394
 AliFlowAnalysisWithCumulants.cxx:2395
 AliFlowAnalysisWithCumulants.cxx:2396
 AliFlowAnalysisWithCumulants.cxx:2397
 AliFlowAnalysisWithCumulants.cxx:2398
 AliFlowAnalysisWithCumulants.cxx:2399
 AliFlowAnalysisWithCumulants.cxx:2400
 AliFlowAnalysisWithCumulants.cxx:2401
 AliFlowAnalysisWithCumulants.cxx:2402
 AliFlowAnalysisWithCumulants.cxx:2403
 AliFlowAnalysisWithCumulants.cxx:2404
 AliFlowAnalysisWithCumulants.cxx:2405
 AliFlowAnalysisWithCumulants.cxx:2406
 AliFlowAnalysisWithCumulants.cxx:2407
 AliFlowAnalysisWithCumulants.cxx:2408
 AliFlowAnalysisWithCumulants.cxx:2409
 AliFlowAnalysisWithCumulants.cxx:2410
 AliFlowAnalysisWithCumulants.cxx:2411
 AliFlowAnalysisWithCumulants.cxx:2412
 AliFlowAnalysisWithCumulants.cxx:2413
 AliFlowAnalysisWithCumulants.cxx:2414
 AliFlowAnalysisWithCumulants.cxx:2415
 AliFlowAnalysisWithCumulants.cxx:2416
 AliFlowAnalysisWithCumulants.cxx:2417
 AliFlowAnalysisWithCumulants.cxx:2418
 AliFlowAnalysisWithCumulants.cxx:2419
 AliFlowAnalysisWithCumulants.cxx:2420
 AliFlowAnalysisWithCumulants.cxx:2421
 AliFlowAnalysisWithCumulants.cxx:2422
 AliFlowAnalysisWithCumulants.cxx:2423
 AliFlowAnalysisWithCumulants.cxx:2424
 AliFlowAnalysisWithCumulants.cxx:2425
 AliFlowAnalysisWithCumulants.cxx:2426
 AliFlowAnalysisWithCumulants.cxx:2427
 AliFlowAnalysisWithCumulants.cxx:2428
 AliFlowAnalysisWithCumulants.cxx:2429
 AliFlowAnalysisWithCumulants.cxx:2430
 AliFlowAnalysisWithCumulants.cxx:2431
 AliFlowAnalysisWithCumulants.cxx:2432
 AliFlowAnalysisWithCumulants.cxx:2433
 AliFlowAnalysisWithCumulants.cxx:2434
 AliFlowAnalysisWithCumulants.cxx:2435
 AliFlowAnalysisWithCumulants.cxx:2436
 AliFlowAnalysisWithCumulants.cxx:2437
 AliFlowAnalysisWithCumulants.cxx:2438
 AliFlowAnalysisWithCumulants.cxx:2439
 AliFlowAnalysisWithCumulants.cxx:2440
 AliFlowAnalysisWithCumulants.cxx:2441
 AliFlowAnalysisWithCumulants.cxx:2442
 AliFlowAnalysisWithCumulants.cxx:2443
 AliFlowAnalysisWithCumulants.cxx:2444
 AliFlowAnalysisWithCumulants.cxx:2445
 AliFlowAnalysisWithCumulants.cxx:2446
 AliFlowAnalysisWithCumulants.cxx:2447
 AliFlowAnalysisWithCumulants.cxx:2448
 AliFlowAnalysisWithCumulants.cxx:2449
 AliFlowAnalysisWithCumulants.cxx:2450
 AliFlowAnalysisWithCumulants.cxx:2451
 AliFlowAnalysisWithCumulants.cxx:2452
 AliFlowAnalysisWithCumulants.cxx:2453
 AliFlowAnalysisWithCumulants.cxx:2454
 AliFlowAnalysisWithCumulants.cxx:2455
 AliFlowAnalysisWithCumulants.cxx:2456
 AliFlowAnalysisWithCumulants.cxx:2457
 AliFlowAnalysisWithCumulants.cxx:2458
 AliFlowAnalysisWithCumulants.cxx:2459
 AliFlowAnalysisWithCumulants.cxx:2460
 AliFlowAnalysisWithCumulants.cxx:2461
 AliFlowAnalysisWithCumulants.cxx:2462
 AliFlowAnalysisWithCumulants.cxx:2463
 AliFlowAnalysisWithCumulants.cxx:2464
 AliFlowAnalysisWithCumulants.cxx:2465
 AliFlowAnalysisWithCumulants.cxx:2466
 AliFlowAnalysisWithCumulants.cxx:2467
 AliFlowAnalysisWithCumulants.cxx:2468
 AliFlowAnalysisWithCumulants.cxx:2469
 AliFlowAnalysisWithCumulants.cxx:2470
 AliFlowAnalysisWithCumulants.cxx:2471
 AliFlowAnalysisWithCumulants.cxx:2472
 AliFlowAnalysisWithCumulants.cxx:2473
 AliFlowAnalysisWithCumulants.cxx:2474
 AliFlowAnalysisWithCumulants.cxx:2475
 AliFlowAnalysisWithCumulants.cxx:2476
 AliFlowAnalysisWithCumulants.cxx:2477
 AliFlowAnalysisWithCumulants.cxx:2478
 AliFlowAnalysisWithCumulants.cxx:2479
 AliFlowAnalysisWithCumulants.cxx:2480
 AliFlowAnalysisWithCumulants.cxx:2481
 AliFlowAnalysisWithCumulants.cxx:2482
 AliFlowAnalysisWithCumulants.cxx:2483
 AliFlowAnalysisWithCumulants.cxx:2484
 AliFlowAnalysisWithCumulants.cxx:2485
 AliFlowAnalysisWithCumulants.cxx:2486
 AliFlowAnalysisWithCumulants.cxx:2487
 AliFlowAnalysisWithCumulants.cxx:2488
 AliFlowAnalysisWithCumulants.cxx:2489
 AliFlowAnalysisWithCumulants.cxx:2490
 AliFlowAnalysisWithCumulants.cxx:2491
 AliFlowAnalysisWithCumulants.cxx:2492
 AliFlowAnalysisWithCumulants.cxx:2493
 AliFlowAnalysisWithCumulants.cxx:2494
 AliFlowAnalysisWithCumulants.cxx:2495
 AliFlowAnalysisWithCumulants.cxx:2496
 AliFlowAnalysisWithCumulants.cxx:2497
 AliFlowAnalysisWithCumulants.cxx:2498
 AliFlowAnalysisWithCumulants.cxx:2499
 AliFlowAnalysisWithCumulants.cxx:2500
 AliFlowAnalysisWithCumulants.cxx:2501
 AliFlowAnalysisWithCumulants.cxx:2502
 AliFlowAnalysisWithCumulants.cxx:2503
 AliFlowAnalysisWithCumulants.cxx:2504
 AliFlowAnalysisWithCumulants.cxx:2505
 AliFlowAnalysisWithCumulants.cxx:2506
 AliFlowAnalysisWithCumulants.cxx:2507
 AliFlowAnalysisWithCumulants.cxx:2508
 AliFlowAnalysisWithCumulants.cxx:2509
 AliFlowAnalysisWithCumulants.cxx:2510
 AliFlowAnalysisWithCumulants.cxx:2511
 AliFlowAnalysisWithCumulants.cxx:2512
 AliFlowAnalysisWithCumulants.cxx:2513
 AliFlowAnalysisWithCumulants.cxx:2514
 AliFlowAnalysisWithCumulants.cxx:2515
 AliFlowAnalysisWithCumulants.cxx:2516
 AliFlowAnalysisWithCumulants.cxx:2517
 AliFlowAnalysisWithCumulants.cxx:2518
 AliFlowAnalysisWithCumulants.cxx:2519
 AliFlowAnalysisWithCumulants.cxx:2520
 AliFlowAnalysisWithCumulants.cxx:2521
 AliFlowAnalysisWithCumulants.cxx:2522
 AliFlowAnalysisWithCumulants.cxx:2523
 AliFlowAnalysisWithCumulants.cxx:2524
 AliFlowAnalysisWithCumulants.cxx:2525
 AliFlowAnalysisWithCumulants.cxx:2526
 AliFlowAnalysisWithCumulants.cxx:2527
 AliFlowAnalysisWithCumulants.cxx:2528
 AliFlowAnalysisWithCumulants.cxx:2529
 AliFlowAnalysisWithCumulants.cxx:2530
 AliFlowAnalysisWithCumulants.cxx:2531
 AliFlowAnalysisWithCumulants.cxx:2532
 AliFlowAnalysisWithCumulants.cxx:2533
 AliFlowAnalysisWithCumulants.cxx:2534
 AliFlowAnalysisWithCumulants.cxx:2535
 AliFlowAnalysisWithCumulants.cxx:2536
 AliFlowAnalysisWithCumulants.cxx:2537
 AliFlowAnalysisWithCumulants.cxx:2538
 AliFlowAnalysisWithCumulants.cxx:2539
 AliFlowAnalysisWithCumulants.cxx:2540
 AliFlowAnalysisWithCumulants.cxx:2541
 AliFlowAnalysisWithCumulants.cxx:2542
 AliFlowAnalysisWithCumulants.cxx:2543
 AliFlowAnalysisWithCumulants.cxx:2544
 AliFlowAnalysisWithCumulants.cxx:2545
 AliFlowAnalysisWithCumulants.cxx:2546
 AliFlowAnalysisWithCumulants.cxx:2547
 AliFlowAnalysisWithCumulants.cxx:2548
 AliFlowAnalysisWithCumulants.cxx:2549
 AliFlowAnalysisWithCumulants.cxx:2550
 AliFlowAnalysisWithCumulants.cxx:2551
 AliFlowAnalysisWithCumulants.cxx:2552
 AliFlowAnalysisWithCumulants.cxx:2553
 AliFlowAnalysisWithCumulants.cxx:2554
 AliFlowAnalysisWithCumulants.cxx:2555
 AliFlowAnalysisWithCumulants.cxx:2556
 AliFlowAnalysisWithCumulants.cxx:2557
 AliFlowAnalysisWithCumulants.cxx:2558
 AliFlowAnalysisWithCumulants.cxx:2559
 AliFlowAnalysisWithCumulants.cxx:2560
 AliFlowAnalysisWithCumulants.cxx:2561
 AliFlowAnalysisWithCumulants.cxx:2562
 AliFlowAnalysisWithCumulants.cxx:2563
 AliFlowAnalysisWithCumulants.cxx:2564
 AliFlowAnalysisWithCumulants.cxx:2565
 AliFlowAnalysisWithCumulants.cxx:2566
 AliFlowAnalysisWithCumulants.cxx:2567
 AliFlowAnalysisWithCumulants.cxx:2568
 AliFlowAnalysisWithCumulants.cxx:2569
 AliFlowAnalysisWithCumulants.cxx:2570
 AliFlowAnalysisWithCumulants.cxx:2571
 AliFlowAnalysisWithCumulants.cxx:2572
 AliFlowAnalysisWithCumulants.cxx:2573
 AliFlowAnalysisWithCumulants.cxx:2574
 AliFlowAnalysisWithCumulants.cxx:2575
 AliFlowAnalysisWithCumulants.cxx:2576
 AliFlowAnalysisWithCumulants.cxx:2577
 AliFlowAnalysisWithCumulants.cxx:2578
 AliFlowAnalysisWithCumulants.cxx:2579
 AliFlowAnalysisWithCumulants.cxx:2580
 AliFlowAnalysisWithCumulants.cxx:2581
 AliFlowAnalysisWithCumulants.cxx:2582
 AliFlowAnalysisWithCumulants.cxx:2583
 AliFlowAnalysisWithCumulants.cxx:2584
 AliFlowAnalysisWithCumulants.cxx:2585
 AliFlowAnalysisWithCumulants.cxx:2586
 AliFlowAnalysisWithCumulants.cxx:2587
 AliFlowAnalysisWithCumulants.cxx:2588
 AliFlowAnalysisWithCumulants.cxx:2589
 AliFlowAnalysisWithCumulants.cxx:2590
 AliFlowAnalysisWithCumulants.cxx:2591
 AliFlowAnalysisWithCumulants.cxx:2592
 AliFlowAnalysisWithCumulants.cxx:2593
 AliFlowAnalysisWithCumulants.cxx:2594
 AliFlowAnalysisWithCumulants.cxx:2595
 AliFlowAnalysisWithCumulants.cxx:2596
 AliFlowAnalysisWithCumulants.cxx:2597
 AliFlowAnalysisWithCumulants.cxx:2598
 AliFlowAnalysisWithCumulants.cxx:2599
 AliFlowAnalysisWithCumulants.cxx:2600
 AliFlowAnalysisWithCumulants.cxx:2601
 AliFlowAnalysisWithCumulants.cxx:2602
 AliFlowAnalysisWithCumulants.cxx:2603
 AliFlowAnalysisWithCumulants.cxx:2604
 AliFlowAnalysisWithCumulants.cxx:2605
 AliFlowAnalysisWithCumulants.cxx:2606
 AliFlowAnalysisWithCumulants.cxx:2607
 AliFlowAnalysisWithCumulants.cxx:2608
 AliFlowAnalysisWithCumulants.cxx:2609
 AliFlowAnalysisWithCumulants.cxx:2610
 AliFlowAnalysisWithCumulants.cxx:2611
 AliFlowAnalysisWithCumulants.cxx:2612
 AliFlowAnalysisWithCumulants.cxx:2613
 AliFlowAnalysisWithCumulants.cxx:2614
 AliFlowAnalysisWithCumulants.cxx:2615
 AliFlowAnalysisWithCumulants.cxx:2616
 AliFlowAnalysisWithCumulants.cxx:2617
 AliFlowAnalysisWithCumulants.cxx:2618
 AliFlowAnalysisWithCumulants.cxx:2619
 AliFlowAnalysisWithCumulants.cxx:2620
 AliFlowAnalysisWithCumulants.cxx:2621
 AliFlowAnalysisWithCumulants.cxx:2622
 AliFlowAnalysisWithCumulants.cxx:2623
 AliFlowAnalysisWithCumulants.cxx:2624
 AliFlowAnalysisWithCumulants.cxx:2625
 AliFlowAnalysisWithCumulants.cxx:2626
 AliFlowAnalysisWithCumulants.cxx:2627
 AliFlowAnalysisWithCumulants.cxx:2628
 AliFlowAnalysisWithCumulants.cxx:2629
 AliFlowAnalysisWithCumulants.cxx:2630
 AliFlowAnalysisWithCumulants.cxx:2631
 AliFlowAnalysisWithCumulants.cxx:2632
 AliFlowAnalysisWithCumulants.cxx:2633
 AliFlowAnalysisWithCumulants.cxx:2634
 AliFlowAnalysisWithCumulants.cxx:2635
 AliFlowAnalysisWithCumulants.cxx:2636
 AliFlowAnalysisWithCumulants.cxx:2637
 AliFlowAnalysisWithCumulants.cxx:2638
 AliFlowAnalysisWithCumulants.cxx:2639
 AliFlowAnalysisWithCumulants.cxx:2640
 AliFlowAnalysisWithCumulants.cxx:2641
 AliFlowAnalysisWithCumulants.cxx:2642
 AliFlowAnalysisWithCumulants.cxx:2643
 AliFlowAnalysisWithCumulants.cxx:2644
 AliFlowAnalysisWithCumulants.cxx:2645
 AliFlowAnalysisWithCumulants.cxx:2646
 AliFlowAnalysisWithCumulants.cxx:2647
 AliFlowAnalysisWithCumulants.cxx:2648
 AliFlowAnalysisWithCumulants.cxx:2649
 AliFlowAnalysisWithCumulants.cxx:2650
 AliFlowAnalysisWithCumulants.cxx:2651
 AliFlowAnalysisWithCumulants.cxx:2652
 AliFlowAnalysisWithCumulants.cxx:2653
 AliFlowAnalysisWithCumulants.cxx:2654
 AliFlowAnalysisWithCumulants.cxx:2655
 AliFlowAnalysisWithCumulants.cxx:2656
 AliFlowAnalysisWithCumulants.cxx:2657
 AliFlowAnalysisWithCumulants.cxx:2658
 AliFlowAnalysisWithCumulants.cxx:2659
 AliFlowAnalysisWithCumulants.cxx:2660
 AliFlowAnalysisWithCumulants.cxx:2661
 AliFlowAnalysisWithCumulants.cxx:2662
 AliFlowAnalysisWithCumulants.cxx:2663
 AliFlowAnalysisWithCumulants.cxx:2664
 AliFlowAnalysisWithCumulants.cxx:2665
 AliFlowAnalysisWithCumulants.cxx:2666
 AliFlowAnalysisWithCumulants.cxx:2667
 AliFlowAnalysisWithCumulants.cxx:2668
 AliFlowAnalysisWithCumulants.cxx:2669
 AliFlowAnalysisWithCumulants.cxx:2670
 AliFlowAnalysisWithCumulants.cxx:2671
 AliFlowAnalysisWithCumulants.cxx:2672
 AliFlowAnalysisWithCumulants.cxx:2673
 AliFlowAnalysisWithCumulants.cxx:2674
 AliFlowAnalysisWithCumulants.cxx:2675
 AliFlowAnalysisWithCumulants.cxx:2676
 AliFlowAnalysisWithCumulants.cxx:2677
 AliFlowAnalysisWithCumulants.cxx:2678
 AliFlowAnalysisWithCumulants.cxx:2679
 AliFlowAnalysisWithCumulants.cxx:2680
 AliFlowAnalysisWithCumulants.cxx:2681
 AliFlowAnalysisWithCumulants.cxx:2682
 AliFlowAnalysisWithCumulants.cxx:2683
 AliFlowAnalysisWithCumulants.cxx:2684
 AliFlowAnalysisWithCumulants.cxx:2685
 AliFlowAnalysisWithCumulants.cxx:2686
 AliFlowAnalysisWithCumulants.cxx:2687
 AliFlowAnalysisWithCumulants.cxx:2688
 AliFlowAnalysisWithCumulants.cxx:2689
 AliFlowAnalysisWithCumulants.cxx:2690
 AliFlowAnalysisWithCumulants.cxx:2691
 AliFlowAnalysisWithCumulants.cxx:2692
 AliFlowAnalysisWithCumulants.cxx:2693
 AliFlowAnalysisWithCumulants.cxx:2694
 AliFlowAnalysisWithCumulants.cxx:2695
 AliFlowAnalysisWithCumulants.cxx:2696
 AliFlowAnalysisWithCumulants.cxx:2697
 AliFlowAnalysisWithCumulants.cxx:2698
 AliFlowAnalysisWithCumulants.cxx:2699
 AliFlowAnalysisWithCumulants.cxx:2700
 AliFlowAnalysisWithCumulants.cxx:2701
 AliFlowAnalysisWithCumulants.cxx:2702
 AliFlowAnalysisWithCumulants.cxx:2703
 AliFlowAnalysisWithCumulants.cxx:2704
 AliFlowAnalysisWithCumulants.cxx:2705
 AliFlowAnalysisWithCumulants.cxx:2706
 AliFlowAnalysisWithCumulants.cxx:2707
 AliFlowAnalysisWithCumulants.cxx:2708
 AliFlowAnalysisWithCumulants.cxx:2709
 AliFlowAnalysisWithCumulants.cxx:2710
 AliFlowAnalysisWithCumulants.cxx:2711
 AliFlowAnalysisWithCumulants.cxx:2712
 AliFlowAnalysisWithCumulants.cxx:2713
 AliFlowAnalysisWithCumulants.cxx:2714
 AliFlowAnalysisWithCumulants.cxx:2715
 AliFlowAnalysisWithCumulants.cxx:2716
 AliFlowAnalysisWithCumulants.cxx:2717
 AliFlowAnalysisWithCumulants.cxx:2718
 AliFlowAnalysisWithCumulants.cxx:2719
 AliFlowAnalysisWithCumulants.cxx:2720
 AliFlowAnalysisWithCumulants.cxx:2721
 AliFlowAnalysisWithCumulants.cxx:2722
 AliFlowAnalysisWithCumulants.cxx:2723
 AliFlowAnalysisWithCumulants.cxx:2724
 AliFlowAnalysisWithCumulants.cxx:2725
 AliFlowAnalysisWithCumulants.cxx:2726
 AliFlowAnalysisWithCumulants.cxx:2727
 AliFlowAnalysisWithCumulants.cxx:2728
 AliFlowAnalysisWithCumulants.cxx:2729
 AliFlowAnalysisWithCumulants.cxx:2730
 AliFlowAnalysisWithCumulants.cxx:2731
 AliFlowAnalysisWithCumulants.cxx:2732
 AliFlowAnalysisWithCumulants.cxx:2733
 AliFlowAnalysisWithCumulants.cxx:2734
 AliFlowAnalysisWithCumulants.cxx:2735
 AliFlowAnalysisWithCumulants.cxx:2736
 AliFlowAnalysisWithCumulants.cxx:2737
 AliFlowAnalysisWithCumulants.cxx:2738
 AliFlowAnalysisWithCumulants.cxx:2739
 AliFlowAnalysisWithCumulants.cxx:2740
 AliFlowAnalysisWithCumulants.cxx:2741
 AliFlowAnalysisWithCumulants.cxx:2742
 AliFlowAnalysisWithCumulants.cxx:2743
 AliFlowAnalysisWithCumulants.cxx:2744
 AliFlowAnalysisWithCumulants.cxx:2745
 AliFlowAnalysisWithCumulants.cxx:2746
 AliFlowAnalysisWithCumulants.cxx:2747
 AliFlowAnalysisWithCumulants.cxx:2748
 AliFlowAnalysisWithCumulants.cxx:2749
 AliFlowAnalysisWithCumulants.cxx:2750
 AliFlowAnalysisWithCumulants.cxx:2751
 AliFlowAnalysisWithCumulants.cxx:2752
 AliFlowAnalysisWithCumulants.cxx:2753
 AliFlowAnalysisWithCumulants.cxx:2754
 AliFlowAnalysisWithCumulants.cxx:2755
 AliFlowAnalysisWithCumulants.cxx:2756
 AliFlowAnalysisWithCumulants.cxx:2757
 AliFlowAnalysisWithCumulants.cxx:2758
 AliFlowAnalysisWithCumulants.cxx:2759
 AliFlowAnalysisWithCumulants.cxx:2760
 AliFlowAnalysisWithCumulants.cxx:2761
 AliFlowAnalysisWithCumulants.cxx:2762
 AliFlowAnalysisWithCumulants.cxx:2763
 AliFlowAnalysisWithCumulants.cxx:2764
 AliFlowAnalysisWithCumulants.cxx:2765
 AliFlowAnalysisWithCumulants.cxx:2766
 AliFlowAnalysisWithCumulants.cxx:2767
 AliFlowAnalysisWithCumulants.cxx:2768
 AliFlowAnalysisWithCumulants.cxx:2769
 AliFlowAnalysisWithCumulants.cxx:2770
 AliFlowAnalysisWithCumulants.cxx:2771
 AliFlowAnalysisWithCumulants.cxx:2772
 AliFlowAnalysisWithCumulants.cxx:2773
 AliFlowAnalysisWithCumulants.cxx:2774
 AliFlowAnalysisWithCumulants.cxx:2775
 AliFlowAnalysisWithCumulants.cxx:2776
 AliFlowAnalysisWithCumulants.cxx:2777
 AliFlowAnalysisWithCumulants.cxx:2778
 AliFlowAnalysisWithCumulants.cxx:2779
 AliFlowAnalysisWithCumulants.cxx:2780
 AliFlowAnalysisWithCumulants.cxx:2781
 AliFlowAnalysisWithCumulants.cxx:2782
 AliFlowAnalysisWithCumulants.cxx:2783
 AliFlowAnalysisWithCumulants.cxx:2784
 AliFlowAnalysisWithCumulants.cxx:2785
 AliFlowAnalysisWithCumulants.cxx:2786
 AliFlowAnalysisWithCumulants.cxx:2787
 AliFlowAnalysisWithCumulants.cxx:2788
 AliFlowAnalysisWithCumulants.cxx:2789
 AliFlowAnalysisWithCumulants.cxx:2790
 AliFlowAnalysisWithCumulants.cxx:2791
 AliFlowAnalysisWithCumulants.cxx:2792
 AliFlowAnalysisWithCumulants.cxx:2793
 AliFlowAnalysisWithCumulants.cxx:2794
 AliFlowAnalysisWithCumulants.cxx:2795
 AliFlowAnalysisWithCumulants.cxx:2796
 AliFlowAnalysisWithCumulants.cxx:2797
 AliFlowAnalysisWithCumulants.cxx:2798
 AliFlowAnalysisWithCumulants.cxx:2799
 AliFlowAnalysisWithCumulants.cxx:2800
 AliFlowAnalysisWithCumulants.cxx:2801
 AliFlowAnalysisWithCumulants.cxx:2802
 AliFlowAnalysisWithCumulants.cxx:2803
 AliFlowAnalysisWithCumulants.cxx:2804
 AliFlowAnalysisWithCumulants.cxx:2805
 AliFlowAnalysisWithCumulants.cxx:2806
 AliFlowAnalysisWithCumulants.cxx:2807
 AliFlowAnalysisWithCumulants.cxx:2808
 AliFlowAnalysisWithCumulants.cxx:2809
 AliFlowAnalysisWithCumulants.cxx:2810
 AliFlowAnalysisWithCumulants.cxx:2811
 AliFlowAnalysisWithCumulants.cxx:2812
 AliFlowAnalysisWithCumulants.cxx:2813
 AliFlowAnalysisWithCumulants.cxx:2814
 AliFlowAnalysisWithCumulants.cxx:2815
 AliFlowAnalysisWithCumulants.cxx:2816
 AliFlowAnalysisWithCumulants.cxx:2817
 AliFlowAnalysisWithCumulants.cxx:2818
 AliFlowAnalysisWithCumulants.cxx:2819
 AliFlowAnalysisWithCumulants.cxx:2820
 AliFlowAnalysisWithCumulants.cxx:2821
 AliFlowAnalysisWithCumulants.cxx:2822
 AliFlowAnalysisWithCumulants.cxx:2823
 AliFlowAnalysisWithCumulants.cxx:2824
 AliFlowAnalysisWithCumulants.cxx:2825
 AliFlowAnalysisWithCumulants.cxx:2826
 AliFlowAnalysisWithCumulants.cxx:2827
 AliFlowAnalysisWithCumulants.cxx:2828
 AliFlowAnalysisWithCumulants.cxx:2829
 AliFlowAnalysisWithCumulants.cxx:2830
 AliFlowAnalysisWithCumulants.cxx:2831
 AliFlowAnalysisWithCumulants.cxx:2832
 AliFlowAnalysisWithCumulants.cxx:2833
 AliFlowAnalysisWithCumulants.cxx:2834
 AliFlowAnalysisWithCumulants.cxx:2835
 AliFlowAnalysisWithCumulants.cxx:2836
 AliFlowAnalysisWithCumulants.cxx:2837
 AliFlowAnalysisWithCumulants.cxx:2838
 AliFlowAnalysisWithCumulants.cxx:2839
 AliFlowAnalysisWithCumulants.cxx:2840
 AliFlowAnalysisWithCumulants.cxx:2841
 AliFlowAnalysisWithCumulants.cxx:2842
 AliFlowAnalysisWithCumulants.cxx:2843
 AliFlowAnalysisWithCumulants.cxx:2844
 AliFlowAnalysisWithCumulants.cxx:2845
 AliFlowAnalysisWithCumulants.cxx:2846
 AliFlowAnalysisWithCumulants.cxx:2847
 AliFlowAnalysisWithCumulants.cxx:2848
 AliFlowAnalysisWithCumulants.cxx:2849
 AliFlowAnalysisWithCumulants.cxx:2850
 AliFlowAnalysisWithCumulants.cxx:2851
 AliFlowAnalysisWithCumulants.cxx:2852
 AliFlowAnalysisWithCumulants.cxx:2853
 AliFlowAnalysisWithCumulants.cxx:2854
 AliFlowAnalysisWithCumulants.cxx:2855
 AliFlowAnalysisWithCumulants.cxx:2856
 AliFlowAnalysisWithCumulants.cxx:2857
 AliFlowAnalysisWithCumulants.cxx:2858
 AliFlowAnalysisWithCumulants.cxx:2859
 AliFlowAnalysisWithCumulants.cxx:2860
 AliFlowAnalysisWithCumulants.cxx:2861
 AliFlowAnalysisWithCumulants.cxx:2862
 AliFlowAnalysisWithCumulants.cxx:2863
 AliFlowAnalysisWithCumulants.cxx:2864
 AliFlowAnalysisWithCumulants.cxx:2865
 AliFlowAnalysisWithCumulants.cxx:2866
 AliFlowAnalysisWithCumulants.cxx:2867
 AliFlowAnalysisWithCumulants.cxx:2868
 AliFlowAnalysisWithCumulants.cxx:2869
 AliFlowAnalysisWithCumulants.cxx:2870
 AliFlowAnalysisWithCumulants.cxx:2871
 AliFlowAnalysisWithCumulants.cxx:2872
 AliFlowAnalysisWithCumulants.cxx:2873
 AliFlowAnalysisWithCumulants.cxx:2874
 AliFlowAnalysisWithCumulants.cxx:2875
 AliFlowAnalysisWithCumulants.cxx:2876
 AliFlowAnalysisWithCumulants.cxx:2877
 AliFlowAnalysisWithCumulants.cxx:2878
 AliFlowAnalysisWithCumulants.cxx:2879
 AliFlowAnalysisWithCumulants.cxx:2880
 AliFlowAnalysisWithCumulants.cxx:2881
 AliFlowAnalysisWithCumulants.cxx:2882
 AliFlowAnalysisWithCumulants.cxx:2883
 AliFlowAnalysisWithCumulants.cxx:2884
 AliFlowAnalysisWithCumulants.cxx:2885
 AliFlowAnalysisWithCumulants.cxx:2886
 AliFlowAnalysisWithCumulants.cxx:2887
 AliFlowAnalysisWithCumulants.cxx:2888
 AliFlowAnalysisWithCumulants.cxx:2889
 AliFlowAnalysisWithCumulants.cxx:2890
 AliFlowAnalysisWithCumulants.cxx:2891
 AliFlowAnalysisWithCumulants.cxx:2892
 AliFlowAnalysisWithCumulants.cxx:2893
 AliFlowAnalysisWithCumulants.cxx:2894
 AliFlowAnalysisWithCumulants.cxx:2895
 AliFlowAnalysisWithCumulants.cxx:2896
 AliFlowAnalysisWithCumulants.cxx:2897
 AliFlowAnalysisWithCumulants.cxx:2898
 AliFlowAnalysisWithCumulants.cxx:2899
 AliFlowAnalysisWithCumulants.cxx:2900
 AliFlowAnalysisWithCumulants.cxx:2901
 AliFlowAnalysisWithCumulants.cxx:2902
 AliFlowAnalysisWithCumulants.cxx:2903
 AliFlowAnalysisWithCumulants.cxx:2904
 AliFlowAnalysisWithCumulants.cxx:2905
 AliFlowAnalysisWithCumulants.cxx:2906
 AliFlowAnalysisWithCumulants.cxx:2907
 AliFlowAnalysisWithCumulants.cxx:2908
 AliFlowAnalysisWithCumulants.cxx:2909
 AliFlowAnalysisWithCumulants.cxx:2910
 AliFlowAnalysisWithCumulants.cxx:2911
 AliFlowAnalysisWithCumulants.cxx:2912
 AliFlowAnalysisWithCumulants.cxx:2913
 AliFlowAnalysisWithCumulants.cxx:2914
 AliFlowAnalysisWithCumulants.cxx:2915
 AliFlowAnalysisWithCumulants.cxx:2916
 AliFlowAnalysisWithCumulants.cxx:2917
 AliFlowAnalysisWithCumulants.cxx:2918
 AliFlowAnalysisWithCumulants.cxx:2919
 AliFlowAnalysisWithCumulants.cxx:2920
 AliFlowAnalysisWithCumulants.cxx:2921
 AliFlowAnalysisWithCumulants.cxx:2922
 AliFlowAnalysisWithCumulants.cxx:2923
 AliFlowAnalysisWithCumulants.cxx:2924
 AliFlowAnalysisWithCumulants.cxx:2925
 AliFlowAnalysisWithCumulants.cxx:2926
 AliFlowAnalysisWithCumulants.cxx:2927
 AliFlowAnalysisWithCumulants.cxx:2928
 AliFlowAnalysisWithCumulants.cxx:2929
 AliFlowAnalysisWithCumulants.cxx:2930
 AliFlowAnalysisWithCumulants.cxx:2931
 AliFlowAnalysisWithCumulants.cxx:2932
 AliFlowAnalysisWithCumulants.cxx:2933
 AliFlowAnalysisWithCumulants.cxx:2934
 AliFlowAnalysisWithCumulants.cxx:2935
 AliFlowAnalysisWithCumulants.cxx:2936
 AliFlowAnalysisWithCumulants.cxx:2937
 AliFlowAnalysisWithCumulants.cxx:2938
 AliFlowAnalysisWithCumulants.cxx:2939
 AliFlowAnalysisWithCumulants.cxx:2940
 AliFlowAnalysisWithCumulants.cxx:2941
 AliFlowAnalysisWithCumulants.cxx:2942
 AliFlowAnalysisWithCumulants.cxx:2943
 AliFlowAnalysisWithCumulants.cxx:2944
 AliFlowAnalysisWithCumulants.cxx:2945
 AliFlowAnalysisWithCumulants.cxx:2946
 AliFlowAnalysisWithCumulants.cxx:2947
 AliFlowAnalysisWithCumulants.cxx:2948
 AliFlowAnalysisWithCumulants.cxx:2949
 AliFlowAnalysisWithCumulants.cxx:2950
 AliFlowAnalysisWithCumulants.cxx:2951
 AliFlowAnalysisWithCumulants.cxx:2952
 AliFlowAnalysisWithCumulants.cxx:2953
 AliFlowAnalysisWithCumulants.cxx:2954
 AliFlowAnalysisWithCumulants.cxx:2955
 AliFlowAnalysisWithCumulants.cxx:2956
 AliFlowAnalysisWithCumulants.cxx:2957
 AliFlowAnalysisWithCumulants.cxx:2958
 AliFlowAnalysisWithCumulants.cxx:2959
 AliFlowAnalysisWithCumulants.cxx:2960
 AliFlowAnalysisWithCumulants.cxx:2961
 AliFlowAnalysisWithCumulants.cxx:2962
 AliFlowAnalysisWithCumulants.cxx:2963
 AliFlowAnalysisWithCumulants.cxx:2964
 AliFlowAnalysisWithCumulants.cxx:2965
 AliFlowAnalysisWithCumulants.cxx:2966
 AliFlowAnalysisWithCumulants.cxx:2967
 AliFlowAnalysisWithCumulants.cxx:2968
 AliFlowAnalysisWithCumulants.cxx:2969
 AliFlowAnalysisWithCumulants.cxx:2970
 AliFlowAnalysisWithCumulants.cxx:2971
 AliFlowAnalysisWithCumulants.cxx:2972
 AliFlowAnalysisWithCumulants.cxx:2973
 AliFlowAnalysisWithCumulants.cxx:2974
 AliFlowAnalysisWithCumulants.cxx:2975
 AliFlowAnalysisWithCumulants.cxx:2976
 AliFlowAnalysisWithCumulants.cxx:2977
 AliFlowAnalysisWithCumulants.cxx:2978
 AliFlowAnalysisWithCumulants.cxx:2979
 AliFlowAnalysisWithCumulants.cxx:2980
 AliFlowAnalysisWithCumulants.cxx:2981
 AliFlowAnalysisWithCumulants.cxx:2982
 AliFlowAnalysisWithCumulants.cxx:2983
 AliFlowAnalysisWithCumulants.cxx:2984
 AliFlowAnalysisWithCumulants.cxx:2985
 AliFlowAnalysisWithCumulants.cxx:2986
 AliFlowAnalysisWithCumulants.cxx:2987
 AliFlowAnalysisWithCumulants.cxx:2988
 AliFlowAnalysisWithCumulants.cxx:2989
 AliFlowAnalysisWithCumulants.cxx:2990
 AliFlowAnalysisWithCumulants.cxx:2991
 AliFlowAnalysisWithCumulants.cxx:2992
 AliFlowAnalysisWithCumulants.cxx:2993
 AliFlowAnalysisWithCumulants.cxx:2994
 AliFlowAnalysisWithCumulants.cxx:2995
 AliFlowAnalysisWithCumulants.cxx:2996
 AliFlowAnalysisWithCumulants.cxx:2997
 AliFlowAnalysisWithCumulants.cxx:2998
 AliFlowAnalysisWithCumulants.cxx:2999
 AliFlowAnalysisWithCumulants.cxx:3000
 AliFlowAnalysisWithCumulants.cxx:3001
 AliFlowAnalysisWithCumulants.cxx:3002
 AliFlowAnalysisWithCumulants.cxx:3003
 AliFlowAnalysisWithCumulants.cxx:3004
 AliFlowAnalysisWithCumulants.cxx:3005
 AliFlowAnalysisWithCumulants.cxx:3006
 AliFlowAnalysisWithCumulants.cxx:3007
 AliFlowAnalysisWithCumulants.cxx:3008
 AliFlowAnalysisWithCumulants.cxx:3009
 AliFlowAnalysisWithCumulants.cxx:3010
 AliFlowAnalysisWithCumulants.cxx:3011
 AliFlowAnalysisWithCumulants.cxx:3012
 AliFlowAnalysisWithCumulants.cxx:3013
 AliFlowAnalysisWithCumulants.cxx:3014
 AliFlowAnalysisWithCumulants.cxx:3015
 AliFlowAnalysisWithCumulants.cxx:3016
 AliFlowAnalysisWithCumulants.cxx:3017
 AliFlowAnalysisWithCumulants.cxx:3018
 AliFlowAnalysisWithCumulants.cxx:3019
 AliFlowAnalysisWithCumulants.cxx:3020
 AliFlowAnalysisWithCumulants.cxx:3021
 AliFlowAnalysisWithCumulants.cxx:3022
 AliFlowAnalysisWithCumulants.cxx:3023
 AliFlowAnalysisWithCumulants.cxx:3024
 AliFlowAnalysisWithCumulants.cxx:3025
 AliFlowAnalysisWithCumulants.cxx:3026
 AliFlowAnalysisWithCumulants.cxx:3027
 AliFlowAnalysisWithCumulants.cxx:3028
 AliFlowAnalysisWithCumulants.cxx:3029
 AliFlowAnalysisWithCumulants.cxx:3030
 AliFlowAnalysisWithCumulants.cxx:3031
 AliFlowAnalysisWithCumulants.cxx:3032
 AliFlowAnalysisWithCumulants.cxx:3033
 AliFlowAnalysisWithCumulants.cxx:3034
 AliFlowAnalysisWithCumulants.cxx:3035
 AliFlowAnalysisWithCumulants.cxx:3036
 AliFlowAnalysisWithCumulants.cxx:3037
 AliFlowAnalysisWithCumulants.cxx:3038
 AliFlowAnalysisWithCumulants.cxx:3039
 AliFlowAnalysisWithCumulants.cxx:3040
 AliFlowAnalysisWithCumulants.cxx:3041
 AliFlowAnalysisWithCumulants.cxx:3042
 AliFlowAnalysisWithCumulants.cxx:3043
 AliFlowAnalysisWithCumulants.cxx:3044
 AliFlowAnalysisWithCumulants.cxx:3045
 AliFlowAnalysisWithCumulants.cxx:3046
 AliFlowAnalysisWithCumulants.cxx:3047
 AliFlowAnalysisWithCumulants.cxx:3048
 AliFlowAnalysisWithCumulants.cxx:3049
 AliFlowAnalysisWithCumulants.cxx:3050
 AliFlowAnalysisWithCumulants.cxx:3051
 AliFlowAnalysisWithCumulants.cxx:3052
 AliFlowAnalysisWithCumulants.cxx:3053
 AliFlowAnalysisWithCumulants.cxx:3054
 AliFlowAnalysisWithCumulants.cxx:3055
 AliFlowAnalysisWithCumulants.cxx:3056
 AliFlowAnalysisWithCumulants.cxx:3057
 AliFlowAnalysisWithCumulants.cxx:3058
 AliFlowAnalysisWithCumulants.cxx:3059
 AliFlowAnalysisWithCumulants.cxx:3060
 AliFlowAnalysisWithCumulants.cxx:3061
 AliFlowAnalysisWithCumulants.cxx:3062
 AliFlowAnalysisWithCumulants.cxx:3063
 AliFlowAnalysisWithCumulants.cxx:3064
 AliFlowAnalysisWithCumulants.cxx:3065
 AliFlowAnalysisWithCumulants.cxx:3066
 AliFlowAnalysisWithCumulants.cxx:3067
 AliFlowAnalysisWithCumulants.cxx:3068
 AliFlowAnalysisWithCumulants.cxx:3069
 AliFlowAnalysisWithCumulants.cxx:3070
 AliFlowAnalysisWithCumulants.cxx:3071
 AliFlowAnalysisWithCumulants.cxx:3072
 AliFlowAnalysisWithCumulants.cxx:3073
 AliFlowAnalysisWithCumulants.cxx:3074
 AliFlowAnalysisWithCumulants.cxx:3075
 AliFlowAnalysisWithCumulants.cxx:3076
 AliFlowAnalysisWithCumulants.cxx:3077
 AliFlowAnalysisWithCumulants.cxx:3078
 AliFlowAnalysisWithCumulants.cxx:3079
 AliFlowAnalysisWithCumulants.cxx:3080
 AliFlowAnalysisWithCumulants.cxx:3081
 AliFlowAnalysisWithCumulants.cxx:3082
 AliFlowAnalysisWithCumulants.cxx:3083
 AliFlowAnalysisWithCumulants.cxx:3084
 AliFlowAnalysisWithCumulants.cxx:3085
 AliFlowAnalysisWithCumulants.cxx:3086
 AliFlowAnalysisWithCumulants.cxx:3087
 AliFlowAnalysisWithCumulants.cxx:3088
 AliFlowAnalysisWithCumulants.cxx:3089
 AliFlowAnalysisWithCumulants.cxx:3090
 AliFlowAnalysisWithCumulants.cxx:3091
 AliFlowAnalysisWithCumulants.cxx:3092
 AliFlowAnalysisWithCumulants.cxx:3093
 AliFlowAnalysisWithCumulants.cxx:3094
 AliFlowAnalysisWithCumulants.cxx:3095
 AliFlowAnalysisWithCumulants.cxx:3096
 AliFlowAnalysisWithCumulants.cxx:3097
 AliFlowAnalysisWithCumulants.cxx:3098
 AliFlowAnalysisWithCumulants.cxx:3099
 AliFlowAnalysisWithCumulants.cxx:3100
 AliFlowAnalysisWithCumulants.cxx:3101
 AliFlowAnalysisWithCumulants.cxx:3102
 AliFlowAnalysisWithCumulants.cxx:3103
 AliFlowAnalysisWithCumulants.cxx:3104
 AliFlowAnalysisWithCumulants.cxx:3105
 AliFlowAnalysisWithCumulants.cxx:3106
 AliFlowAnalysisWithCumulants.cxx:3107
 AliFlowAnalysisWithCumulants.cxx:3108
 AliFlowAnalysisWithCumulants.cxx:3109
 AliFlowAnalysisWithCumulants.cxx:3110
 AliFlowAnalysisWithCumulants.cxx:3111
 AliFlowAnalysisWithCumulants.cxx:3112
 AliFlowAnalysisWithCumulants.cxx:3113
 AliFlowAnalysisWithCumulants.cxx:3114
 AliFlowAnalysisWithCumulants.cxx:3115
 AliFlowAnalysisWithCumulants.cxx:3116
 AliFlowAnalysisWithCumulants.cxx:3117
 AliFlowAnalysisWithCumulants.cxx:3118
 AliFlowAnalysisWithCumulants.cxx:3119
 AliFlowAnalysisWithCumulants.cxx:3120
 AliFlowAnalysisWithCumulants.cxx:3121
 AliFlowAnalysisWithCumulants.cxx:3122
 AliFlowAnalysisWithCumulants.cxx:3123
 AliFlowAnalysisWithCumulants.cxx:3124
 AliFlowAnalysisWithCumulants.cxx:3125
 AliFlowAnalysisWithCumulants.cxx:3126
 AliFlowAnalysisWithCumulants.cxx:3127
 AliFlowAnalysisWithCumulants.cxx:3128
 AliFlowAnalysisWithCumulants.cxx:3129
 AliFlowAnalysisWithCumulants.cxx:3130
 AliFlowAnalysisWithCumulants.cxx:3131
 AliFlowAnalysisWithCumulants.cxx:3132
 AliFlowAnalysisWithCumulants.cxx:3133
 AliFlowAnalysisWithCumulants.cxx:3134
 AliFlowAnalysisWithCumulants.cxx:3135
 AliFlowAnalysisWithCumulants.cxx:3136
 AliFlowAnalysisWithCumulants.cxx:3137
 AliFlowAnalysisWithCumulants.cxx:3138
 AliFlowAnalysisWithCumulants.cxx:3139
 AliFlowAnalysisWithCumulants.cxx:3140
 AliFlowAnalysisWithCumulants.cxx:3141
 AliFlowAnalysisWithCumulants.cxx:3142
 AliFlowAnalysisWithCumulants.cxx:3143
 AliFlowAnalysisWithCumulants.cxx:3144
 AliFlowAnalysisWithCumulants.cxx:3145
 AliFlowAnalysisWithCumulants.cxx:3146
 AliFlowAnalysisWithCumulants.cxx:3147
 AliFlowAnalysisWithCumulants.cxx:3148
 AliFlowAnalysisWithCumulants.cxx:3149
 AliFlowAnalysisWithCumulants.cxx:3150
 AliFlowAnalysisWithCumulants.cxx:3151
 AliFlowAnalysisWithCumulants.cxx:3152
 AliFlowAnalysisWithCumulants.cxx:3153
 AliFlowAnalysisWithCumulants.cxx:3154
 AliFlowAnalysisWithCumulants.cxx:3155
 AliFlowAnalysisWithCumulants.cxx:3156
 AliFlowAnalysisWithCumulants.cxx:3157
 AliFlowAnalysisWithCumulants.cxx:3158
 AliFlowAnalysisWithCumulants.cxx:3159
 AliFlowAnalysisWithCumulants.cxx:3160
 AliFlowAnalysisWithCumulants.cxx:3161
 AliFlowAnalysisWithCumulants.cxx:3162
 AliFlowAnalysisWithCumulants.cxx:3163
 AliFlowAnalysisWithCumulants.cxx:3164
 AliFlowAnalysisWithCumulants.cxx:3165
 AliFlowAnalysisWithCumulants.cxx:3166
 AliFlowAnalysisWithCumulants.cxx:3167
 AliFlowAnalysisWithCumulants.cxx:3168
 AliFlowAnalysisWithCumulants.cxx:3169
 AliFlowAnalysisWithCumulants.cxx:3170
 AliFlowAnalysisWithCumulants.cxx:3171
 AliFlowAnalysisWithCumulants.cxx:3172
 AliFlowAnalysisWithCumulants.cxx:3173
 AliFlowAnalysisWithCumulants.cxx:3174
 AliFlowAnalysisWithCumulants.cxx:3175
 AliFlowAnalysisWithCumulants.cxx:3176
 AliFlowAnalysisWithCumulants.cxx:3177
 AliFlowAnalysisWithCumulants.cxx:3178
 AliFlowAnalysisWithCumulants.cxx:3179
 AliFlowAnalysisWithCumulants.cxx:3180
 AliFlowAnalysisWithCumulants.cxx:3181
 AliFlowAnalysisWithCumulants.cxx:3182
 AliFlowAnalysisWithCumulants.cxx:3183
 AliFlowAnalysisWithCumulants.cxx:3184
 AliFlowAnalysisWithCumulants.cxx:3185
 AliFlowAnalysisWithCumulants.cxx:3186
 AliFlowAnalysisWithCumulants.cxx:3187
 AliFlowAnalysisWithCumulants.cxx:3188
 AliFlowAnalysisWithCumulants.cxx:3189
 AliFlowAnalysisWithCumulants.cxx:3190
 AliFlowAnalysisWithCumulants.cxx:3191
 AliFlowAnalysisWithCumulants.cxx:3192
 AliFlowAnalysisWithCumulants.cxx:3193
 AliFlowAnalysisWithCumulants.cxx:3194
 AliFlowAnalysisWithCumulants.cxx:3195
 AliFlowAnalysisWithCumulants.cxx:3196
 AliFlowAnalysisWithCumulants.cxx:3197
 AliFlowAnalysisWithCumulants.cxx:3198
 AliFlowAnalysisWithCumulants.cxx:3199
 AliFlowAnalysisWithCumulants.cxx:3200
 AliFlowAnalysisWithCumulants.cxx:3201
 AliFlowAnalysisWithCumulants.cxx:3202
 AliFlowAnalysisWithCumulants.cxx:3203
 AliFlowAnalysisWithCumulants.cxx:3204
 AliFlowAnalysisWithCumulants.cxx:3205
 AliFlowAnalysisWithCumulants.cxx:3206
 AliFlowAnalysisWithCumulants.cxx:3207
 AliFlowAnalysisWithCumulants.cxx:3208
 AliFlowAnalysisWithCumulants.cxx:3209
 AliFlowAnalysisWithCumulants.cxx:3210
 AliFlowAnalysisWithCumulants.cxx:3211
 AliFlowAnalysisWithCumulants.cxx:3212
 AliFlowAnalysisWithCumulants.cxx:3213
 AliFlowAnalysisWithCumulants.cxx:3214
 AliFlowAnalysisWithCumulants.cxx:3215
 AliFlowAnalysisWithCumulants.cxx:3216
 AliFlowAnalysisWithCumulants.cxx:3217
 AliFlowAnalysisWithCumulants.cxx:3218
 AliFlowAnalysisWithCumulants.cxx:3219
 AliFlowAnalysisWithCumulants.cxx:3220
 AliFlowAnalysisWithCumulants.cxx:3221
 AliFlowAnalysisWithCumulants.cxx:3222
 AliFlowAnalysisWithCumulants.cxx:3223
 AliFlowAnalysisWithCumulants.cxx:3224
 AliFlowAnalysisWithCumulants.cxx:3225
 AliFlowAnalysisWithCumulants.cxx:3226
 AliFlowAnalysisWithCumulants.cxx:3227
 AliFlowAnalysisWithCumulants.cxx:3228
 AliFlowAnalysisWithCumulants.cxx:3229
 AliFlowAnalysisWithCumulants.cxx:3230
 AliFlowAnalysisWithCumulants.cxx:3231
 AliFlowAnalysisWithCumulants.cxx:3232
 AliFlowAnalysisWithCumulants.cxx:3233
 AliFlowAnalysisWithCumulants.cxx:3234
 AliFlowAnalysisWithCumulants.cxx:3235
 AliFlowAnalysisWithCumulants.cxx:3236
 AliFlowAnalysisWithCumulants.cxx:3237
 AliFlowAnalysisWithCumulants.cxx:3238
 AliFlowAnalysisWithCumulants.cxx:3239
 AliFlowAnalysisWithCumulants.cxx:3240
 AliFlowAnalysisWithCumulants.cxx:3241
 AliFlowAnalysisWithCumulants.cxx:3242
 AliFlowAnalysisWithCumulants.cxx:3243
 AliFlowAnalysisWithCumulants.cxx:3244
 AliFlowAnalysisWithCumulants.cxx:3245
 AliFlowAnalysisWithCumulants.cxx:3246
 AliFlowAnalysisWithCumulants.cxx:3247
 AliFlowAnalysisWithCumulants.cxx:3248
 AliFlowAnalysisWithCumulants.cxx:3249
 AliFlowAnalysisWithCumulants.cxx:3250
 AliFlowAnalysisWithCumulants.cxx:3251
 AliFlowAnalysisWithCumulants.cxx:3252
 AliFlowAnalysisWithCumulants.cxx:3253
 AliFlowAnalysisWithCumulants.cxx:3254
 AliFlowAnalysisWithCumulants.cxx:3255
 AliFlowAnalysisWithCumulants.cxx:3256
 AliFlowAnalysisWithCumulants.cxx:3257
 AliFlowAnalysisWithCumulants.cxx:3258
 AliFlowAnalysisWithCumulants.cxx:3259
 AliFlowAnalysisWithCumulants.cxx:3260
 AliFlowAnalysisWithCumulants.cxx:3261
 AliFlowAnalysisWithCumulants.cxx:3262
 AliFlowAnalysisWithCumulants.cxx:3263
 AliFlowAnalysisWithCumulants.cxx:3264
 AliFlowAnalysisWithCumulants.cxx:3265
 AliFlowAnalysisWithCumulants.cxx:3266
 AliFlowAnalysisWithCumulants.cxx:3267
 AliFlowAnalysisWithCumulants.cxx:3268
 AliFlowAnalysisWithCumulants.cxx:3269
 AliFlowAnalysisWithCumulants.cxx:3270
 AliFlowAnalysisWithCumulants.cxx:3271
 AliFlowAnalysisWithCumulants.cxx:3272
 AliFlowAnalysisWithCumulants.cxx:3273
 AliFlowAnalysisWithCumulants.cxx:3274
 AliFlowAnalysisWithCumulants.cxx:3275
 AliFlowAnalysisWithCumulants.cxx:3276
 AliFlowAnalysisWithCumulants.cxx:3277
 AliFlowAnalysisWithCumulants.cxx:3278
 AliFlowAnalysisWithCumulants.cxx:3279
 AliFlowAnalysisWithCumulants.cxx:3280
 AliFlowAnalysisWithCumulants.cxx:3281
 AliFlowAnalysisWithCumulants.cxx:3282
 AliFlowAnalysisWithCumulants.cxx:3283
 AliFlowAnalysisWithCumulants.cxx:3284
 AliFlowAnalysisWithCumulants.cxx:3285
 AliFlowAnalysisWithCumulants.cxx:3286
 AliFlowAnalysisWithCumulants.cxx:3287
 AliFlowAnalysisWithCumulants.cxx:3288
 AliFlowAnalysisWithCumulants.cxx:3289
 AliFlowAnalysisWithCumulants.cxx:3290
 AliFlowAnalysisWithCumulants.cxx:3291
 AliFlowAnalysisWithCumulants.cxx:3292
 AliFlowAnalysisWithCumulants.cxx:3293