Double_t d1half(Int_t m1,Int_t m2,Double_t theta){
  Double_t d1halfVal = -100;
  if (m1 ==  1 && m2 ==  1) d1halfVal =  cos(theta/2);
  if (m1 == -1 && m2 ==  1) d1halfVal = -sin(theta/2);
  if (m1 ==  1 && m2 == -1) d1halfVal =  sin(theta/2);
  //if (m1 ==  1 && m2 == -1) d1halfVal =  -sin(theta/2);
  if (m1 == -1 && m2 == -1) d1halfVal =  cos(theta/2);
  return d1halfVal;
}
Double_t d3half(Int_t m1,Int_t m2,Double_t theta){
  Double_t d3halfVal = -100;
  if (m1 ==  1 && m2 ==  1) d3halfVal =  (1.0/2)*cos(theta/2)*(3*cos(theta) - 1);
  if (m1 == -1 && m2 ==  1) d3halfVal = -(1.0/2)*sin(theta/2)*(3*cos(theta) + 1);
  if (m1 ==  1 && m2 == -1) d3halfVal =  (1.0/2)*sin(theta/2)*(3*cos(theta) + 1);
  if (m1 == -1 && m2 == -1) d3halfVal =  (1.0/2)*cos(theta/2)*(3*cos(theta) - 1);

  if (m1 ==  3 && m2 ==  1) d3halfVal =  sqrt(3.0)*sin(theta/2)*pow(cos(theta/2),2);
  if (m1 == -3 && m2 ==  1) d3halfVal =  sqrt(3.0)*pow(sin(theta/2),2)*cos(theta/2);
  if (m1 ==  3 && m2 == -1) d3halfVal =  sqrt(3.0)*pow(sin(theta/2),2)*cos(theta/2);
  if (m1 == -3 && m2 == -1) d3halfVal = -sqrt(3.0)*sin(theta/2)*pow(cos(theta/2),2);

  if (m1 ==  1 && m2 ==  3) d3halfVal = -sqrt(3.0)*sin(theta/2)*pow(cos(theta/2),2);
  if (m1 == -1 && m2 ==  3) d3halfVal =  sqrt(3.0)*pow(sin(theta/2),2)*cos(theta/2);
  if (m1 ==  1 && m2 == -3) d3halfVal =  sqrt(3.0)*pow(sin(theta/2),2)*cos(theta/2);
  if (m1 == -1 && m2 == -3) d3halfVal =  sqrt(3.0)*sin(theta/2)*pow(cos(theta/2),2);

  if (m1 ==  3 && m2 ==  3) d3halfVal =  pow(cos(theta/2),3);
  if (m1 == -3 && m2 ==  3) d3halfVal = -pow(sin(theta/2),3);
  if (m1 ==  3 && m2 == -3) d3halfVal =  pow(sin(theta/2),3);
  if (m1 == -3 && m2 == -3) d3halfVal =  pow(cos(theta/2),3);
  return d3halfVal;
}
Double_t d5half(Int_t m1,Int_t m2,Double_t theta){
  Double_t d5halfVal = -100;

  //if (m1 ==  1 && m2 ==  1) d5halfVal =  cos(theta/2)*(2.5*pow(cos(theta) - 1,2) + 4*(cos(theta - 1) + 1);
  //if (m1 == -1 && m2 ==  1) d5halfVal = -sin(theta/2)*(2.5*pow(cos(theta) - 1,2) + 6*(cos(theta - 1) + 3);
  //if (m1 ==  1 && m2 == -1) d5halfVal =  sin(theta/2)*(2.5*pow(cos(theta) - 1,2) + 6*(cos(theta - 1) + 3);
  //if (m1 == -1 && m2 == -1) d5halfVal =  cos(theta/2)*(2.5*pow(cos(theta) - 1,2) + 4*(cos(theta - 1) + 1);

  return d5halfVal;
}
Double_t fWave(Double_t *x,Double_t *parPtr){
  Double_t fitVal,xVal;

  xVal = *x;
  fitVal = 0.0;

  double thetaVal = acos(xVal);
  double a0     = parPtr[0];
  /////////////////////////
  //    j=1/2 and l=0    //
  /////////////////////////
  //j=1/2, m = 1/2, l = 0, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a1101Mag  = parPtr[1];
  double phase1101 = parPtr[2];
  double d1101Val  = d1half(1,1,thetaVal)+d1half(1,-1,thetaVal);
  double f1101re   = d1101Val*a1101Mag*cos(phase1101);
  double f1101im   = d1101Val*a1101Mag*sin(phase1101);

  //j=1/2, m = -1/2, l = 0, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a1n101Mag  = parPtr[3];
  double phase1n101 = parPtr[4];
  double d1n101Val  = d1half(-1,1,thetaVal)+d1half(-1,-1,thetaVal);
  double f1n101re   = d1n101Val*a1n101Mag*cos(phase1n101);
  double f1n101im   = d1n101Val*a1n101Mag*sin(phase1n101);
  /////////////////////////
  //    j=1/2 and l=1    //
  /////////////////////////
  //j=1/2, m = 1/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a1111Mag  = parPtr[5];
  double phase1111 = parPtr[6];
  double d1111Val  = -sqrt(1.0/3)*d1half(1,1,thetaVal)+sqrt(1.0/3)*d1half(1,-1,thetaVal);
  double f1111re   = d1111Val*a1111Mag*cos(phase1111);
  double f1111im   = d1111Val*a1111Mag*sin(phase1111);

  //j=1/2, m = -1/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a1n111Mag  = parPtr[7];
  double phase1n111 = parPtr[8];
  double d1n111Val  = -sqrt(1.0/3)*d1half(-1,1,thetaVal)+sqrt(1.0/3)*d1half(-1,-1,thetaVal);
  double f1n111re   = d1n111Val*a1n111Mag*cos(phase1n111);
  double f1n111im   = d1n111Val*a1n111Mag*sin(phase1n111);
  /////////////////////////
  //    j=3/2 and l=1    //
  /////////////////////////
  //j=3/2, m = 3/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a3311Mag  = parPtr[9];
  double phase3311 = parPtr[10];
  double d3311Val  = sqrt(2.0/3)*d3half(3,1,thetaVal)+sqrt(2.0/3)*d3half(3,-1,thetaVal);
  double f3311re   = d3311Val*a3311Mag*cos(phase3311);
  double f3311im   = d3311Val*a3311Mag*sin(phase3311);
  //j=3/2, m = -3/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a3n311Mag  = parPtr[11];
  double phase3n311 = parPtr[12];
  double d3n311Val  = sqrt(2.0/3)*d3half(-3,1,thetaVal)+sqrt(2.0/3)*d3half(-3,-1,thetaVal);
  double f3n311re   = d3n311Val*a3n311Mag*cos(phase3n311);
  double f3n311im   = d3n311Val*a3n311Mag*sin(phase3n311);
  //j=3/2, m = 1/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a3111Mag  = parPtr[13];
  double phase3111 = parPtr[14];
  double d3111Val  = sqrt(2.0/3)*d3half(1,1,thetaVal)+sqrt(2.0/3)*d3half(1,-1,thetaVal);
  double f3111re   = d3111Val*a3111Mag*cos(phase3111);
  double f3111im   = d3111Val*a3111Mag*sin(phase3111);
  //j=3/2, m = -1/2, l = 1, s = 1/2 (lambda = 1/2 + lambda = -1/2)
  double a3n111Mag  = parPtr[15];
  double phase3n111 = parPtr[16];
  double d3n111Val  = sqrt(2.0/3)*d3half(1,1,thetaVal)+sqrt(2.0/3)*d3half(1,-1,thetaVal);
  double f3n111re   = d3n111Val*a3n111Mag*cos(phase3n111);
  double f3n111im   = d3n111Val*a3n111Mag*sin(phase3n111);


  double fre = f1101re + f1n101re + f1111re + f1n111re;
  double fim = f1101im + f1n101im + f1111im + f1n111im;
  double fre2 = f3311re + f3n311re;
  double fim2 = f3311im + f3n311im;
  double fre3 = f3111re + f3n111re;
  double fim3 = f3111im + f3n111im;

  //ORIG: fitVal = pow(a0,2) + pow(fre,2) + pow(fim,2) + pow(fre2+fre3,2) + pow(fim2+fim3,2);
  //fitVal = pow(a0,2) + pow(fre,2) + pow(fim,2) + pow(fre2+fre3,2) + pow(fim2+fim3,2);

  //fitVal = pow(f3311re,2) +  pow(f3311im,2);
  //fitVal = pow(f3n311re,2) +  pow(f3n311im,2);

  //fitVal = pow(f3311re,2) +  pow(f3311im,2) + pow(f3n311re,2) +  pow(f3n311im,2);
  //fitVal = pow(f3111re,2) +  pow(f3111im,2) + pow(f3n111re,2) +  pow(f3n111im,2);

  //fitVal = pow(fre2,2) +  pow(fim2,2) + pow(fre3,2) +  pow(fim3,2) + parPtr[17]*(2*fre2*fim3 + 2*fim2*fre3);

  //////////////////START OF FULL ORDEAL J=1/2/////////////////////////////////
  //fitVal = pow(f1101re,2) +  pow(f1101im,2) + 
  //pow(f1n101re,2) +  pow(f1n101im,2) + parPtr[17]*(2*f1101re*f1n101im + 2*f1101im*f1n101re);

  //fitVal += pow(f1111re,2) +  pow(f1111im,2) + 
  //pow(f1n111re,2) +  pow(f1n111im,2) + parPtr[18]*(2*f1111re*f1n111im + 2*f1111im*f1n111re);

  //fitVal += parPtr[19]*(2*f1101re*f1111im) + parPtr[23]*(2*f1101im*f1111re);
  //fitVal += parPtr[20]*(2*f1n101re*f1n111im) + parPtr[24]*(2*f1n101im*f1n111re);
  //fitVal += parPtr[21]*(2*f1n101re*f1111im) + parPtr[25]*(2*f1n101im*f1111re);
  //fitVal += parPtr[22]*(2*f1101re*f1n111im) + parPtr[26]*(2*f1101im*f1n111re);
  /////////////////END OF FULL ORDEAL J=1/2/////////////////////////////////

  /////////////////START OF FULL ORDEAL J=3/2///////////////////////////////
  fitVal = pow(f3311re,2) +  pow(f3311im,2) + 
  pow(f3n311re,2) +  pow(f3n311im,2) + parPtr[17]*(2*f3311re*f3n311im + 2*f3311im*f3n311re);

  fitVal += pow(f3111re,2) +  pow(f3111im,2) + 
    pow(f3n111re,2) +  pow(f3n111im,2) + parPtr[18]*(2*f3111re*f3n111im + 2*f3111im*f3n111re);

  fitVal += parPtr[19]*(2*f3311re*f3111im) + parPtr[23]*(2*f3311im*f3111re);
  fitVal += parPtr[20]*(2*f3n311re*f3n111im) + parPtr[24]*(2*f3n311im*f3n111re);
  fitVal += parPtr[21]*(2*f3n311re*f3111im) + parPtr[25]*(2*f3n311im*f3111re);
  fitVal += parPtr[22]*(2*f3311re*f3n111im) + parPtr[26]*(2*f3311im*f3n111re);
  ///////////////////END OF FULL ORDEAL J=3/2///////////////////////////////

  //fitVal = pow(f3311re,2) +  pow(f3311im,2) + pow(f3n311re,2) +  pow(f3n311im,2) + 
  //parPtr[17]*(2*f3311re*f3n311im + 2*f3n311re*f3311im);

  //fre2 = 0;fim2=0;
  //fitVal = pow(a0,2) + pow(fre,2) + pow(fim,2) + pow(fre2,2) + pow(fim2,2) + pow(fre3,2) + pow(fim3,2);
  //fitVal += parPtr[17]*fre2*fim3 + parPtr[18]*
  return fitVal;
}


Double_t fTest(Double_t *x,Double_t *parPtr) {
  Double_t fitVal,xVal;
 
  xVal = *x;
  fitVal = 0.0;

  double gMag   = parPtr[0];
  double center = parPtr[1];
  double sigma  = parPtr[2];

  double gFun = TMath::Gaus(xVal,center,sigma)*gMag;

  double bkg = parPtr[3] + parPtr[4]*xVal + parPtr[5]*pow(xVal,2);

  double sCenter1 = parPtr[6];
  double sWidth1 = parPtr[7];
  double sFun1 = 1.0/(exp((-xVal + sCenter1)*sWidth1) + 1);

  fitVal = fabs(gFun) + sFun1*bkg;

  return fitVal;

}

Double_t fTest2(Double_t *x,Double_t *parPtr) {
  Double_t fitVal,xVal;
 
  xVal = *x;
  fitVal = 0.0;

  double gMag   = parPtr[0];
  double center = parPtr[1];
  double sigma  = parPtr[2];

  double gFun = TMath::Gaus(xVal,center,sigma)*gMag;

  double bkg = parPtr[3] + parPtr[4]*xVal + parPtr[5]*pow(xVal,2);

  double sCenter1 = parPtr[6];
  double sWidth1 = parPtr[7];
  double sFun1 = 1.0/(exp((-xVal + sCenter1)*sWidth1) + 1);

  //peak 2
  double gMag2   = parPtr[8];
  double center2 = parPtr[9];
  double sigma2  = parPtr[10];

  double gFun2 = TMath::Gaus(xVal,center2,sigma2)*gMag2;

  //peak 3
  double gMag3   = parPtr[11];
  double center3 = parPtr[12];
  double sigma3  = parPtr[13];

  double gFun3 = TMath::Gaus(xVal,center3,sigma3)*gMag3;

  fitVal = fabs(gFun) + sFun1*bkg + fabs(gFun2) + fabs(gFun3);

  return fitVal;

}

Double_t fTest3(Double_t *x,Double_t *parPtr) {
  Double_t fitVal,xVal;
 
  xVal = *x;
  fitVal = 0.0;

  double gMag   = parPtr[0];
  double center = parPtr[1];
  double sigma  = parPtr[2];

  double gFun = TMath::Gaus(xVal,center,sigma)*gMag;

  double bkg = parPtr[3] + parPtr[4]*xVal + parPtr[5]*pow(xVal,2);

  double sCenter1 = parPtr[6];
  double sWidth1 = parPtr[7];
  double sFun1 = 1.0/(exp((-xVal + sCenter1)*sWidth1) + 1);

  //peak 2
  double gMag2   = parPtr[8];
  double center2 = parPtr[9];
  double sigma2  = parPtr[10];

  double gFun2 = TMath::Gaus(xVal,center2,sigma2)*gMag2;

  //peak 3
  double gMag3   = parPtr[11];
  double center3 = parPtr[12];
  double sigma3  = parPtr[13];

  double gFun3 = TMath::Gaus(xVal,center3,sigma3)*gMag3;

  //peak 4
  double gMag4   = parPtr[14];
  double center4 = parPtr[15];
  double sigma4  = parPtr[16];

  double gFun4 = TMath::Gaus(xVal,center4,sigma4)*gMag4;

  //peak 5
  double gMag5   = parPtr[17];
  double center5 = parPtr[18];
  double sigma5  = parPtr[19];

  double gFun5 = TMath::Gaus(xVal,center5,sigma5)*gMag5;

  //peak 6
  double gMag6   = parPtr[20];
  double center6 = parPtr[21];
  double sigma6  = parPtr[22];

  double gFun6 = TMath::Gaus(xVal,center6,sigma6)*gMag6;


  fitVal = fabs(gFun) + sFun1*bkg + fabs(gFun2) + fabs(gFun3);
  fitVal += fabs(gFun4) + fabs(gFun5) + fabs(gFun6);

  return fitVal;

}



void cosThetaGJ1530(int iShow,int fitType){
  gROOT->Reset();
  gROOT->SetStyle("Plain");
  gStyle->SetOptStat(0);

  int sBin = -1;
  char  hId[120];
  TFile *hFileMC = new TFile("./allBrandonMC.root");
  //TFile *hFile = new TFile("./allSp18.root");
  TFile *hFile = new TFile("./all18.root");


  TH2D *hMassXY; hFile->GetObject("hCosThetaGJzVsCasStar_MC_Kin_4K",hMassXY);
  TH2D *hMassXYMC; hFileMC->GetObject("hCosThetaGJzVsCasStar_MC_Kin_4K",hMassXYMC);

  TH1D *hAcc = (TH1D*) hMassXYMC->ProjectionY("hAcc",1,40,"");
  
  TH1D *hMassY = (TH1D*) hMassXY->ProjectionY("hY",13,15,"");

  TH1D *hMassX1 = (TH1D*) hMassXY->ProjectionX("hX1",1,2,"");
  TH1D *hMassX2 = (TH1D*) hMassXY->ProjectionX("hX2",3,4,"");
  TH1D *hMassX3 = (TH1D*) hMassXY->ProjectionX("hX3",5,6,"");
  TH1D *hMassX4 = (TH1D*) hMassXY->ProjectionX("hX4",7,8,"");
  TH1D *hMassX5 = (TH1D*) hMassXY->ProjectionX("hX5",9,10,"");
  TH1D *hMassX6 = (TH1D*) hMassXY->ProjectionX("hX6",11,12,"");
  TH1D *hMassX7 = (TH1D*) hMassXY->ProjectionX("hX7",13,14,"");
  TH1D *hMassX8 = (TH1D*) hMassXY->ProjectionX("hX8",15,16,"");
  TH1D *hMassX9 = (TH1D*) hMassXY->ProjectionX("hX9",17,18,"");
  TH1D *hMassX10 = (TH1D*) hMassXY->ProjectionX("hX10",19,20,"");

  TF1 *f2 = new TF1("f2",fTest,0,100,8);
  TF1 *f4 = new TF1("f4",fTest2,0,100,14);
  TF1 *f5 = new TF1("f5",fTest3,0,100,23);
  TF1 *f1 = new TF1("f1","gaus(0)+pol2(3)");
  TF1 *f0 = new TF1("f0","gaus");
  TF1 *f3 = new TF1("f3",fWave,-1,1,27);

  TH1D *hDiv = new TH1D("hDiv","",10,-1.0,1.0);
  TH1D *hY = new TH1D("hY","",10,-1.0,1.0);

  TH1D *hB1 = new TH1D("hB1","",140,1.4,2.8);
  TH1D *hB2 = new TH1D("hB2","",140,1.4,2.8);
  TH1D *hB3 = new TH1D("hB3","",140,1.4,2.8);
  TH1D *hB4 = new TH1D("hB4","",140,1.4,2.8);
  TH1D *hB5 = new TH1D("hB5","",140,1.4,2.8);
  TH1D *hB6 = new TH1D("hB6","",140,1.4,2.8);
  TH1D *hB7 = new TH1D("hB7","",140,1.4,2.8);
  TH1D *hB8 = new TH1D("hB8","",140,1.4,2.8);
  TH1D *hB9 = new TH1D("hB9","",140,1.4,2.8);
  TH1D *hB10 = new TH1D("hB10","",140,1.4,2.8);

  TH1D *hB1r = new TH1D("hB1r","",140,1.4,2.8);
  TH1D *hB2r = new TH1D("hB2r","",140,1.4,2.8);
  TH1D *hB3r = new TH1D("hB3r","",140,1.4,2.8);
  TH1D *hB4r = new TH1D("hB4r","",140,1.4,2.8);
  TH1D *hB5r = new TH1D("hB5r","",140,1.4,2.8);
  TH1D *hB6r = new TH1D("hB6r","",140,1.4,2.8);
  TH1D *hB7r = new TH1D("hB7r","",140,1.4,2.8);
  TH1D *hB8r = new TH1D("hB8r","",140,1.4,2.8);
  TH1D *hB9r = new TH1D("hB9r","",140,1.4,2.8);
  TH1D *hB10r = new TH1D("hB10r","",140,1.4,2.8);

  hB1->SetLineWidth(2);
  hB1->SetLineColor(2);
  hB2->SetLineWidth(2);
  hB2->SetLineColor(2);
  hB3->SetLineWidth(2);
  hB3->SetLineColor(2);
  hB4->SetLineWidth(2);
  hB4->SetLineColor(2);
  hB5->SetLineWidth(2);
  hB5->SetLineColor(2);
  hB6->SetLineWidth(2);
  hB6->SetLineColor(2);
  hB7->SetLineWidth(2);
  hB7->SetLineColor(2);
  hB8->SetLineWidth(2);
  hB8->SetLineColor(2);
  hB9->SetLineWidth(2);
  hB9->SetLineColor(2);
  hB10->SetLineWidth(2);
  hB10->SetLineColor(2);


  TH1D *hS1 = new TH1D("hS1","",140,1.4,2.8);
  TH1D *hS2 = new TH1D("hS2","",140,1.4,2.8);
  TH1D *hS3 = new TH1D("hS3","",140,1.4,2.8);
  TH1D *hS4 = new TH1D("hS4","",140,1.4,2.8);
  TH1D *hS5 = new TH1D("hS5","",140,1.4,2.8);
  TH1D *hS6 = new TH1D("hS6","",140,1.4,2.8);
  TH1D *hS7 = new TH1D("hS7","",140,1.4,2.8);
  TH1D *hS8 = new TH1D("hS8","",140,1.4,2.8);
  TH1D *hS9 = new TH1D("hS9","",140,1.4,2.8);
  TH1D *hS10 = new TH1D("hS10","",140,1.4,2.8);

  hS1->SetLineColor(3);
  hS1->SetFillStyle(3001);
  hS1->SetFillColor(3);

  hS2->SetLineColor(3);
  hS2->SetFillStyle(3001);
  hS2->SetFillColor(3);

  hS3->SetLineColor(3);
  hS3->SetFillStyle(3001);
  hS3->SetFillColor(3);

  hS4->SetLineColor(3);
  hS4->SetFillStyle(3001);
  hS4->SetFillColor(3);

  hS5->SetLineColor(3);
  hS5->SetFillStyle(3001);
  hS5->SetFillColor(3);

  hS6->SetLineColor(3);
  hS6->SetFillStyle(3001);
  hS6->SetFillColor(3);

  hS7->SetLineColor(3);
  hS7->SetFillStyle(3001);
  hS7->SetFillColor(3);

  hS8->SetLineColor(3);
  hS8->SetFillStyle(3001);
  hS8->SetFillColor(3);

  hS9->SetLineColor(3);
  hS9->SetFillStyle(3001);
  hS9->SetFillColor(3);

  hS10->SetLineColor(3);
  hS10->SetFillStyle(3001);
  hS10->SetFillColor(3);



  hMassX1->Rebin(2); hB1r->Rebin(2); hS1->Rebin(2);
  hMassX2->Rebin(2); hB2r->Rebin(2); hS2->Rebin(2);
  hMassX3->Rebin(2); hB3r->Rebin(2); hS3->Rebin(2);
  hMassX4->Rebin(2); hB4r->Rebin(2); hS4->Rebin(2);
  hMassX5->Rebin(2); hB5r->Rebin(2); hS5->Rebin(2);
  hMassX6->Rebin(2); hB6r->Rebin(2); hS6->Rebin(2);
  hMassX7->Rebin(2); hB7r->Rebin(2); hS7->Rebin(2);
  hMassX8->Rebin(2); hB8r->Rebin(2); hS8->Rebin(2);
  hMassX9->Rebin(2); hB9r->Rebin(2); hS9->Rebin(2);
  hMassX10->Rebin(2); hB10r->Rebin(2); hS10->Rebin(2);

  //hMassX1->Rebin(2);

  double bFrac = -1.0;

  double fitLow = 1.45;
  double fitHigh = 2.2;
  //double fitHigh = 1.75;
  double fitLow1 = fitLow;
  double fitHigh1 = fitHigh;
  double fitLow2 = fitLow;
  double fitHigh2 = fitHigh;
  double fitLow3 = fitLow;
  double fitHigh3 = fitHigh;
  double fitLow4 = fitLow;
  double fitHigh4 = fitHigh;
  double fitLow5 = fitLow;
  double fitHigh5 = fitHigh;
  double fitLow6 = fitLow+0.04;
  double fitHigh6 = fitHigh;
  double fitLow7 = fitLow;
  double fitHigh7 = fitHigh;
  double fitLow8 = fitLow;
  double fitHigh8 = fitHigh;
  double fitLow9 = fitLow;
  double fitHigh9 = fitHigh;
  double fitLow10 = fitLow;
  double fitHigh10 = fitHigh;
  //f2->SetParameter(0,20);
  f2->FixParameter(1,1.53);
  f4->FixParameter(1,1.53);
  //f2->SetParLimits(1,1.52,1.54);
  f2->FixParameter(2,0.01);
  f4->FixParameter(2,0.01);

  //f2->SetParLimits(2,0.008,0.01);
  f2->SetParameter(6,1.45);
  f2->SetParameter(7,200);

  ///FIT 1
  hMassX1->Fit("f2","IB","R",fitLow1,fitHigh1);
  
  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,5);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);

  hMassX1->Fit("f4","IB","R",fitLow1,fitHigh1);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.006,0.01);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.58,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.015);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX1->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB1->Eval(f5);
  hB1r->Eval(f5);


  hMassX1->GetXaxis()->SetRangeUser(fitLow1,fitHigh1);
  hS1->Add(hMassX1,hB1r,1.0,bFrac);

  int binLow = sBin;
  int binHigh = binLow;
  if (sBin < 0){ 
    binLow = 6;
    binHigh = 9;
  }
  hS1->GetXaxis()->SetRange(binLow,binHigh);
  double yErr1;
  double yVal1 = hS1->IntegralAndError(binLow,binHigh,yErr1);

  double showLow = fitLow1;
  double showHigh = 1.75;
  //double showHigh = 2.2;

  if (iShow == 1){
    hMassX1->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX1->Draw("e");
    hB1->Draw("csame");
    hS1->Draw("same");
    cout<<"y1 = "<<yVal1<<" +/- "<<yErr1<<endl;
    return;
  }   

  ///FIT 2
  hMassX2->Fit("f2","IB","R",fitLow2,fitHigh2);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->FixParameter(3,f2->GetParameter(3));
  f4->FixParameter(4,f2->GetParameter(4));
  f4->FixParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,5);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);

  hMassX2->Fit("f4","IB","R",fitLow2,fitHigh2);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParameter(13,f4->GetParameter(13));
  //1590
  f5->SetParameter(14,0);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.58,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.015);
  //1820
  f5->SetParameter(17,0);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,0);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.01,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX2->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB2->Eval(f5);
  hB2r->Eval(f5);



  hMassX2->GetXaxis()->SetRangeUser(fitLow2,fitHigh2);
  hS2->Add(hMassX2,hB2r,1.0,bFrac);
  //binLow = 6;
  //binHigh = 8;
  hS2->GetXaxis()->SetRange(binLow,binHigh);
  double yErr2;
  double yVal2 = hS2->IntegralAndError(binLow,binHigh,yErr2);

  if (iShow == 2){
    hMassX2->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX2->Draw("e");
    hB2->Draw("csame");
    hS2->Draw("same");
    cout<<"y2 = "<<yVal2<<" +/- "<<yErr2<<endl;
    return;
  } 

  ///FIT 3
  hMassX3->Fit("f2","IB","R",fitLow3,fitHigh3);
  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX3->Fit("f4","IB","R",fitLow3,fitHigh3);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.006,0.01);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.58,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.015);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX3->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB3->Eval(f5);
  hB3r->Eval(f5);

  hMassX3->GetXaxis()->SetRangeUser(fitLow3,fitHigh3);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB3->Eval(f4);

  hS3->Add(hMassX3,hB3r,1.0,bFrac);
  //binLow = 6;
  //binHigh = 8;
  hS3->GetXaxis()->SetRange(binLow,binHigh);
  double yErr3;
  double yVal3 = hS3->IntegralAndError(binLow,binHigh,yErr3);

  if (iShow == 3){
    hMassX3->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX3->Draw("e");
    hB3->Draw("csame");
    hS3->Draw("same");
    cout<<"y3 = "<<yVal3<<" +/- "<<yErr3<<endl;
    return;
  } 
  ///FIT 4
  hMassX4->Fit("f2","IB","R",fitLow4,fitHigh4);
  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.6,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX4->Fit("f4","IB","R",fitLow4,fitHigh4);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.006,0.01);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.58,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.015);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX4->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB4->Eval(f5);
  hB4r->Eval(f5);

  hMassX4->GetXaxis()->SetRangeUser(fitLow4,fitHigh4);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB4->Eval(f4);

  hS4->Add(hMassX4,hB4r,1.0,bFrac);
  //binLow = 7;
  //binHigh = 9;
  hS4->GetXaxis()->SetRange(binLow,binHigh);
  double yErr4;
  double yVal4 = hS4->IntegralAndError(binLow,binHigh,yErr4);

  if (iShow == 4){
    hMassX4->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX4->Draw("e");
    hB4->Draw("csame");
    hS4->Draw("same");
    cout<<"y4 = "<<yVal4<<" +/- "<<yErr4<<endl;
    return;
  } 

  fitHigh = 1.65;
  f2->SetParameter(1,1.53);
  f2->SetParLimits(1,1.52,1.54);
  f2->SetParameter(2,0.001);
  f2->SetParLimits(2,0.008,0.01);

  ///FIT 5
  hMassX5->Fit("f2","IB","R",fitLow5,fitHigh5);
  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX5->Fit("f4","IB","R",fitLow5,fitHigh5);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.006,0.01);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.57,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX5->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB5->Eval(f5);
  hB5r->Eval(f5);

  hMassX5->GetXaxis()->SetRangeUser(fitLow5,fitHigh5);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB5->Eval(f4);

  hS5->Add(hMassX5,hB5r,1.0,bFrac);
  //binLow = 6;
  //binHigh = 8;
  hS5->GetXaxis()->SetRange(binLow,binHigh);
  double yErr5;
  double yVal5 = hS5->IntegralAndError(binLow,binHigh,yErr5);

  if (iShow == 5){
    hMassX5->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX5->Draw("e");
    hB5->Draw("csame");
    hS5->Draw("same");
    cout<<"y5 = "<<yVal5<<" +/- "<<yErr5<<endl;
    return;
  } 


  ///FIT 6
  hMassX6->Fit("f2","IB","R",fitLow6,fitHigh6);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX6->Fit("f4","IB","R",fitLow6,fitHigh6);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.006,0.01);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.57,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX6->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB6->Eval(f5);
  hB6r->Eval(f5);

  hMassX6->GetXaxis()->SetRangeUser(fitLow6,fitHigh6);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB6->Eval(f4);
  hS6->Add(hMassX6,hB6r,1.0,bFrac);

  //binLow = 6;
  //binHigh = 8;
  hS6->GetXaxis()->SetRange(binLow,binHigh);
  double yErr6;
  double yVal6 = hS6->IntegralAndError(binLow,binHigh,yErr6);

  if (iShow == 6){
    hMassX6->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX6->Draw("e");
    hB6->Draw("csame");
    hS6->Draw("same");
    cout<<"y6 = "<<yVal6<<" +/- "<<yErr6<<endl;
    return;
  } 

  ///FIT 7
  hMassX7->Fit("f2","IB","R",fitLow7,fitHigh7);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX7->Fit("f4","IB","R",fitLow7,fitHigh7);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParLimits(1,1.53,1.54);
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.01,0.012);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.57,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX7->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB7->Eval(f5);
  hB7r->Eval(f5);

  hMassX7->GetXaxis()->SetRangeUser(fitLow7,fitHigh7);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB7->Eval(f4);
  hS7->Add(hMassX7,hB7r,1.0,bFrac);


  hS7->GetXaxis()->SetRange(binLow,binHigh);
  double yErr7;
  double yVal7 = hS7->IntegralAndError(binLow,binHigh,yErr7);

  if (iShow == 7){
    hMassX7->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX7->Draw("e");
    hB7->Draw("csame");
    hS7->Draw("same");
    cout<<"y7 = "<<yVal7<<" +/- "<<yErr7<<endl;
    return;
  } 

  f2->SetParLimits(1,1.52,1.58);
  //fitHigh = 1.65;

  ///FIT 8
  hMassX8->Fit("f2","IB","R",fitLow8,fitHigh8);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX8->Fit("f4","IB","R",fitLow8,fitHigh8);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParLimits(1,1.53,1.54);
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.01,0.012);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.57,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX8->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB8->Eval(f5);
  hB8r->Eval(f5);


  hMassX8->GetXaxis()->SetRangeUser(fitLow8,fitHigh8);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB8->Eval(f4);
  hS8->Add(hMassX8,hB8r,1.0,bFrac);

  //binLow = 6;
  //binHigh = 8;
  hS8->GetXaxis()->SetRange(binLow,binHigh);
  double yErr8;
  double yVal8 = hS8->IntegralAndError(binLow,binHigh,yErr8);

  if (iShow == 8){
    hMassX8->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX8->Draw("e");
    hB8->Draw("csame");
    hS8->Draw("same");
    cout<<"y8 = "<<yVal8<<" +/- "<<yErr8<<endl;
    return;
  } 

  ///FIT 9
  hMassX9->Fit("f2","IB","R",fitLow9,fitHigh9);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX9->Fit("f4","IB","R",fitLow9,fitHigh9);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParLimits(1,1.53,1.54);
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.01,0.012);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.57,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX9->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB9->Eval(f5);
  hB9r->Eval(f5);


  hMassX9->GetXaxis()->SetRangeUser(fitLow9,fitHigh9);
  //f4->SetParameter(0,0.0);
  //f4->SetParameter(8,0.0);
  //f4->SetParameter(11,0.0);
  //hB9->Eval(f4);
  hS9->Add(hMassX9,hB9r,1.0,bFrac);

  //binLow = 6;
  //binHigh = 8;
  hS9->GetXaxis()->SetRange(binLow,binHigh);
  double yErr9;
  double yVal9 = hS9->IntegralAndError(binLow,binHigh,yErr9);

  if (iShow == 9){
    hMassX9->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX9->Draw("e");
    hB9->Draw("csame");
    hS9->Draw("same");
    cout<<"y9 = "<<yVal9<<" +/- "<<yErr9<<endl;
    return;
  } 

  //fitLow = 1.47;
  //fitHigh = 1.75;
  //f2->FixParameter(0,3);
  //f2->FixParameter(1,1.53);
  //f2->FixParameter(2,0.02);

  ///FIT 10
  hMassX10->Fit("f2","IB","R",fitLow10,fitHigh10);

  f4->SetParameter(0,f2->GetParameter(0));
  f4->SetParameter(1,f2->GetParameter(1));
  f4->SetParameter(2,f2->GetParameter(2));
  f4->SetParameter(3,f2->GetParameter(3));
  f4->SetParameter(4,f2->GetParameter(4));
  f4->SetParameter(5,f2->GetParameter(5));
  f4->SetParameter(6,f2->GetParameter(6));
  f4->SetParameter(7,f2->GetParameter(7));
  f4->SetParameter(8,5);
  f4->SetParameter(9,1.62);
  f4->SetParLimits(9,1.61,1.64);
  f4->SetParameter(10,0.016);
  f4->SetParLimits(10,0.01,0.02);
  f4->SetParameter(11,0);
  f4->SetParameter(12,1.69);
  f4->SetParLimits(12,1.67,1.7);
  f4->SetParameter(13,0.017);
  f4->SetParLimits(13,0.01,0.02);
  hMassX9->Fit("f4","IB","R",fitLow9,fitHigh9);

  f5->SetParameter(0,f4->GetParameter(0));
  f5->SetParameter(1,f4->GetParameter(1));
  f5->SetParLimits(1,1.53,1.54);
  f5->SetParameter(2,f4->GetParameter(2));
  f5->SetParLimits(2,0.01,0.012);
  f5->SetParameter(3,f4->GetParameter(3));
  f5->SetParameter(4,f4->GetParameter(4));
  f5->SetParameter(5,f4->GetParameter(5));
  f5->SetParameter(6,f4->GetParameter(6));
  f5->SetParameter(7,f4->GetParameter(7));
  f5->SetParameter(8,f4->GetParameter(8));
  f5->SetParameter(9,f4->GetParameter(9));
  f5->SetParLimits(9,1.61,1.64);
  f5->SetParameter(10,f4->GetParameter(10));
  f5->SetParLimits(10,0.01,0.02);
  f5->SetParameter(11,f4->GetParameter(11));
  f5->SetParameter(12,f4->GetParameter(12));
  f5->SetParLimits(12,1.67,1.7);
  f5->SetParameter(13,f4->GetParameter(13));
  f5->SetParLimits(13,0.01,0.02);
  //1590
  f5->SetParameter(14,2);
  f5->SetParameter(15,1.59);
  f5->SetParLimits(15,1.59,1.6);
  f5->SetParameter(16,0.01);
  f5->SetParLimits(16,0.01,0.016);
  //1820
  f5->SetParameter(17,2);
  f5->SetParameter(18,1.82);
  f5->SetParLimits(18,1.80,1.85);
  f5->SetParameter(19,0.01);
  f5->SetParLimits(19,0.01,0.02);
  //2050
  f5->SetParameter(20,2);
  f5->SetParameter(21,2.05);
  f5->SetParLimits(21,2.04,2.06);
  f5->SetParameter(22,0.01);
  f5->SetParLimits(22,0.01,0.03);
  hMassX10->Fit("f5","IB","R",fitLow1,fitHigh1);
  f5->SetParameter(0,0.0);
  hB10->Eval(f5);
  hB10r->Eval(f5);

  hMassX10->GetXaxis()->SetRangeUser(fitLow10,fitHigh10);
  //f2->SetParameter(0,0.0);
  //hB10->Eval(f2);
  hS10->Add(hMassX10,hB10r,1.0,bFrac);
  //binLow = 7;
  //binHigh = 9;
  hS10->GetXaxis()->SetRange(binLow,binHigh);
  double yErr10;
  double yVal10 = hS10->IntegralAndError(binLow,binHigh,yErr10);

  if (iShow == 10){
    hMassX10->GetXaxis()->SetRangeUser(showLow,showHigh);
    hMassX10->Draw("e");
    hB10->Draw("csame");
    hS10->Draw("same");
    cout<<"y10 = "<<yVal10<<" +/- "<<yErr10<<endl;
    return;
  } 
  hY->SetBinContent(1,yVal1);
  hY->SetBinError(1,yErr1);

  hY->SetBinContent(2,yVal2);
  hY->SetBinError(2,yErr2);

  hY->SetBinContent(3,yVal3);
  hY->SetBinError(3,yErr3);

  hY->SetBinContent(4,yVal4);
  hY->SetBinError(4,yErr4);

  hY->SetBinContent(5,yVal5);
  hY->SetBinError(5,yErr5);

  hY->SetBinContent(6,yVal6);
  hY->SetBinError(6,yErr6);

  hY->SetBinContent(7,yVal7);
  hY->SetBinError(7,yErr7);

  hY->SetBinContent(8,yVal8);
  hY->SetBinError(8,yErr8);

  hY->SetBinContent(9,yVal9);
  hY->SetBinError(9,yErr9);

  hY->SetBinContent(10,yVal10);
  hY->SetBinError(10,yErr10);

  int rebinFac = 2;
  hAcc->Rebin(rebinFac);
  //hMassY->Rebin(rebinFac);
  //hDiv->Rebin(rebinFac);

  hDiv->Sumw2();

  //hDiv->Divide(hMassY,hAcc);
  hDiv->Divide(hY,hAcc);

  hDiv->SetMinimum(0);
  
  //hDiv->Fit("pol2");
  //f3->FixParameter(1,0);
  //f3->FixParameter(0,0);
  f3->SetParameter(0,0.2);
  // j=1/2, m=+1/2, l=0, s=1/2
  f3->SetParameter(1,1);
  f3->SetParameter(2,0);
  f3->SetParLimits(2,-3.14,3.14);
  // j=1/2, m=-1/2, l=0, s=1/2
  f3->SetParameter(3,1);
  f3->SetParameter(4,0);
  f3->SetParLimits(4,-3.14,3.14);
  // j=1/2, m=+1/2, l=1, s=1/2
  f3->SetParameter(5,1);
  f3->SetParameter(6,0);
  f3->SetParLimits(6,-3.14,3.14);
  // j=1/2, m=-1/2, l=1, s=1/2
  f3->SetParameter(7,1);
  f3->SetParameter(8,0);
  f3->SetParLimits(8,-3.14,3.14);
  // j=3/2, m=+3/2, l=1, s=1/2
  f3->SetParameter(9,1);
  f3->SetParameter(10,0);
  f3->SetParLimits(10,-3.14,3.14);
  // j=3/2, m=-3/2, l=1, s=1/2
  f3->SetParameter(11,1);
  f3->SetParameter(12,0);
  f3->SetParLimits(12,-3.14,3.14);
  // j=3/2, m=+1/2, l=1, s=1/2
  f3->SetParameter(13,1);
  f3->SetParameter(14,0);
  f3->SetParLimits(14,-3.14,3.14);
  // j=3/2, m=-1/2, l=1, s=1/2
  f3->SetParameter(15,1);
  f3->SetParameter(16,0);
  f3->SetParLimits(16,-3.14,3.14);

  //f3->FixParameter(2,0);//Set one phase to zero
  f3->FixParameter(0,0);

  f3->SetParameter(9,4.43922e-01);
  f3->SetParameter(10,1.44860e+00);
  f3->SetParameter(11,7.58508e+00);
  f3->SetParameter(12,5.59227e-02);
  f3->SetParameter(13,-1.19572e-02);
  f3->SetParameter(14,-3.12437e+00);
  f3->SetParameter(15,2.03115e+00);
  f3->SetParameter(16,7.16435e-02);

  bool fitJhalf = true;

  if (fitType == 0) fitJhalf = false; 

  if (fitJhalf == true){
    //Kill j=3/2
    f3->FixParameter(9,0);
    f3->FixParameter(11,0);
    f3->FixParameter(13,0);
    f3->FixParameter(15,0);
  } else {
    f3->FixParameter(1,0);
    f3->FixParameter(3,0);
    f3->FixParameter(5,0);
    f3->FixParameter(7,0);
  }




  //hDiv->SetBinError(7,0);
  //hDiv->SetBinContent(7,-10);
  hDiv->Fit("f3","IB");



  double aVal = f3->GetParameter(0);
  double aErr = f3->GetParError(0);
  double bVal = f3->GetParameter(2);
  double baFrac = 2*bVal/(3*aVal);
  //cout<<"baFrac = "<<baFrac<<endl;


  double fVal0 = f3->GetParameter(0);
  double fVal1 = f3->GetParameter(1);
  double fVal2 = f3->GetParameter(2);
  double fVal3 = f3->GetParameter(3);
  double fVal4 = f3->GetParameter(4);
  double fVal5 = f3->GetParameter(5);
  double fVal6 = f3->GetParameter(6);
  double fVal7 = f3->GetParameter(7);
  double fVal8 = f3->GetParameter(8);
  double fVal9 = f3->GetParameter(9);
  double fVal10 = f3->GetParameter(10);
  double fVal11 = f3->GetParameter(11);
  double fVal12 = f3->GetParameter(12);
  double fVal13 = f3->GetParameter(13);
  double fVal14 = f3->GetParameter(14);
  double fVal15 = f3->GetParameter(15);
  double fVal16 = f3->GetParameter(16);



  cout<<"constant squared = "<<pow(f3->GetParameter(0),2)<<endl;
  cout<<" J    M   L   S   AmpSquared"<<endl;
  cout<<"1/2 +1/2  0  1/2 "<<pow(f3->GetParameter(1),2)<<endl;
  cout<<"1/2 -1/2  0  1/2 "<<pow(f3->GetParameter(3),2)<<endl;
  cout<<"1/2 +1/2  1  1/2 "<<pow(f3->GetParameter(5),2)<<endl;
  cout<<"1/2 -1/2  1  1/2 "<<pow(f3->GetParameter(7),2)<<endl;
  cout<<"3/2 +3/2  1  1/2 "<<pow(f3->GetParameter(9),2)<<endl;
  cout<<"3/2 -3/2  1  1/2 "<<pow(f3->GetParameter(11),2)<<endl;
  cout<<"3/2 +1/2  1  1/2 "<<pow(f3->GetParameter(13),2)<<endl;
  cout<<"3/2 -1/2  1  1/2 "<<pow(f3->GetParameter(15),2)<<endl;

  TH1D *h0 = new TH1D("h0","",100,-1.0,1.0);

  TH1D *hFuckYou = new TH1D("hFuckYou","",100,-1.0,1.0);




  //hDiv->Fit("pol4","IB");
  hDiv->SetMarkerStyle(21);

  hDiv->GetYaxis()->SetTitle("N[#Xi(1530)]/#epsilon");
  hDiv->GetYaxis()->SetTitleOffset(1.2);
  hDiv->GetXaxis()->SetTitle("cos(#theta_{GJ})");

  
  hDiv->Draw("e1");

  TH1D *hJhalf = new TH1D("hJhalf","",100,-1.0,1.0);
  TH1D *hJthreehalf = new TH1D("hJthreehalf","",100,-1.0,1.0);
  f3->SetParameter(0,0);
  f3->SetParameter(9,0);
  f3->SetParameter(11,0);
  f3->SetParameter(13,0);
  f3->SetParameter(15,0);
  hJhalf->Eval(f3);
  //hJhalf->Draw("same");

  f3->SetParameter(1,0);
  f3->SetParameter(3,0);
  f3->SetParameter(5,0);
  f3->SetParameter(7,0);
  f3->SetParameter(9,fVal9);
  f3->SetParameter(11,fVal11);
  f3->SetParameter(13,fVal13);
  f3->SetParameter(15,fVal15);
  hJthreehalf->Eval(f3);
  hJthreehalf->SetLineColor(3);
  //hJthreehalf->Draw("same");

  f3->SetParameter(0,fVal0);
  f3->SetParameter(9,0);
  f3->SetParameter(11,0);
  f3->SetParameter(13,0);
  f3->SetParameter(15,0);
  h0->Eval(f3);
  h0->SetLineColor(4);
  //h0->Draw("same");


  double intErr;
  double intVal = hDiv->IntegralAndError(1,10,intErr);

  if (bVal < 0){
    aVal = aVal - fabs(bVal);
  }
  
  double aFrac = aVal*10/intVal;
  double aFracErr = aErr*10/intVal;
  double binC = hMassX5->GetBinCenter(sBin);
  
  //cout<<"aFrac = "<<aFrac<<" +/- "<<aFracErr<<endl;
  cout<<"binCenter = "<<binC<<endl;
}
