void plotResults(){

  // Make arrays to hold results
  const int nFiles = 34;
  int pulseSeps[nFiles] = {8,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,55,60,65,70,80,90,100,150,200};
  double pulseSepsDouble[nFiles] = {8,10,11,12,13,14,15,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,55,60,65,70,80,90,100,150,200};

  // One per channel
  Double_t nHits[4][nFiles];
  double widths_1[4][nFiles];
  double widths_2[4][nFiles];
  double separations[4][nFiles];

  for(int file = 0; file < nFiles; file++){

    // Start by making plots from long 200ns run
    TFile* f = new TFile(Form("Data/PulseSeparation_%dns.root",pulseSeps[file]));
    TTree* tree = (TTree*)f->Get("RefireRate-STRAWS/StrawsTDCProcessed");
    TBranch* branch = tree->GetBranch("StrawsTDCProcessed");

    // Set branch addresses
    int num_tdcs;
    int num_hits;
    int readout_start_time_utc_s;
    long tdc_id;
    int spill_num;
    int integration_num;
    long integration_start_time;
    long integration_end_time;
    int header_id[6];
    int header_version[1];
    int reg0_data_valid;
    int reg1_scalars_edges;
    int reg2_start_time;
    int reg3_selb_time;
    int reg4_not_used;
    int reg5_end_time;
    int reg6_not_used;
    int reg7_not_used;
    int scalar_count[16];
    double hit_time_ns[2016];
    int hit_channel[2016];
    int hit_edge[2016];
    
    TObjArray* leaves = branch->GetListOfLeaves();
    void* addresses[22] = {
      &num_tdcs,
      &num_hits,
      &readout_start_time_utc_s,
      &tdc_id,
      &spill_num,
      &integration_num,
      &integration_start_time,
      &integration_end_time,
      &header_id[0],
      &header_version[0],
      &reg0_data_valid,
      &reg1_scalars_edges,
      &reg2_start_time,
      &reg3_selb_time,
      &reg4_not_used,
      &reg5_end_time,
      &reg6_not_used,
      &reg7_not_used,
      &scalar_count[0],
      &hit_time_ns[0],
      &hit_channel[0],
      &hit_edge[0]
    };
    TLeaf *leaf[22];
    for(int i=0 ; i<22; i++){
      leaf[i] = (TLeaf*)leaves->At(i);
      leaf[i]->SetAddress(addresses[i]);
    }
    
    double nHitsTotal[4]  = {0,0,0,0};
    double sepsTotal[4]   = {0,0,0,0};
    double widthsTotal_1[4] = {0,0,0,0};
    double widthsTotal_2[4] = {0,0,0,0};
    int nAccumulations[4] = {0,0,0,0};

    for(int i = 0; i < tree->GetEntries(); i++){
      tree->GetEntry(i);
      
      // Skip accumulations where there aren't any hits
      if(num_hits == 0) continue;

      // Only take accumulations where both edges have been registered 
      if(num_hits%2 != 0) continue;
      
      // Kill accumulations where there's lots of noise hits
      if(num_hits > 100) continue;
      
      // Remove accumulations where there are hits in spurious channels
      bool skip = false;
      for(int n = 0; n < num_hits; n++){
	if(hit_channel[n] < 8 || hit_channel[n]%2 !=0) skip = true;
      }
      if(skip) continue;
      
      // Make and fill vectors for each channel
      vector<double> hit_time[4];
      
      for(int n = 0; n < num_hits; n++){
	if(hit_channel[n] == 8)  hit_time[0].push_back(hit_time_ns[n]);
	if(hit_channel[n] == 10) hit_time[1].push_back(hit_time_ns[n]);
	if(hit_channel[n] == 12) hit_time[2].push_back(hit_time_ns[n]);
	if(hit_channel[n] == 14) hit_time[3].push_back(hit_time_ns[n]);
      }
      
      // Fill histograms with good events
      for(int j = 0; j < 4; j++){
	nAccumulations[j]++;
	nHitsTotal[j]+=hit_time[j].size();
	for(int k = 0; k < hit_time[j].size(); k++){
	  if(k > 0 && k%2 == 0) sepsTotal[j]+=(hit_time[j].at(k)-hit_time[j].at(k-2));
	  if(k == 1){
	    widthsTotal_1[j]+=(hit_time[j].at(k)-hit_time[j].at(k-1));}
	  else if(k%2 != 0){
	    widthsTotal_2[j]+=(hit_time[j].at(k)-hit_time[j].at(k-1));
	  }
	}
      }
    }

    for(int j = 0; j < 4; j++){
      nHits[j][file] = nHitsTotal[j]/(2*nAccumulations[j]);  // Both edges recorded so divide by 2
      widths_1[j][file] = widthsTotal_1[j]/(nAccumulations[j]);
      widths_2[j][file] = widthsTotal_2[j]/(nAccumulations[j]);
      separations[j][file] = sepsTotal[j]/nAccumulations[j];
    }
  }

  // Draw graphs
  TCanvas* cNHits = new TCanvas("cNHits");
  TMultiGraph* mg_nHits = new TMultiGraph();  
  TGraph* tg_nHits[4];
  for(int i = 0; i < 4; i++){
    tg_nHits[i] = new TGraph(nFiles,pulseSepsDouble,nHits[i]);
    tg_nHits[i]->SetMarkerStyle(20);
    tg_nHits[i]->SetMarkerColor(i+1);
    tg_nHits[i]->SetLineColor(i+1);
    mg_nHits->Add(tg_nHits[i]);
  }
  mg_nHits->SetTitle(";Pulse Separation (ns); No. hits per accumulation");
  mg_nHits->Draw("ALP");
  mg_nHits->GetXaxis()->SetLimits(0,200);
  mg_nHits->GetYaxis()->SetRangeUser(0.8,2.2);
  mg_nHits->Draw("ALP");

  TLegend* leg = new TLegend(0.682,0.186,0.946,0.513);
  leg->AddEntry(tg_nHits[0],"Channel 8","l");
  leg->AddEntry(tg_nHits[1],"Channel 10","l");
  leg->AddEntry(tg_nHits[2],"Channel 12","l");
  leg->AddEntry(tg_nHits[3],"Channel 14","l");
  leg->SetFillStyle(0);
  leg->SetBorderSize(0);
  leg->Draw();
  cNHits->SaveAs("Hits_per_accumulation.png");

  TCanvas* cWidths_1 = new TCanvas("cWidths_1");
  TMultiGraph* mg_widths_1 = new TMultiGraph();  
  TGraph* tg_widths_1[4];
  for(int i = 0; i < 4; i++){
    tg_widths_1[i] = new TGraph(nFiles,pulseSepsDouble,widths_1[i]);
    tg_widths_1[i]->SetMarkerStyle(20);
    tg_widths_1[i]->SetMarkerColor(i+1);
    tg_widths_1[i]->SetLineColor(i+1);
    mg_widths_1->Add(tg_widths_1[i]);
  }
  mg_widths_1->SetTitle(";Pulse Separation (ns); Pulse 1 - Mean ASDQ width (ns)");
  mg_widths_1->Draw("ALP");
  mg_widths_1->GetXaxis()->SetLimits(0,200);
  mg_widths_1->Draw("ALP");
  leg->Draw();
  cWidths_1->SaveAs("Pulse_1_Width.png");

  TCanvas* cWidths_2 = new TCanvas("cWidths_2");
  TMultiGraph* mg_widths_2 = new TMultiGraph();  
  TGraph* tg_widths_2[4];
  for(int i = 0; i < 4; i++){
    tg_widths_2[i] = new TGraph(nFiles,pulseSepsDouble,widths_2[i]);
    tg_widths_2[i]->SetMarkerStyle(20);
    tg_widths_2[i]->SetMarkerColor(i+1);
    tg_widths_2[i]->SetLineColor(i+1);
    mg_widths_2->Add(tg_widths_2[i]);
  }
  mg_widths_2->SetTitle(";Pulse Separation (ns); Pulse 2 - Mean ASDQ width (ns)");
  mg_widths_2->Draw("ALP");
  mg_widths_2->GetXaxis()->SetLimits(0,200);
  mg_widths_2->Draw("ALP");
  leg->Draw();
  cWidths_2->SaveAs("Pulse_2_Width.png");

  TCanvas* cSeparations = new TCanvas("cSeparations");
  TMultiGraph* mg_separations = new TMultiGraph();  
  TGraph* tg_separations[4];
  for(int i = 0; i < 4; i++){
    tg_separations[i] = new TGraph(nFiles,pulseSepsDouble,separations[i]);
    tg_separations[i]->SetMarkerStyle(20);
    tg_separations[i]->SetMarkerColor(i+1);
    tg_separations[i]->SetLineColor(i+1);
    mg_separations->Add(tg_separations[i]);
  }
  mg_separations->SetTitle(";Pulse Separation (ns); Mean hit separation (ns)");
  mg_separations->Draw("ALP");
  mg_separations->GetXaxis()->SetLimits(0,200);
  mg_separations->GetYaxis()->SetRangeUser(0,210);
  mg_separations->Draw("ALP");
  leg->Draw();
  cSeparations->SaveAs("Pulse_Separation.png");
 

  return;
}