void asym_summary(Int_t slugn) {

  //  if (slugn < 5) cout<<"Warning: no pion group information for slugs < 5"<<endl;

  const Int_t slugnumber = slugn;

  Double_t *slug, *slugerr;
  slug = new Double_t [slugnumber];
  slugerr= new Double_t [slugnumber];
  for (Int_t i = 1; i<= slugnumber; i++) {
    slug[i-1] = i;
    slugerr[i-1] = 0;
  }
  //global electron asymmetries
  Double_t *lenar, *lewid, *renar, *rewid;
  lenar = new Double_t [slugnumber];
  lewid = new Double_t [slugnumber];
  renar = new Double_t [slugnumber];
  rewid = new Double_t [slugnumber];
  Double_t *lenarerr, *lewiderr, *renarerr, *rewiderr;
  lenarerr = new Double_t [slugnumber];
  lewiderr = new Double_t [slugnumber];
  renarerr = new Double_t [slugnumber];
  rewiderr = new Double_t [slugnumber];

  Double_t lpnar[slugnumber], lpwid[slugnumber], rpnar[slugnumber], rpwid[slugnumber];
  Double_t lpnarerr[slugnumber], lpwiderr[slugnumber], rpnarerr[slugnumber], rpwiderr[slugnumber];
  for (Int_t i = 0; i<slugnumber; i++){
    lpnar[i] = 0; lenar[i] = 0;
    lpwid[i] = 0; lewid[i] = 0;
    rpnar[i] = 0; renar[i] = 0;
    rpwid[i] = 0; rewid[i] = 0;
    lpnarerr[i] = 0; lenarerr[i] = 0;
    lpwiderr[i] = 0; lewiderr[i] = 0;
    rpnarerr[i] = 0; renarerr[i] = 0;
    rpwiderr[i] = 0; rewiderr[i] = 0;
  }

  //electron group asymmetries
  Double_t len[7][slugnumber], lew[7][slugnumber], ren[9][slugnumber], rew[9][slugnumber];

  Double_t lenerr[7][slugnumber], lewerr[7][slugnumber], renerr[9][slugnumber], rewerr[9][slugnumber];

  Double_t lpn[7][slugnumber], lpw[7][slugnumber], rpn[9][slugnumber], rpw[9][slugnumber];
  Double_t lpnerr[7][slugnumber], lpwerr[7][slugnumber], rpnerr[9][slugnumber], rpwerr[9][slugnumber];

  //bpm difference 
  Double_t bpm12x[slugnumber], bpm12xer[slugnumber];
  Double_t bpm4ax[slugnumber], bpm4axer[slugnumber], bpm4ay[slugnumber], bpm4ayer[slugnumber];
  Double_t bpm4bx[slugnumber], bpm4bxer[slugnumber], bpm4by[slugnumber], bpm4byer[slugnumber];

  Int_t flipsign;

//   Double_t sigbpm12x=0,  sigbpm4ax=0, sigbpm4ay=0, sigbpm4bx=0, sigbpm4by=0;
//   Double_t diffbpm12x=0, diffbpm4ax=0, diffbpm4ay=0, diffbpm4bx=, diffbpm4by=0;



  //loop over slug number
  for (Int_t i=1; i<= slugnumber; i++) {
    if (i < 10)
    TString rfn = "ROOTfiles/parity09_000";
    else 
      TString rfn = "ROOTfiles/parity09_00";
    rfn += i;
    rfn += "_slug.root";
    TFile *_file0 = TFile::Open(rfn);
    cout<<"open rootfile successful!"<<rfn<<endl;

    Double_t rmstemp, enttemp;

    //////////////////global electron
    //left global eletron nar, 
    TString slenar = "asym_dislenar>>h1";
    S->Draw(slenar, "ok_regL", "goff");
    lenar[i-1] = h1->GetMean();
    cout<<"lenar="<<lenar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      lenarerr[i-1] = rmstemp / sqrt(enttemp);
    else lenarerr[i-1] = 0;

    //left global electron wid;
   TString slewid = "asym_dislewid>>h1";
    S->Draw(slewid, "ok_regL", "goff");
    lewid[i-1] = h1->GetMean();
    //    cout<<"lenar="<<lenar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      lewiderr[i-1] = rmstemp / sqrt(enttemp);
    else lewiderr[i-1] = 0;

    //right global eletron nar, 
    TString srenar = "asym_disrenar>>h1";
    S->Draw(srenar, "ok_regR", "goff");
    renar[i-1] = h1->GetMean();
    cout<<"renar="<<renar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      renarerr[i-1] = rmstemp / sqrt(enttemp);
    else renarerr[i-1] = 0;

    //right global electron wid;
    TString srewid = "asym_disrewid>>h1";
    S->Draw(srewid, "ok_regR", "goff");
    rewid[i-1] = h1->GetMean();
    //    cout<<"lenar="<<lenar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      rewiderr[i-1] = rmstemp / sqrt(enttemp);
    else rewiderr[i-1] = 0;


    /////////////////////////global pion 
    //left global pion nar, 
    TString slpnar = "asym_dislpnar>>h1";
    S->Draw(slpnar, "ok_regL", "goff");
    lpnar[i-1] = h1->GetMean();
    cout<<"lpnar="<<lpnar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      lpnarerr[i-1] = rmstemp / sqrt(enttemp);
    else lpnarerr[i-1] = 0;

    //left global pion wid;
   TString slpwid = "asym_dislpwid>>h1";
    S->Draw(slpwid, "ok_regL", "goff");
    lpwid[i-1] = h1->GetMean();
    //    cout<<"lenar="<<lenar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      lpwiderr[i-1] = rmstemp / sqrt(enttemp);
    else lpwiderr[i-1] = 0;

    //right global pion nar, 
    TString srpnar = "asym_disrpnar>>h1";
    S->Draw(srpnar, "ok_regR", "goff");
    rpnar[i-1] = h1->GetMean();
    cout<<"rpnar="<<rpnar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      rpnarerr[i-1] = rmstemp / sqrt(enttemp);
    else rpnarerr[i-1] = 0;

    //right global pion wid;
    TString srpwid = "asym_disrpwid>>h1";
    S->Draw(srpwid, "ok_regR", "goff");
    rpwid[i-1] = h1->GetMean();
    //    cout<<"lenar="<<lenar[i-1]<<endl;
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp > 0)
      rpwiderr[i-1] = rmstemp / sqrt(enttemp);
    else rpwiderr[i-1] = 0;



    ///////////////////////////

    //////////////////////////left electron & pion groups
    for (Int_t k = 1; k<= 6; k++) {
      //electron narrow
      TString sleng = "asym_dislen";
      sleng += k;
      sleng += ">>h1";
      //      cout<<sleng<<endl;
      S->Draw(sleng, "ok_regL", "goff");
      len[k][i-1] = h1->GetMean();
      cout<<"lenki="<<len[k][i-1]<<endl;
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	lenerr[k][i-1] = rmstemp / sqrt(enttemp);
      else lenerr[k][i-1] = 0;
      //electron wide
      TString slewg = "asym_dislew";
      slewg += k;
      slewg += ">>h1";
      S->Draw(slewg, "ok_regL", "goff");
      lew[k][i-1] = h1->GetMean();
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	lewerr[k][i-1] = rmstemp / sqrt(enttemp);
      else lewerr[k][i-1] = 0;

//       if (i <= 4) {
// 	lpn[k][i-1] = 0;
// 	lpnerr[k][i-1] = 0;
// 	lpw[k][i-1] = 0;
// 	lpwerr[k][i-1] = 0;
//       }
      //     else {

      //pion narrow
      TString slpng = "asym_dislpn";
      slpng += k;
      slpng += ">>h1";
      //      cout<<slpng<<endl;
      S->Draw(slpng, "ok_regL", "goff");
      lpn[k][i-1] = h1->GetMean();
      cout<<"lpnki="<<lpn[k][i-1]<<endl;
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	lpnerr[k][i-1] = rmstemp / sqrt(enttemp);
      else lpnerr[k][i-1] = 0;
      //pion wide
      TString slpwg = "asym_dislpw";
      slpwg += k;
      slpwg += ">>h1";
      S->Draw(slpwg, "ok_regL", "goff");
      lpw[k][i-1] = h1->GetMean();
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	lpwerr[k][i-1] = rmstemp / sqrt(enttemp);
      else lpwerr[k][i-1] = 0;
      //      }

    }

    /////////////////////////right electron & pion groups
    for (Int_t k = 1; k<= 8; k++) {
      //electron narrow
      TString sreng = "asym_disren";
      sreng += k;
      sreng += ">>h1";
      S->Draw(sreng, "ok_regR", "goff");
      ren[k][i-1] = h1->GetMean();
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	renerr[k][i-1] = rmstemp / sqrt(enttemp);
      else renerr[k][i-1] = 0;

      //electron wide
      TString srewg = "asym_disrew";
      srewg += k;
      srewg += ">>h1";
      S->Draw(srewg, "ok_regR", "goff");
      rew[k][i-1] = h1->GetMean();
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	rewerr[k][i-1] = rmstemp / sqrt(enttemp);
      else rewerr[k][i-1] = 0;


      //////pion groups
//       if (i <= 4) {
// 	rpn[k][i-1] = 0;
// 	rpnerr[k][i-1] = 0;
// 	rpw[k][i-1] = 0;
// 	rpwerr[k][i-1] = 0;
//       }
//      else {
      //pion narrow
      TString srpng = "asym_disrpn";
      srpng += k;
      srpng += ">>h1";
      //      cout<<srpng<<endl;
      S->Draw(srpng, "ok_regR", "goff");
      rpn[k][i-1] = h1->GetMean();
      cout<<"rpnki="<<rpn[k][i-1]<<endl;
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	rpnerr[k][i-1] = rmstemp / sqrt(enttemp);
      else rpnerr[k][i-1] = 0;
      //pion wide
      TString srpwg = "asym_disrpw";
      srpwg += k;
      srpwg += ">>h1";
      S->Draw(srpwg, "ok_regR", "goff");
      rpw[k][i-1] = h1->GetMean();
      rmstemp = h1->GetRMS();
      enttemp = h1->GetEntries();
      if (enttemp > 0)
	rpwerr[k][i-1] = rmstemp / sqrt(enttemp);
      else rpwerr[k][i-1] = 0;
      //      }


    }
    //////////////////////////bpm diffs 

    if ((i%2) == 1) flipsign =1;
    else flipsign = -1;
    cout<<"flipsign="<<flipsign<<endl;

    S->Draw("diff_bpm12x>>h1","","goff");
    bpm12x[i-1] = h1->GetMean() * flipsign;
    bpm12xer[i-1] = h1->GetRMS() / sqrt(h1->GetEntries());

    S->Draw("diff_bpm4ax>>h1","","goff");
    bpm4ax[i-1] = h1->GetMean() * flipsign;
    bpm4axer[i-1] = h1->GetRMS() / sqrt(h1->GetEntries());

    S->Draw("diff_bpm4ay>>h1","","goff");
    bpm4ay[i-1] = h1->GetMean() * flipsign;
    bpm4ayer[i-1] = h1->GetRMS() / sqrt(h1->GetEntries()); 

    S->Draw("diff_bpm4bx>>h1","","goff");
    bpm4bx[i-1] = h1->GetMean() * flipsign;
    bpm4bxer[i-1] = h1->GetRMS() / sqrt(h1->GetEntries());

    S->Draw("diff_bpm4by>>h1","","goff");
    bpm4by[i-1] = h1->GetMean() * flipsign;
    bpm4byer[i-1] = h1->GetRMS() / sqrt(h1->GetEntries());


  } //end of loop over slugnumber



  ////////////////////////////plots////////////////////////////////
  //  new TCanvas;
  /////////////////////////global electron plots
  TCanvas *c1 = new TCanvas("c1", "global electron asyms", 1000, 800);
  c1->Divide(2,2);

  c1->cd(1);

  TGraphErrors * t1 = new TGraphErrors(slugnumber, slug, lenar, slugerr, lenarerr);
  t1->SetTitle("left arm electron narrow");
  t1->GetXaxis()->SetTitle("Slug number");
  t1->GetYaxis()->SetTitle("Asymmetries");
  t1->Draw("AP*");

  c1->cd(2);
  TGraphErrors * t2 = new TGraphErrors(slugnumber, slug, lewid, slugerr, lewiderr);
  t2->SetTitle("left arm electron wide");
  t2->GetXaxis()->SetTitle("Slug number");
  t2->GetYaxis()->SetTitle("Asymmetries");
  t2->Draw("AP*");

  c1->cd(3);
  TGraphErrors *t3 = new TGraphErrors(slugnumber, slug, renar, slugerr, renarerr);
  t3->SetTitle("right arm electron narrow");
  t3->GetXaxis()->SetTitle("Slug number");
  t3->GetYaxis()->SetTitle("Asymmetries");
  t3->Draw("AP*");

  c1->cd(4);
  TGraphErrors *t4 = new TGraphErrors(slugnumber, slug, rewid, slugerr, rewiderr);
  t4->SetTitle("right arm electron wide");
  t4->GetXaxis()->SetTitle("Slug number");
  t4->GetYaxis()->SetTitle("Asymmetries");
  t4->Draw("AP*");

  // TString plotname = "globalelc.gif";
  c1->Print("globele.gif");


  //////////////////////////global pion plots

  TCanvas *p1 = new TCanvas("p1", "global pion asyms", 1000, 800);
  p1->Divide(2,2);
  p1->cd(1);

  TGraphErrors * pi1 = new TGraphErrors(slugnumber, slug, lpnar, slugerr, lpnarerr);
  pi1->SetTitle("left arm pion narrow");
  pi1->GetXaxis()->SetTitle("Slug number");
  pi1->GetYaxis()->SetTitle("Asymmetries");
  pi1->Draw("AP*");

  p1->cd(2);
  TGraphErrors * pi2 = new TGraphErrors(slugnumber, slug, lpwid, slugerr, lpwiderr);
  pi2->SetTitle("left arm pion wide");
  pi2->GetXaxis()->SetTitle("Slug number");
  pi2->GetYaxis()->SetTitle("Asymmetries");
  pi2->Draw("AP*");

  p1->cd(3);
  TGraphErrors *pi3 = new TGraphErrors(slugnumber, slug, rpnar, slugerr, rpnarerr);
  pi3->SetTitle("right arm pion narrow");
  pi3->GetXaxis()->SetTitle("Slug number");
  pi3->GetYaxis()->SetTitle("Asymmetries");
  pi3->Draw("AP*");

  p1->cd(4);
  TGraphErrors *pi4 = new TGraphErrors(slugnumber, slug, rpwid, slugerr, rpwiderr);
  pi4->SetTitle("right arm pion wide");
  pi4->GetXaxis()->SetTitle("Slug number");
  pi4->GetYaxis()->SetTitle("Asymmetries");
  pi4->Draw("AP*");

  p1->Print("globpion.gif");


  ///////////////left arm electron narrow plots
  TCanvas *c2 = new TCanvas("c2", "left electron narrow groups", 1000, 800);
  c2->Divide(2,3);

  TGraphErrors *glen[6];
  for (Int_t i = 0; i<6; i++) {
  c2->cd(i+1);
  glen[i] = new TGraphErrors(slugnumber, slug, len[i+1], slugerr, lenerr[i+1]);
  TString sglen = "left arm el nar group";
  sglen += (i+1);
  glen[i]->SetTitle(sglen);
  glen[i]->GetXaxis()->SetTitle("Slug number");
  glen[i]->GetYaxis()->SetTitle("Asymmetries");
  glen[i]->Draw("AP*");
  }

  c2->Print("lelecnar.gif");

  ///////////////left arm pion narrow plots
  TCanvas *c12 = new TCanvas("c12", "left pion narrow groups", 1000, 800);
  c12->Divide(2,3);

  TGraphErrors *glpn[6];
  for (Int_t i = 0; i<6; i++) {
  c12->cd(i+1);
  glpn[i] = new TGraphErrors(slugnumber, slug, lpn[i+1], slugerr, lpnerr[i+1]);
  TString sglpn = "left arm pi nar group";
  sglpn += (i+1);
  glpn[i]->SetTitle(sglpn);
  glpn[i]->GetXaxis()->SetTitle("Slug number");
  glpn[i]->GetYaxis()->SetTitle("Asymmetries");
  glpn[i]->Draw("AP*");
  }

  c12->Print("lpionnar.gif");


  ///////////////left arm electron wide plots
  TCanvas *c3 = new TCanvas("c3", "left electron wide groups", 1000, 800);
  c3->Divide(2,3);

  TGraphErrors *glew[6];
  for (Int_t i = 0; i<6; i++) {
  c3->cd(i+1);
  glew[i] = new TGraphErrors(slugnumber, slug, lew[i+1], slugerr, lewerr[i+1]);
  TString sglew = "left arm el wid group";
  sglew += (i+1);
  glew[i]->SetTitle(sglew);
  glew[i]->GetXaxis()->SetTitle("Slug number");
  glew[i]->GetYaxis()->SetTitle("Asymmetries");
  glew[i]->Draw("AP*");
  }

  c3->Print("lelecwid.gif");


  ///////////////left arm pion wide plots
  TCanvas *c13 = new TCanvas("c13", "left pion wide groups", 1000, 800);
  c13->Divide(2,3);

  TGraphErrors *glpw[6];
  for (Int_t i = 0; i<6; i++) {
  c13->cd(i+1);
  glpw[i] = new TGraphErrors(slugnumber, slug, lpw[i+1], slugerr, lpwerr[i+1]);
  TString sglpw = "left arm pi wid group";
  sglpw += (i+1);
  glpw[i]->SetTitle(sglpw);
  glpw[i]->GetXaxis()->SetTitle("Slug number");
  glpw[i]->GetYaxis()->SetTitle("Asymmetries");
  glpw[i]->Draw("AP*");
  }
  c13->Print("lpionwid.gif");


  //////////////right arm electron narrow plots
  TCanvas *c4 = new TCanvas("c4", "right electron narrow groups", 1000, 800);
  c4->Divide(2,4);

  TGraphErrors *gren[8];
  for (Int_t i = 0; i<8; i++) {
  c4->cd(i+1);
  gren[i] = new TGraphErrors(slugnumber, slug, ren[i+1], slugerr, renerr[i+1]);
  TString sgren = "right arm el narrow group";
  sgren += (i+1);
  gren[i]->SetTitle(sgren);
  gren[i]->GetXaxis()->SetTitle("Slug number");
  gren[i]->GetYaxis()->SetTitle("Asymmetries");
  gren[i]->Draw("AP*");
  }

  c4->Print("relecnar.gif");


  //////////////right arm pion narrow plots
  TCanvas *c14 = new TCanvas("c14", "right pion narrow groups", 1000, 800);
  c14->Divide(2,4);

  TGraphErrors *grpn[8];
  for (Int_t i = 0; i<8; i++) {
  c14->cd(i+1);
  grpn[i] = new TGraphErrors(slugnumber, slug, rpn[i+1], slugerr, rpnerr[i+1]);
  TString sgrpn = "right arm pi narrow group";
  sgrpn += (i+1);
  grpn[i]->SetTitle(sgrpn);
  grpn[i]->GetXaxis()->SetTitle("Slug number");
  grpn[i]->GetYaxis()->SetTitle("Asymmetries");
  grpn[i]->Draw("AP*");
  }

  c14->Print("rpionnar.gif");

  ////////////////right arm electron wide plots
  TCanvas *c5 = new TCanvas("c5", "right electron wide groups", 1000, 800);
  c5->Divide(2,4);

  TGraphErrors *grew[8];
  for (Int_t i = 0; i<8; i++) {
  c5->cd(i+1);
  grew[i] = new TGraphErrors(slugnumber, slug, rew[i+1], slugerr, rewerr[i+1]);
  TString sgrew = "right arm el wide group";
  sgrew += (i+1);
  grew[i]->SetTitle(sgrew);
  grew[i]->GetXaxis()->SetTitle("Slug number");
  grew[i]->GetYaxis()->SetTitle("Asymmetries");
  grew[i]->Draw("AP*");
  }

  c5->Print("relecwid.gif");


  ////////////////right arm pion wide plots
  TCanvas *c15 = new TCanvas("c15", "right pion wide groups", 1000, 800);
  c15->Divide(2,4);

  TGraphErrors *grpw[8];
  for (Int_t i = 0; i<8; i++) {
  c15->cd(i+1);
  grpw[i] = new TGraphErrors(slugnumber, slug, rpw[i+1], slugerr, rpwerr[i+1]);
  TString sgrpw = "right arm pi wide group";
  sgrpw += (i+1);
  grpw[i]->SetTitle(sgrpw);
  grpw[i]->GetXaxis()->SetTitle("Slug number");
  grpw[i]->GetYaxis()->SetTitle("Asymmetries");
  grpw[i]->Draw("AP*");
  }

  c15->Print("rpionwid.gif");

  gStyle->SetOptFit(1);

  ////////////////bpm diffs
  TCanvas *c6 = new TCanvas("c6", "bpm diffs", 1000, 800);
  c6->Divide(2,3);

  c6->cd(1);
  TGraphErrors *gbpm12x = new TGraphErrors(slugnumber, slug, bpm12x, slugerr, bpm12xer);
  gbpm12x->SetTitle("bpm12x diff");
  gbpm12x->GetXaxis()->SetTitle("Slug number");
  gbpm12x->GetYaxis()->SetTitle("diff_bpm12x");
  gbpm12x->Draw("AP");
  gbpm12x->Fit("pol0");

  c6->cd(2);
  TGraphErrors *gbpm4ax = new TGraphErrors(slugnumber, slug, bpm4ax, slugerr, bpm4axer);
  gbpm4ax->SetTitle("bpm4ax diff");
  gbpm4ax->GetXaxis()->SetTitle("Slug number");
  gbpm4ax->GetYaxis()->SetTitle("diff_bpm4ax");
  gbpm4ax->Draw("AP");
  gbpm4ax->Fit("pol0");

  c6->cd(3);
  TGraphErrors * gbpm4ay = new TGraphErrors(slugnumber, slug, bpm4ay, slugerr, bpm4ayer);
  gbpm4ay->SetTitle("bpm4ay diff");
  gbpm4ay->GetXaxis()->SetTitle("Slug number");
  gbpm4ay->GetYaxis()->SetTitle("diff_bpm4ay");
  gbpm4ay->Draw("AP");
  gbpm4ay->Fit("pol0");

  c6->cd(4);
  TGraphErrors * gbpm4bx = new TGraphErrors(slugnumber, slug, bpm4bx, slugerr, bpm4bxer);
  gbpm4bx->SetTitle("bpm4bx diff");
  gbpm4bx->GetXaxis()->SetTitle("Slug number");
  gbpm4bx->GetYaxis()->SetTitle("diff_bpm4bx");
  gbpm4bx->Draw("AP");
  gbpm4bx->Fit("pol0");

  c6->cd(5);
  TGraphErrors * gbpm4by = new TGraphErrors(slugnumber, slug, bpm4by, slugerr, bpm4byer);
  gbpm4by->SetTitle("bpm4by diff");
  gbpm4by->GetXaxis()->SetTitle("Slug number");
  gbpm4by->GetYaxis()->SetTitle("diff_bpm4by");
  gbpm4by->Draw("AP");
  gbpm4by->Fit("pol0");

  c6->Print("bpmdiff.gif");

}