[u/mrichter/AliRoot.git] / PWG2 / FLOW / macros / CompareFlowResults.C

void CompareFlowResults()
{
 gSystem->AddIncludePath("-I$ALICE_ROOT/include");
 gSystem->AddIncludePath("-I$ROOTSYS/include");
 
 //load needed libraries:
 gSystem->Load("libTree.so");
 gSystem->Load("libANALYSIS.so");
 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);
 
 //open the output files:
 TString inputFileNameMCEP = "outputMCEPanalysisESD.root";
 TFile* file_MCEP = NULL;
 file_MCEP = TFile::Open(inputFileNameMCEP.Data(), "READ"); 
 
 TString inputFileNameLYZ1 = "outputLYZ1analysisESD_firstrun.root";
 TFile* file_LYZ1 = NULL;
 file_LYZ1 = TFile::Open(inputFileNameLYZ1.Data(), "READ"); 
 
 /*
 TString inputFileNameSP = "outputSPanalysisESD.root";
 TFile* file_SP = NULL;
 file_SP = TFile::Open(inputFileNameSP.Data(), "READ"); 
 */
 
 TString inputFileNameFQD = "outputFQDanalysisESD.root";
 TFile* file_FQD = NULL;
 file_FQD = TFile::Open(inputFileNameFQD.Data(), "READ"); 
 
 TString inputFileNameGFC = "outputGFCanalysisESD.root";
 TFile* file_GFC = NULL;
 file_GFC = TFile::Open(inputFileNameGFC.Data(), "READ"); 
 
 TString inputFileNameQC = "outputQCanalysisESD.root";
 TFile* file_QC = NULL;
 file_QC = TFile::Open(inputFileNameQC.Data(), "READ"); 

 //==================================================================================
 //                              INTEGRATED FLOW
 //==================================================================================
 
 //booking the histogram for the integrated flow results from all methods
 TH1D* intFlow = new TH1D("intFlow","Integrated Flow",11,0,11);  

 intFlow->SetLabelSize(0.044);
 intFlow->SetMarkerStyle(25);
 (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}"); 
 
 //MCEP = Monte Carlo Event Plane
 TList *pListMCEP = NULL;
 AliFlowCommonHistResults *mcep = NULL; 
 if(file_MCEP) 
 {
  file_MCEP->GetObject("cobjMCEP",pListMCEP); 
  if(pListMCEP) 
  {
   mcep = dynamic_cast<AliFlowCommonHistResults*> (pListMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
   if(mcep)
   {
    intFlow->SetBinContent(1,(mcep->GetHistIntFlow())->GetBinContent(1));   
    intFlow->SetBinError(1,(mcep->GetHistIntFlow())->GetBinError(1));
   }
  }
 }
 
 //LYZ1 = Lee-Yang Zeros (1st run)
 TList *pListLYZ1 = NULL;
 AliFlowCommonHistResults *lyz1 = NULL; 
 if(file_LYZ1) 
 {
  file_LYZ1->GetObject("cobjLYZ1",pListLYZ1); 
  if(pListLYZ1) 
  {
   lyz1 = dynamic_cast<AliFlowCommonHistResults*> (pListLYZ1->FindObject("AliFlowCommonHistResultsLYZ"));
   if(lyz1)
   {
    intFlow->SetBinContent(2,(lyz1->GetHistIntFlow())->GetBinContent(1));   
    intFlow->SetBinError(2,(lyz1->GetHistIntFlow())->GetBinError(1));
   }
  }
 }
 
 //FQD = Fitting q-distribution
 TList *pListFQD = NULL;
 AliFlowCommonHistResults *fqd = NULL; 
 if(file_FQD) 
 {
  file_FQD->GetObject("cobjFQD",pListFQD); 
  if(pListFQD) 
  {
   fqd = dynamic_cast<AliFlowCommonHistResults*> (pListFQD->FindObject("AliFlowCommonHistResultsFQD"));
   if(fqd)
   {
    intFlow->SetBinContent(3,(fqd->GetHistIntFlow())->GetBinContent(1));   
    intFlow->SetBinError(3,(fqd->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) 
 {
  file_GFC->GetObject("cobjGFC",pListGFC);
  if(pListGFC) 
  {
   gfc2 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
   if(gfc2) 
   {
    intFlow->SetBinContent(4,(gfc2->GetHistIntFlow())->GetBinContent(1)); 
    intFlow->SetBinError(4,(gfc2->GetHistIntFlow())->GetBinError(1));
   }
   gfc4 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
   if(gfc4) 
   {
    intFlow->SetBinContent(5,(gfc4->GetHistIntFlow())->GetBinContent(1));
    intFlow->SetBinError(5,(gfc4->GetHistIntFlow())->GetBinError(1));
   }
   gfc6 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
   if(gfc6) 
   {
    intFlow->SetBinContent(6,(gfc6->GetHistIntFlow())->GetBinContent(1)); 
    intFlow->SetBinError(6,(gfc6->GetHistIntFlow())->GetBinError(1));
   }
   gfc8 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
   if(gfc8) 
   {
    intFlow->SetBinContent(7,(gfc8->GetHistIntFlow())->GetBinContent(1));
    intFlow->SetBinError(7,(gfc8->GetHistIntFlow())->GetBinError(1));
   }
  }
 }
 
 //QC = Q-cumulants
 TList *pListQC = NULL;
 AliFlowCommonHist *qcCommonHist = NULL;//to be improved
 AliFlowCommonHistResults *qc2 = NULL; 
 AliFlowCommonHistResults *qc4 = NULL; 
 AliFlowCommonHistResults *qc6 = NULL; 
 AliFlowCommonHistResults *qc8 = NULL; 
 if(file_QC) 
 {
  file_QC->GetObject("cobjQC",pListQC);
  if(pListQC) 
  {
   qcCommonHist = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHistQC"));//to be improved
   qc2 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
   if(qc2) 
   {
    intFlow->SetBinContent(8,(qc2->GetHistIntFlow())->GetBinContent(1)); 
    intFlow->SetBinError(8,(qc2->GetHistIntFlow())->GetBinError(1));
   }
   qc4 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
   if(qc4) 
   {
    intFlow->SetBinContent(9,(qc4->GetHistIntFlow())->GetBinContent(1));
    intFlow->SetBinError(9,(qc4->GetHistIntFlow())->GetBinError(1));
   }
   qc6 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
   if(qc6) 
   {
    intFlow->SetBinContent(10,(qc6->GetHistIntFlow())->GetBinContent(1)); 
    intFlow->SetBinError(10,(qc6->GetHistIntFlow())->GetBinError(1));
   }
   qc8 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
   if(qc8) 
   {
    intFlow->SetBinContent(11,(qc8->GetHistIntFlow())->GetBinContent(1));
    intFlow->SetBinError(11,(qc8->GetHistIntFlow())->GetBinError(1));
   }
  }
 }
 
 /*
 //SP = Scalar Product
 TList *pListSP = NULL;
 AliFlowCommonHistResults *sp = NULL; 
 if(file_SP) 
 {
  file_SP->GetObject("cobjSP",pListSP);
  if(pListSP) 
  {
   sp = dynamic_cast<AliFlowCommonHistResults*> (pListSP->FindObject("AliFlowCommonHistResultsSP"));
  }
 }
 */
 
 //cosmetics: Monte Carlo error bands for integrated flow
 if(intFlow)
 {
  Double_t valueMC = intFlow->GetBinContent(1);
  Double_t errorMC = intFlow->GetBinError(1);  
  Int_t nPts       = intFlow->GetNbinsX();     
     
  TGraph* pGraphIF = 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->SetFillStyle(3044);
  pGraphIF->SetFillColor(kRed-4);
 }
            
 //cosmetics: legend     
 TString *avM = new TString("AvM = ");//to be improved
 TString *nEvts = new TString("nEvts = ");//to be improved
 TLegend* legendIntFlow = new TLegend(0.15,0.15,0.44,0.35);
 legendIntFlow->SetTextFont(72);
 legendIntFlow->SetTextSize(0.03);
 if(qcCommonHist)
 {
  (*avM)+=(qcCommonHist->GetHistMultInt())->GetMean();//to be improved
  (*nEvts)+=(qcCommonHist->GetHistMultInt())->GetEntries();//to be improved
  legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),avM->Data(),"");
  legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),nEvts->Data(),"");
 }
 
 //drawing everything for integrated flow:
 TCanvas* intFlowCanvas = new TCanvas("Integrated Flow","Integrated Flow",1000,600);
 
 intFlow->Draw();      
 pGraphIF->Draw("LFSAME");                    
 legendIntFlow->Draw("");  
 
 //==================================================================================   
 

 //==================================================================================
 //                            DIFFERENTIAL FLOW
 //==================================================================================

 TCanvas* diffFlowCanvas = new TCanvas("Differential Flow","Differential Flow",1000,600);
 
 TLegend* legendDiffFlow = new TLegend(0.15,0.15,0.3,0.35);
 legendDiffFlow->SetTextFont(72);
 legendDiffFlow->SetTextSize(0.03);
 
 //to be improved
 TLegend* legendDiffFlow2 = new TLegend(0.15,0.60,0.40,0.80);
 legendDiffFlow2->SetTextFont(72);
 legendDiffFlow2->SetTextSize(0.03);
 if(qcCommonHist)
 {
  legendDiffFlow2->AddEntry(qcCommonHist->GetHistMultInt(),avM->Data(),"");
  legendDiffFlow2->AddEntry(qcCommonHist->GetHistMultInt(),nEvts->Data(),"");
 }
 
 //GFC = Generating Function Cumulants
 if(file_GFC)
 {
  if(gfc2)
  {
   (gfc2->GetHistDiffFlow())->SetMarkerColor(28);
   (gfc2->GetHistDiffFlow())->SetMarkerStyle(20);
   (gfc2->GetHistDiffFlow())->SetTitle("Differential Flow");
   (gfc2->GetHistDiffFlow())->SetXTitle("p_{t} [GeV]");
   (gfc2->GetHistDiffFlow())->SetYTitle("v_{n}");
   (gfc2->GetHistDiffFlow())->Draw(""); 
   legendDiffFlow->AddEntry(gfc2->GetHistDiffFlow(),"v_{n}{2}","p");
  }
  if(gfc4)
  { 
   (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"); 
  }
 }

 //QC = Q-cumulants
 if(file_QC)
 {
  if(qc2)
  {
   (qc2->GetHistDiffFlow())->SetMarkerColor(44);
   (qc2->GetHistDiffFlow())->SetMarkerStyle(20);
   (qc2->GetHistDiffFlow())->Draw("E1PSAME");
   legendDiffFlow->AddEntry(qc2->GetHistDiffFlow(),"v_{n}^{Q}{2}","p"); 
  }
  if(qc4)
  {
   (qc4->GetHistDiffFlow())->SetMarkerColor(44);
   (qc4->GetHistDiffFlow())->SetMarkerStyle(21);
   (qc4->GetHistDiffFlow())->Draw("E1PSAME"); 
   legendDiffFlow->AddEntry(qc4->GetHistDiffFlow(),"v_{n}^{Q}{4}","p");
  }
 } 
 
 //MCEP = Monte Carlo Event Plane
 if(file_MCEP)
 {
  if(mcep)
  {
   (mcep->GetHistDiffFlow())->Scale(0.01);//to be improved
   (mcep->GetHistDiffFlow())->SetMarkerColor(2);
   (mcep->GetHistDiffFlow())->SetMarkerStyle(20);
   (mcep->GetHistDiffFlow())->SetFillStyle(3044);
   (mcep->GetHistDiffFlow())->SetFillColor(kRed-4);
   //(mcep->GetHistDiffFlow())->Draw("E1PSAME"); 
   legendDiffFlow->AddEntry(mcep->GetHistDiffFlow(),"v_{n}{MC}","f");
  } 
 } 

 /*
 //SP = Scalar Product
 if(file_SP)
 {
  if(sp)
  {
   (sp->GetHistDiffFlow())->SetMarkerColor(3);
   (sp->GetHistDiffFlow())->SetMarkerStyle(28);
   (sp->GetHistDiffFlow())->Draw("E1PSAME"); 
   legend1->AddEntry(sp->GetHistDiffFlow(),"v_{n}{SP}","p");
  } 
 } 
 */
 
 //cosmetics: Monte Carlo error bands for differential flow
 if(mcep)
 {
  Int_t nPtsDF       = (mcep->GetHistDiffFlow())->GetNbinsX();
  Double_t binWidth  = (mcep->GetHistDiffFlow())->GetBinWidth(1);//assuming that all bins have the same width
       
  TGraph* pGraphDF = new TGraph(2*nPts);
  
  for(Int_t i=1;i<nPtsDF+1;i++)
  {
   Double_t valueMC = (mcep->GetHistDiffFlow())->GetBinContent(i);
   Double_t errorMC = (mcep->GetHistDiffFlow())->GetBinError(i);       
   pGraphDF->SetPoint(i,(i-0.5)*binWidth,valueMC+errorMC);
  }
     
  for(Int_t i=nPtsDF;i<2*nPtsDF;i++)
  {
   Double_t valueMC = (mcep->GetHistDiffFlow())->GetBinContent(2*nPtsDF-i);
   Double_t errorMC = (mcep->GetHistDiffFlow())->GetBinError(2*nPtsDF-i);       
   pGraphDF->SetPoint(i,(2*nPtsDF-i-0.5)*binWidth,valueMC-errorMC); 
  }

  pGraphDF->SetFillStyle(3044);
  pGraphDF->SetFillColor(kRed-4);
 }            
                     
 legendDiffFlow->Draw("");   
 legendDiffFlow2->Draw(""); 
 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;
  
  
}
*/
//=====================================================================================
 
 
}
Commit	Line	Data
9d3cbee7	1	void CompareFlowResults()
	2	{
	3	gSystem->AddIncludePath("-I$ALICE_ROOT/include");
	4	gSystem->AddIncludePath("-I$ROOTSYS/include");
	5
	6	//load needed libraries:
	7	gSystem->Load("libTree.so");
	8	gSystem->Load("libANALYSIS.so");
	9	gSystem->Load("libPWG2flow.so");
	10	cerr<<"libPWG2flow.so loaded ..."<<endl;
	11	cout<<endl;
	12
	13	//removing the title and stat. box from all histograms:
	14	gStyle->SetOptTitle(0);
	15	gStyle->SetOptStat(0);
	16
	17	//open the output files:
	18	TString inputFileNameMCEP = "outputMCEPanalysisESD.root";
	19	TFile* file_MCEP = NULL;
	20	file_MCEP = TFile::Open(inputFileNameMCEP.Data(), "READ");
	21
	22	TString inputFileNameLYZ1 = "outputLYZ1analysisESD_firstrun.root";
	23	TFile* file_LYZ1 = NULL;
	24	file_LYZ1 = TFile::Open(inputFileNameLYZ1.Data(), "READ");
	25
	26	/*
	27	TString inputFileNameSP = "outputSPanalysisESD.root";
	28	TFile* file_SP = NULL;
	29	file_SP = TFile::Open(inputFileNameSP.Data(), "READ");
	30	*/
	31
	32	TString inputFileNameFQD = "outputFQDanalysisESD.root";
	33	TFile* file_FQD = NULL;
	34	file_FQD = TFile::Open(inputFileNameFQD.Data(), "READ");
	35
	36	TString inputFileNameGFC = "outputGFCanalysisESD.root";
	37	TFile* file_GFC = NULL;
	38	file_GFC = TFile::Open(inputFileNameGFC.Data(), "READ");
	39
	40	TString inputFileNameQC = "outputQCanalysisESD.root";
	41	TFile* file_QC = NULL;
	42	file_QC = TFile::Open(inputFileNameQC.Data(), "READ");
	43
	44	//==================================================================================
	45	// INTEGRATED FLOW
	46	//==================================================================================
	47
	48	//booking the histogram for the integrated flow results from all methods
	49	TH1D* intFlow = new TH1D("intFlow","Integrated Flow",11,0,11);
	50
	51	intFlow->SetLabelSize(0.044);
	52	intFlow->SetMarkerStyle(25);
	53	(intFlow->GetXaxis())->SetBinLabel(1,"v_{n}{MC}");
	54	(intFlow->GetXaxis())->SetBinLabel(2,"v_{n}{LYZ}");
	55	(intFlow->GetXaxis())->SetBinLabel(3,"v_{n}{FQD}");
	56	(intFlow->GetXaxis())->SetBinLabel(4,"v_{n}{2}");
	57	(intFlow->GetXaxis())->SetBinLabel(5,"v_{n}{4}");
	58	(intFlow->GetXaxis())->SetBinLabel(6,"v_{n}{6}");
	59	(intFlow->GetXaxis())->SetBinLabel(7,"v_{n}{8}");
	60	(intFlow->GetXaxis())->SetBinLabel(8,"v_{n}^{Q}{2}");
	61	(intFlow->GetXaxis())->SetBinLabel(9,"v_{n}^{Q}{4}");
	62	(intFlow->GetXaxis())->SetBinLabel(10,"v_{n}^{Q}{6}");
	63	(intFlow->GetXaxis())->SetBinLabel(11,"v_{n}^{Q}{8}");
	64
65	//MCEP = Monte Carlo Event Plane
66	TList *pListMCEP = NULL;
67	AliFlowCommonHistResults *mcep = NULL;
68	if(file_MCEP)
69	{
70	file_MCEP->GetObject("cobjMCEP",pListMCEP);
71	if(pListMCEP)
72	{
73	mcep = dynamic_cast<AliFlowCommonHistResults*> (pListMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
74	if(mcep)
75	{
76	intFlow->SetBinContent(1,(mcep->GetHistIntFlow())->GetBinContent(1));
77	intFlow->SetBinError(1,(mcep->GetHistIntFlow())->GetBinError(1));
78	}
79	}
80	}
81
82	//LYZ1 = Lee-Yang Zeros (1st run)
83	TList *pListLYZ1 = NULL;
84	AliFlowCommonHistResults *lyz1 = NULL;
85	if(file_LYZ1)
86	{
87	file_LYZ1->GetObject("cobjLYZ1",pListLYZ1);
88	if(pListLYZ1)
89	{
90	lyz1 = dynamic_cast<AliFlowCommonHistResults*> (pListLYZ1->FindObject("AliFlowCommonHistResultsLYZ"));
91	if(lyz1)
92	{
93	intFlow->SetBinContent(2,(lyz1->GetHistIntFlow())->GetBinContent(1));
94	intFlow->SetBinError(2,(lyz1->GetHistIntFlow())->GetBinError(1));
95	}
96	}
97	}
98
99	//FQD = Fitting q-distribution
100	TList *pListFQD = NULL;
101	AliFlowCommonHistResults *fqd = NULL;
102	if(file_FQD)
103	{
104	file_FQD->GetObject("cobjFQD",pListFQD);
105	if(pListFQD)
106	{
107	fqd = dynamic_cast<AliFlowCommonHistResults*> (pListFQD->FindObject("AliFlowCommonHistResultsFQD"));
108	if(fqd)
109	{
110	intFlow->SetBinContent(3,(fqd->GetHistIntFlow())->GetBinContent(1));
111	intFlow->SetBinError(3,(fqd->GetHistIntFlow())->GetBinError(1));
112	}
113	}
114	}
115
116	//GFC = Generating Function Cumulants
117	TList *pListGFC = NULL;
118	AliFlowCommonHistResults *gfc2 = NULL;
119	AliFlowCommonHistResults *gfc4 = NULL;
120	AliFlowCommonHistResults *gfc6 = NULL;
121	AliFlowCommonHistResults *gfc8 = NULL;
122	if(file_GFC)
123	{
124	file_GFC->GetObject("cobjGFC",pListGFC);
125	if(pListGFC)
126	{
127	gfc2 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
128	if(gfc2)
129	{
130	intFlow->SetBinContent(4,(gfc2->GetHistIntFlow())->GetBinContent(1));
131	intFlow->SetBinError(4,(gfc2->GetHistIntFlow())->GetBinError(1));
132	}
133	gfc4 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
134	if(gfc4)
135	{
136	intFlow->SetBinContent(5,(gfc4->GetHistIntFlow())->GetBinContent(1));
137	intFlow->SetBinError(5,(gfc4->GetHistIntFlow())->GetBinError(1));
138	}
139	gfc6 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
140	if(gfc6)
141	{
142	intFlow->SetBinContent(6,(gfc6->GetHistIntFlow())->GetBinContent(1));
143	intFlow->SetBinError(6,(gfc6->GetHistIntFlow())->GetBinError(1));
144	}
145	gfc8 = dynamic_cast<AliFlowCommonHistResults*> (pListGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
146	if(gfc8)
147	{
148	intFlow->SetBinContent(7,(gfc8->GetHistIntFlow())->GetBinContent(1));
149	intFlow->SetBinError(7,(gfc8->GetHistIntFlow())->GetBinError(1));
150	}
151	}
152	}
153
154	//QC = Q-cumulants
155	TList *pListQC = NULL;
156	AliFlowCommonHist *qcCommonHist = NULL;//to be improved
157	AliFlowCommonHistResults *qc2 = NULL;
158	AliFlowCommonHistResults *qc4 = NULL;
159	AliFlowCommonHistResults *qc6 = NULL;
160	AliFlowCommonHistResults *qc8 = NULL;
161	if(file_QC)
162	{
163	file_QC->GetObject("cobjQC",pListQC);
164	if(pListQC)
165	{
166	qcCommonHist = dynamic_cast<AliFlowCommonHist*> (pListQC->FindObject("AliFlowCommonHistQC"));//to be improved
167	qc2 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
168	if(qc2)
169	{
170	intFlow->SetBinContent(8,(qc2->GetHistIntFlow())->GetBinContent(1));
171	intFlow->SetBinError(8,(qc2->GetHistIntFlow())->GetBinError(1));
172	}
173	qc4 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
174	if(qc4)
175	{
176	intFlow->SetBinContent(9,(qc4->GetHistIntFlow())->GetBinContent(1));
177	intFlow->SetBinError(9,(qc4->GetHistIntFlow())->GetBinError(1));
178	}
179	qc6 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
180	if(qc6)
181	{
182	intFlow->SetBinContent(10,(qc6->GetHistIntFlow())->GetBinContent(1));
183	intFlow->SetBinError(10,(qc6->GetHistIntFlow())->GetBinError(1));
184	}
185	qc8 = dynamic_cast<AliFlowCommonHistResults*> (pListQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
186	if(qc8)
187	{
188	intFlow->SetBinContent(11,(qc8->GetHistIntFlow())->GetBinContent(1));
189	intFlow->SetBinError(11,(qc8->GetHistIntFlow())->GetBinError(1));
190	}
191	}
192	}
193
194	/*
195	//SP = Scalar Product
196	TList *pListSP = NULL;
197	AliFlowCommonHistResults *sp = NULL;
198	if(file_SP)
199	{
200	file_SP->GetObject("cobjSP",pListSP);
201	if(pListSP)
202	{
203	sp = dynamic_cast<AliFlowCommonHistResults*> (pListSP->FindObject("AliFlowCommonHistResultsSP"));
204	}
205	}
206	*/
207
6f62c2a7	208	//cosmetics: Monte Carlo error bands for integrated flow
	209	if(intFlow)
	210	{
	211	Double_t valueMC = intFlow->GetBinContent(1);
	212	Double_t errorMC = intFlow->GetBinError(1);
	213	Int_t nPts = intFlow->GetNbinsX();
	214
	215	TGraph* pGraphIF = new TGraph(nPts);
	216
	217	pGraphIF->SetPoint(1,0,valueMC+errorMC);
	218	pGraphIF->SetPoint(2,nPts+1,valueMC+errorMC);
	219	pGraphIF->SetPoint(3,nPts+1,valueMC-errorMC);
	220	pGraphIF->SetPoint(4,0,valueMC-errorMC);
	221
	222	pGraphIF->SetFillStyle(3044);
	223	pGraphIF->SetFillColor(kRed-4);
	224	}
	225
	226	//cosmetics: legend
9d3cbee7	227	TString *avM = new TString("AvM = ");//to be improved
9d3cbee7	228	TString *nEvts = new TString("nEvts = ");//to be improved
9d3cbee7	229	TLegend* legendIntFlow = new TLegend(0.15,0.15,0.44,0.35);
	230	legendIntFlow->SetTextFont(72);
	231	legendIntFlow->SetTextSize(0.03);
	232	if(qcCommonHist)
	233	{
	234	(*avM)+=(qcCommonHist->GetHistMultInt())->GetMean();//to be improved
	235	(*nEvts)+=(qcCommonHist->GetHistMultInt())->GetEntries();//to be improved
	236	legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),avM->Data(),"");
	237	legendIntFlow->AddEntry(qcCommonHist->GetHistMultInt(),nEvts->Data(),"");
	238	}
6f62c2a7	239
	240	//drawing everything for integrated flow:
	241	TCanvas* intFlowCanvas = new TCanvas("Integrated Flow","Integrated Flow",1000,600);
	242
	243	intFlow->Draw();
	244	pGraphIF->Draw("LFSAME");
	245	legendIntFlow->Draw("");
9d3cbee7	246
	247	//==================================================================================
	248
	249
	250
	251
	252	//==================================================================================
	253	// DIFFERENTIAL FLOW
	254	//==================================================================================
	255
	256	TCanvas* diffFlowCanvas = new TCanvas("Differential Flow","Differential Flow",1000,600);
	257
	258	TLegend* legendDiffFlow = new TLegend(0.15,0.15,0.3,0.35);
	259	legendDiffFlow->SetTextFont(72);
	260	legendDiffFlow->SetTextSize(0.03);
	261
	262	//to be improved
	263	TLegend* legendDiffFlow2 = new TLegend(0.15,0.60,0.40,0.80);
	264	legendDiffFlow2->SetTextFont(72);
	265	legendDiffFlow2->SetTextSize(0.03);
	266	if(qcCommonHist)
	267	{
	268	legendDiffFlow2->AddEntry(qcCommonHist->GetHistMultInt(),avM->Data(),"");
	269	legendDiffFlow2->AddEntry(qcCommonHist->GetHistMultInt(),nEvts->Data(),"");
	270	}
	271
	272	//GFC = Generating Function Cumulants
	273	if(file_GFC)
	274	{
	275	if(gfc2)
	276	{
	277	(gfc2->GetHistDiffFlow())->SetMarkerColor(28);
	278	(gfc2->GetHistDiffFlow())->SetMarkerStyle(20);
	279	(gfc2->GetHistDiffFlow())->SetTitle("Differential Flow");
	280	(gfc2->GetHistDiffFlow())->SetXTitle("p_{t} [GeV]");
	281	(gfc2->GetHistDiffFlow())->SetYTitle("v_{n}");
	282	(gfc2->GetHistDiffFlow())->Draw("");
	283	legendDiffFlow->AddEntry(gfc2->GetHistDiffFlow(),"v_{n}{2}","p");
	284	}
	285	if(gfc4)
	286	{
	287	(gfc4->GetHistDiffFlow())->SetMarkerColor(28);
	288	(gfc4->GetHistDiffFlow())->SetMarkerStyle(21);
	289	(gfc4->GetHistDiffFlow())->Draw("E1PSAME");
	290	legendDiffFlow->AddEntry(gfc4->GetHistDiffFlow(),"v_{n}{4}","p");
	291	//(gfc6->GetHistDiffFlow())->Draw("SAME");
	292	//(gfc8->GetHistDiffFlow())->Draw("SAME");
	293	}
	294	}
	295
	296	//QC = Q-cumulants
	297	if(file_QC)
	298	{
	299	if(qc2)
	300	{
	301	(qc2->GetHistDiffFlow())->SetMarkerColor(44);
	302	(qc2->GetHistDiffFlow())->SetMarkerStyle(20);
	303	(qc2->GetHistDiffFlow())->Draw("E1PSAME");
	304	legendDiffFlow->AddEntry(qc2->GetHistDiffFlow(),"v_{n}^{Q}{2}","p");
	305	}
	306	if(qc4)
	307	{
	308	(qc4->GetHistDiffFlow())->SetMarkerColor(44);
	309	(qc4->GetHistDiffFlow())->SetMarkerStyle(21);
310	(qc4->GetHistDiffFlow())->Draw("E1PSAME");
311	legendDiffFlow->AddEntry(qc4->GetHistDiffFlow(),"v_{n}^{Q}{4}","p");
312	}
313	}
314
315	//MCEP = Monte Carlo Event Plane
316	if(file_MCEP)
317	{
318	if(mcep)
319	{
320	(mcep->GetHistDiffFlow())->Scale(0.01);//to be improved
321	(mcep->GetHistDiffFlow())->SetMarkerColor(2);
322	(mcep->GetHistDiffFlow())->SetMarkerStyle(20);
6f62c2a7	323	(mcep->GetHistDiffFlow())->SetFillStyle(3044);
	324	(mcep->GetHistDiffFlow())->SetFillColor(kRed-4);
	325	//(mcep->GetHistDiffFlow())->Draw("E1PSAME");
	326	legendDiffFlow->AddEntry(mcep->GetHistDiffFlow(),"v_{n}{MC}","f");
9d3cbee7	327	}
9d3cbee7	328	}
6f62c2a7	329
9d3cbee7	330	/*
	331	//SP = Scalar Product
	332	if(file_SP)
	333	{
	334	if(sp)
	335	{
	336	(sp->GetHistDiffFlow())->SetMarkerColor(3);
	337	(sp->GetHistDiffFlow())->SetMarkerStyle(28);
	338	(sp->GetHistDiffFlow())->Draw("E1PSAME");
	339	legend1->AddEntry(sp->GetHistDiffFlow(),"v_{n}{SP}","p");
	340	}
	341	}
	342	*/
6f62c2a7	343
	344	//cosmetics: Monte Carlo error bands for differential flow
	345	if(mcep)
	346	{
	347	Int_t nPtsDF = (mcep->GetHistDiffFlow())->GetNbinsX();
	348	Double_t binWidth = (mcep->GetHistDiffFlow())->GetBinWidth(1);//assuming that all bins have the same width
	349
	350	TGraph* pGraphDF = new TGraph(2*nPts);
	351
	352	for(Int_t i=1;i<nPtsDF+1;i++)
	353	{
	354	Double_t valueMC = (mcep->GetHistDiffFlow())->GetBinContent(i);
	355	Double_t errorMC = (mcep->GetHistDiffFlow())->GetBinError(i);
	356	pGraphDF->SetPoint(i,(i-0.5)*binWidth,valueMC+errorMC);
	357	}
	358
	359	for(Int_t i=nPtsDF;i<2*nPtsDF;i++)
	360	{
	361	Double_t valueMC = (mcep->GetHistDiffFlow())->GetBinContent(2*nPtsDF-i);
	362	Double_t errorMC = (mcep->GetHistDiffFlow())->GetBinError(2*nPtsDF-i);
	363	pGraphDF->SetPoint(i,(2nPtsDF-i-0.5)binWidth,valueMC-errorMC);
	364	}
	365
	366	pGraphDF->SetFillStyle(3044);
	367	pGraphDF->SetFillColor(kRed-4);
	368	}
	369
9d3cbee7	370	legendDiffFlow->Draw("");
9d3cbee7	371	legendDiffFlow2->Draw("");
6f62c2a7	372	pGraphDF->Draw("LFSAME");
6f62c2a7	373
9d3cbee7	374	//==================================================================================
9d3cbee7	375
6f62c2a7	376
	377
	378	//==========================================================
	379	/*
	380	TGraph* fillAreaBetweenFunctions(TF1* fUp, TF1*fDown, double nfmin,
	381	double nfmax, int npf, int fillStyle,
	382	int fillColor){
	383
	384	fDown->SetLineColor(fillColor);
	385	fDown->SetLineWidth(0.3);
	386	fUp->SetLineColor(fillColor);
	387	fUp->SetLineWidth(0.3);
	388
	389	TArrayD xf(2npf+1), yf(2npf+1);
	390
	391	//make and closed area and fill it
	392	Double_t xfmin = nfmin; Double_t xfmax = nfmax;
	393	Double_t dxf = (xfmax-xfmin)/(npf-1);
	394	for (Int_t i=0;i<npf;i++) {
	395	xf[i] = xfmin + dxf*i;
	396	yf[i] = fDown->Eval(xf[i]);
	397	xf[npf+i] = xfmax - dxf*i;
	398	yf[npf+i] = fUp->Eval(xf[npf+i]);
	399	}
	400	xf[2npf] = xf[0]; yf[2npf] = yf[0];
	401	TGraph grf = new TGraph(2npf+1);
	402	for (int i=0; i<2*npf+1; i++) grf->SetPoint(i,xf[i],yf[i]);
	403	grf->SetFillStyle(fillStyle);
	404	grf->SetFillColor(fillColor);
	405	return grf;
	406
	407
	408	}
	409	*/
	410	//=====================================================================================
	411
	412
	413
	414
	415
	416
9d3cbee7	417	}