{
#define NSlug 19

  const Int_t NR = NSlug - 2;
  const Int_t NL1 = 10;
  const Int_t NL2 = NSlug - 17;

  Double_t asymR[NR], asymRerr[NR], slugR[NR], slugRerr[NR];
  Double_t avgRIN =0, sigmaRIN =0, avgROUT = 0, sigmaROUT = 0;
  Double_t asymL1[NL1], asymL1err[NL1], slugL1[NL1], slugL1err[NL1];
  Double_t avgL1IN = 0, sigmaL1IN = 0, avgL1OUT = 0, sigmaL1OUT = 0;
  Double_t asymL2[NL2], asymL2err[NL2], slugL2[NL2], slugL2err[NL2];
  Double_t avgL2IN = 0, sigmaL2IN = 0, avgL2OUT = 0, sigmaL2OUT = 0;

  Int_t HWP[NSlug] = {1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,1,-1,-1,1};

  /////right arm
  Int_t k = 0;
  Int_t NINR = 0, NOUTR = 0;
  for (Int_t i=0; i < NSlug; i++) {
    if ((i == 11) || (i == 12))
      continue;
    slugR[k] = i+1;
    slugRerr[k] = 0;
    if (i < 9)
    TString rfn = "~/pvdis/wac/ROOTfiles/parity09_000";
    else 
      TString rfn = "~/pvdis/wac/ROOTfiles/parity09_00";
    rfn += i+1;
    rfn += "_slug.root";
    TFile *_file0 = TFile::Open(rfn);
    cout<<"open rootfile successful!"<<rfn<<endl;

    Double_t rmstemp, enttemp;

    TString sr = "asym_disrenar>>h1";
    S->Draw(sr, "ok_regR", "goff");
    asymR[k] = h1->GetMean();
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();
    if (enttemp <= 0) {
      cout<<"ERROR: Slug"<<i+1<<"  NO Entries??"<<endl;
      asymRerr[k] = 0;
    }
    else 
      asymRerr[k] = rmstemp / sqrt(enttemp); 

    if (HWP[i] == 1) {  //HWP OUT
      avgROUT += asymR[k]/pow(asymRerr[k], 2);
      sigmaROUT += 1/pow(asymRerr[k], 2);
      NOUTR++;
    }
    else {
      avgRIN += asymR[k]/pow(asymRerr[k], 2);
      sigmaRIN += 1/pow(asymRerr[k], 2);
      NINR++;
    }

    k++;
  }

  ///////seperate the asym into HWP IN and OUT
  Double_t *asymRIN, *asymROUT, *slugRIN, *slugROUT;
  Double_t *asymRINerr, *asymROUTerr, *slugRINerr, *slugROUTerr;
  asymRIN = new Double_t [NINR];
  asymROUT = new Double_t [NOUTR];
  slugRIN = new Double_t [NINR];
  slugROUT = new Double_t [NOUTR];
  asymRINerr = new Double_t [NINR];
  asymROUTerr = new Double_t [NOUTR];
  slugRINerr = new Double_t [NINR];
  slugROUTerr = new Double_t [NOUTR];

  Int_t iin = 0, iout = 0;
  for (Int_t i=0; i<k; i++) {
    Int_t slugnumber = slugR[i] - 1;
    if(HWP[slugnumber] == 1) { //HWP OUT
      asymROUT[iout] = asymR[i];
      slugROUT[iout] = slugR[i];
      asymROUTerr[iout] = asymRerr[i];
      slugROUTerr[iout] = slugRerr[i];
      iout++; 
   }
    else {
      asymRIN[iin] = asymR[i];
      slugRIN[iin] = slugR[i];
      asymRINerr[iin] = asymRerr[i];
      slugRINerr[iin] = slugRerr[i];
      iin++;
    }

  }

  avgROUT = avgROUT / sigmaROUT;
  avgRIN = avgRIN / sigmaRIN;
  Double_t errROUT = sqrt(1/sigmaROUT);
  Double_t  errRIN = sqrt(1/sigmaRIN);


  /////left arm kine 1
  Int_t k1=0;
  Int_t NINL1 = 0, NOUTL1 =0;
  for (Int_t i=1; i<11; i++ ) {     //slug 2-11
    slugL1[k1] = i+1;
    slugL1err[k1] = 0;
    if (i < 9)
    TString rfn = "~/pvdis/wac/ROOTfiles/parity09_000";
    else 
      TString rfn = "~/pvdis/wac/ROOTfiles/parity09_00";
    rfn += i+1;
    rfn += "_slug.root";
    TFile *_file0 = TFile::Open(rfn);
    cout<<"open rootfile successful!"<<rfn<<endl;

    Double_t rmstemp, enttemp;

    TString sl1 = "asym_dislenar>>h1";
    S->Draw(sl1, "ok_regL", "goff");
    asymL1[k1] = h1->GetMean();
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();

    if (enttemp <= 0) {
      cout<<"ERROR: Slug"<<i+1<<"  NO Entries??"<<endl;
      asymL1err[k1] = 0;
    }
    else 
      asymL1err[k1] = rmstemp / sqrt(enttemp); 

    if (HWP[i] == 1) { //HWP OUT
      avgL1OUT += asymL1[k1]/pow(asymL1err[k1], 2);
      sigmaL1OUT += 1/pow(asymL1err[k1], 2);
      NOUTL1 ++;
    }
    else {
      avgL1IN += asymL1[k1]/pow(asymL1err[k1], 2);
      sigmaL1IN += 1/pow(asymL1err[k1], 2);
      NINL1 ++;
    }

    k1++;

  }

  cout<<"k1= "<<k1<<"NINL1= "<<NINL1<<"NOUTL1=  "<<NOUTL1<<endl;

  Double_t *asymL1IN, *asymL1OUT, *slugL1IN, *slugL1OUT;
  Double_t *asymL1INerr, *asymL1OUTerr, *slugL1INerr, *slugL1OUTerr;
  asymL1IN = new Double_t [NINL1];
  asymL1OUT = new Double_t [NOUTL1];
  slugL1IN = new Double_t [NINL1];
  slugL1OUT = new Double_t [NOUTL1];
  asymL1INerr = new Double_t [NINL1];
  asymL1OUTerr = new Double_t [NOUTL1];
  slugL1INerr = new Double_t [NINL1];
  slugL1OUTerr = new Double_t [NOUTL1];

  iin = 0; iout = 0;
  for (Int_t i=0; i<k1; i++) {
    Int_t slugnumber = slugL1[i] - 1;
    if(HWP[slugnumber] == 1) { //HWP OUT
      asymL1OUT[iout] = asymL1[i];
      slugL1OUT[iout] = slugL1[i];
      asymL1OUTerr[iout] = asymL1err[i];
      slugL1OUTerr[iout] = slugL1err[i];
      iout++; 
   }
    else {
      asymL1IN[iin] = asymL1[i];
      slugL1IN[iin] = slugL1[i];
      asymL1INerr[iin] = asymL1err[i];
      slugL1INerr[iin] = slugL1err[i];
      iin++;
    }

  }
  cout<<"iin= "<<iin<<"iout=  "<<iout<<endl;



  avgL1OUT = avgL1OUT / sigmaL1OUT;
  avgL1IN = avgL1IN / sigmaL1IN;
  Double_t errL1OUT = sqrt(1/sigmaL1OUT);
  Double_t  errL1IN = sqrt(1/sigmaL1IN);


  ////////left arm kine 2
  Int_t k2=0;
  Int_t NINL2=0, NOUTL2=0;
  for (Int_t i = 17; i<NSlug; i++) {   //starting from slug 18
    slugL2[k2] = i+1;
    slugL2err[k2] = 0;
    if (i < 9)
    TString rfn = "~/pvdis/wac/ROOTfiles/parity09_000";
    else 
      TString rfn = "~/pvdis/wac/ROOTfiles/parity09_00";
    rfn += i+1;
    rfn += "_slug.root";
    TFile *_file0 = TFile::Open(rfn);
    cout<<"open rootfile successful!"<<rfn<<endl;


    Double_t rmstemp, enttemp;

    TString sl2 = "asym_dislenar>>h1";
    S->Draw(sl2, "ok_regL", "goff");
    asymL2[k2] = h1->GetMean();
    rmstemp = h1->GetRMS();
    enttemp = h1->GetEntries();

    if (enttemp <= 0) {
      cout<<"ERROR: Slug"<<i+1<<"  NO Entries??"<<endl;
      asymL2err[k2] = 0;
    }
    else 
      asymL2err[k2] = rmstemp / sqrt(enttemp); 

    if (HWP[i] == 1) { //HWP OUT
      avgL2OUT += asymL2[k2]/pow(asymL2err[k2], 2);
      sigmaL2OUT += 1/pow(asymL2err[k2], 2);
      NINL2++;
    }
    else {
      avgL2IN += asymL2[k2]/pow(asymL2err[k2], 2);
      sigmaL2IN += 1/pow(asymL2err[k2], 2);
      NOUTL2++;
    }

    k2++;
  }

  Double_t *asymL2IN, *asymL2OUT, *slugL2IN, *slugL2OUT;
  Double_t *asymL2INerr, *asymL2OUTerr, *slugL2INerr, *slugL2OUTerr;
  asymL2IN = new Double_t [NINL2];
  asymL2OUT = new Double_t [NOUTL2];
  slugL2IN = new Double_t [NINL2];
  slugL2OUT = new Double_t [NOUTL2];
  asymL2INerr = new Double_t [NINL2];
  asymL2OUTerr = new Double_t [NOUTL2];
  slugL2INerr = new Double_t [NINL2];
  slugL2OUTerr = new Double_t [NOUTL2];

  iin = 0; iout = 0;
  for (Int_t i=0; i<k2; i++) {
    Int_t slugnumber = slugL2[i] - 1;
    if(HWP[slugnumber] == 1) { //HWP OUT
      asymL2OUT[iout] = asymL2[i];
      slugL2OUT[iout] = slugL2[i];
      asymL2OUTerr[iout] = asymL2err[i];
      slugL2OUTerr[iout] = slugL2err[i];
      iout++; 
   }
    else {
      asymL2IN[iin] = asymL2[i];
      slugL2IN[iin] = slugL2[i];
      asymL2INerr[iin] = asymL2err[i];
      slugL2INerr[iin] = slugL2err[i];
      iin++;
    }

  }


  avgL2OUT = avgL2OUT / sigmaL2OUT;
  avgL2IN = avgL2IN / sigmaL2IN;
  Double_t errL2OUT = sqrt(1/sigmaL2OUT);
  Double_t errL2IN = sqrt(1/sigmaL2IN);

  cout<<"left arm kine 2:"<<endl;
  cout<<"HWP OUT: "<<"asym= "<<avgL2OUT<<"  error= "<<errL2OUT<<endl;
  cout<<"HWP IN:"<<"asym= "<<avgL2IN<<"  error= "<<errL2IN<<endl;

  ///////////plotting right arm
  TCanvas *c1 = new TCanvas("c1", "right arm asymmetries", 1400, 1000);
  TGraphErrors *gRIN = new TGraphErrors(NINR, slugRIN, asymRIN, slugRINerr, asymRINerr);
  gRIN->SetTitle("asymmetries of right arm, P0 = 2.63GeV");
  gRIN->GetXaxis()->SetTitle("Slug");
  gRIN->GetYaxis()->SetTitle("asymmetry (ppm)");
  gRIN->GetYaxis()->SetRangeUser(-300, 300);
  gRIN->SetMarkerStyle(20);
  gRIN->SetMarkerSize(1.5);
  gRIN->SetMarkerColor(kRed);
  gRIN->SetLineColor(kRed);
  gRIN->Draw("AP");

  TGraphErrors *gROUT = new TGraphErrors(NOUTR, slugROUT, asymROUT, slugROUTerr, asymROUTerr);
  gROUT->SetMarkerStyle(22);
  gROUT->SetMarkerSize(1.5);
  gROUT->SetMarkerColor(kBlue);
  gROUT->SetLineColor(kBlue);
  gROUT->Draw("sameP");

   TLine *lROUT = new TLine(1.00,avgROUT,19.0,avgROUT);
   lROUT->SetLineWidth(3);
   lROUT->SetLineColor(kBlue);
   lROUT->Draw("same");
   TString tROUT = Form("HWP OUT, asym(blinded) = %.1f +/- %.1f(ppm)", avgROUT, errROUT);
      tex = new TLatex(2.0,250,tROUT);
   tex->SetLineWidth(3);
   tex->SetTextColor(kBlue);
   tex->Draw("same");

   TLine *lRIN = new TLine(1.0, avgRIN, 19.0, avgRIN);
   lRIN->SetLineWidth(3);
   lRIN->SetLineColor(kRed);
   lRIN->Draw("same");
   TString tRIN = Form("HWP IN, asym(blinded) = %.1f +/- %.1f(ppm)", avgRIN, errRIN);
   texRIN = new TLatex(2.0, -250, tRIN);
   texRIN->SetLineWidth(3);
   texRIN->SetTextColor(kRed);
   texRIN->Draw("same");

   /////////////plotting left kine 1

  TCanvas *c2 = new TCanvas("c2", "left arm asymmetries kine 1", 1400, 1000);
  //  c2->DrawFrame(1,-150,12,150);
  TGraphErrors *gL1IN = new TGraphErrors(NINL1, slugL1IN, asymL1IN, slugL1INerr, asymL1INerr);
  gL1IN->SetTitle("asymmetries of left arm, P0 = 3.66GeV");
  gL1IN->GetXaxis()->SetTitle("Slug");
  gL1IN->GetYaxis()->SetTitle("asymmetry (ppm)");
  gL1IN->GetYaxis()->SetRangeUser(-150, 150);
  //  gL1IN->GetXaxis()->SetMinimum(1);
  //  gL1IN->GetXaxis()->SetMaximum(12);
  gL1IN->GetXaxis()->SetLimits(1,12);
  gL1IN->SetMarkerStyle(20);
  gL1IN->SetMarkerSize(1.5);
  gL1IN->SetMarkerColor(kRed);
  gL1IN->SetLineColor(kRed);
  gL1IN->Draw("AP");

  TGraphErrors *gL1OUT = new TGraphErrors(NOUTL1, slugL1OUT, asymL1OUT, slugL1OUTerr, asymL1OUTerr);
  gL1OUT->SetMarkerStyle(22);
  gL1OUT->SetMarkerSize(1.5);
  gL1OUT->SetMarkerColor(kBlue);
  gL1OUT->SetLineColor(kBlue);
  gL1OUT->Draw("sameP");

   TLine *lL1OUT = new TLine(2.00,avgL1OUT,11.0,avgL1OUT);
   lL1OUT->SetLineWidth(3);
   lL1OUT->SetLineColor(kBlue);
   lL1OUT->Draw("same");
   TString tL1OUT = Form("HWP OUT, asym(blinded) = %.1f +/- %.1f(ppm)", avgL1OUT, errL1OUT);
      texL1OUT = new TLatex(2.0,100,tL1OUT);
   texL1OUT->SetLineWidth(3);
   texL1OUT->SetTextColor(kBlue);
   texL1OUT->Draw("same");

   TLine *lL1IN = new TLine(2.0, avgL1IN, 11.0, avgL1IN);
   lL1IN->SetLineWidth(3);
   lL1IN->SetLineColor(kRed);
   lL1IN->Draw("same");
   TString tL1IN = Form("HWP IN, asym(blinded) = %.1f +/- %.1f(ppm)", avgL1IN, errL1IN);
   texL1IN = new TLatex(2.0, -100, tL1IN);
   texL1IN->SetLineWidth(3);
   texL1IN->SetTextColor(kRed);
   texL1IN->Draw("same");




}