#include <iostream>
#include <fstream>
#include <string>

void asym_asymcorr(void) {

  // Open data file for input
  ifstream f_input("asym_asymcorr_cuts.dat");

  // First line of input file just contains header info
  Char_t junk[100];
  f_input.getline(junk, 99);
  //  printf("%s\n", junk);

  const UInt_t kMaxDet = 15;
  Float_t fr_in_det[kMaxDet], na_in_det[kMaxDet];
  Float_t fr_in_detcorr[kMaxDet], na_in_detcorr[kMaxDet];
  Float_t fr_out_det[kMaxDet], na_out_det[kMaxDet];
  Float_t fr_out_detcorr[kMaxDet], na_out_detcorr[kMaxDet];
  Float_t fr_in_asym[kMaxDet], na_in_asym[kMaxDet];
  Float_t fr_in_asym_err[kMaxDet], na_in_asym_err[kMaxDet];
  Float_t fr_in_asymcorr[kMaxDet], na_in_asymcorr[kMaxDet];
  Float_t fr_in_asymcorr_err[kMaxDet], na_in_asymcorr_err[kMaxDet];
  Float_t fr_out_asym[kMaxDet], na_out_asym[kMaxDet];
  Float_t fr_out_asym_err[kMaxDet], na_out_asym_err[kMaxDet];
  Float_t fr_out_asymcorr[kMaxDet], na_out_asymcorr[kMaxDet];
  Float_t fr_out_asymcorr_err[kMaxDet], na_out_asymcorr_err[kMaxDet];
  UInt_t n_fr_in = 0;
  UInt_t n_fr_out = 0;
  UInt_t n_na_in = 0;
  UInt_t n_na_out = 0;

  Float_t fr_in_deldet[kMaxDet], na_in_deldet[kMaxDet];
  Float_t fr_out_deldet[kMaxDet], na_out_deldet[kMaxDet];
  Float_t fr_in_del[kMaxDet], na_in_del[kMaxDet];
  Float_t fr_in_del_err[kMaxDet], na_in_del_err[kMaxDet];
  Float_t fr_out_del[kMaxDet], na_out_del[kMaxDet];
  Float_t fr_out_del_err[kMaxDet], na_out_del_err[kMaxDet];
  const UInt_t kDeltaScale = 1;

  //  string make, ihwp;
  Char_t make[3], ihwp[4];
  UInt_t det;
  Float_t asym, asym_err, asymcorr, asymcorr_err;

  // Loop over input file and fill arrays sorted by detector make and
  // IHWP state
  while (!f_input.eof()) {

    // Read a line of data into the temporary variables
    f_input >> make;
    f_input >> det >> ihwp;
    f_input >> asym >> asym_err >> asymcorr >> asymcorr_err;

    if (f_input.eof()) {
      break;
    }

    cout << make << " " << det << " " << ihwp << " " << asym << endl;

    string s_make = make;
    string s_ihwp = ihwp;

    if (!s_make.compare("fr")) {
      // French data
      if (!s_ihwp.compare("in")) {
	// French IN data
	fr_in_det[n_fr_in] = det - 0.1;
	fr_in_detcorr[n_fr_in] = det + 0.1;
	fr_in_asym[n_fr_in] = asym;
	fr_in_asym_err[n_fr_in] = asym_err;
	fr_in_asymcorr[n_fr_in] = asymcorr;
	fr_in_asymcorr_err[n_fr_in] = asymcorr_err;

	fr_in_deldet[n_fr_in] = det - 0.1;
	fr_in_del[n_fr_in] = asym-asymcorr;
	fr_in_del_err[n_fr_in] = asym_err*asym_err;
	fr_in_del_err[n_fr_in] += asymcorr_err*asymcorr_err;
	fr_in_del_err[n_fr_in] = TMath::Abs(TMath::Sqrt(fr_in_del_err[n_fr_in]));
	
	fr_in_del[n_fr_in] *= kDeltaScale;
	fr_in_del_err[n_fr_in] *= kDeltaScale;

	n_fr_in++;
      } else {
	// French OUT data
	fr_out_det[n_fr_out] = det - 0.1;
	fr_out_detcorr[n_fr_out] = det + 0.1;
	fr_out_asym[n_fr_out] = asym;
	fr_out_asym_err[n_fr_out] = asym_err;
	fr_out_asymcorr[n_fr_out] = asymcorr;
	fr_out_asymcorr_err[n_fr_out] = asymcorr_err;

	fr_out_deldet[n_fr_out] = det + 0.1;
	fr_out_del[n_fr_out] = asym-asymcorr;
	fr_out_del_err[n_fr_out] = asym_err*asym_err;
	fr_out_del_err[n_fr_out] += asymcorr_err*asymcorr_err;
	fr_out_del_err[n_fr_out] = TMath::Abs(TMath::Sqrt(fr_out_del_err[n_fr_out]));
	
	fr_out_del[n_fr_out] *= kDeltaScale;
	fr_out_del_err[n_fr_out] *= kDeltaScale;

	n_fr_out++;
      }
    } else {
      // NA data
      if (!s_ihwp.compare("in")) {
	// NA IN data
	na_in_det[n_na_in] = det - 0.1;
	na_in_detcorr[n_na_in] = det + 0.1;
	na_in_asym[n_na_in] = asym;
	na_in_asym_err[n_na_in] = asym_err;
	na_in_asymcorr[n_na_in] = asymcorr;
	na_in_asymcorr_err[n_na_in] = asymcorr_err;

	na_in_deldet[n_na_in] = det - 0.1;
	na_in_del[n_na_in] = asym-asymcorr;
	na_in_del_err[n_na_in] = asym_err*asym_err;
	na_in_del_err[n_na_in] += asymcorr_err*asymcorr_err;
	na_in_del_err[n_na_in] = TMath::Abs(TMath::Sqrt(na_in_del_err[n_na_in]));
	
	na_in_del[n_na_in] *= kDeltaScale;
	na_in_del_err[n_na_in] *= kDeltaScale;

	//	cerr << "NA[" << n_na_in << "] IN: " << na_in_del[n_na_in];
	//	cerr << " +/- " << na_in_del_err[n_na_in] << endl;

	n_na_in++;
      } else {
	// NA OUT data
	na_out_det[n_na_out] = det - 0.1;
	na_out_detcorr[n_na_out] = det + 0.1;
	na_out_asym[n_na_out] = asym;
	na_out_asym_err[n_na_out] = asym_err;
	na_out_asymcorr[n_na_out] = asymcorr;
	na_out_asymcorr_err[n_na_out] = asymcorr_err;

	na_out_deldet[n_na_out] = det + 0.1;
	na_out_del[n_na_out] = asym-asymcorr;
	na_out_del_err[n_na_out] = asym_err*asym_err;
	na_out_del_err[n_na_out] += asymcorr_err*asymcorr_err;
	na_out_del_err[n_na_out] = TMath::Abs(TMath::Sqrt(na_out_del_err[n_na_out]));
	
	na_out_del[n_na_out] *= kDeltaScale;
	na_out_del_err[n_na_out] *= kDeltaScale;

	//	cerr << "NA[" << n_na_out << "] OUT: " << na_out_del[n_na_out];
	//	cerr << " +/- " << na_out_del_err[n_na_out] << endl;

	n_na_out++;
      }
    }
  }

  Float_t fr_det[kMaxDet], na_det[kMaxDet];
  Float_t fr_detcorr[kMaxDet], na_detcorr[kMaxDet];
  Float_t fr_deldet[kMaxDet], na_deldet[kMaxDet];
  Float_t fr_asym[kMaxDet], na_asym[kMaxDet];
  Float_t fr_asym_err[kMaxDet], na_asym_err[kMaxDet];
  Float_t fr_asymcorr[kMaxDet], na_asymcorr[kMaxDet];
  Float_t fr_asymcorr_err[kMaxDet], na_asymcorr_err[kMaxDet];
  Float_t fr_del[kMaxDet], na_del[kMaxDet];
  Float_t fr_del_err[kMaxDet], na_del_err[kMaxDet];
  Float_t fr_dela[kMaxDet], na_dela[kMaxDet];
  
  const UInt_t kDeltaAScale = 100;

  for (UInt_t i = 0; i < n_fr_out; i++) {
    fr_det[i] = fr_out_det[i];
    fr_detcorr[i] = fr_out_detcorr[i];
    fr_asym[i] = fr_out_asym[i] - fr_in_asym[i];
    fr_asym_err[i] = TMath::Sqrt(fr_out_asym_err[i]*fr_out_asym_err[i] 
				 + fr_in_asym_err[i]*fr_in_asym_err[i]);
    fr_asymcorr[i] = fr_out_asymcorr[i] - fr_in_asymcorr[i];
    fr_asymcorr_err[i] = TMath::Sqrt(fr_out_asymcorr_err[i]*fr_out_asymcorr_err[i] 
				 + fr_in_asymcorr_err[i]*fr_in_asymcorr_err[i]);
    fr_deldet[i] = fr_in_deldet[i];
    fr_del[i] = fr_asym[i] - fr_asymcorr[i];
    fr_del_err[i] = TMath::Sqrt(fr_asym_err[i]*fr_asym_err[i] 
				 + fr_asymcorr_err[i]*fr_asymcorr_err[i]);
    fr_dela[i] = fr_del[i]/fr_asym[i];
    fr_dela[i] *= kDeltaAScale;

    na_det[i] = na_out_det[i];
    na_detcorr[i] = na_out_detcorr[i];
    na_asym[i] = na_out_asym[i] - na_in_asym[i];
    na_asym_err[i] = TMath::Sqrt(na_out_asym_err[i]*na_out_asym_err[i] 
				 + na_in_asym_err[i]*na_in_asym_err[i]);
    na_asymcorr[i] = na_out_asymcorr[i] - na_in_asymcorr[i];
    na_asymcorr_err[i] = TMath::Sqrt(na_out_asymcorr_err[i]*na_out_asymcorr_err[i] 
				 + na_in_asymcorr_err[i]*na_in_asymcorr_err[i]);
    na_deldet[i] = na_out_deldet[i];
    na_del[i] = na_asym[i] - na_asymcorr[i];
    na_del_err[i] = TMath::Sqrt(na_asym_err[i]*na_asym_err[i] 
				 + na_asymcorr_err[i]*na_asymcorr_err[i]);
    na_dela[i] = na_del[i]/na_asym[i];
    na_dela[i] *= kDeltaAScale;
  }


  f_input.close();

  const UInt_t kMarkerIn = 4;
  const UInt_t kMarkerInCorr = 20;
  const UInt_t kMarkerOut = 26;
  const UInt_t kMarkerOutCorr = 22;
  const UInt_t kColorIn = 2;
  const UInt_t kColorOut = 4;
  /*
   * Raw and Corrected Asymmetry Graphs
   */
  TGraphErrors *g_fr_in_asym = new TGraphErrors(n_fr_in, fr_in_det, 
						fr_in_asym, 0, 
						fr_in_asym_err);
  g_fr_in_asym->SetMarkerStyle(kMarkerIn);
  g_fr_in_asym->SetMarkerColor(kColorIn);
  g_fr_in_asym->SetLineColor(kColorIn);
  TGraphErrors *g_fr_in_asymcorr = new TGraphErrors(n_fr_in, fr_in_detcorr, 
						fr_in_asymcorr, 0, 
						fr_in_asymcorr_err);
  g_fr_in_asymcorr->SetMarkerStyle(kMarkerInCorr);
  g_fr_in_asymcorr->SetMarkerColor(kColorIn);
  g_fr_in_asymcorr->SetLineColor(kColorIn);
  TGraphErrors *g_fr_out_asym = new TGraphErrors(n_fr_out, fr_out_det, 
						fr_out_asym, 0, 
						fr_out_asym_err);
  g_fr_out_asym->SetMarkerStyle(kMarkerOut);
  g_fr_out_asym->SetMarkerColor(kColorOut);
  g_fr_out_asym->SetLineColor(kColorOut);
  TGraphErrors *g_fr_out_asymcorr = new TGraphErrors(n_fr_out, fr_out_detcorr, 
						fr_out_asymcorr, 0, 
						fr_out_asymcorr_err);
  g_fr_out_asymcorr->SetMarkerStyle(kMarkerOutCorr);
  g_fr_out_asymcorr->SetMarkerColor(kColorOut);
  g_fr_out_asymcorr->SetLineColor(kColorOut);
  TGraphErrors *g_na_in_asym = new TGraphErrors(n_na_in, na_in_det, 
						na_in_asym, 0, 
						na_in_asym_err);
  g_na_in_asym->SetMarkerStyle(kMarkerIn);
  g_na_in_asym->SetMarkerColor(kColorIn);
  g_na_in_asym->SetLineColor(kColorIn);
  TGraphErrors *g_na_in_asymcorr = new TGraphErrors(n_na_in, na_in_detcorr, 
						na_in_asymcorr, 0, 
						na_in_asymcorr_err);
  g_na_in_asymcorr->SetMarkerStyle(kMarkerInCorr);
  g_na_in_asymcorr->SetMarkerColor(kColorIn);
  g_na_in_asymcorr->SetLineColor(kColorIn);
  TGraphErrors *g_na_out_asym = new TGraphErrors(n_na_out, na_out_det, 
						na_out_asym, 0, 
						na_out_asym_err);
  g_na_out_asym->SetMarkerStyle(kMarkerOut);
  g_na_out_asym->SetMarkerColor(kColorOut);
  g_na_out_asym->SetLineColor(kColorOut);
  TGraphErrors *g_na_out_asymcorr = new TGraphErrors(n_na_out, na_out_detcorr, 
						na_out_asymcorr, 0, 
						na_out_asymcorr_err);
  g_na_out_asymcorr->SetMarkerStyle(kMarkerOutCorr);
  g_na_out_asymcorr->SetMarkerColor(kColorOut);
  g_na_out_asymcorr->SetLineColor(kColorOut);

  TMultiGraph *mg_fr = new TMultiGraph("mg_fr", "French Detector Asymmetries");
  mg_fr->Add(g_fr_in_asym, "p");
  mg_fr->Add(g_fr_in_asymcorr, "p");
  mg_fr->Add(g_fr_out_asym, "p");
  mg_fr->Add(g_fr_out_asymcorr, "p");

  TMultiGraph *mg_na = new TMultiGraph("mg_na", "North American Detector Asymetries");
  mg_na->Add(g_na_in_asym, "p");
  mg_na->Add(g_na_in_asymcorr, "p");
  mg_na->Add(g_na_out_asym, "p");
  mg_na->Add(g_na_out_asymcorr, "p");

  /*
   * Delta Graphs
   */
  TGraphErrors *g_fr_in_del = new TGraphErrors(n_fr_in, fr_in_deldet, 
					       fr_in_del, 0, 
					       0);
  //					       fr_in_del_err);
  g_fr_in_del->SetMarkerStyle(kMarkerIn);
  g_fr_in_del->SetMarkerColor(kColorIn);
  g_fr_in_del->SetLineColor(kColorIn);
  TGraphErrors *g_fr_out_del = new TGraphErrors(n_fr_out, fr_out_deldet, 
					       fr_out_del, 0, 
					       0);
  //					       fr_out_del_err);
  g_fr_out_del->SetMarkerStyle(kMarkerOut);
  g_fr_out_del->SetMarkerColor(kColorOut);
  g_fr_out_del->SetLineColor(kColorOut);
  TGraphErrors *g_na_in_del = new TGraphErrors(n_na_in, na_in_deldet, 
					       na_in_del, 0, 
					       0);
  //					       na_in_del_err);
  g_na_in_del->SetMarkerStyle(kMarkerIn);
  g_na_in_del->SetMarkerColor(kColorIn);
  g_na_in_del->SetLineColor(kColorIn);
  TGraphErrors *g_na_out_del = new TGraphErrors(n_na_out, na_out_deldet, 
					       na_out_del, 0, 
					       0);
  //					       na_out_del_err);
  g_na_out_del->SetMarkerStyle(kMarkerOut);
  g_na_out_del->SetMarkerColor(kColorOut);
  g_na_out_del->SetLineColor(kColorOut);

  TMultiGraph *mg_fr_del = new 
    TMultiGraph("mg_fr_del", "French Asymmetry Deltas");
  mg_fr_del->Add(g_fr_in_del, "p");
  mg_fr_del->Add(g_fr_out_del, "p");

  TMultiGraph *mg_na_del = new 
    TMultiGraph("mg_na_del", "North American Asymmetry Deltas");
  mg_na_del->Add(g_na_in_del, "p");
  mg_na_del->Add(g_na_out_del, "p");

  /*
   * Helicity Averaged Graphs (Out - In)
   */
  TGraphErrors* g_fr_asym = new TGraphErrors(n_fr_in, fr_det, fr_asym,
					    0, fr_asym_err);
  g_fr_asym->SetMarkerStyle(kMarkerOut);
  g_fr_asym->SetMarkerColor(kColorOut);
  g_fr_asym->SetLineColor(kColorOut);
  TGraphErrors* g_fr_asymcorr = new TGraphErrors(n_fr_in, fr_detcorr, 
						fr_asymcorr,
						0, fr_asymcorr_err);
  g_fr_asymcorr->SetMarkerStyle(kMarkerOutCorr);
  g_fr_asymcorr->SetMarkerColor(kColorOut);
  g_fr_asymcorr->SetLineColor(kColorOut);
  TGraphErrors* g_na_asym = new TGraphErrors(n_na_in, na_det, na_asym,
					    0, na_asym_err);
  g_na_asym->SetMarkerStyle(kMarkerIn);
  g_na_asym->SetMarkerColor(kColorIn);
  g_na_asym->SetLineColor(kColorIn);
  TGraphErrors* g_na_asymcorr = new TGraphErrors(n_na_in, na_detcorr, 
						na_asymcorr,
						0, na_asymcorr_err);
  g_na_asymcorr->SetMarkerStyle(kMarkerInCorr);
  g_na_asymcorr->SetMarkerColor(kColorIn);
  g_na_asymcorr->SetLineColor(kColorIn);
  TGraphErrors* g_fr_del = new TGraphErrors(n_fr_in, fr_deldet, fr_del,
					    0, 0);
  //					    0, fr_del_err);
  g_fr_del->SetMarkerStyle(kMarkerOut);
  g_fr_del->SetMarkerColor(kColorOut);
  g_fr_del->SetLineColor(kColorOut);
  TGraphErrors* g_na_del = new TGraphErrors(n_na_in, na_deldet, na_del,
					    0, 0);
  //					    0, na_del_err);
  g_na_del->SetMarkerStyle(kMarkerIn);
  g_na_del->SetMarkerColor(kColorIn);
  g_na_del->SetLineColor(kColorIn);
  TGraphErrors* g_fr_dela = new TGraphErrors(n_fr_in, fr_deldet, fr_dela,
					    0, 0);
  g_fr_dela->SetMarkerStyle(kMarkerOut);
  g_fr_dela->SetMarkerColor(kColorOut);
  g_fr_dela->SetLineColor(kColorOut);
  TGraphErrors* g_na_dela = new TGraphErrors(n_na_in, na_deldet, na_dela,
					    0, 0);
  g_na_dela->SetMarkerStyle(kMarkerIn);
  g_na_dela->SetMarkerColor(kColorIn);
  g_na_dela->SetLineColor(kColorIn);

  TMultiGraph *mg_fr_ave = 
    new TMultiGraph("mg_fr_ave", "French Asymmetries (Out - In)");
  mg_fr_ave->Add(g_fr_asym, "p");
  mg_fr_ave->Add(g_fr_asymcorr, "p");

  TMultiGraph *mg_na_ave = 
    new TMultiGraph("mg_na_ave", "North American Asymmetries (Out - In)");
  mg_na_ave->Add(g_na_asym, "p");
  mg_na_ave->Add(g_na_asymcorr, "p");

  TMultiGraph *mg_del_ave = 
    new TMultiGraph("mg_del_ave", "Asymmetry Deltas (Out - In)");
  mg_del_ave->Add(g_fr_del, "p");
  mg_del_ave->Add(g_na_del, "p");

  TMultiGraph *mg_dela_ave = 
    new TMultiGraph("mg_dela_ave", "Asymmetry Delta As (Out - In)");
  mg_dela_ave->Add(g_fr_dela, "p");
  mg_dela_ave->Add(g_na_dela, "p");

  /*
   * Output
   */

  cout << endl;
  cout << "French Corrected Asymmetry Data (%)" << endl;
  g_fr_asymcorr->Print();
  cout << endl;
  cout << "North American Corrected Asymmetry Data (%)" << endl;
  g_na_asymcorr->Print();
  cout << endl;
  cout << "French Delta A Data (%)" << endl;
  g_fr_dela->Print();
  cout << endl;
  cout << "North American Delta A Data (%)" << endl;
  g_na_dela->Print();

  return;

  TCanvas *c1 = new TCanvas("c1","Asymmetry Corrections",600,777);
  c1->Divide(1,2);
  TPostScript *ps= new TPostScript("asym_asymcorr_cuts.ps", 111);
  TLine l_zero;

  // Asymmetries
  ps->NewPage();
  c1->cd(1);
  mg_fr->Draw("a");
  mg_fr->GetYaxis()->SetTitle("Asymmetry (ppm)");
  mg_fr->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_fr->GetXaxis()->GetXmin(), 0.0, 
		  mg_fr->GetXaxis()->GetXmax(), 0.0);
  const UInt_t kFontTNR = 132;
  TLegend* fr_leg = new TLegend(0.15, 0.15, 0.25, 0.3, "", "NDC");
  TLegendEntry le_temp;
  le_temp = fr_leg->AddEntry(g_fr_in_asym, "A_{R} : IN", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = fr_leg->AddEntry(g_fr_in_asymcorr, "A_{C} : IN", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = fr_leg->AddEntry(g_fr_out_asym, "A_{R} : OUT", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = fr_leg->AddEntry(g_fr_out_asymcorr, "A_{C} : OUT", "p");
  le_temp->SetTextFont(kFontTNR);
  fr_leg->Draw();
  //  gPad->Update();

  c1->cd(2);
  mg_fr_del->Draw("a");
  mg_fr_del->GetYaxis()->SetTitle("Delta = A_{R} - A_{C} (ppm)");
  mg_fr_del->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_fr_del->GetXaxis()->GetXmin(), 0.0, 
		  mg_fr_del->GetXaxis()->GetXmax(), 0.0);
  //  gPad->Update();
  c1->Update();

  // Deltas
  ps->NewPage();
  c1->Clear();
  c1->Divide(1,2);
  c1->cd(1);
  mg_na->Draw("a");
  mg_na->GetYaxis()->SetTitle("Asymmetry (ppm)");
  mg_na->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_na->GetXaxis()->GetXmin(), 0.0, 
		  mg_na->GetXaxis()->GetXmax(), 0.0);
  TLegend* na_leg = new TLegend(0.15, 0.15, 0.25, 0.3, "", "NDC");
  le_temp = na_leg->AddEntry(g_na_in_asym, "A_{R} : IN", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = na_leg->AddEntry(g_na_in_asymcorr, "A_{C} : IN", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = na_leg->AddEntry(g_na_out_asym, "A_{R} : OUT", "p");
  le_temp->SetTextFont(kFontTNR);
  le_temp = na_leg->AddEntry(g_na_out_asymcorr, "A_{C} : OUT", "p");
  le_temp->SetTextFont(kFontTNR);
  na_leg->Draw();
  //  gPad->Update();

  c1->cd(2);
  mg_na_del->Draw("a");
  mg_na_del->GetYaxis()->SetTitle("Delta = A_{R} - A_{C} (ppm)");
  mg_na_del->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_na_del->GetXaxis()->GetXmin(), 0.0, 
		  mg_na_del->GetXaxis()->GetXmax(), 0.0);
  //  gPad->Update();
  c1->Update();

  // Helicity Averaged
  ps->NewPage();
  c1->Clear();
  c1->Divide(1,4);

  c1->cd(1);
  mg_fr_ave->Draw("a");
  mg_fr_ave->GetYaxis()->SetTitle("Asymmetry (ppm)");
  mg_fr_ave->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_fr_ave->GetXaxis()->GetXmin(), 0.0, 
		  mg_fr_ave->GetXaxis()->GetXmax(), 0.0);
  TLegend* fr_ave_leg = new TLegend(0.15, 0.15, 0.25, 0.3);
  fr_ave_leg->AddEntry(g_fr_asym, "A_{R}", "p");
  fr_ave_leg->AddEntry(g_fr_asymcorr, "A_{C}", "p");
  fr_ave_leg->Draw();

  c1->cd(2);
  mg_na_ave->Draw("a");
  mg_na_ave->GetYaxis()->SetTitle("Asymmetry (ppm)");
  mg_na_ave->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_na_ave->GetXaxis()->GetXmin(), 0.0, 
		  mg_na_ave->GetXaxis()->GetXmax(), 0.0);
  TLegend* na_ave_leg = new TLegend(0.15, 0.15, 0.25, 0.3);
  na_ave_leg->AddEntry(g_na_asym, "A_{R}", "p");
  na_ave_leg->AddEntry(g_na_asymcorr, "A_{C}", "p");
  na_ave_leg->Draw();

  c1->cd(3);
  mg_del_ave->Draw("a");
  mg_del_ave->GetYaxis()->SetTitle("Delta = A_{R} - A_{C} (ppm)");
  mg_del_ave->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_del_ave->GetXaxis()->GetXmin(), 0.0, 
		  mg_del_ave->GetXaxis()->GetXmax(), 0.0);
  TLegend* na_del_leg = new TLegend(0.15, 0.15, 0.25, 0.3);
  na_del_leg->AddEntry(g_fr_del, "French", "p");
  na_del_leg->AddEntry(g_na_del, "North American", "p");
  na_del_leg->Draw();

  c1->cd(4);
  mg_dela_ave->Draw("a");
  mg_dela_ave->GetYaxis()->SetTitle("Delta = (A_{R} - A_{C})/A_{R} (%)");
  mg_dela_ave->GetXaxis()->SetTitle("Detector Number");
  l_zero.DrawLine(mg_dela_ave->GetXaxis()->GetXmin(), 0.0, 
		  mg_dela_ave->GetXaxis()->GetXmax(), 0.0);
  TLegend* na_dela_leg = new TLegend(0.15, 0.15, 0.25, 0.3);
  na_dela_leg->AddEntry(g_fr_dela, "French", "p");
  na_dela_leg->AddEntry(g_na_dela, "North American", "p");
  na_dela_leg->Draw();

  c1->Update();

  ps->Close();

}