improved the look of the figure to compare the different methods

diff --git a/PWG2/FLOW/macros/CompareFlowResults.C b/PWG2/FLOW/macros/CompareFlowResults.C
index bcdf27350080128d0116c98d4919e119854e2fce..2f56eecbaf849f9fde2a7cebbb7dae66c79e5f4c 100644 (file)
--- a/PWG2/FLOW/macros/CompareFlowResults.C
+++ b/PWG2/FLOW/macros/CompareFlowResults.C
@@ -9,334 +9,544 @@ void CompareFlowResults()
  gSystem->Load("libPWG2flow.so");
  cerr<<"libPWG2flow.so loaded ..."<<endl;
  cout<<endl;
+  
 
- //removing the title and stat. box from all histograms:
- gStyle->SetOptTitle(0);
- gStyle->SetOptStat(0);
- 
- //choosing the style and color of mesh for MC error bands:
- Int_t meshStyle = 3044;//see documentation of TAttFill
- Int_t meshColor = kRed-4;
- 
+ //==================================================================================
+ //                         accessing output files
+ //==================================================================================
  //type of analysis was: ESD, AOD, MC, ESDMC0, ESDMC1
  const TString type = "ESD";
  
  //open the output files:
  TString inputFileNameMCEP = "outputMCEPanalysis";
- TFile* file_MCEP = NULL;
- file_MCEP = TFile::Open(((inputFileNameMCEP.Append(type)).Append(".root")).Data(), "READ"); 
+ TFile* fileMCEP = NULL;
+ fileMCEP = TFile::Open(((inputFileNameMCEP.Append(type)).Append(".root")).Data(), "READ"); 
  
  TString inputFileNameLYZ1 = "outputLYZ1analysis";
- TFile* file_LYZ1 = NULL;
- file_LYZ1 = TFile::Open(((inputFileNameLYZ1.Append(type)).Append("_firstrun.root")).Data(), "READ"); 
+ TFile* fileLYZ1 = NULL;
+ fileLYZ1 = TFile::Open(((inputFileNameLYZ1.Append(type)).Append("_firstrun.root")).Data(), "READ"); 
+
+ TString inputFileNameLYZ2 = "outputLYZ2analysis";
+ TFile* fileLYZ2 = NULL;
+ fileLYZ2 = TFile::Open(((inputFileNameLYZ2.Append(type)).Append("_secondrun.root")).Data(), "READ"); 
  
- /*
- TString inputFileNameSP = "outputSPanalysis";
- TFile* file_SP = NULL;
- file_SP = TFile::Open(((inputFileNameSP.Append(type)).Append(".root")).Data(), "READ"); 
- */
+ TString inputFileNameLYZEP = "outputLYZEPanalysis";
+ TFile* fileLYZEP = NULL;
+ fileLYZEP = TFile::Open(((inputFileNameLYZEP.Append(type)).Append(".root")).Data(), "READ");
  
  TString inputFileNameFQD = "outputFQDanalysis";
- TFile* file_FQD = NULL;
- file_FQD = TFile::Open(((inputFileNameFQD.Append(type)).Append(".root")).Data(), "READ"); 
+ TFile* fileFQD = NULL;
+ fileFQD = TFile::Open(((inputFileNameFQD.Append(type)).Append(".root")).Data(), "READ"); 
  
  TString inputFileNameGFC = "outputGFCanalysis";
- TFile* file_GFC = NULL;
- file_GFC = TFile::Open(((inputFileNameGFC.Append(type)).Append(".root")).Data(), "READ"); 
+ TFile* fileGFC = NULL;
+ fileGFC = TFile::Open(((inputFileNameGFC.Append(type)).Append(".root")).Data(), "READ"); 
  
  TString inputFileNameQC = "outputQCanalysis";
- TFile* file_QC = NULL;
- file_QC = TFile::Open(((inputFileNameQC.Append(type)).Append(".root")).Data(), "READ"); 
+ TFile* fileQC = NULL;
+ fileQC = TFile::Open(((inputFileNameQC.Append(type)).Append(".root")).Data(), "READ"); 
+ //==================================================================================
+ 
+ //==================================================================================
+ //                                 cosmetics
+ //==================================================================================
+ //removing the title and stat. box from all histograms:
+ gStyle->SetOptTitle(0);
+ gStyle->SetOptStat(0);
+ 
+ //choosing the style and color of mesh for MC error bands:
+ Int_t meshStyle = 1001;
+ Int_t meshColor = kRed-10;
+
+ //marker style and color (int. flow) 
+ Int_t markerStyle = 21;
+ Int_t markerColor = kRed-3;
+ //==================================================================================
 
+   
+      
+         
+               
  //==================================================================================
  //                              INTEGRATED FLOW
  //==================================================================================
- 
- //booking the histogram for the integrated flow results from all methods
- TH1D* intFlow = new TH1D("intFlow","Integrated Flow",11,0,11);  
+ //the number of different methods:
+ const Int_t nMethods=12;
 
- intFlow->SetLabelSize(0.044);
- intFlow->SetMarkerStyle(21);
- intFlow->SetMarkerColor(kRed-4);
- (intFlow->GetXaxis())->SetBinLabel(1,"v_{n}{MC}");
- (intFlow->GetXaxis())->SetBinLabel(2,"v_{n}{LYZ}");
- (intFlow->GetXaxis())->SetBinLabel(3,"v_{n}{FQD}");
- (intFlow->GetXaxis())->SetBinLabel(4,"v_{n}{2}");
- (intFlow->GetXaxis())->SetBinLabel(5,"v_{n}{4}");
- (intFlow->GetXaxis())->SetBinLabel(6,"v_{n}{6}");
- (intFlow->GetXaxis())->SetBinLabel(7,"v_{n}{8}");
- (intFlow->GetXaxis())->SetBinLabel(8,"v_{n}^{Q}{2}");
- (intFlow->GetXaxis())->SetBinLabel(9,"v_{n}^{Q}{4}");
- (intFlow->GetXaxis())->SetBinLabel(10,"v_{n}^{Q}{6}");
- (intFlow->GetXaxis())->SetBinLabel(11,"v_{n}^{Q}{8}"); 
- 
+ //booking the histogram for the integrated flow results from all methods:
+ TH1D* intFlowAll = new TH1D("intFlowAll","Integrated Flow",nMethods,0,nMethods);      
+ //intFlowAll->SetLabelSize(0.036,"X");
+ //intFlowAll->SetLabelSize(0.036,"Y");
+ intFlowAll->SetMarkerStyle(markerStyle);
+ intFlowAll->SetMarkerColor(markerColor);
+ (intFlowAll->GetXaxis())->SetBinLabel(1,"v_{2}{MC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(2,"v_{2}{2,GFC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(3,"v_{2}{2,QC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(4,"v_{2}{4,GFC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(5,"v_{2}{4,QC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(6,"v_{2}{6,GFC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(7,"v_{2}{6,QC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(8,"v_{2}{8,GFC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(9,"v_{2}{8,QC}");
+ (intFlowAll->GetXaxis())->SetBinLabel(10,"v_{2}{FQD}");
+ (intFlowAll->GetXaxis())->SetBinLabel(11,"v_{2}{LYZ}");
+ (intFlowAll->GetXaxis())->SetBinLabel(12,"v_{2}{LYZEP}");
+ 
+ //booking the graph to store flow values and errors from all methods:  
+ Double_t x[nMethods] = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 11.5};
+ Double_t xError[nMethods] = {0.};
+ Double_t flowValue[nMethods] = {0.};
+ Double_t flowError[nMethods] = {0.};
+ 
+ //accessing the results for each method:
  //MCEP = Monte Carlo Event Plane
  TList *pListMCEP = NULL;
+ AliFlowCommonHist *mcepCommonHist = NULL;
  AliFlowCommonHistResults *mcepCommonHistRes = NULL; 
- if(file_MCEP) 
+ if(fileMCEP) 
  {
-  file_MCEP->GetObject("cobjMCEP",pListMCEP); 
+  fileMCEP->GetObject("cobjMCEP",pListMCEP); 
   if(pListMCEP) 
   {
    mcepCommonHist    = dynamic_cast<AliFlowCommonHist*> (pListMCEP->FindObject("AliFlowCommonHistMCEP"));
    mcepCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (pListMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
    if(mcepCommonHistRes)
    {
-    intFlow->SetBinContent(1,(mcepCommonHistRes->GetHistIntFlow())->GetBinContent(1));   
-    intFlow->SetBinError(1,(mcepCommonHistRes->GetHistIntFlow())->GetBinError(1));
+    flowValue[0] = (mcepCommonHistRes->GetHistIntFlow())->GetBinContent(1);
+    flowError[0] = (mcepCommonHistRes->GetHistIntFlow())->GetBinError(1);
    }
   }
  }
  
  //LYZ1 = Lee-Yang Zeros (1st run)
  TList *pListLYZ1 = NULL;
- AliFlowCommonHistResults *lyz1 = NULL; 
- if(file_LYZ1) 
+ AliFlowCommonHist *lyz1CommonHist = NULL;
+ AliFlowCommonHistResults *lyz1CommonHistRes = NULL; 
+ if(fileLYZ1) 
  {
-  file_LYZ1->GetObject("cobjLYZ1",pListLYZ1); 
+  fileLYZ1->GetObject("cobjLYZ1",pListLYZ1); 
   if(pListLYZ1) 
   {
-   lyz1 = dynamic_cast<AliFlowCommonHistResults*> (pListLYZ1->FindObject("AliFlowCommonHistResultsLYZ"));
-   if(lyz1)
+   lyz1CommonHist = dynamic_cast<AliFlowCommonHist*> (pListLYZ1->FindObject("AliFlowCommonHistLYZ1"));
+   lyz1CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (pListLYZ1->FindObject("AliFlowCommonHistResultsLYZ1"));
+   if(lyz1CommonHistRes)
+   {
+    flowValue[10] = (lyz1CommonHistRes->GetHistIntFlow())->GetBinContent(1);
+    flowError[10] = (lyz1CommonHistRes->GetHistIntFlow())->GetBinError(1);
+   }
+  }
+ }
+ 
+ //LYZ2 = Lee-Yang Zeros (2nd run) (needed only for differential flow)
+ TList *pListLYZ2 = NULL;
+ AliFlowCommonHist *lyz2CommonHist = NULL;
+ AliFlowCommonHistResults *lyz2CommonHistRes = NULL; 
+ if(fileLYZ2) 
+ {
+  fileLYZ2->GetObject("cobjLYZ2",pListLYZ2); 
+  if(pListLYZ2) 
+  {
+   lyz2CommonHist = dynamic_cast<AliFlowCommonHist*> (pListLYZ2->FindObject("AliFlowCommonHistLYZ2"));
+   lyz2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (pListLYZ2->FindObject("AliFlowCommonHistResultsLYZ2"));
+  }
+ }
+
+ //LYZEP = Lee-Yang Zeros Event Plane
+ TList *pListLYZEP = NULL;
+ AliFlowCommonHist *lyzepCommonHist = NULL;
+ AliFlowCommonHistResults *lyzepCommonHistRes = NULL; 
+ if(fileLYZEP) 
+ {
+  fileLYZEP->GetObject("cobjLYZEP",pListLYZEP); 
+  if(pListLYZEP) 
+  {
+   lyzepCommonHist = dynamic_cast<AliFlowCommonHist*> (pListLYZEP->FindObject("AliFlowCommonHistLYZEP"));
+   lyzepCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (pListLYZEP->FindObject("AliFlowCommonHistResultsLYZEP"));
+   if(lyzepCommonHistRes)
    {
-    intFlow->SetBinContent(2,(lyz1->GetHistIntFlow())->GetBinContent(1));   
-    intFlow->SetBinError(2,(lyz1->GetHistIntFlow())->GetBinError(1));
+    flowValue[11] = (lyzepCommonHistRes->GetHistIntFlow())->GetBinContent(1);
+    //flowError[11] = (lyzepCommonHistRes->GetHistIntFlow())->GetBinError(1);
    }
   }
  }
  
  //FQD = Fitting q-distribution
  TList *pListFQD = NULL;
- AliFlowCommonHistResults *fqd = NULL; 
- if(file_FQD) 
+ AliFlowCommonHist *fqdCommonHist = NULL;
+ AliFlowCommonHistResults *fqdCommonHistRes = NULL; 
+ if(fileFQD) 
  {
-  file_FQD->GetObject("cobjFQD",pListFQD); 
+  fileFQD->GetObject("cobjFQD",pListFQD); 
   if(pListFQD) 
   {
-   fqd = dynamic_cast<AliFlowCommonHistResults*> (pListFQD->FindObject("AliFlowCommonHistResultsFQD"));
-   if(fqd)
+   fqdCommonHist = dynamic_cast<AliFlowCommonHist*> (pListFQD->FindObject("AliFlowCommonHistFQD"));
+   fqdCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (pListFQD->FindObject("AliFlowCommonHistResultsFQD"));
+   if(fqdCommonHistRes)
    {
-    intFlow->SetBinContent(3,(fqd->GetHistIntFlow())->GetBinContent(1));   
-    intFlow->SetBinError(3,(fqd->GetHistIntFlow())->GetBinError(1));
+    flowValue[9] = (fqdCommonHistRes->GetHistIntFlow())->GetBinContent(1);
+    flowError[9] = (fqdCommonHistRes->GetHistIntFlow())->GetBinError(1);
    }
   }
  }
  
  //GFC = Generating Function Cumulants
  TList *pListGFC = NULL;
- AliFlowCommonHistResults *gfc2 = NULL; 
- AliFlowCommonHistResults *gfc4 = NULL; 
- AliFlowCommonHistResults *gfc6 = NULL; 
- AliFlowCommonHistResults *gfc8 = NULL; 
- if(file_GFC) 
+ AliFlowCommonHist *gfcCommonHist = NULL;
+ AliFlowCommonHistResults *gfcCommonHistRes2 = NULL; 
+ AliFlowCommonHistResults *gfcCommonHistRes4 = NULL; 
+ AliFlowCommonHistResults *gfcCommonHistRes6 = NULL; 
+ AliFlowCommonHistResults *gfcCommonHistRes8 = NULL; 
+ if(fileGFC) 
  {
-  file_GFC->GetObject("cobjGFC",pListGFC);
+  fileGFC->GetObject("cobjGFC",pListGFC);
   if(pListGFC) 
   {
-   gfc2 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
-   if(gfc2) 
+   gfcCommonHist = dynamic_cast<AliFlowCommonHist*> (pListGFC->FindObject("AliFlowCommonHistGFC"));
+   gfcCommonHistRes2 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
+   if(gfcCommonHistRes2) 
    {
-    intFlow->SetBinContent(4,(gfc2->GetHistIntFlow())->GetBinContent(1)); 
-    intFlow->SetBinError(4,(gfc2->GetHistIntFlow())->GetBinError(1));
+    flowValue[1] = (gfcCommonHistRes2->GetHistIntFlow())->GetBinContent(1);
+    flowError[1] = (gfcCommonHistRes2->GetHistIntFlow())->GetBinError(1);
    }
-   gfc4 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
-   if(gfc4) 
+   gfcCommonHistRes4 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
+   if(gfcCommonHistRes4) 
    {
-    intFlow->SetBinContent(5,(gfc4->GetHistIntFlow())->GetBinContent(1));
-    intFlow->SetBinError(5,(gfc4->GetHistIntFlow())->GetBinError(1));
+    flowValue[3] = (gfcCommonHistRes4->GetHistIntFlow())->GetBinContent(1);
+    flowError[3] = (gfcCommonHistRes4->GetHistIntFlow())->GetBinError(1);
    }
-   gfc6 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
-   if(gfc6) 
+   gfcCommonHistRes6 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
+   if(gfcCommonHistRes6) 
    {
-    intFlow->SetBinContent(6,(gfc6->GetHistIntFlow())->GetBinContent(1)); 
-    intFlow->SetBinError(6,(gfc6->GetHistIntFlow())->GetBinError(1));
+    flowValue[5] = (gfcCommonHistRes6->GetHistIntFlow())->GetBinContent(1);
+    flowError[5] = (gfcCommonHistRes6->GetHistIntFlow())->GetBinError(1);
    }
-   gfc8 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
-   if(gfc8) 
+   gfcCommonHistRes8 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
+   if(gfcCommonHistRes8) 
    {
-    intFlow->SetBinContent(7,(gfc8->GetHistIntFlow())->GetBinContent(1));
-    intFlow->SetBinError(7,(gfc8->GetHistIntFlow())->GetBinError(1));
+    flowValue[7] = (gfcCommonHistRes8->GetHistIntFlow())->GetBinContent(1);
+    flowError[7] = (gfcCommonHistRes8->GetHistIntFlow())->GetBinError(1);
    }
   }
  }
  
  //QC = Q-cumulants
  TList *pListQC = NULL;
- AliFlowCommonHist *qcCommonHist2 = NULL, *qcCommonHist4 = NULL;
+ AliFlowCommonHist *qcCommonHist2 = NULL; 
+ AliFlowCommonHist *qcCommonHist4 = NULL; 
+ AliFlowCommonHist *qcCommonHist6 = NULL; 
+ AliFlowCommonHist *qcCommonHist8 = NULL; 
  AliFlowCommonHistResults *qcCommonHistRes2 = NULL; 
  AliFlowCommonHistResults *qcCommonHistRes4 = NULL; 
  AliFlowCommonHistResults *qcCommonHistRes6 = NULL; 
  AliFlowCommonHistResults *qcCommonHistRes8 = NULL; 
- if(file_QC) 
+ 
+ if(fileQC) 
  {
-  file_QC->GetObject("cobjQC",pListQC);
+  fileQC->GetObject("cobjQC",pListQC);
   if(pListQC) 
   {
-   qcCommonHist2 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHistQC"));//to be improved
+   qcCommonHist2 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHist2ndOrderQC"));
    qcCommonHistRes2 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
    if(qcCommonHistRes2) 
    {
-    intFlow->SetBinContent(8,(qcCommonHistRes2->GetHistIntFlow())->GetBinContent(1)); 
-    intFlow->SetBinError(8,(qcCommonHistRes2->GetHistIntFlow())->GetBinError(1));
+    flowValue[2] = (qcCommonHistRes2->GetHistIntFlow())->GetBinContent(1);
+    //flowError[2] = (qcCommonHistRes2->GetHistIntFlow())->GetBinError(1);
    }
-   qcCommonHist4 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHistQC"));//to be improved
+   qcCommonHist4 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHist4thOrderQC"));
    qcCommonHistRes4 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
    if(qcCommonHistRes4) 
    {
-    intFlow->SetBinContent(9,(qcCommonHistRes4->GetHistIntFlow())->GetBinContent(1));
-    intFlow->SetBinError(9,(qcCommonHistRes4->GetHistIntFlow())->GetBinError(1));
+    flowValue[4] = (qcCommonHistRes4->GetHistIntFlow())->GetBinContent(1);
+    //flowError[4] = (qcCommonHistRes4->GetHistIntFlow())->GetBinError(1);
    }
+   qcCommonHist6 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHist6thOrderQC"));
    qcCommonHistRes6 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
    if(qcCommonHistRes6) 
    {
-    intFlow->SetBinContent(10,(qcCommonHistRes6->GetHistIntFlow())->GetBinContent(1)); 
-    intFlow->SetBinError(10,(qcCommonHistRes6->GetHistIntFlow())->GetBinError(1));
+    flowValue[6] = (qcCommonHistRes6->GetHistIntFlow())->GetBinContent(1);
+    //flowError[6] = (qcCommonHistRes6->GetHistIntFlow())->GetBinError(1);
    }
+   qcCommonHist8 = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHist8thOrderQC"));
    qcCommonHistRes8 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
    if(qcCommonHistRes8) 
    {
-    intFlow->SetBinContent(11,(qcCommonHistRes8->GetHistIntFlow())->GetBinContent(1));
-    intFlow->SetBinError(11,(qcCommonHistRes8->GetHistIntFlow())->GetBinError(1));
+    flowValue[8] = (qcCommonHistRes8->GetHistIntFlow())->GetBinContent(1);
+    //flowError[8] = (qcCommonHistRes8->GetHistIntFlow())->GetBinError(1);
    }
   }
- }
+ }        
+
+ Double_t dMax=flowValue[0]+flowError[0];
+ Double_t dMin=flowValue[0]-flowError[0];
+
+ for(Int_t i=1;i<nMethods;i++)
+ {
+  if(!(flowValue[i]==0. && flowError[i]==0.)) 
+  {
+   if(dMax<flowValue[i]+flowError[i]) dMax=flowValue[i]+flowError[i];
+   if(dMin>flowValue[i]-flowError[i]) dMin=flowValue[i]-flowError[i];
+  } 
+ }  
+                                                                                                                                                                                    
+ TGraph* flowResults = new TGraphErrors(nMethods, x, flowValue, xError, flowError);
  
+ flowResults->SetMarkerStyle(markerStyle);
+ flowResults->SetMarkerColor(markerColor);
+ //-----------------------------------------------------------------------------------
+  
  //----------------------------------------------------------------------------------
  //cosmetics: mesh for MC error bands (integrated flow)
- TGraph* pGraphIF = NULL;
- if(intFlow && mcepCommonHistRes)
- {
-  Double_t valueMC = intFlow->GetBinContent(1);
-  Double_t errorMC = intFlow->GetBinError(1);  
-  Int_t nPts       = intFlow->GetNbinsX();     
-     
-  pGraphIF = new TGraph(nPts); 
+ TGraph* pMesh = NULL;
+ if(intFlowAll && mcepCommonHistRes)
+ {
+  //Double_t valueMC = intFlowAll->GetBinContent(1);
+  //Double_t errorMC = intFlowAll->GetBinError(1);  
+  //Int_t nPts       = intFlowAll->GetNbinsX();     
+
+  Double_t valueMC = flowValue[0];
+  Double_t errorMC = flowError[0];  
+  Int_t nPts       = nMethods;     
+       
+  pMesh = new TGraph(nPts); 
   
-  pGraphIF->SetPoint(1,0,valueMC+errorMC);
-  pGraphIF->SetPoint(2,nPts+1,valueMC+errorMC);
-  pGraphIF->SetPoint(3,nPts+1,valueMC-errorMC);
-  pGraphIF->SetPoint(4,0,valueMC-errorMC);
-  pGraphIF->SetPoint(5,0,valueMC+errorMC);
+  pMesh->SetPoint(1,0,valueMC+errorMC);
+  pMesh->SetPoint(2,nPts+1,valueMC+errorMC);
+  pMesh->SetPoint(3,nPts+1,valueMC-errorMC);
+  pMesh->SetPoint(4,0,valueMC-errorMC);
+  pMesh->SetPoint(5,0,valueMC+errorMC);
   
-  pGraphIF->SetFillStyle(meshStyle);
-  pGraphIF->SetFillColor(meshColor);
+  pMesh->SetFillStyle(meshStyle);
+  pMesh->SetFillColor(meshColor);
  }
-  
- /*                     
- //cosmetics: legend     
- TString *avM = new TString("M = ");//to be improved
- TString *nEvts = new TString("N = ");//to be improved
- TLegend *legendIntFlow = new TLegend(0.15,0.15,0.44,0.35);
- legendIntFlow->SetTextFont(72);
- legendIntFlow->SetTextSize(0.03);
- if(qcCommonHist2)
- {
-  (*avM)+=(qcCommonHist->GetHistMultInt())->GetMean();//to be improved
-  (*N)+=(Long_t)(qcCommonHist->GetHistMultInt())->GetEntries();//to be improved
-  legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),avM->Data(),"");
-  legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),N->Data(),"");
- }
- */
+ //---------------------------------------------------------------------------------- 
  
- /*
- //cosmetics: legend (integrated flow)    
- TString *entryMC  = new TString("MC ......... ");
- TString *entryQC2 = new TString("QC{2} .... ");
- TString *entryQC4 = new TString("QC{4} .... ");
  
- TLegend *legendIntFlow = new TLegend(0.15,0.15,0.44,0.35); 
- legendIntFlow->SetTextFont(72);
- legendIntFlow->SetTextSize(0.03);
+ //----------------------------------------------------------------------------------
+ //cosmetics: text (integrated flow) 
+ //default text:
+ TPaveText *textDefault = new TPaveText(0.05,0.77,0.95,0.90,"NDC");
+ textDefault->SetTextFont(72);
+ textDefault->SetTextSize(0.08);
+ //textDefault->SetLineColor(kFALSE);
+ //textDefault->SetShadowColor(kFALSE);
+
+ TString *entryDefaultAvM = new TString("Average Multiplicity");
+ TString *entryDefaultAnd = new TString("and"); 
+ TString *entryDefaultNumOfEvts = new TString("Number of Events:");
+
+ textDefault->AddText(entryDefaultAvM->Data());
+ textDefault->AddText(entryDefaultAnd->Data());
+ textDefault->AddText(entryDefaultNumOfEvts->Data());
+ 
+ //results:
+ TPaveText *textResults = new TPaveText(0.05,0.12,0.95,0.70,"NDC");
+ textResults->SetTextFont(72);
+ textResults->SetTextSize(0.06);
+ //textResults->SetLineColor(kFALSE);
+ //textResults->SetShadowColor(kFALSE);
+       
+ TString *entryMC    = new TString("MC ...... ");
+ TString *entryGFC   = new TString("GFC ..... "); 
+ TString *entryQC2   = new TString("QC{2} ... ");
+ TString *entryQC4   = new TString("QC{4} ... ");
+ TString *entryQC6   = new TString("QC{6} ... ");
+ TString *entryQC8   = new TString("QC{8} ... ");
+ TString *entryFQD   = new TString("FQD ..... "); 
+ TString *entryLYZ1  = new TString("LYZ ..... "); 
+ TString *entryLYZEP = new TString("LYZEP ... "); 
+
+ Double_t avMultMC=0.;
+ Long_t nEvtsMC=0;
+
+ Double_t avMultGFC=0.;
+ Long_t nEvtsGFC=0;
+  
+ Double_t avMultQC2=0., avMultQC4=0., avMultQC6=0., avMultQC8=0.;
+ Long_t nEvtsQC2=0, nEvtsQC4=0, nEvtsQC6=0, nEvtsQC8=0;
+
+ Double_t avMultFQD=0.;
+ Long_t nEvtsFQD=0;
+
+ Double_t avMultLYZ1=0.;
+ Long_t nEvtsLYZ1=0;
  
+ Double_t avMultLYZEP=0.;
+ Long_t nEvtsLYZEP=0;
  
- Double_t avMultMC=0., avMultQC2=0., avMultQC4=0.;
- Long_t nEvtsMC=0, nEvtsQC2=0, nEvtsQC4=0;
+ //MC:  
  if(mcepCommonHist)
  {
   avMultMC = (mcepCommonHist->GetHistMultInt())->GetMean();
   nEvtsMC  = (mcepCommonHist->GetHistMultInt())->GetEntries();
+ }
+ if(entryMC)
+ {   
   entryMC->Append("M = ");
   (*entryMC)+=(Long_t)avMultMC;
   entryMC->Append(", N = ");
   (*entryMC)+=(Long_t)nEvtsMC;
-  legendIntFlow->AddEntry(mcepCommonHist->GetHistMultInt(),entryMC->Data(),"f");
  }
+ 
+ //GFC:
+ if(gfcCommonHist)
+ {
+  avMultGFC = (gfcCommonHist->GetHistMultInt())->GetMean();
+  nEvtsGFC  = (gfcCommonHist->GetHistMultInt())->GetEntries();
+ }
+ if(entryGFC)
+ { 
+  entryGFC->Append("M = ");
+  (*entryGFC)+=(Long_t)avMultGFC;
+  entryGFC->Append(", N = ");
+  (*entryGFC)+=(Long_t)nEvtsGFC;
+ }
+ 
+ //QC:
  if(qcCommonHist2)
  {
   avMultQC2 = (qcCommonHist2->GetHistMultInt())->GetMean();
   nEvtsQC2  = (qcCommonHist2->GetHistMultInt())->GetEntries();
+ } 
+ if(entryQC2)
+ { 
   entryQC2->Append("M = ");
   (*entryQC2)+=(Long_t)avMultQC2;
   entryQC2->Append(", N = ");
   (*entryQC2)+=(Long_t)nEvtsQC2;
-  legendIntFlow->AddEntry(qcCommonHist2->GetHistMultInt(),entryQC2->Data(),"f");
  }
  if(qcCommonHist4)
  {
   avMultQC4 = (qcCommonHist4->GetHistMultInt())->GetMean();
   nEvtsQC4  = (qcCommonHist4->GetHistMultInt())->GetEntries();
+ }
+ if(entryQC4)
+ {
   entryQC4->Append("M = ");
   (*entryQC4)+=(Long_t)avMultQC4;
   entryQC4->Append(", N = ");
   (*entryQC4)+=(Long_t)nEvtsQC4;
-  legendIntFlow->AddEntry(qcCommonHist4->GetHistMultInt(),entryQC4->Data(),"f");
  }
- */ 
- 
- 
+ if(qcCommonHist6)
+ {
+  avMultQC6 = (qcCommonHist6->GetHistMultInt())->GetMean();
+  nEvtsQC6  = (qcCommonHist6->GetHistMultInt())->GetEntries();
+ }
+ if(entryQC6)
+ {  
+  entryQC6->Append("M = ");
+  (*entryQC6)+=(Long_t)avMultQC6;
+  entryQC6->Append(", N = ");
+  (*entryQC6)+=(Long_t)nEvtsQC6;
+ }
+ if(qcCommonHist8)
+ {
+  avMultQC8 = (qcCommonHist8->GetHistMultInt())->GetMean();
+  nEvtsQC8  = (qcCommonHist8->GetHistMultInt())->GetEntries();
+ }
+ if(entryQC8)
+ {
+  entryQC8->Append("M = ");
+  (*entryQC8)+=(Long_t)avMultQC8;
+  entryQC8->Append(", N = ");
+  (*entryQC8)+=(Long_t)nEvtsQC8;
+ }
  
- //cosmetics: text (integrated flow)    
- TString *entryMC  = new TString("MC ......... ");
- TString *entryQC2 = new TString("QC{2} .... ");
- TString *entryQC4 = new TString("QC{4} .... ");
+ //FQD:
+ if(fqdCommonHist)
+ {
+  avMultFQD = (fqdCommonHist->GetHistMultInt())->GetMean();
+  nEvtsFQD  = (fqdCommonHist->GetHistMultInt())->GetEntries();
+ } 
+ if(entryFQD)
+ {
+  entryFQD->Append("M = ");
+  (*entryFQD)+=(Long_t)avMultFQD;
+  entryFQD->Append(", N = ");
+  (*entryFQD)+=(Long_t)nEvtsFQD;
+ }
  
- TPaveText *text = new TPaveText(0.15,0.15,0.44,0.35,"NDC");
- text->SetTextFont(72);
- text->SetTextSize(0.03);
+ //LYZ1:
+ if(lyz1CommonHist)
+ {
+  avMultLYZ1 = (lyz1CommonHist->GetHistMultInt())->GetMean();
+  nEvtsLYZ1  = (lyz1CommonHist->GetHistMultInt())->GetEntries();
+ }
+ if(entryLYZ1) 
+ {
+  entryLYZ1->Append("M = ");
+  (*entryLYZ1)+=(Long_t)avMultLYZ1;
+  entryLYZ1->Append(", N = ");
+  (*entryLYZ1)+=(Long_t)nEvtsLYZ1;
+ }
  
- Double_t avMultMC=0., avMultQC2=0., avMultQC4=0.;
- Long_t nEvtsMC=0, nEvtsQC2=0, nEvtsQC4=0;
- if(mcepCommonHist)
+ //LYZEP:
+ if(lyzepCommonHist)
  {
-  avMultMC = (mcepCommonHist->GetHistMultInt())->GetMean();
-  nEvtsMC  = (mcepCommonHist->GetHistMultInt())->GetEntries();
-  entryMC->Append("M = ");
-  (*entryMC)+=(Long_t)avMultMC;
-  entryMC->Append(", N = ");
-  (*entryMC)+=(Long_t)nEvtsMC;
-  text->AddText(entryMC->Data());
+  avMultcLYZEP = (lyzepCommonHist->GetHistMultInt())->GetMean();
+  nEvtsLYZEP  = (lyzepCommonHist->GetHistMultInt())->GetEntries();
  }
- if(qcCommonHist2)
+ if(entryLYZEP)
  {
-  avMultQC2 = (qcCommonHist2->GetHistMultInt())->GetMean();
-  nEvtsQC2  = (qcCommonHist2->GetHistMultInt())->GetEntries();
-  entryQC2->Append("M = ");
-  (*entryQC2)+=(Long_t)avMultQC2;
-  entryQC2->Append(", N = ");
-  (*entryQC2)+=(Long_t)nEvtsQC2;
-  text->AddText(entryQC2->Data());
+  entryLYZEP->Append("M = ");
+  (*entryLYZEP)+=(Long_t)avMultLYZEP;
+  entryLYZEP->Append(", N = ");
+  (*entryLYZEP)+=(Long_t)nEvtsLYZEP;
  }
- if(qcCommonHist4)
+ 
+ if(textResults)
  {
-  avMultQC4 = (qcCommonHist4->GetHistMultInt())->GetMean();
-  nEvtsQC4  = (qcCommonHist4->GetHistMultInt())->GetEntries();
-  entryQC4->Append("M = ");
-  (*entryQC4)+=(Long_t)avMultQC4;
-  entryQC4->Append(", N = ");
-  (*entryQC4)+=(Long_t)nEvtsQC4;
-  text->AddText(entryQC4->Data());
+  textResults->AddText(entryMC->Data());
+  textResults->AddText(entryGFC->Data());
+  textResults->AddText(entryQC2->Data());
+  textResults->AddText(entryQC4->Data());
+  textResults->AddText(entryQC6->Data());
+  textResults->AddText(entryQC8->Data());
+  textResults->AddText(entryFQD->Data());
+  textResults->AddText(entryLYZ1->Data());
+  textResults->AddText(entryLYZEP->Data());
  }
+ //----------------------------------------------------------------------------------
  
  //----------------------------------------------------------------------------------
+ //final drawing for integrated flow:
+ TCanvas* intFlowAllCanvas = new TCanvas("Integrated Flow","Integrated Flow",1000,600);
  
- //drawing everything for integrated flow:
- TCanvas* intFlowCanvas = new TCanvas("Integrated Flow","Integrated Flow",1000,600);
+ intFlowAllCanvas->Divide(2,1);
  
- if(intFlow) intFlow->Draw("E1");      
- if(pGraphIF) pGraphIF->Draw("LFSAME");                    
- //if(legendIntFlow) legendIntFlow->Draw("");   
- text->Draw("SAME");
+ //1st pad is for plot:
+ (intFlowAllCanvas->cd(1))->SetPad(0.0,0.0,0.75,1.0);
  
+ if(intFlowAll)
+ {
+  if(dMin>0. && dMax>0.)
+  {
+   (intFlowAll->GetYaxis())->SetRangeUser(0.9744*dMin,1.0144*dMax);
+  } else if(dMin<0. && dMax>0.)
+    {
+     if(!(-1.*dMin<4.*dMax))
+     {  
+      (intFlowAll->GetYaxis())->SetRangeUser(1.0266*dMin,1.0144*dMax);
+     } else {(intFlowAll->GetYaxis())->SetRangeUser(1.1266*dMin,1.0144*dMax);}  
+    } else if(dMin<0. && dMax<0.)
+      {
+       (intFlowAll->GetYaxis())->SetRangeUser(1.0266*dMin,0.9866*dMax);      
+      }
+  intFlowAll->Draw("E1");
+ }
+                        
+ if(pMesh) pMesh->Draw("LFSAME");
+  
+ if(flowResults) flowResults->Draw("PSAME");
+
+ //2nd pad is for legend:
+ (intFlowAllCanvas->cd(2))->SetPad(0.75,0.0,1.0,1.0);
+ 
+ if(textDefault)
+ {
+  textDefault->Draw();
+  textResults->Draw();
+ }
+ //----------------------------------------------------------------------------------
  //==================================================================================   
  
 
@@ -345,237 +555,258 @@ void CompareFlowResults()
  //==================================================================================
  //                            DIFFERENTIAL FLOW
  //==================================================================================
-
- TCanvas* diffFlowCanvas = new TCanvas("Differential Flow","Differential Flow",1000,600);
- 
  Int_t iNbinsPt  = AliFlowCommonConstants::GetNbinsPt();
  Double_t dPtMin = AliFlowCommonConstants::GetPtMin();
  Double_t dPtMax = AliFlowCommonConstants::GetPtMax();
  
+ //----------------------------------------------------------------------------------
+ //cosmetics: the style histogram:
  TH1D *styleHist = new TH1D("styleHist","styleHist",iNbinsPt,dPtMin,dPtMax);
  styleHist->SetTitle("Differential Flow");
  styleHist->SetXTitle("p_{t} [GeV]");
  styleHist->SetYTitle("v_{n}");
- styleHist->Draw();
- 
- TString *entryDiffMC  = new TString("v_{n}{MC} ");
- TString *entryDiffQC2 = new TString("v_{n}^{Q}{2} ");
- TString *entryDiffQC4 = new TString("v_{n}^{Q}{4} ");
- 
- TLegend* legendDiffFlow = new TLegend(0.15,0.15,0.44,0.35);
- legendDiffFlow->SetTextFont(72);
- legendDiffFlow->SetTextSize(0.03);
+ //----------------------------------------------------------------------------------
  
+ //----------------------------------------------------------------------------------
+ //cosmetics: Monte Carlo error bands for differential flow
+ TGraph* pMeshDiffFlow = NULL;
+ if(mcepCommonHistRes)
+ {
+  Int_t nPtsDF = (mcepCommonHistRes->GetHistDiffFlow())->GetNbinsX();
+  Double_t binWidth = (mcepCommonHistRes->GetHistDiffFlow())->GetBinWidth(1);//assuming that all bins have the same width
+       
+  pMeshDiffFlow = new TGraph(2*nPts+1);
+  
+  Double_t valueMC=0., errorMC=0.;
+  for(Int_t i=1;i<nPtsDF+1;i++)
+  {
+   valueMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinContent(i);
+   errorMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinError(i);       
+   pMeshDiffFlow->SetPoint(i,(i-0.5)*binWidth,valueMC+errorMC);
+  }    
+  for(Int_t i=nPtsDF+1;i<2*nPtsDF+1;i++)
+  {
+   valueMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinContent(2*nPtsDF+1-i);
+   errorMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinError(2*nPtsDF+1-i);       
+   pMeshDiffFlow->SetPoint(i,(2*nPtsDF-i+0.5)*binWidth,valueMC-errorMC); 
+  }
+  pMeshDiffFlow->SetPoint(2*nPtsDF+1,0.5*binWidth,valueMC+errorMC); 
+  pMeshDiffFlow->SetFillStyle(meshStyle);
+  pMeshDiffFlow->SetFillColor(meshColor);
+ } 
+ //----------------------------------------------------------------------------------
+  
  //MCEP = Monte Carlo Event Plane
- if(file_MCEP)
+ Double_t avMultDiffFlowMC=0.;
+ Double_t nEvtsDiffFlowMC=0;
+ if(fileMCEP)
  {
   if(mcepCommonHistRes)
   {
-   (mcepCommonHistRes->GetHistDiffFlow())->Scale(0.01);//to be improved
    (mcepCommonHistRes->GetHistDiffFlow())->SetMarkerColor(2);
    (mcepCommonHistRes->GetHistDiffFlow())->SetMarkerStyle(20);
-   (mcepCommonHistRes->GetHistDiffFlow())->SetFillStyle(meshStyle);
-   (mcepCommonHistRes->GetHistDiffFlow())->SetFillColor(meshColor);
-   entryDiffMC->Append("(M = ");
-   (*entryDiffMC)+=(Long_t)avMultMC;
-   entryDiffMC->Append(", N = ");
-   (*entryDiffMC)+=(Long_t)nEvtsMC; 
-   entryDiffMC->Append(")");
-   //(mcepCommonHistRes->GetHistDiffFlow())->Draw("E1PSAME"); 
-   legendDiffFlow->AddEntry(mcepCommonHistRes->GetHistDiffFlow(),entryDiffMC->Data(),"f");
+  } 
+  if(mcepCommonHist)
+  {
+   avMultDiffFlowMC = (mcepCommonHist->GetHistMultDiff())->GetMean();
+   nEvtsDiffFlowMC  = (mcepCommonHist->GetHistMultDiff())->GetEntries();
   } 
  } 
- 
+
  //GFC = Generating Function Cumulants
- if(file_GFC)
+ Double_t avMultDiffFlowGFC=0.;
+ Double_t nEvtsDiffFlowGFC=0.;
+ if(fileGFC)
  {
-  if(gfc2)
+  if(gfcCommonHistRes2)
   {
-   (gfc2->GetHistDiffFlow())->SetMarkerColor(28);
-   (gfc2->GetHistDiffFlow())->SetMarkerStyle(20);
-   (gfc2->GetHistDiffFlow())->Draw("E1PSAME"); 
-   legendDiffFlow->AddEntry(gfc2->GetHistDiffFlow(),"v_{n}{2}","p");
+   (gfcCommonHistRes2->GetHistDiffFlow())->SetMarkerColor(kViolet+3);
+   (gfcCommonHistRes2->GetHistDiffFlow())->SetMarkerStyle(20);
   }
-  if(gfc4)
+  if(gfcCommonHistRes4)
   { 
-   (gfc4->GetHistDiffFlow())->SetMarkerColor(28);
-   (gfc4->GetHistDiffFlow())->SetMarkerStyle(21);
-   (gfc4->GetHistDiffFlow())->Draw("E1PSAME");
-   legendDiffFlow->AddEntry(gfc4->GetHistDiffFlow(),"v_{n}{4}","p"); 
-   //(gfc6->GetHistDiffFlow())->Draw("SAME"); 
-   //(gfc8->GetHistDiffFlow())->Draw("SAME"); 
+   (gfcCommonHistRes4->GetHistDiffFlow())->SetMarkerColor(kViolet-6);
+   (gfcCommonHistRes4->GetHistDiffFlow())->SetMarkerStyle(21);
   }
+  if(gfcCommonHist)
+  {
+   avMultDiffFlowGFC = (gfcCommonHist->GetHistMultDiff())->GetMean();
+   nEvtsDiffFlowGFC  = (gfcCommonHist->GetHistMultDiff())->GetEntries();
+  } 
  }
-
+  
  //QC = Q-cumulants
- if(file_QC)
+ Double_t avMultDiffFlowQC2=0., avMultDiffFlowQC4=0.;
+ Double_t nEvtsDiffFlowQC2=0., nEvtsDiffFlowQC4=0.;
+ if(fileQC)
  {
+  //QC{2}
   if(qcCommonHistRes2)
   {
-   (qcCommonHistRes2->GetHistDiffFlow())->SetMarkerColor(44);
+   (qcCommonHistRes2->GetHistDiffFlow())->SetMarkerColor(kOrange+3);
    (qcCommonHistRes2->GetHistDiffFlow())->SetMarkerStyle(20);
-   (qcCommonHistRes2->GetHistDiffFlow())->Draw("E1PSAME");
-   entryDiffQC2->Append("(M = ");
-   (*entryDiffQC2)+=(Long_t)avMultQC2;
-   entryDiffQC2->Append(", N = ");
-   (*entryDiffQC2)+=(Long_t)nEvtsQC2; 
-   entryDiffQC2->Append(")");
-   legendDiffFlow->AddEntry(qcCommonHistRes2->GetHistDiffFlow(),entryDiffQC2->Data(),"p"); 
   }
+  if(qcCommonHist2)
+  {
+   avMultDiffFlowQC2 = (qcCommonHist2->GetHistMultDiff())->GetMean();
+   nEvtsDiffFlowQC2  = (qcCommonHist2->GetHistMultDiff())->GetEntries();
+  }
+  //QC{4}
   if(qcCommonHistRes4)
   {
-   (qcCommonHistRes4->GetHistDiffFlow())->SetMarkerColor(44);
+   (qcCommonHistRes4->GetHistDiffFlow())->SetMarkerColor(kOrange-6);
    (qcCommonHistRes4->GetHistDiffFlow())->SetMarkerStyle(21);
-   (qcCommonHistRes4->GetHistDiffFlow())->Draw("E1PSAME"); 
-   entryDiffQC4->Append("(M = ");
-   (*entryDiffQC4)+=(Long_t)avMultQC4;
-   entryDiffQC4->Append(", N = ");
-   (*entryDiffQC4)+=(Long_t)nEvtsQC4; 
-   entryDiffQC4->Append(")");
-   legendDiffFlow->AddEntry(qcCommonHistRes4->GetHistDiffFlow(),entryDiffQC4->Data(),"p");
+  }
+  if(qcCommonHist4)
+  {
+   avMultDiffFlowQC4 = (qcCommonHist4->GetHistMultDiff())->GetMean();
+   nEvtsDiffFlowQC4  = (qcCommonHist4->GetHistMultDiff())->GetEntries();
   }
  } 
- 
- 
 
- 
- /*
- //SP = Scalar Product
- TList *pListSP = NULL;
- AliFlowCommonHistResults *sp = NULL; 
- if(file_SP) 
+ //LYZ2 = Lee-Yang Zeros (2nd run)
+ Double_t avMultDiffFlowLYZ2=0.;
+ Double_t nEvtsDiffFlowLYZ2=0;
+ if(fileLYZ2)
  {
-  file_SP->GetObject("cobjSP",pListSP);
-  if(pListSP) 
+  if(lyz2CommonHistRes)
   {
-   sp = dynamic_cast<AliFlowCommonHistResults*> (pListSP->FindObject("AliFlowCommonHistResultsSP"));
-  }
- }
- */
- 
- 
- /*
- //SP = Scalar Product
- if(file_SP)
- {
-  if(sp)
+   (lyz2CommonHistRes->GetHistDiffFlow())->Scale(0.01);//to be improved
+   (lyz2CommonHistRes->GetHistDiffFlow())->SetMarkerColor(kGreen+3);
+   (lyz2CommonHistRes->GetHistDiffFlow())->SetMarkerStyle(22);
+  } 
+  if(lyz2CommonHist)
   {
-   (sp->GetHistDiffFlow())->SetMarkerColor(3);
-   (sp->GetHistDiffFlow())->SetMarkerStyle(28);
-   (sp->GetHistDiffFlow())->Draw("E1PSAME"); 
-   legend1->AddEntry(sp->GetHistDiffFlow(),"v_{n}{SP}","p");
+   avMultDiffFlowLYZ2 = (lyz2CommonHist->GetHistMultDiff())->GetMean();
+   nEvtsDiffFlowLYZ2  = (lyz2CommonHist->GetHistMultDiff())->GetEntries();
   } 
  } 
- */
- 
- 
- 
- 
- 
- 
- 
- 
- 
 
- //cosmetics: additional legend (differential flow) 
+ //----------------------------------------------------------------------------------
+ //final drawing for differential flow:
+ TCanvas* diffFlowAllCanvas = new TCanvas("Differential Flow","Differential Flow",1000,600);
  
+ diffFlowAllCanvas->Divide(2,1);
  
- /*
+ //1st pad is for plot:
+ (diffFlowAllCanvas->cd(1))->SetPad(0.0,0.0,0.75,1.0);
  
- //to be improved
- TLegend* legendDiffFlow2 = new TLegend(0.15,0.60,0.40,0.80);
- legendDiffFlow2->SetTextFont(72);
- legendDiffFlow2->SetTextSize(0.03);
- if(qcCommonHist2)
+ if(styleHist)
  {
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),avM->Data(),"");
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),nEvts->Data(),"");
+  styleHist->Draw();
  }
- if(qcCommonHist2)
+ if(pMeshDiffFlow)
  {
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),avM->Data(),"");
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),nEvts->Data(),"");
+  pMeshDiffFlow->Draw("LFSAME");
  }
- if(qcCommonHist2)
- {
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),avM->Data(),"");
-  legendDiffFlow2->AddEntry(qcCommonHist2->GetHistMultInt(),nEvts->Data(),"");
+ //MC 
+ if(mcepCommonHistRes)
+ { 
+  //(mcepCommonHistRes->GetHistDiffFlow())->Draw("E1PSAME");
+ }
+ //GFC
+ if(gfcCommonHistRes2)
+ { 
+  (gfcCommonHistRes2->GetHistDiffFlow())->Draw("E1PSAME"); 
+ } 
+ if(gfcCommonHistRes4)
+ { 
+  (gfcCommonHistRes4->GetHistDiffFlow())->Draw("E1PSAME"); 
+ } 
+ //QC
+ if(qcCommonHistRes2)
+ { 
+  (qcCommonHistRes2->GetHistDiffFlow())->Draw("E1PSAME");
+ }
+ if(qcCommonHistRes4)
+ { 
+  (qcCommonHistRes4->GetHistDiffFlow())->Draw("E1PSAME");
+ }
+ //LYZ2
+ if(lyz2CommonHistRes)
+ { 
+  (lyz2CommonHistRes->GetHistDiffFlow())->Draw("E1PSAME");
  }
  
- */
- 
- //cosmetics: Monte Carlo error bands for differential flow
- TGraph* pGraphDF = NULL;
+ //2nd pad is for legend:
+ (diffFlowAllCanvas->cd(2))->SetPad(0.75,0.0,1.0,1.0);
+
+ TLegend* legendDiffFlow = new TLegend(0.02,0.25,0.97,0.75);
+ legendDiffFlow->SetTextFont(72);
+ legendDiffFlow->SetTextSize(0.06);
+
+ //legend's entries:
+ TString *entryDiffMC   = new TString("MC ....... ");
+ TString *entryDiffGFC2 = new TString("GFC{2} ... ");
+ TString *entryDiffGFC4 = new TString("GFC{4} ... ");
+ TString *entryDiffQC2  = new TString("QC{2} .... ");
+ TString *entryDiffQC4  = new TString("QC{4} .... ");
+ TString *entryDiffLYZ2 = new TString("LYZ ...... ");
+ 
+ //MC
  if(mcepCommonHistRes)
  {
-  Int_t nPtsDF       = (mcepCommonHistRes->GetHistDiffFlow())->GetNbinsX();
-  Double_t binWidth  = (mcepCommonHistRes->GetHistDiffFlow())->GetBinWidth(1);//assuming that all bins have the same width
-       
-  pGraphDF = new TGraph(2*nPts);
-  
-  for(Int_t i=1;i<nPtsDF+1;i++)
-  {
-   Double_t valueMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinContent(i);
-   Double_t errorMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinError(i);       
-   pGraphDF->SetPoint(i,(i-0.5)*binWidth,valueMC+errorMC);
-  }
-     
-  for(Int_t i=nPtsDF;i<2*nPtsDF;i++)
-  {
-   Double_t valueMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinContent(2*nPtsDF-i);
-   Double_t errorMC = (mcepCommonHistRes->GetHistDiffFlow())->GetBinError(2*nPtsDF-i);       
-   pGraphDF->SetPoint(i,(2*nPtsDF-i-0.5)*binWidth,valueMC-errorMC); 
-  }
+  (mcepCommonHistRes->GetHistDiffFlow())->SetFillStyle(meshStyle);
+  (mcepCommonHistRes->GetHistDiffFlow())->SetFillColor(meshColor);
+  entryDiffMC->Append("M = ");
+  (*entryDiffMC)+=(Long_t)avMultDiffFlowMC;
+  entryDiffMC->Append(", N = ");
+  (*entryDiffMC)+=(Long_t)nEvtsDiffFlowMC; 
+  legendDiffFlow->AddEntry(mcepCommonHistRes->GetHistDiffFlow(),entryDiffMC->Data(),"f");
+ }
 
-  pGraphDF->SetFillStyle(meshStyle);
-  pGraphDF->SetFillColor(meshColor);
- }            
-                     
- if(legendDiffFlow) legendDiffFlow->Draw("");   
- if(pGraphDF) pGraphDF->Draw("LFSAME");        
-                                                                                            
- //================================================================================== 
- 
- 
- 
- //==========================================================
-/*
- TGraph* fillAreaBetweenFunctions(TF1* fUp, TF1*fDown, double nfmin, 
-                                double nfmax, int npf, int fillStyle, 
-                                int fillColor){
-  
-  fDown->SetLineColor(fillColor);
-  fDown->SetLineWidth(0.3);
-  fUp->SetLineColor(fillColor);
-  fUp->SetLineWidth(0.3);
-  
-  TArrayD xf(2*npf+1), yf(2*npf+1);
-  
-  //make and closed area and fill it
-  Double_t xfmin = nfmin; Double_t xfmax = nfmax;
-  Double_t dxf = (xfmax-xfmin)/(npf-1);
-  for (Int_t i=0;i<npf;i++) {
-    xf[i] = xfmin + dxf*i;
-    yf[i] = fDown->Eval(xf[i]);
-    xf[npf+i] = xfmax - dxf*i;
-    yf[npf+i] = fUp->Eval(xf[npf+i]);
-  }
-  xf[2*npf] = xf[0]; yf[2*npf] = yf[0];
-  TGraph *grf = new TGraph(2*npf+1);
-  for (int i=0; i<2*npf+1; i++) grf->SetPoint(i,xf[i],yf[i]);
-  grf->SetFillStyle(fillStyle);
-  grf->SetFillColor(fillColor);
-  return grf;
-  
+ //GFC
+ if(gfcCommonHistRes2)
+ {
+  entryDiffGFC2->Append("M = ");
+  (*entryDiffGFC2)+=(Long_t)avMultDiffFlowGFC;
+  entryDiffGFC2->Append(", N = ");
+  (*entryDiffGFC2)+=(Long_t)nEvtsDiffFlowGFC; 
+  legendDiffFlow->AddEntry(gfcCommonHistRes2->GetHistDiffFlow(),entryDiffGFC2->Data(),"p");
+ }
+ if(gfcCommonHistRes4)
+ {
+  entryDiffGFC4->Append("M = ");
+  (*entryDiffGFC4)+=(Long_t)avMultDiffFlowGFC;
+  entryDiffGFC4->Append(", N = ");
+  (*entryDiffGFC4)+=(Long_t)nEvtsDiffFlowGFC; 
+  legendDiffFlow->AddEntry(gfcCommonHistRes4->GetHistDiffFlow(),entryDiffGFC4->Data(),"p");
+ }
   
-}
-
-*/
-//=====================================================================================
- 
- 
+ //QC
+ if(qcCommonHistRes2)
+ {
+  entryDiffQC2->Append("M = ");
+  (*entryDiffQC2)+=(Long_t)avMultDiffFlowQC2;
+  entryDiffQC2->Append(", N = ");
+  (*entryDiffQC2)+=(Long_t)nEvtsDiffFlowQC2; 
+  legendDiffFlow->AddEntry(qcCommonHistRes2->GetHistDiffFlow(),entryDiffQC2->Data(),"p");
+ }
+ if(qcCommonHistRes4)
+ {
+  entryDiffQC4->Append("M = ");
+  (*entryDiffQC4)+=(Long_t)avMultDiffFlowQC4;
+  entryDiffQC4->Append(", N = ");
+  (*entryDiffQC4)+=(Long_t)nEvtsDiffFlowQC4; 
+  legendDiffFlow->AddEntry(qcCommonHistRes4->GetHistDiffFlow(),entryDiffQC4->Data(),"p");
+ }
  
+ //LYZ
+ if(lyz2CommonHistRes)
+ {
+  entryDiffLYZ2->Append("M = ");
+  (*entryDiffLYZ2)+=(Long_t)avMultDiffFlowLYZ2;
+  entryDiffLYZ2->Append(", N = ");
+  (*entryDiffLYZ2)+=(Long_t)nEvtsDiffFlowLYZ2; 
+  legendDiffFlow->AddEntry(lyz2CommonHistRes->GetHistDiffFlow(),entryDiffLYZ2->Data(),"p");
+ }
+
+ //drawing finally the legend in the 2nd pad:     
+ if(legendDiffFlow)
+ {
+  legendDiffFlow->Draw();
+ }
  
-                                
-  
+ //=====================================================================================
+
 }