TH1D *fHistOmega_Rsn;
TH1D *efficiency_N_rho;
TH1D *fHistEta_Rsn;
TH1D *fHistEtaprime_Rsn;

float fit_lo_lim = 0.34;  
float fit_up_lim = 1.80;

int fix_width_f0_pdg = 0;
int fix_width_f2_pdg = 0;

int ptbin = 1 ;

float width = 2;
 
Double_t Total_fit (Double_t *x, Double_t *par);
Double_t rho_bw(Double_t *x, Double_t *par);
Double_t k0_guass(Double_t *x, Double_t*par);
Double_t omega_three (Double_t *x, Double_t *par);
Double_t f0_bw (Double_t *x, Double_t *par);
Double_t bkgrnd (Double_t *x, Double_t *par);
Double_t f2_bw (Double_t *x, Double_t *par);
Double_t eta_function (Double_t *x, Double_t *par);
Double_t etaprime_function (Double_t *x, Double_t *par);

TF1 *rho_bw_fit_bin1, *rho_bw_fit_bin2, *rho_bw_fit_bin3, *rho_bw_fit_bin4, *rho_bw_fit_bin5, *rho_bw_fit_bin6, *rho_bw_fit_bin7, *rho_bw_fit_bin8;
TF1 *omega_bin1, *omega_bin2, *omega_bin3, *omega_bin4, *omega_bin5, *omega_bin6, *omega_bin7, *omega_bin8;
TF1 *k0_bin1, *k0_bin2, *k0_bin3, *k0_bin4, *k0_bin5, *k0_bin6, *k0_bin7, *k0_bin8;
TF1 *f0_bin1, *f0_bin2, *f0_bin3, *f0_bin4, *f0_bin5, *f0_bin6, *f0_bin7, *f0_bin8;
TF1 *f2_bin1, *f2_bin2, *f2_bin3, *f2_bin4, *f2_bin5, *f2_bin6, *f2_bin7, *f2_bin8;
TF1 *eta_bin1, *eta_bin2, *eta_bin3, *eta_bin4, *eta_bin5, *eta_bin6, *eta_bin7, *eta_bin8;
TF1 *etaprime_bin1, *etaprime_bin2, *etaprime_bin3, *etaprime_bin4, *etaprime_bin5, *etaprime_bin6, *etaprime_bin7, *etaprime_bin8;
TF1 *bkg_bin1, *bkg_bin2, *bkg_bin3, *bkg_bin4, *bkg_bin5, *bkg_bin6, *bkg_bin7, *bkg_bin8;

void myParameters() { 
   
  TF1 *Rel_BW_rho = new TF1("Rel_BW_rho",Total_fit,fit_lo_lim, fit_up_lim,23);
 
 //rho peak  
  Rel_BW_rho->SetParameter(0,3.01230e-01);
  // Rel_BW_rho->SetParLimits(0,0,1e+01);
   {
    {if(ptbin == 1)Rel_BW_rho->SetParLimits(0,0,3.0e+01);}
    {if(ptbin == 2)Rel_BW_rho->SetParLimits(0,0,2.0e+01);}
    {if(ptbin == 3)Rel_BW_rho->SetParLimits(0,0,2.1e+01);}
    {if(ptbin == 4)Rel_BW_rho->SetParLimits(0,0,4.0e+01);}
    {if(ptbin == 5 || ptbin == 6 )Rel_BW_rho->SetParLimits(0,0,2.0e+01);}
    {if(ptbin == 7 || ptbin == 8)Rel_BW_rho->SetParLimits(0,0,1.0e+01);}
    }
   Rel_BW_rho->SetParameter(1,0.775);
   Rel_BW_rho->SetParLimits(1,0.7,0.79);
  
   Rel_BW_rho->SetParameter(2,0.149);  
   Rel_BW_rho->FixParameter(3,0);
  
   //omega Small peak
   Rel_BW_rho->FixParameter(4,7.81578e-01);
   Rel_BW_rho->FixParameter(5,8.49000e-03);
   
   //kshort peak
   Rel_BW_rho->SetParameter(6,1.21111e+04);
   Rel_BW_rho->SetParLimits(6,0,5e+05);
   Rel_BW_rho->FixParameter(7,0.497614);
   //Rel_BW_rho->SetParLimits(7,4.90018e-01,0.5);
   Rel_BW_rho->FixParameter(8,3.71497e-03);
   //Rel_BW_rho->SetParLimits(8,3e-03,6e-03);
 
   //omega template size
   // Rel_BW_rho->SetParLimits(9,1,10);
     { 
    {if (ptbin == 1 || ptbin == 2)
	{Rel_BW_rho->SetParameter(9,2.0);
	  Rel_BW_rho->SetParLimits(9,1.75,2.25);} }
    { if (ptbin == 3)
	{Rel_BW_rho->SetParameter(9,2.0);
       Rel_BW_rho->SetParLimits(9,1.0,2.25);}}
    { if (ptbin == 4)
	{Rel_BW_rho->SetParameter(9,1.0);
	  Rel_BW_rho->SetParLimits(9,0.5,2.25);}}
    { if(ptbin == 5 )
	{Rel_BW_rho->SetParameter(9,1.0);
	  Rel_BW_rho->SetParLimits(9,0.0,2.25);}}
    { if(ptbin ==6 )
	{Rel_BW_rho->SetParameter(9,2.0);
	  Rel_BW_rho->SetParLimits(9,0.0,2.25);}}
    { if(ptbin == 7 || ptbin == 8)
	{ Rel_BW_rho->SetParameter(9,1.0);
	  Rel_BW_rho->SetParLimits(9,1,10); }}
     }
     //Background
     Rel_BW_rho->SetParameter(10,1.36435e+08);
     Rel_BW_rho->SetParameter(11,2.47638e+00);
     Rel_BW_rho->SetParameter(12,9.45407e+00);
     Rel_BW_rho->SetParameter(13,1.04364e+00);
     // Rel_BW_rho->SetParLimits(13,0,1.04364e+00);//added to force gamma positive
     
     // f0 peak
     Rel_BW_rho->SetParameter(14,3.23645e+04);
     // Rel_BW_rho->SetParLimits(14,0.0,3.23645e+04);
     Rel_BW_rho->SetParameter(15,9.70509e-01);
     Rel_BW_rho->SetParLimits(15,0.96,0.99);
     
     if(fix_width_f0_pdg == 1){
       Rel_BW_rho->FixParameter(16,0.1);
     }
     
     if(fix_width_f0_pdg == 0){
       Rel_BW_rho->SetParameter(16,0.1);
       Rel_BW_rho->SetParLimits(16,0.03,0.12);
     }
     
     //PS factor
     Rel_BW_rho->FixParameter(17,1.0);
     
     // f2 peak
     Rel_BW_rho->SetParameter(18,3.38158e+04);
     Rel_BW_rho->SetParLimits(18,0.0,1e+05);
     Rel_BW_rho->SetParameter(19,1.27500e+00);
     Rel_BW_rho->SetParLimits(19,1.20,1.4);
     
     if(fix_width_f2_pdg == 1){
       Rel_BW_rho->FixParameter(20,0.1851);
     }
     
     if(fix_width_f2_pdg == 0){
       Rel_BW_rho->SetParameter(20,0.1851);
       Rel_BW_rho->SetParLimits(20,0.16,0.25);
     }
     
     //eta template
     Rel_BW_rho->SetParameter(21,5);
     Rel_BW_rho->SetParLimits(21,1.5,8);
     
     //eta prime template
     Rel_BW_rho->SetParameter(22,3);
     Rel_BW_rho->SetParLimits(22,3,6);
     // Rel_BW_rho->SetParLimits(21,0.0,10);
     
     // Naming Parameters
     Rel_BW_rho->SetParName(0,"rho^{0} BW Size");
     Rel_BW_rho->SetParName(1,"rho^{0} BW Mean");
     Rel_BW_rho->SetParName(2,"rho^{0} BW Width");
     Rel_BW_rho->SetParName(3,"omega BW Size");
     Rel_BW_rho->SetParName(4,"omega BW Mean");
     Rel_BW_rho->SetParName(5,"omega BW Width");
     
     Rel_BW_rho->SetParName(6,"K^{0}_{s} Gaus Size");
     Rel_BW_rho->SetParName(7,"K^{0}_{s} Gaus Mean");
     Rel_BW_rho->SetParName(8,"K^{0}_{s} Gaus #sigma");
     Rel_BW_rho->SetParName(9,"omega template Size");
    
     Rel_BW_rho->SetParName(10,"Background Size");
     Rel_BW_rho->SetParName(11,"alpha");
     Rel_BW_rho->SetParName(12,"beta");
     Rel_BW_rho->SetParName(13,"gamma");
     Rel_BW_rho->SetParName(14,"f_{0} BW Size");
     Rel_BW_rho->SetParName(15,"f_{0} BW Mean");
     Rel_BW_rho->SetParName(16,"f_{0} BW Width");
     Rel_BW_rho->SetParName(17,"Pt");
     Rel_BW_rho->SetParName(18,"f_{2} BW Size");
     Rel_BW_rho->SetParName(19,"f_{2} BW Mean");
     Rel_BW_rho->SetParName(20,"f_{2} BW Width");     
     Rel_BW_rho->SetParName(21,"eta template Size");
     Rel_BW_rho->SetParName(22,"eta' template Size");
     Rel_BW_rho->SetLineColor(50);
     Rel_BW_rho->SetLineWidth(width);
     return ;   
}
void rho_peak(TCanvas *canvas) {
  //Rho Fit
    TF1 *rho_bw_tf1 = new TF1("rho_bw_tf1", rho_bw,fit_lo_lim, fit_up_lim,7);
    rho_bw_tf1->SetParameter(0,Rel_BW_rho->GetParameter(0));
    rho_bw_tf1->SetParameter(1,Rel_BW_rho->GetParameter(1));
    rho_bw_tf1->SetParameter(2,Rel_BW_rho->GetParameter(2));
    rho_bw_tf1->SetParameter(3,Rel_BW_rho->GetParameter(10));
    rho_bw_tf1->SetParameter(4,Rel_BW_rho->GetParameter(11));
    rho_bw_tf1->SetParameter(5,Rel_BW_rho->GetParameter(12));
    rho_bw_tf1->SetParameter(6,Rel_BW_rho->GetParameter(13));
    rho_bw_tf1->SetLineColor(2);
    rho_bw_tf1->SetLineWidth(width);   
    {
       //canvas->cd(ptbin);
      if(ptbin == 1 ){ rho_bw_fit_bin1 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin1->Draw("same");}
      if(ptbin == 2 ){  rho_bw_fit_bin2 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin2->Draw("same");}
      if(ptbin == 3 ){  rho_bw_fit_bin3 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin3->Draw("same");}
      if(ptbin == 4 ){  rho_bw_fit_bin4 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin4->Draw("same");}
      if(ptbin == 5 ){  rho_bw_fit_bin5 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin5->Draw("same");}
      if(ptbin == 6 ){  rho_bw_fit_bin6 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin6->Draw("same");}
      if(ptbin == 7 ){  rho_bw_fit_bin7 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fit_bin7->Draw("same");}
      if(ptbin == 8 ){  rho_bw_fit_bin8 = (TF1*) rho_bw_tf1->Clone(); rho_bw_fi_bin8->Draw("same");}}
    return ;
}
void omega_peak(TCanvas *canvas) {
 //Omega Fit
    TF1 *omega_three_tf3 = new TF1("omega_three_tf3", omega_three,fit_lo_lim, fit_up_lim,1);
    omega_three_tf3->SetParameter(0,Rel_BW_rho->GetParameter(9));
    omega_three_tf3->SetLineColor(3);
    omega_three_tf3->SetLineWidth(width);
    {
      //canvas->cd(ptbin);
      if(ptbin == 1 ){  omega_bin1 = (TF1*) omega_three_tf3->Clone(); omega_bin1->Draw("same");}
      if(ptbin == 2 ){  omega_bin2 = (TF1*) omega_three_tf3->Clone(); omega_bin2->Draw("same");}
      if(ptbin == 3 ){  omega_bin3 = (TF1*) omega_three_tf3->Clone(); omega_bin3->Draw("same");}
      if(ptbin == 4 ){  omega_bin4 = (TF1*) omega_three_tf3->Clone(); omega_bin4->Draw("same");}
      if(ptbin == 5 ){  omega_bin5 = (TF1*) omega_three_tf3->Clone(); omega_bin5->Draw("same");}
      if(ptbin == 6 ){  omega_bin6 = (TF1*) omega_three_tf3->Clone(); omega_bin6->Draw("same");}
      if(ptbin == 7 ){  omega_bin7 = (TF1*) omega_three_tf3->Clone(); omega_bin7->Draw("same");}
      if(ptbin == 8 ){  omega_bin8 = (TF1*) omega_three_tf3->Clone(); omega_bin8->Draw("same");}
    }
    return ;
}
void k0_peak(TCanvas *canvas)
 {
    //K0 Fit
    TF1 *k0_guass_tf2 = new TF1("k0_guass_tf2", k0_guass,fit_lo_lim, fit_up_lim,3);
    k0_guass_tf2->SetParameter(0,Rel_BW_rho->GetParameter(6));
    k0_guass_tf2->SetParameter(1,Rel_BW_rho->GetParameter(7));
    k0_guass_tf2->SetParameter(2,Rel_BW_rho->GetParameter(8));
    k0_guass_tf2->SetLineColor(4);
    k0_guass_tf2->SetLineWidth(width);
    {
      //canvas->cd(ptbin);
      if(ptbin == 1 ){  k0_bin1 = (TF1*) k0_guass_tf2->Clone(); k0_bin1->Draw("same");}
      if(ptbin == 2 ){  k0_bin2 = (TF1*) k0_guass_tf2->Clone(); k0_bin2->Draw("same");}
      if(ptbin == 3 ){  k0_bin3 = (TF1*) k0_guass_tf2->Clone(); k0_bin3->Draw("same");}
      if(ptbin == 4 ){  k0_bin4 = (TF1*) k0_guass_tf2->Clone(); k0_bin4->Draw("same");}
      if(ptbin == 5 ){  k0_bin5 = (TF1*) k0_guass_tf2->Clone(); k0_bin5->Draw("same");}
      if(ptbin == 6 ){  k0_bin6 = (TF1*) k0_guass_tf2->Clone(); k0_bin6->Draw("same");}
      if(ptbin == 7 ){  k0_bin7 = (TF1*) k0_guass_tf2->Clone(); k0_bin7->Draw("same");}
      if(ptbin == 8 ){  k0_bin8 = (TF1*) k0_guass_tf2->Clone(); k0_bin8->Draw("same");}
    }  

  return ;
} 
void f0_peak(TCanvas *canvas) {
  //f0 Fit
    TF1 *f0_bw_tf4 = new TF1("f0_bw_tf4",f0_bw,fit_lo_lim, fit_up_lim,4);
    f0_bw_tf4->SetParameter(0,Rel_BW_rho->GetParameter(7));
    f0_bw_tf4->SetParameter(1,Rel_BW_rho->GetParameter(14));
    f0_bw_tf4->SetParameter(2,Rel_BW_rho->GetParameter(15));
    f0_bw_tf4->SetParameter(3,Rel_BW_rho->GetParameter(16));
    f0_bw_tf4->SetLineColor(9);
    f0_bw_tf4->SetLineWidth(width);
    {
      //canvas->cd(ptbin);
      if(ptbin == 1 ){  f0_bin1 = (TF1*) f0_bw_tf4->Clone(); f0_bin1->Draw("same");}
      if(ptbin == 2 ){  f0_bin2 = (TF1*) f0_bw_tf4->Clone(); f0_bin2->Draw("same");}
      if(ptbin == 3 ){  f0_bin3 = (TF1*) f0_bw_tf4->Clone(); f0_bin3->Draw("same");}
      if(ptbin == 4 ){  f0_bin4 = (TF1*) f0_bw_tf4->Clone(); f0_bin4->Draw("same");}
      if(ptbin == 5 ){  f0_bin5 = (TF1*) f0_bw_tf4->Clone(); f0_bin5->Draw("same");}
      if(ptbin == 6 ){  f0_bin6 = (TF1*) f0_bw_tf4->Clone(); f0_bin6->Draw("same");}
      if(ptbin == 7 ){  f0_bin7 = (TF1*) f0_bw_tf4->Clone(); f0_bin7->Draw("same");}
      if(ptbin == 8 ){  f0_bin8 = (TF1*) f0_bw_tf4->Clone(); f0_bin8->Draw("same");}  
    }
  return ;
} 
void f2_peak(TCanvas *canvas) {
  //f2 Fit
      TF1 *f2_bw_tf7 = new TF1("f2_bw_tf7",f2_bw,fit_lo_lim, fit_up_lim,3);   
      f2_bw_tf7->SetParameter(0,Rel_BW_rho->GetParameter(18));
      f2_bw_tf7->SetParameter(1,Rel_BW_rho->GetParameter(19));
      f2_bw_tf7->SetParameter(2,Rel_BW_rho->GetParameter(20));
      f2_bw_tf7->SetLineColor(12);
      f2_bw_tf7->SetLineWidth(width);    
      {
	//canvas->cd(ptbin);
	if(ptbin == 1 ){  f2_bin1 = (TF1*) f2_bw_tf7->Clone(); f2_bin1->Draw("same");}
	if(ptbin == 2 ){  f2_bin2 = (TF1*) f2_bw_tf7->Clone(); f2_bin2->Draw("same");}
	if(ptbin == 3 ){  f2_bin3 = (TF1*) f2_bw_tf7->Clone(); f2_bin3->Draw("same");}
	if(ptbin == 4 ){  f2_bin4 = (TF1*) f2_bw_tf7->Clone(); f2_bin4->Draw("same");}
	if(ptbin == 5 ){  f2_bin5 = (TF1*) f2_bw_tf7->Clone(); f2_bin5->Draw("same");}
	if(ptbin == 6 ){  f2_bin6 = (TF1*) f2_bw_tf7->Clone(); f2_bin6->Draw("same");}
	if(ptbin == 7 ){  f2_bin7 = (TF1*) f2_bw_tf7->Clone(); f2_bin7->Draw("same");}
	if(ptbin == 8 ){  f2_bin8 = (TF1*) f2_bw_tf7->Clone(); f2_bin8->Draw("same");}  
      }
  return ;
} 
void eta_peak(TCanvas *canvas) {
    //Eta Fit
    TF1 *eta_func_tf6 = new TF1("eta_func_tf6",eta_function,fit_lo_lim, fit_up_lim,1);
    eta_func_tf6->SetParameter(0,Rel_BW_rho->GetParameter(21));
    eta_func_tf6->SetLineColor(20);
    eta_func_tf6->SetLineWidth(width); 
    {
       //canvas->cd(ptbin);
      if(ptbin == 1 ){  eta_bin1 = (TF1*) eta_func_tf6->Clone(); eta_bin1->Draw("same");}
      if(ptbin == 2 ){  eta_bin2 = (TF1*) eta_func_tf6->Clone(); eta_bin2->Draw("same");}
      if(ptbin == 3 ){  eta_bin3 = (TF1*) eta_func_tf6->Clone(); eta_bin3->Draw("same");}
      if(ptbin == 4 ){  eta_bin4 = (TF1*) eta_func_tf6->Clone(); eta_bin4->Draw("same");}
      if(ptbin == 5 ){  eta_bin5 = (TF1*) eta_func_tf6->Clone(); eta_bin5->Draw("same");}
      if(ptbin == 6 ){  eta_bin6 = (TF1*) eta_func_tf6->Clone(); eta_bin6->Draw("same");}
      if(ptbin == 7 ){  eta_bin7 = (TF1*) eta_func_tf6->Clone(); eta_bin7->Draw("same");}
      if(ptbin == 8 ){  eta_bin8 = (TF1*) eta_func_tf6->Clone(); eta_bin8->Draw("same");} 
    }    
    return ;
} 
void etaprime_peak(TCanvas *canvas) {
  //EtaPrmime
    TF1 *eta_func_tf8 = new TF1("eta_func_tf8",etaprime_function,fit_lo_lim, fit_up_lim,1);
    eta_func_tf8->SetParameter(0,Rel_BW_rho->GetParameter(22));
    eta_func_tf8->SetLineColor(28);
    eta_func_tf8->SetLineWidth(width);    
    {
       //canvas->cd(ptbin);
      if(ptbin == 1 ){  etaprime_bin1 = (TF1*) eta_func_tf8->Clone(); etaprime_bin1->Draw("same");}
      if(ptbin == 2 ){  etaprime_bin2 = (TF1*) eta_func_tf8->Clone(); etaprime_bin2->Draw("same");}
      if(ptbin == 3 ){  etaprime_bin3 = (TF1*) eta_func_tf8->Clone(); etaprime_bin3->Draw("same");}
      if(ptbin == 4 ){  etaprime_bin7 = (TF1*) eta_func_tf8->Clone(); etaprime_bin4->Draw("same");}
      if(ptbin == 5 ){  etaprime_bin5 = (TF1*) eta_func_tf8->Clone(); etaprime_bin5->Draw("same");}
      if(ptbin == 6 ){  etaprime_bin6 = (TF1*) eta_func_tf8->Clone(); etaprime_bin6->Draw("same");}
      if(ptbin == 7 ){  etaprime_bin7 = (TF1*) eta_func_tf8->Clone(); etaprime_bin7->Draw("same");}
      if(ptbin == 8 ){  etaprime_bin8 = (TF1*) eta_func_tf8->Clone(); etaprime_bin8->Draw("same");}  
    }   
  return ;
} 

void background(TCanvas *canvas) {

 //BackGround Curve
    TF1 *bkgrnd_tf5 = new TF1("bkgrnd_tf5",bkgrnd,fit_lo_lim, fit_up_lim,4); 
    bkgrnd_tf5->SetParameter(0,Rel_BW_rho->GetParameter(10));
    bkgrnd_tf5->SetParameter(1,Rel_BW_rho->GetParameter(11));
    bkgrnd_tf5->SetParameter(2,Rel_BW_rho->GetParameter(12));
    bkgrnd_tf5->SetParameter(3,Rel_BW_rho->GetParameter(13));
    bkgrnd_tf5->SetLineColor(41);
    bkgrnd_tf5->SetLineWidth(width);
    {
       //canvas->cd(ptbin);
      if(ptbin == 1 ){  bkg_bin1 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin1->Draw("same");}
      if(ptbin == 2 ){  bkg_bin2 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin2->Draw("same");}
      if(ptbin == 3 ){  bkg_bin3 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin3->Draw("same");}
      if(ptbin == 4 ){  bkg_bin7 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin4->Draw("same");}
      if(ptbin == 5 ){  bkg_bin5 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin5->Draw("same");}
      if(ptbin == 6 ){  bkg_bin6 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin6->Draw("same");}
      if(ptbin == 7 ){  bkg_bin7 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin7->Draw("same");}
      if(ptbin == 8 ){  bkg_bin8 = (TF1*) bkgrnd_tf5->Clone(); bkg_bin8->Draw("same");} 
    }
    
    return ;
} 

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//


void macro00() {
  
  TFile *_file0 = TFile::Open("/Users/inayat/RhoMacrosNoPID/AnalysisResultsRHODATA.root");
  TList *list = (TList*)_file0->Get("RsnHistMini_Rho_RhoNsigma_qualityonly");
  
 
  int centlo = 0;
  int centup = 100;

  int ptbin = 1 ;

  float ptlimlo = 0.2 ;
  float ptlimhi = 0.2 ;

   TCanvas *canvas = new TCanvas("canvas","",1300,950);
     canvas->Divide(4,2);
  
     for(ptbin = 1; ptbin <= 8; ++ptbin ) {
       if ( ptbin >=1 || ptbin <= 6) ptlimhi = ptlimlo + 0.4;
       if( ptbin == 7 || ptbin == 8) ptlimhi = ptlimlo + 1.2;
       /*if (ptlimlo <= 2.6) ptlimhi = ptlimlo + 0.4;
    else  ptlimhi = ptlimlo + 1.2;
       */
    
  //***********************************************************************//
  //for Pi+ Pi- distribution
  fHistRho_clean_Rsn_unlike = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Unlike"));
  fHistRho_clean_Rsn_unlike->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_unlike->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);		      	
  TH1D * fHistRho_clean_Rsn_unlike_invmas = new TH1D(*fHistRho_clean_Rsn_unlike->Projection(0));
  //***********************************************************************//
  // for pi+ pi+ like distribution
  fHistRho_like_plus_Rsn = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_LikePP"));
  fHistRho_like_plus_Rsn->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_like_plus_Rsn->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);
  TH1D * fHistRho_like_plus_Rsn_invmas = new TH1D(*fHistRho_like_plus_Rsn->Projection(0));  
  //***********************************************************************//
   //for pi- pi- like distribution
  fHistRho_like_minus_Rsn = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_LikeMM"));
  fHistRho_like_minus_Rsn->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_like_minus_Rsn->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);
  TH1D * fHistRho_like_minus_Rsn_invmas = new TH1D(*fHistRho_like_minus_Rsn->Projection(0));
  //***********************************************************************//   
  //like sign for combined pi+ pi+ and pi- pi- distributions using 2*geometric mean
   TH1D * fHistRho_like_mean_Rsn_invmas =  new TH1D("fHistRho_like_mean_Rsn_invmas","projection",180,0.2,2.0);
  for(int i = 0; i <=180; i++) {
    Double_t binplus =  fHistRho_like_plus_Rsn_invmas->GetBinContent(i);
    Double_t binminus =  fHistRho_like_minus_Rsn_invmas->GetBinContent(i);
    
    Double_t errorplus = fHistRho_like_plus_Rsn_invmas->GetBinError(i);
    Double_t errorminus = fHistRho_like_minus_Rsn_invmas->GetBinError(i);
    Double_t Background = 2*(sqrt(binplus*binminus));
    Double_t error = (errorplus + errorminus)/2.0;
     
    fHistRho_like_mean_Rsn_invmas ->SetBinContent(i,Background);
    fHistRho_like_mean_Rsn_invmas->SetBinError(i,error);
  }
  //*************************************************************************//  
  //Normalized event mixing background, normalized w.r.t combined pi+ pi+ and pi- pi-  
  fHistRho_clean_Rsn_mixing = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Mixing"));
  fHistRho_clean_Rsn_mixing->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_mixing->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);
  TH1D * fHistRho_clean_Rsn_mixing_invmas = new TH1D(*fHistRho_clean_Rsn_mixing->Projection(0));
  Double_t num = fHistRho_like_mean_Rsn_invmas-> Integral(0,180);
  Double_t den =  fHistRho_clean_Rsn_mixing_invmas ->Integral(0,180);
  Double_t factor = num/den;
  fHistRho_clean_Rsn_mixing_invmas->Scale(factor);

  //*********************************************************************************//      
 
  TH1D *fHist_unlike_copy_data_ls = new TH1D (*fHistRho_clean_Rsn_unlike_invmas);
  fHist_unlike_copy_data_ls->Add(fHistRho_like_mean_Rsn_invmas,-1);
  //++ptbin;
  /* { {if(ptbin==1) TCanvas *C1 = new TCanvas("C1","bin1",600,600);}
  {if(ptbin==2) TCanvas *C2 = new TCanvas("C2","bin2",600,600);}
  {if(ptbin==3) TCanvas *C3 = new TCanvas("C3","bin3",600,600);}
  {if(ptbin==4) TCanvas *C4 = new TCanvas("C4","bin4",600,600);}
  {if(ptbin==5) TCanvas *C5 = new TCanvas("C5","bin5",600,600);}
  {if(ptbin==6) TCanvas *C6 = new TCanvas("C6","bin6",600,600);}
  {if(ptbin==7) TCanvas *C7 = new TCanvas("C7","bin7",600,600);}
  {if(ptbin==8) TCanvas *C8 = new TCanvas("C8","bin8",600,600);}}*/
  //if(ptbin > 8) break;
    canvas->cd(ptbin);
  fHist_unlike_copy_data_ls->Draw("");
  fHist_unlike_copy_data_ls->GetXaxis()->SetTitle("invariant mass GeV/c^{2}"); 
  fHist_unlike_copy_data_ls->GetYaxis()->SetTitle("");
  fHist_unlike_copy_data_ls->SetLineWidth(width);
  fHist_unlike_copy_data_ls->SetLineColor(9);
  {
    {if( ptbin == 1) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 0.2 - 0.6 GeV/c");
      fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,450000);}}
    {if (ptbin == 2) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 0.6 - 1.0 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,120000);}}
    {if (ptbin == 3){fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 1.0 - 1.4 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,80000);}}
    {if (ptbin == 4) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 1.4 - 1.8 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,50000);}}
    {if (ptbin == 5){fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 1.8 - 2.2 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,35000);}}
    {if (ptbin == 6) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 2.2 - 2.6 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,17000);}}
    {if (ptbin == 7) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 2.6 - 3.8 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,17000);}}
    {if (ptbin == 8) {fHist_unlike_copy_data_ls ->SetTitle("p_{T} bin 3.8 - 5.0 GeV/c");
	fHist_unlike_copy_data_ls ->GetYaxis()->SetRangeUser(0.0,4000);}}
  }
  
  
   //*********************************************************************************//      
//Efficiency Correction
  TFile *_file0 = TFile::Open("/Users/inayat/RhoMacrosNoPID/AnalysisResultsRHOMC.root");
  TList *list = (TList*)_file0-> Get("RsnHistMini_Rho_RhoNsigma_qualityonly");
  
  fHistRho_clean_Rsn_trues = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Trues"));
  fHistRho_clean_Rsn_trues->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_trues->GetAxis(0)->SetRangeUser(0.2,1.4);
  fHistRho_clean_Rsn_trues->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);					
  TH1D * fHistRho_clean_Rsn_trues_invmas = new TH1D(*fHistRho_clean_Rsn_trues->Projection(0));
  
  Double_t ReconRho = fHistRho_clean_Rsn_trues_invmas->Integral(0,180);
  
  fHistRho_clean_Rsn_mcgenrho = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho_MCGenrho.RhoNsigma_qualityonly"));
  fHistRho_clean_Rsn_mcgenrho->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_mcgenrho->GetAxis(0)->SetRangeUser(0.2,1.4);
  fHistRho_clean_Rsn_mcgenrho->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);	
  TH1D * fHistRho_clean_Rsn_mcgenrho_invmas = new TH1D(*fHistRho_clean_Rsn_mcgenrho->Projection(0)); 
  
  Double_t GenerRho = fHistRho_clean_Rsn_mcgenrho_invmas->Integral(0,180);
  Double_t Effic = ReconRho/GenerRho;
  TH1D *fHistRho_clean_Rsn_trues_invmas = new TH1D(*fHistRho_clean_Rsn_trues_invmas);
  fHistRho_clean_Rsn_trues_invmas->Divide(fHistRho_clean_Rsn_mcgenrho_invmas); 
  efficiency_N_rho = new TH1D(*fHistRho_clean_Rsn_trues_invmas);
  //*********************************************************************************//        

  // Monte Carlo Templates
  
  //MC Omega file for template
  TFile *_file1 = TFile::Open("/Users/inayat/RhoMacrosNoPID/AnalysisResultsOMEGA.root");
  TList *list = (TList*)_file1->Get("RsnHistMini_Rho_RhoNsigma_qualityonly");
  fHistRho_clean_Rsn_trues_omega = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Trues")); 
  fHistRho_clean_Rsn_trues_omega->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_trues_omega->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);			
  TH1D * fHistRho_clean_Rsn_trues_omega_invmas = new TH1D(*fHistRho_clean_Rsn_trues_omega->Projection(0));
  fHistOmega_Rsn = new TH1D(*fHistRho_clean_Rsn_trues_omega_invmas);
  
  //MC eta file for template  
  TFile *_file2 = TFile::Open("/Users/inayat/RhoMacrosNoPID/AnalysisResultsETA.root");
  fHistRho_clean_Rsn_trues_eta = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Trues"));
  fHistRho_clean_Rsn_trues_eta->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_trues_eta->GetAxis(0)->SetRangeUser(fit_lo_lim,2.0);
  fHistRho_clean_Rsn_trues_eta->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);					
  TH1D * fHistRho_clean_Rsn_trues_eta_invmas = new TH1D(*fHistRho_clean_Rsn_trues_eta->Projection(0));
  fHistEta_Rsn = new TH1D (*fHistRho_clean_Rsn_trues_eta_invmas);
   
  //MC Eta Prime file template
  TFile *_file3 = TFile::Open("/Users/inayat/RhoMacrosNoPID/AnalysisResultsETAPRIME.root"); 
  TList *list = (TList*)_file3->Get("RsnHistMini_Rho_RhoNsigma_qualityonly");
  fHistRho_clean_Rsn_trues_etaprime = dynamic_cast<THnSparseT<TArrayF>*>(RsnHistMini_Rho_RhoNsigma_qualityonly->FindObject("RsnMini_rho.RhoNsigma_qualityonly_Trues"));
  fHistRho_clean_Rsn_trues_etaprime->GetAxis(2)->SetRangeUser(centlo,centup);
  fHistRho_clean_Rsn_trues_etaprime->GetAxis(0)->SetRangeUser(fit_lo_lim,2.0);
  fHistRho_clean_Rsn_trues_etaprime->GetAxis(1)->SetRangeUser(ptlimlo,ptlimhi);					
  TH1D * fHistRho_clean_Rsn_trues_etaprime_invmas = new TH1D(*fHistRho_clean_Rsn_trues_etaprime->Projection(0));
  fHistEtaprime_Rsn = new TH1D (*fHistRho_clean_Rsn_trues_etaprime_invmas);
 
 
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING///  
///FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING///  
///FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING  FITTING///  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

  myParameters();
 
  fHist_unlike_copy_data_ls->Fit("Rel_BW_rho","M","",fit_lo_lim, fit_up_lim);
 
  Double_t chi2_ndf = Rel_BW_rho->GetChisquare() / Rel_BW_rho->GetNDF();
  cout<<"Chi2_ndf for ptbin = " << ptbin << " equals "<< chi2_ndf <<endl;
  gStyle->SetOptFit(1);  
  
  rho_peak(canvas); omega_peak(canvas);  k0_peak(canvas);  f0_peak(canvas);  f2_peak(canvas);  eta_peak(canvas);  etaprime_peak(canvas);  background(canvas); 
  //rho mean
  cout <<"Mean of Rho for ptbin = " << ptbin << " equals "<< Rel_BW_rho->GetParameter(1)<<endl;
  
  //Rho Yield
  TH1D * rho_bw_th1d =  new TH1D("rho_bw_th1d","rho peak",180,0.2,2.0);
  rho_bw_th1d->Add(rho_bw_tf1);
  Double_t Rhos = rho_bw_th1d->Integral(0,180);
  Double_t Rhos_eff = Rhos / Effic;
  Double_t pt = (ptlimlo + ptlimhi)/2;
  Double_t dpt = (ptlimhi - ptlimlo);
  cout << "Normalized Yield for ptbin = " <<ptbin << " equals "<< Rhos_eff*8.279e-9/(pt*dpt) <<endl;  

  TLegend *leg = new TLegend(0.7, 0.9, 0.5, 0.6, NULL, "brNDC");
  leg->SetBorderSize(1);
  leg->SetTextFont(52);
  leg->SetTextSize(0.02806229);
  leg->SetLineColor(1);
  leg->SetLineStyle(1);
  leg->SetLineWidth(1.5);
  leg->SetFillColor(18);
  leg->SetFillStyle(3001);
 
  TLegendEntry *entry=leg->AddEntry( Rel_BW_rho,"Total Fit","l");
   entry=leg->AddEntry( rho_bw_tf1,"#rho^{0}","l");
   entry=leg->AddEntry(omega_three_tf3,"#omega Components","l");
   entry=leg->AddEntry(eta_func_tf6,"#eta","l");
   entry=leg->AddEntry(eta_func_tf8,"#eta'","l");
   entry=leg->AddEntry(k0_guass_tf2,"K_{s} decay ","l");
   entry=leg->AddEntry(f0_bw_tf4,"f0 ","l");
   entry=leg->AddEntry(f2_bw_tf7,"f2","l");
   entry=leg->AddEntry(bkgrnd_tf5,"Background","l");
   leg->Draw();
   
    cout <<"  Lower pt limit = " << ptlimlo<< endl; 
    cout <<" Upper pt limit = " << ptlimhi<< endl;

    ptlimlo =ptlimhi;
  
    //  cout <<" ptlimlo after = " << ptlimlo<< endl; 
    //cout <<" ptlimhi after = " << ptlimhi<< endl; 
  }
}    
 
//Total fit function for the total spectra ( Total like minus combined like ) 

Double_t Total_fit (Double_t *x, Double_t *par) {
  
  Double_t width_rho = (par[2] * par[1] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[1] * par[1]) - (4 * (0.13957) * (0.13957))),3.0/2.0);
  
  Double_t rho_function_bw = par[0] * x[0] * TMath::Power(par[1], 1.0) * TMath::Power(width_rho, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[1], 2.0), 2.0) + (TMath::Power(par[1], 2.0) * TMath::Power(width_rho, 2.0))));
  
  Double_t width_f0 = (par[16] * par[15] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[15] * par[7]) - (4 * (0.13957) * (0.13957))),1.0/2.0);
  
  width_f0 = par[16];
 
  Double_t f0_function_bw = par[14] * x[0] * TMath::Power(par[15], 1.0) * TMath::Power(width_f0, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[15], 2.0), 2.0) + (TMath::Power(par[15], 2.0) * TMath::Power(width_f0, 2.0))));
  

   Double_t width_f2 = (par[20] * par[19] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[19] * par[19]) - (4 * (0.13957) * (0.13957))),5.0/2.0);

       width_f2 = par[20];

       Double_t f2_function_bw = par[18] * x[0] * TMath::Power(par[19], 1.0) * TMath::Power(width_f2, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[19], 2.0), 2.0) + (TMath::Power(par[19], 2.0) * TMath::Power(width_f2, 2.0))));

  Double_t omega_function_bw = 2 * par[3] * x[0] * TMath::Power(par[4], 1.0) * TMath::Power(par[5], 1.0) / (TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[4], 2.0), 2.0) + (TMath::Power(x[0], 4.0) * TMath::Power(par[5], 2.0) / TMath::Power(par[4], 2.0)) ) );
  
  Double_t k0_function_bw = par[6] * TMath::Gaus(x[0],par[7],par[8]);
  
  Double_t background_function = par[10] * TMath::Power(x[0] - 0.28, par[11]) * exp( -par[12] * (x[0] - 0.28) + (par[13] * TMath::Power(x[0] - 0.28, 3.0) ) );
  
  //MC Template Omega
  Double_t omega_three_body_bin = fHistOmega_Rsn->GetXaxis()->FindBin(x[0]);
  Double_t omega_three_body = par[9] * (fHistOmega_Rsn->GetBinContent(omega_three_body_bin));
  
   Double_t efficiency_N_rho_bin = efficiency_N_rho->GetXaxis()->FindBin(x[0]);
   Double_t efficiency_N_rho_mod = efficiency_N_rho->GetBinContent(efficiency_N_rho_bin);
  
   rho_function_bw = rho_function_bw * efficiency_N_rho_mod;
  
  Double_t eta_bin = fHistEta_Rsn->GetXaxis()->FindBin(x[0]);
  Double_t eta_temp = par[21] * (fHistEta_Rsn->GetBinContent(eta_bin));// + fHistEtaprim_Rsn->GetBinContent(eta_bin));

  Double_t etaprime_bin = fHistEtaprime_Rsn->GetXaxis()->FindBin(x[0]); 
  Double_t etaprime_temp = par[22] * (fHistEtaprime_Rsn->GetBinContent(etaprime_bin)) ;
 
  int pt = par[17];
  Double_t PS = (x[0] / TMath::Power((x[0] * x[0]) + (pt * pt), 0.5)) * exp(-1 * TMath::Power((x[0]*x[0]) + (pt * pt),0.5)  / 170);
  
  return (1 + rho_function_bw ) * background_function + omega_function_bw + omega_three_body + k0_function_bw + eta_temp + f0_function_bw  + f2_function_bw   ;  
}


 Double_t rho_bw(Double_t *x, Double_t *par){
  Double_t width_rho = (par[2] * par[1] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[1] * par[1]) - (4 * (0.13957) * (0.13957))),3.0/2.0);
  
  Double_t rho_function_bw = par[0] * x[0] * TMath::Power(par[1], 1.0) * TMath::Power(width_rho, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[1], 2.0), 2.0) + (TMath::Power(par[1], 2.0) * TMath::Power(width_rho, 2.0))));
  
  Double_t background_function = par[3] * TMath::Power(x[0] - 0.28, par[4]) * exp( -par[5] * (x[0] - 0.28) + (par[6] * TMath::Power(x[0] - 0.28, 3.0) ) );
  
   Double_t efficiency_N_rho_bin = efficiency_N_rho->GetXaxis()->FindBin(x[0]);
   Double_t efficiency_N_rho_mod = efficiency_N_rho->GetBinContent(efficiency_N_rho_bin);
  
  rho_function_bw = rho_function_bw * efficiency_N_rho_mod;
  return background_function * rho_function_bw ;
}

Double_t k0_guass(Double_t *x, Double_t*par){
  
  Double_t k0_function_bw = par[0] * TMath::Gaus(x[0],par[1],par[2]);
  
  return k0_function_bw ;
}


Double_t omega_three (Double_t *x, Double_t *par){

  Double_t omega_three_body_bin = fHistOmega_Rsn->GetXaxis()->FindBin(x[0]);
  Double_t omega_three_body = par[0] * (fHistOmega_Rsn->GetBinContent(omega_three_body_bin));
  
   return   omega_three_body ;
}

Double_t f0_bw (Double_t *x, Double_t *par){
  Double_t width_f0 = (par[3] * par[2] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[2] * par[0]) - (4 * (0.13957) * (0.13957))),1.0/2.0);
  
  width_f0 = par[3];
  
  Double_t f0_function_bw = par[1] * x[0] * TMath::Power(par[2], 1.0) * TMath::Power(width_f0, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[2], 2.0), 2.0) + (TMath::Power(par[2], 2.0) * TMath::Power(width_f0, 2.0))));

  return  f0_function_bw ;
  
}

Double_t bkgrnd (Double_t *x, Double_t *par){
 Double_t background_function = par[0] * TMath::Power(x[0] - 0.28, par[1]) * exp( -par[2] * (x[0] - 0.28) + (par[3] * TMath::Power(x[0] - 0.28, 3.0) ) );
 return  background_function;
}

Double_t f2_bw (Double_t *x, Double_t *par){
  
 Double_t width_f2 = (par[2] * par[1] / x[0]) * TMath::Power(((x[0] * x[0]) - (4 * (0.13957) * (0.13957))) / ((par[1] * par[1]) - (4 * (0.13957) * (0.13957))),5.0/2.0);

       width_f2 = par[2];

       Double_t f2_function_bw = par[0] * x[0] * TMath::Power(par[1], 1.0) * TMath::Power(width_f2, 1.0) / (2 * TMath::Pi() * (TMath::Power(TMath::Power(x[0], 2.0) - TMath::Power(par[1], 2.0), 2.0) + (TMath::Power(par[1], 2.0) * TMath::Power(width_f2, 2.0))));
 
  return f2_function_bw ;
}

Double_t eta_function (Double_t *x, Double_t *par){
 Double_t eta_bin = fHistEta_Rsn->GetXaxis()->FindBin(x[0]);
 Double_t eta_temp = par[0] * (fHistEta_Rsn->GetBinContent(eta_bin)) ;// + fHistEtaprim_Rsn->GetBinContent(eta_bin));

 return  eta_temp;
 }

Double_t etaprime_function (Double_t *x, Double_t *par){
 Double_t etaprime_bin = fHistEtaprime_Rsn->GetXaxis()->FindBin(x[0]);
 Double_t etaprime_temp = par[0] * (fHistEtaprime_Rsn->GetBinContent(etaprime_bin)) ;

 return  etaprime_temp;
}