// file to take current source scan files, analyse and plot them.

#include "../sls_detector_calibration/jungfrauCommonHeader.h"
#include "../sls_detector_calibration/jungfrauCommonFunctions.h"

#include "../sls_detector_calibration/jungfrauFile.C"
#include "../sls_detector_calibration/jungfrauPedestal.C"
#include "../sls_detector_calibration/jungfrauPixelMask.C"

#include "TGraph.h"
#include "TGraphErrors.h"
#include "TF1.h"
#include "TFile.h"
#include "TPaveStats.h"
#include "TLegend.h"
#include "TPaveText.h"

#include <algorithm>
#include <sstream>

double lowestFullySwitchedPoint(const vector<double> &higher_filter, const vector<double> &lower_filter) {

  // find the lowest value in higher_filter that does not appear in lower_filter
  double lowest_fully_switched_val = *max_element(higher_filter.begin(),higher_filter.end());

  for(vector<double>::const_iterator it = higher_filter.begin(); it != higher_filter.end(); ++it) {
    if (find(lower_filter.begin(), lower_filter.end(), *it) == lower_filter.end()) {
      if (*it < lowest_fully_switched_val) {
	lowest_fully_switched_val = *it;
      }
    }
  }

  return lowest_fully_switched_val;
}

double highestFullySwitchedPoint(const vector<double> &lower_filter, const vector<double> &higher_filter) {

  // find the highest value in lower_filter that does not appear in higher_filter
  double highest_fully_switched_val = *min_element(lower_filter.begin(),lower_filter.end());

  for(vector<double>::const_iterator it = lower_filter.begin(); it != lower_filter.end(); ++it) {
    if (find(higher_filter.begin(), higher_filter.end(), *it) == higher_filter.end()) {
      if (*it > highest_fully_switched_val) {
	highest_fully_switched_val = *it;
      }
    }
  }

  return highest_fully_switched_val;
}

int main(int argc, char* argv[]) {

  jungfrauStyle();
  gROOT->SetBatch(1);
  gStyle->SetOptFit(11);

  if (argc != 4) {
    cout << "Correct usage:" << endl;
    cout << "arg 1: specify module number" << endl;
    cout << "arg 2: specify data location" << endl;
    cout << "arg 3: specify data file" << endl;
    cout << " " << endl;
    exit(1);
  }

  string module_str = argv[1];
  string data_loc = argv[2];
  string data_file = argv[3];

  vector<string> scan_v1;
  scan_v1.push_back("002");
  scan_v1.push_back("003");

  vector<string> scan_v2;
  scan_v2.push_back("032");

  vector<string> scan_v3;
  scan_v3.push_back("008");

  vector<string> scan_v4;
  scan_v4.push_back("040");
  scan_v4.push_back("044");

  vector<string> scan_v5;
  scan_v5.push_back("006");
  scan_v5.push_back("022");
  scan_v5.push_back("055");
  scan_v5.push_back("065");
  scan_v5.push_back("066");
  scan_v5.push_back("068");
  scan_v5.push_back("069");
  scan_v5.push_back("088");
  scan_v5.push_back("094");

  vector<string> scan_v6;
  scan_v6.push_back("011");
  scan_v6.push_back("021");
  scan_v6.push_back("023");
  scan_v6.push_back("029");
  scan_v6.push_back("035");
  scan_v6.push_back("039");
  scan_v6.push_back("043");
  scan_v6.push_back("045");
  scan_v6.push_back("046");
  scan_v6.push_back("048");
  scan_v6.push_back("049");
  scan_v6.push_back("050");
  scan_v6.push_back("051");
  scan_v6.push_back("053");
  scan_v6.push_back("054");
  scan_v6.push_back("057");
  scan_v6.push_back("058");
  scan_v6.push_back("059");
  scan_v6.push_back("060");
  scan_v6.push_back("061");
  scan_v6.push_back("062");
  scan_v6.push_back("063");
  scan_v6.push_back("064");
  scan_v6.push_back("067");
  scan_v6.push_back("070");
  scan_v6.push_back("071");
  scan_v6.push_back("072");
  scan_v6.push_back("073");
  scan_v6.push_back("074");
  scan_v6.push_back("075");
  scan_v6.push_back("076");
  scan_v6.push_back("079");
  scan_v6.push_back("080");
  scan_v6.push_back("086");
  scan_v6.push_back("089");
  scan_v6.push_back("090");
  scan_v6.push_back("091");
  scan_v6.push_back("092");
  scan_v6.push_back("093");
  scan_v6.push_back("095");
  scan_v6.push_back("097");
  scan_v6.push_back("098");
  scan_v6.push_back("099");
  scan_v6.push_back("100");
  scan_v6.push_back("102");
  scan_v6.push_back("103");
  scan_v6.push_back("104");
  scan_v6.push_back("106");
  scan_v6.push_back("107");
  scan_v6.push_back("108");
  scan_v6.push_back("109");
  scan_v6.push_back("110");
  scan_v6.push_back("111");
  scan_v6.push_back("112");
  scan_v6.push_back("113");
  scan_v6.push_back("114");
  scan_v6.push_back("115");
  scan_v6.push_back("116");
  scan_v6.push_back("117");
  scan_v6.push_back("118");
  scan_v6.push_back("119");
  scan_v6.push_back("120");
  scan_v6.push_back("121");
  scan_v6.push_back("122");
  scan_v6.push_back("123");
  scan_v6.push_back("124");
  scan_v6.push_back("125");
  scan_v6.push_back("126");
  scan_v6.push_back("129");
  scan_v6.push_back("130");
  scan_v6.push_back("131");
  scan_v6.push_back("132");
  scan_v6.push_back("133");
  scan_v6.push_back("134");
  scan_v6.push_back("135");
  scan_v6.push_back("200");
  scan_v6.push_back("201");
  scan_v6.push_back("202");
  scan_v6.push_back("203");
  scan_v6.push_back("204");
  scan_v6.push_back("205");
  scan_v6.push_back("206");
  scan_v6.push_back("208");
  scan_v6.push_back("209");
  scan_v6.push_back("210");
  scan_v6.push_back("212");
  scan_v6.push_back("214");
  scan_v6.push_back("215");
  scan_v6.push_back("216");
  scan_v6.push_back("217");
  scan_v6.push_back("218");
  scan_v6.push_back("219");
  scan_v6.push_back("221");
  scan_v6.push_back("222");
  scan_v6.push_back("223");
  scan_v6.push_back("224");
  scan_v6.push_back("226");
  scan_v6.push_back("227");
  scan_v6.push_back("229");
  scan_v6.push_back("232");
  scan_v6.push_back("233");
  scan_v6.push_back("234");
  scan_v6.push_back("235");
  scan_v6.push_back("236");

  jungfrauFile *thisfile = new jungfrauFile();

  jungfrauPixelMask *pixelMaskObject = new jungfrauPixelMask();
  bool pixel_mask [NCH];

  jungfrauPedestal *pedestalObject = new jungfrauPedestal();
  pedestalObject->pedestalSetNFrames(640);

  TH2F* pedestalsG0 = new TH2F("pedestalsG0","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* pedestalsG1 = new TH2F("pedestalsG1","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* pedestalsG2 = new TH2F("pedestalsG2","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH2F* pedeRMSG0 = new TH2F("pedeRMSG0","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  char savename[128];

  int createHistoFile = 0;
  int createPerStepHistos = 0;

  // open first file
  sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), data_file.c_str());
  thisfile->open((char*)savename, 0);

  // calculate pixel mask
  pixelMaskObject->initialisePixelMask(pixel_mask);
  if (module_str == "032") {
    pixelMaskObject->maskChip(2,pixel_mask);
    pixelMaskObject->maskChip(3,pixel_mask);
    pixelMaskObject->maskChip(4,pixel_mask);
  } else if (module_str == "002" || module_str == "003") {
    pixelMaskObject->maskChip(3, pixel_mask);
  } else if (module_str == "006") {
    pixelMaskObject->maskChip(6, pixel_mask);
    pixelMaskObject->maskSupercolumn(4,1, pixel_mask);
    pixelMaskObject->maskSupercolumn(4,2, pixel_mask);
  } else if (module_str == "029") {
    pixelMaskObject->maskChip(2, pixel_mask);
  } else if (module_str == "035") {
    pixelMaskObject->maskSupercolumn(2, 2, pixel_mask);
  } else if (module_str == "039") {
    pixelMaskObject->maskChip(7, pixel_mask);
  } else if (module_str == "040") {
    pixelMaskObject->maskSupercolumn(4,2, pixel_mask);
  } else if (module_str == "064") {
    pixelMaskObject->maskSupercolumn(3,4,pixel_mask);
  } else if (module_str == "065") {
    pixelMaskObject->maskChip(5,pixel_mask);
  } else if (module_str == "067") {
    pixelMaskObject->maskChip(1,pixel_mask);
    pixelMaskObject->maskChip(2,pixel_mask);
    pixelMaskObject->maskChip(3,pixel_mask);
    pixelMaskObject->maskChip(4,pixel_mask);
  } else if (module_str == "086") {
    pixelMaskObject->maskChip(8,pixel_mask);
  } else if (module_str == "094") {
    pixelMaskObject->maskChip(6,pixel_mask);
  } else if (module_str == "121") {
    pixelMaskObject->maskChip(1,pixel_mask);
  } else if (module_str == "124") {
    pixelMaskObject->maskChip(1,pixel_mask);
  } else if (module_str == "125") {
    pixelMaskObject->maskChip(7,pixel_mask);
  } else if (module_str == "209") {
    pixelMaskObject->maskChip(8,pixel_mask);
  } else if (module_str == "223") {
    pixelMaskObject->maskChip(2,pixel_mask);
  } else if (module_str == "233") {
    pixelMaskObject->maskChip(7,pixel_mask);
  }

  for (int i = 0; i < 640; i++) {
    thisfile->readNextFrame();
    pixelMaskObject->maskIfGainNot(0, thisfile->getFrameDataHandle(), pixel_mask);
  }
  cout << "after G0, n masked pixels is " << pixelMaskObject->getNMasked(pixel_mask) << endl;

  for (int i = 0; i < 640; i++) {
    thisfile->readNextFrame();
    pixelMaskObject->maskIfGainNot(1, thisfile->getFrameDataHandle(), pixel_mask);
  }
  cout << "after G1, n masked pixels is " << pixelMaskObject->getNMasked(pixel_mask) << endl;

  for (int i = 0; i < 640; i++) {
    thisfile->readNextFrame();
    pixelMaskObject->maskIfGainNot(3, thisfile->getFrameDataHandle(), pixel_mask);
  }
  cout << "after G2, n masked pixels is " << pixelMaskObject->getNMasked(pixel_mask) << endl;

  thisfile->rewind();

  sprintf(savename,"plots/M%s/CurrentSource/pixelmask_M%s.png", module_str.c_str(), module_str.c_str());
  pixelMaskObject->plotPixelMask(pixel_mask,savename);
  cout << "after chip mask, n masked pixels is " << pixelMaskObject->getNMasked(pixel_mask) << endl;

  // calculate pedestals
  for (int j = 0; j < 640; j++) {
    thisfile->readNextFrame();
    pedestalObject->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
  }
  for (int i = 0; i < NCH; i++) {
    if (pixel_mask[i] == true) {
      pedestalsG0->Fill(i%NC,i/NC,pedestalObject->pedestalOfChannel(i));
      pedeRMSG0->Fill(i%NC,i/NC,pedestalObject->rmsOfChannel(i));
    }
  }
  pedestalObject->pedestalClear();

  for (int j = 0; j < 640; j++) {
    thisfile->readNextFrame();
    pedestalObject->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
  }
  for (int i = 0; i < NCH; i++) {
    if (pixel_mask[i] == true) {
      pedestalsG1->Fill(i%NC,i/NC,pedestalObject->pedestalOfChannel(i));
    }
  }
  pedestalObject->pedestalClear();

  for (int j = 0; j < 640; j++) {
    thisfile->readNextFrame();
    pedestalObject->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
  }
  for (int i = 0; i < NCH; i++) {
    if (pixel_mask[i] == true) {
      pedestalsG2->Fill(i%NC,i/NC,pedestalObject->pedestalOfChannel(i));
    }
  }
  pedestalObject->pedestalClear();

  thisfile->close();

  TCanvas *mapcanvas = new TCanvas("mapcanvas","",150,10,800,400);
  mapcanvas->SetLeftMargin(0.1);
  mapcanvas->SetRightMargin(0.13);
  mapcanvas->SetTopMargin(0.08);
  mapcanvas->SetBottomMargin(0.15);

  pedestalsG0->GetXaxis()->SetTitle("Column");
  pedestalsG0->GetYaxis()->SetTitle("Row");
  pedestalsG0->GetYaxis()->SetTitleOffset(0.7);
  pedestalsG0->Draw("colz");
  sprintf(savename,"plots/M%s/CurrentSource/pedeG0_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  pedestalsG1->GetXaxis()->SetTitle("Column");
  pedestalsG1->GetYaxis()->SetTitle("Row");
  pedestalsG1->GetYaxis()->SetTitleOffset(0.7);
  pedestalsG1->Draw("colz");
  sprintf(savename,"plots/M%s/CurrentSource/pedeG1_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  pedestalsG2->GetXaxis()->SetTitle("Column");
  pedestalsG2->GetYaxis()->SetTitle("Row");
  pedestalsG2->GetYaxis()->SetTitleOffset(0.7);
  pedestalsG2->Draw("colz");
  sprintf(savename,"plots/M%s/CurrentSource/pedeG2_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  pedeRMSG0->GetXaxis()->SetTitle("Column");
  pedeRMSG0->GetYaxis()->SetTitle("Row");
  pedeRMSG0->GetYaxis()->SetTitleOffset(0.7);
  if (module_str == "006") {
    pedeRMSG0->GetZaxis()->SetRangeUser(0,50);
  } else {
    pedeRMSG0->GetZaxis()->SetRangeUser(0,25);
  }
  pedeRMSG0->Draw("colz");
  sprintf(savename,"plots/M%s/CurrentSource/pedeRMSG0_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  TH2F *adcmap_avg_g0 [97];
  TH2F *adcmap_avg_g1 [97];
  TH2F *adcmap_avg_g2 [97];
  TH2F *adcermap_avg_g0 [97];
  TH2F *adcermap_avg_g1 [97];
  TH2F *adcermap_avg_g2 [97];

  TCanvas *c1 = new TCanvas("c1","");

  // creating the histograms
  if (createHistoFile) {

    for(int i = 0; i < 97; i++) {
      ostringstream histogramNameStreamg0;
      histogramNameStreamg0 << "adcmap_avg_g0_" << i;
      adcmap_avg_g0[i] = new TH2F(histogramNameStreamg0.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
      ostringstream histogramNameStreamg1;
      histogramNameStreamg1 << "adcmap_avg_g1_" << i;
      adcmap_avg_g1[i] = new TH2F(histogramNameStreamg1.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
      ostringstream histogramNameStreamg2;
      histogramNameStreamg2 << "adcmap_avg_g2_" << i;
      adcmap_avg_g2[i] = new TH2F(histogramNameStreamg2.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
      ostringstream histogramNameStreamg5;
      histogramNameStreamg5 << "adcermap_avg_g0_" << i;
      adcermap_avg_g0[i] = new TH2F(histogramNameStreamg5.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
      ostringstream histogramNameStreamg3;
      histogramNameStreamg3 << "adcermap_avg_g1_" << i;
      adcermap_avg_g1[i] = new TH2F(histogramNameStreamg3.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
      ostringstream histogramNameStreamg4;
      histogramNameStreamg4 << "adcermap_avg_g2_" << i;
      adcermap_avg_g2[i] = new TH2F(histogramNameStreamg4.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
    }

    TH2F *gainmap_all = new TH2F("gainmap_all","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
    TH2F *adcmap_all = new TH2F("adcmap_all","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
    TH2F *gainmap_sel = new TH2F("gainmap_sel","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
    TH2F *adcmap_sel = new TH2F("adcmap_sel","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

    TH1F *gain_avg = new TH1F("gain_avg","",100,-1,4);
    TH2F *gainmap_avg = new TH2F("gainmap_avg","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
    TH1F *adc_avg_g0 = new TH1F("adc_avg_g0","",100,0,17000);
    TH1F *adc_avg_g1 = new TH1F("adc_avg_g1","",100,0,17000);
    TH1F *adc_avg_g2 = new TH1F("adc_avg_g2","",100,0,17000);

    static TH1I *adc_histos_g0 [NCH];
    static TH1I *adc_histos_g1 [NCH];
    static TH1I *adc_histos_g2 [NCH];
    static TH1I *gain_histos [NCH];

    for(int i = 0; i < NCH; i++) {
      ostringstream histogramNameStreamg0;
      histogramNameStreamg0 << "adc_histos_g0_" << i;
      adc_histos_g0[i] = new TH1I(histogramNameStreamg0.str().c_str(),"",100,0,17000);
      ostringstream histogramNameStreamg1;
      histogramNameStreamg1 << "adc_histos_g1_" << i;
      adc_histos_g1[i] = new TH1I(histogramNameStreamg1.str().c_str(),"",100,0,17000);
      ostringstream histogramNameStreamg2;
      histogramNameStreamg2 << "adc_histos_g2_" << i;
      adc_histos_g2[i] = new TH1I(histogramNameStreamg2.str().c_str(),"",100,0,17000);
      ostringstream histogramNameStream2;
      histogramNameStream2 << "gain_histos_" << i;
      gain_histos[i] = new TH1I(histogramNameStream2.str().c_str(),"",4,-0.5,3.5);
    }

    int j = 0;
    int nfiles = 0;
    if (find(scan_v2.begin(), scan_v2.end(), module_str) != scan_v2.end()) {
      nfiles = 2;
    } else if (find(scan_v3.begin(), scan_v3.end(), module_str) != scan_v3.end() || find(scan_v4.begin(), scan_v4.end(), module_str) != scan_v4.end()) {
      nfiles = 3;
    } else if (find(scan_v5.begin(), scan_v5.end(), module_str) != scan_v5.end()) {
      nfiles = 4;
    } else if (find(scan_v6.begin(), scan_v6.end(), module_str) != scan_v6.end()) {
      nfiles = 7;
    } else if (find(scan_v1.begin(), scan_v1.end(), module_str) != scan_v1.end()) {
      nfiles = 6;
    }

    for (int filei = 0; filei < nfiles; filei++) {

      sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), data_file.c_str());
      thisfile->open((char*)savename, filei);

      if (filei == 0) {
	for (int k = 0; k < (640*3); k++) {
	  thisfile->readNextFrame();
	}
      }

      while (thisfile->readNextFrame()) {
	j++;

	uint16_t* imagedptr = thisfile->getFrameDataHandle();
	for (int i = 0; i < NCH; i++) {

	  if ((j-1) < 10 || (j > 8075 && j < 8085)) {
	    if (pixel_mask[i] == true) {
	      uint16_t adc = imagedptr[i]&0x3fff;
	      uint16_t gain = (imagedptr[i]&0xc000) >> 14;
	      adcmap_all->Fill(i%NC,i/NC,adc);
	      gainmap_all->Fill(i%NC,i/NC,gain);
	    }
	  }

	  if (((i/NC <= 255) && (i%64 == (j-1)%64)) ||
	      ((i/NC >= 256) &&((-1*(i-524287))%64 == (j-1)%64))) {

	    if (pixel_mask[i] == true) {
	      uint16_t adc = imagedptr[i]&0x3fff;
	      uint16_t gain = (imagedptr[i]&0xc000) >> 14;

	      if (adc > 0) {
		gain_histos[i]->Fill(gain);
		if (gain == 0) {
		  adc_histos_g0[i]->Fill(adc);
		} else if (gain == 1) {
		  adc_histos_g1[i]->Fill(adc);
		} else if (gain == 3) {
		  adc_histos_g2[i]->Fill(adc);
		}
	      }

	      if ((j-1) < 10 || (j > 8075 && j < 8085)) {
		adcmap_sel->Fill(i%NC,i/NC,adc);
		gainmap_sel->Fill(i%NC,i/NC,gain);
	      }

	    }
	  }
	}
	if (createPerStepHistos && ((j-1) < 10 || (j > 8075 && j < 8085))) {
	  mapcanvas->cd();
	  adcmap_sel->GetXaxis()->SetTitle("Column");
	  adcmap_sel->GetYaxis()->SetTitle("Row");
	  adcmap_sel->GetYaxis()->SetTitleOffset(0.7);
	  adcmap_sel->Draw("colz");
	  sprintf(savename,"plots/M%s/CurrentSource/adcmap_%i_sel_M%s.png", module_str.c_str(), j-1, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
	  adcmap_all->GetXaxis()->SetTitle("Column");
	  adcmap_all->GetYaxis()->SetTitle("Row");
	  adcmap_all->GetYaxis()->SetTitleOffset(0.7);
	  adcmap_all->Draw("colz");
	  sprintf(savename,"plots/M%s/CurrentSource/adcmap_%i_all_M%s.png", module_str.c_str(), j-1, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
      
	  gainmap_sel->GetXaxis()->SetTitle("Column");
	  gainmap_sel->GetYaxis()->SetTitle("Row");
	  gainmap_sel->GetYaxis()->SetTitleOffset(0.7);
	  gainmap_sel->Draw("colz");
	  sprintf(savename,"plots/M%s/CurrentSource/gainmap_%i_sel_M%s.png", module_str.c_str(), j-1, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
	  gainmap_all->GetXaxis()->SetTitle("Column");
	  gainmap_all->GetYaxis()->SetTitle("Row");
	  gainmap_all->GetYaxis()->SetTitleOffset(0.7);
	  gainmap_all->Draw("colz");
	  sprintf(savename,"plots/M%s/CurrentSource/gainmap_%i_all_M%s.png", module_str.c_str(), j-1, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
      
	  adcmap_sel->Reset();
	  adcmap_all->Reset();
	  gainmap_sel->Reset();
	  gainmap_all->Reset();
	}

	// catch the last frame (bad ctrl-c exit)
	// new receiver doesn't have this problem
	int last_frame = 0;
	if (find(scan_v2.begin(), scan_v2.end(), module_str) != scan_v2.end()) {
	  last_frame = 19199-1920;
	} else if (find(scan_v3.begin(), scan_v3.end(), module_str) != scan_v3.end()) {
	  last_frame = 24319-1920;
	} else if (find(scan_v4.begin(), scan_v4.end(), module_str) != scan_v4.end()) {
	  last_frame = 21759-1920;
	} else if (find(scan_v1.begin(), scan_v1.end(), module_str) != scan_v1.end()) {
	  last_frame = 59519-1920;
	}

	if (j%640 == 0 || j == last_frame) {
	  if (j == last_frame) {
	    j = last_frame+1;
	  }
	
	  for (int i = 0; i < NCH; i++) {
	    if (pixel_mask[i] == true) {
	      
	      gainmap_avg->Fill(i%NC,i/NC,gain_histos[i]->GetMean());
	      adcmap_avg_g0[j/640-1]->Fill(i%NC,i/NC,adc_histos_g0[i]->GetMean());
	      adcermap_avg_g0[j/640-1]->Fill(i%NC,i/NC,adc_histos_g0[i]->GetMeanError());
	      adcmap_avg_g1[j/640-1]->Fill(i%NC,i/NC,adc_histos_g1[i]->GetMean());
	      adcermap_avg_g1[j/640-1]->Fill(i%NC,i/NC,adc_histos_g1[i]->GetMeanError());
	      adcmap_avg_g2[j/640-1]->Fill(i%NC,i/NC,adc_histos_g2[i]->GetMean());
	      adcermap_avg_g2[j/640-1]->Fill(i%NC,i/NC,adc_histos_g2[i]->GetMeanError());
	    
	      if (gain_histos[i]->GetEntries() > 0) {
		gain_avg->Fill(gain_histos[i]->GetMean());
	      }
	      if (adc_histos_g0[i]->GetEntries() > 0) {
		adc_avg_g0->Fill(adc_histos_g0[i]->GetMean());
	      }
	      if (adc_histos_g1[i]->GetEntries() > 0) {
		adc_avg_g1->Fill(adc_histos_g1[i]->GetMean());
	      }
	      if (adc_histos_g2[i]->GetEntries() > 0) {
		adc_avg_g2->Fill(adc_histos_g2[i]->GetMean());
	      }

	      gain_histos[i]->Reset();
	      adc_histos_g0[i]->Reset();
	      adc_histos_g1[i]->Reset();
	      adc_histos_g2[i]->Reset();
	    }
	  }

	  if (createPerStepHistos == 1) {
	    c1->cd();
	    gain_avg->GetXaxis()->SetTitle("Average gain");
	    gain_avg->GetXaxis()->SetTitleOffset(1.1);
	    gain_avg->GetYaxis()->SetTitleOffset(1.5);
	    gain_avg->Draw();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/gain_avg_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    gainmap_avg->GetXaxis()->SetTitle("Column");
	    gainmap_avg->GetYaxis()->SetTitle("Row");
	    gainmap_avg->GetYaxis()->SetTitleOffset(0.7);
	    gainmap_avg->Draw("colz");
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/gainmap_avg_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));

	    c1->cd();
	    adc_avg_g0->GetXaxis()->SetTitle("Average G0 ADC");
	    adc_avg_g0->GetXaxis()->SetTitleOffset(1.1);
	    adc_avg_g0->GetYaxis()->SetTitleOffset(1.5);
	    adc_avg_g0->Draw();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adc_avg_g0_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    adcmap_avg_g0[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcmap_avg_g0[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcmap_avg_g0[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcmap_avg_g0[j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcmap_avg_g0_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));
	    adcermap_avg_g0[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcermap_avg_g0[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcermap_avg_g0[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcermap_avg_g0[j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcermap_avg_g0_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));

	    c1->cd();
	    adc_avg_g1->GetXaxis()->SetTitle("Average G1 ADC");
	    adc_avg_g1->GetXaxis()->SetTitleOffset(1.1);
	    adc_avg_g1->GetYaxis()->SetTitleOffset(1.5);
	    adc_avg_g1->Draw();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adc_avg_g1_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    adcmap_avg_g1[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcmap_avg_g1[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcmap_avg_g1[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcmap_avg_g1[j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcmap_avg_g1_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));
	    adcermap_avg_g1[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcermap_avg_g1[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcermap_avg_g1[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcermap_avg_g1[j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcermap_avg_g1_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));

	    c1->cd();
	    adc_avg_g2->GetXaxis()->SetTitle("Average G2 ADC");
	    adc_avg_g2->GetXaxis()->SetTitleOffset(1.1);
	    adc_avg_g2->GetYaxis()->SetTitleOffset(1.5);
	    adc_avg_g2->Draw();
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adc_avg_g2_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    adcmap_avg_g2[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcmap_avg_g2[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcmap_avg_g2[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcmap_avg_g2[j/640-1]->Draw("colz");
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcmap_avg_g2_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));
	    adcermap_avg_g2[j/640-1]->GetXaxis()->SetTitle("Column");
	    adcermap_avg_g2[j/640-1]->GetYaxis()->SetTitle("Row");
	    adcermap_avg_g2[j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcermap_avg_g2[j/640-1]->Draw("colz");
	    sprintf(savename,"plots/M%s/CurrentSource/perStep/adcermap_avg_g2_%i_M%s.png", module_str.c_str(), j/640, module_str.c_str());
	    mapcanvas->SaveAs((const char *)(savename));
	  }

	  gain_avg->Reset();
	  gainmap_avg->Reset();
	  adc_avg_g0->Reset();
	  adc_avg_g1->Reset();
	  adc_avg_g2->Reset();
	}
      } // end of while

      thisfile->close();

    } // end of files

    for (int i = 0; i < NCH; i++) {
      delete gain_histos[i];
      delete adc_histos_g0[i];
      delete adc_histos_g1[i];
      delete adc_histos_g2[i];
    }
 
    // save histograms
    sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/CS_histos_M%s.root", module_str.c_str(), module_str.c_str());
    TFile* saved_file = new TFile((const char *)(savename),"RECREATE");

    for (int i = 0; i < 97; i++) {
      adcmap_avg_g0[i]->Write();
      adcmap_avg_g1[i]->Write();
      adcmap_avg_g2[i]->Write();
      adcermap_avg_g0[i]->Write();
      adcermap_avg_g1[i]->Write();
      adcermap_avg_g2[i]->Write();
    }
    saved_file->Close();
  } else {
    // load histos
    cout << "LOADING HISTOS" << endl;
    sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/CS_histos_M%s.root", module_str.c_str(), module_str.c_str());
    TFile* saved_file = new TFile((const char *)(savename),"READ");
    
    for (int i = 0; i < 97; i++) {
      sprintf(savename,"adcmap_avg_g0_%d", i);
      adcmap_avg_g0[i] = (TH2F*)saved_file->Get((const char *)(savename));
      sprintf(savename,"adcmap_avg_g1_%d", i);
      adcmap_avg_g1[i] = (TH2F*)saved_file->Get((const char *)(savename));
      sprintf(savename,"adcmap_avg_g2_%d", i);
      adcmap_avg_g2[i] = (TH2F*)saved_file->Get((const char *)(savename));

      sprintf(savename,"adcermap_avg_g0_%d", i);
      adcermap_avg_g0[i] = (TH2F*)saved_file->Get((const char *)(savename));
      sprintf(savename,"adcermap_avg_g1_%d", i);
      adcermap_avg_g1[i] = (TH2F*)saved_file->Get((const char *)(savename));
      sprintf(savename,"adcermap_avg_g2_%d", i);
      adcermap_avg_g2[i] = (TH2F*)saved_file->Get((const char *)(savename));
    }
  }
  
  TH2F *g0map = new TH2F("g0map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g0ermap = new TH2F("g0ermap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH2F *g1map = new TH2F("g1map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g1ermap = new TH2F("g1ermap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH2F *g2map = new TH2F("g2map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g2ermap = new TH2F("g2ermap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  
  TH2F *g0overg1map = new TH2F("g0overg1map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g0overg1ermap = new TH2F("g0overg1ermap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH2F *g1overg2map = new TH2F("g1overg2map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g1overg2ermap = new TH2F("g1overg2ermap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  
  TH1F *g0hist = new TH1F("g0hist","",100,10000,50000);
  TH1F *g0erhist = new TH1F("g0erhist","",100,0,200);

  TH1F *g1hist = 0;
  if (module_str == "032") {
    g1hist = new TH1F("g1hist","",100,-12000,-4000);
  } else {
    g1hist = new TH1F("g1hist","",100,-3000,0);
  }
  TH1F *g1erhist = new TH1F("g1erhist","",100,0,50);

  TH1F *g2hist = 0;
  if (module_str == "032") {
    g2hist = new TH1F("g2hist","",100,-1000,-200);
  } else {
    g2hist = new TH1F("g2hist","",100,-300,0);
  }
  TH1F *g2erhist = new TH1F("g2erhist","",100,0,10);

  TH1F *g0overg1hist = new TH1F("g0overg1hist","",100,-50,0);
  TH1F *g0overg1erhist = new TH1F("g0overg1erhist","",100,0,1);

  TH1F *g1overg2hist = new TH1F("g1overg2hist","",100,11,15);
  TH1F *g1overg2erhist = new TH1F("g1overg2erhist","",100,0,1);

  TH1F *g0overg1_isEdge = new TH1F("g0overg1_isEdge","",100,-50,0);
  TH1F *g0overg1_isInnerEdge = new TH1F("g0overg1_isInnerEdge","",100,-50,0);
  TH1F *g0overg1_isDouble = new TH1F("g0overg1_isDouble","",100,-50,0);
  TH1F *g0overg1_isNextToDouble = new TH1F("g0overg1_isNextToDouble","",100,-50,0);
  TH1F *g0overg1_isQuad = new TH1F("g0overg1_isQuad","",100,-50,0);
  TH1F *g0overg1_isBulk = new TH1F("g0overg1_isBulk","",100,-50,0);

  TH1F *g1overg2_isEdge = new TH1F("g1overg2_isEdge","",100,11,15);
  TH1F *g1overg2_isInnerEdge = new TH1F("g1overg2_isInnerEdge","",100,11,15);
  TH1F *g1overg2_isDouble = new TH1F("g1overg2_isDouble","",100,11,15);
  TH1F *g1overg2_isNextToDouble = new TH1F("g1overg2_isNextToDouble","",100,11,15);
  TH1F *g1overg2_isQuad = new TH1F("g1overg2_isQuad","",100,11,15);
  TH1F *g1overg2_isBulk = new TH1F("g1overg2_isBulk","",100,11,15);

  double filter[97];
  if (find(scan_v4.begin(), scan_v4.end(), module_str) != scan_v4.end()) {
    for (int i = 0; i < 5; i++) {
      filter[i] = 0.05+(i*0.05);
    }
    for (int i = 0; i < 9; i++) {
      filter[i+5] = 0.5+(i*0.25);
    }
    for (int i = 0; i < 17; i++) {
      filter[i+5+9] = 5.+(i*2.5);
    }
  } else if (find(scan_v5.begin(), scan_v5.end(), module_str) != scan_v5.end()) {
    for (int i = 0; i < 9; i++) {
      filter[i] = 0.05+(i*0.05);
    }
    for (int i = 0; i < 17; i++) {
      filter[i+9] = 0.5+(i*0.25);
    }
    for (int i = 0; i < 17; i++) {
      filter[i+9+17] = 5.+(i*2.5);
    }
    for (int i = 0; i < 8; i++) {
      filter[i+9+17+17] = 50.+(i*10.);
    }
  } else if (find(scan_v6.begin(), scan_v6.end(), module_str) != scan_v6.end()) {
    // loop 1
    for (int i = 0; i < 9; i++) {
      filter[i] = 0.05+(i*0.05);
    }
    // loop 2a
    for (int i = 0; i < 11; i++) {
      filter[i+9] = 0.5+(i*0.05);
    }
    // loop 2b
    for (int i = 0; i < 10; i++) {
      filter[i+9+11] = 1.10+(i*0.10);
    }
    // loop 2c
    for (int i = 0; i < 10; i++) {
      filter[i+9+11+10] = 2.25+(i*0.25);
    }
    // loop 3a
    for (int i = 0; i < 11; i++) {
      filter[i+9+11+10+10] = 5.+(i*0.5);
    }
    // loop 3b
    for (int i = 0; i < 10; i++) {
      filter[i+9+11+10+10+11] = 11.+(i*1.0);
    }
    // loop 3c
    for (int i = 0; i < 10; i++) {
      filter[i+9+11+10+10+11+10] = 22.5+(i*2.5);
    }
    // loop 4a
    for (int i = 0; i < 11; i++) {
      filter[i+9+11+10+10+11+10+10] = 50.+(i*5.);
    }
    // loop 4b
    for (int i = 0; i < 15; i++) {
      filter[i+9+11+10+10+11+10+10+11] = 110.+(i*10.);
    }
  } else if (find(scan_v1.begin(), scan_v1.end(), module_str) != scan_v1.end()) {
    for (int i = 0; i < 10; i++) {
      filter[i] = 0.2+(i*0.2);
    }
    for (int i = 0; i < 8; i++) {
      filter[i+10] = 3+(i*1);
    }
    for (int i = 0; i < 25; i++) {
      filter[i+10+8] = 12+(i*2);
    }
    for (int i = 0; i < 47; i++) {
      filter[i+10+8+25] = 80+(i*20);
    }
  } else if (find(scan_v3.begin(), scan_v3.end(), module_str) != scan_v3.end()) {
    for (int i = 0; i < 9; i++) {
      filter[i] = 0.05+(i*0.025);
    }
    for (int i = 0; i < 9; i++) {
      filter[i+9] = 0.5+(i*0.25);
    }
    for (int i = 0; i < 17; i++) {
      filter[i+9+9] = 5.+(i*2.5);
    }
  } else if (find(scan_v2.begin(), scan_v2.end(), module_str) != scan_v2.end()) {
    for (int i = 0; i < 9; i++) {
      filter[i] = 0.05+(i*0.025);
    }
    for (int i = 0; i < 9; i++) {
      filter[i+9] = 0.5+(i*0.25);
    }
    for (int i = 0; i < 9; i++) {
      filter[i+9+9] = 5.+(i*2.5);
    }
  }

  mapcanvas->cd();
  mapcanvas->SetLeftMargin(0.13);
  mapcanvas->SetRightMargin(0.05);
  
  for (int i = 0; i < NCH; i++) {

    if (pixel_mask[i] == true) {

      vector<double> r0_adc;
      vector<double> r0_filter;
      vector<double> r0_adcerr;
      vector<double> r0_ferr;

      vector<double> r1_adc;
      vector<double> r1_filter;
      vector<double> r1_adcerr;
      vector<double> r1_ferr;

      vector<double> r2_adc;
      vector<double> r2_filter;
      vector<double> r2_adcerr;
      vector<double> r2_ferr;

      // filter out points at zero and points with 0 error (mean taken from one entry in hist)
      int m_max = 0;
      if (find(scan_v2.begin(), scan_v2.end(), module_str) != scan_v2.end()) {
	m_max = 27;
      } else if (find(scan_v4.begin(), scan_v4.end(), module_str) != scan_v4.end()) {
	m_max = 31;
      } else if (find(scan_v3.begin(), scan_v3.end(), module_str) != scan_v3.end()) {
	m_max = 35;
      } else if (find(scan_v5.begin(), scan_v5.end(), module_str) != scan_v5.end()) {
	m_max = 51;
      } else if (find(scan_v6.begin(), scan_v6.end(), module_str) != scan_v6.end()) {
	m_max = 97;
      } else if (find(scan_v1.begin(), scan_v1.end(), module_str) != scan_v1.end()) {
	m_max = 90;
      }

      for (int m = 0; m < m_max; m++) {

	if (adcmap_avg_g0[m]->GetBinContent((i%NC)+1,(i/NC)+1) != 0 && adcermap_avg_g0[m]->GetBinContent((i%NC)+1,(i/NC)+1) > 0) {
	  r0_adc.push_back(adcmap_avg_g0[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r0_filter.push_back(filter[m]);
	  r0_adcerr.push_back(adcermap_avg_g0[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r0_ferr.push_back(0.);
	}
	if (adcmap_avg_g1[m]->GetBinContent((i%NC)+1,(i/NC)+1) != 0 && adcermap_avg_g1[m]->GetBinContent((i%NC)+1,(i/NC)+1) > 0) {
	  r1_adc.push_back(adcmap_avg_g1[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r1_filter.push_back(filter[m]);
	  r1_adcerr.push_back(adcermap_avg_g1[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r1_ferr.push_back(0.);
	}
	if (adcmap_avg_g2[m]->GetBinContent((i%NC)+1,(i/NC)+1) != 0 && adcermap_avg_g2[m]->GetBinContent((i%NC)+1,(i/NC)+1) > 0) {
	  r2_adc.push_back(adcmap_avg_g2[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r2_filter.push_back(filter[m]);
	  r2_adcerr.push_back(adcermap_avg_g2[m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r2_ferr.push_back(0.);
	}
      }

      TGraphErrors *grap_g0 = 0;
      TGraphErrors *grap_g1 = 0;
      TGraphErrors *grap_g2 = 0;

      TF1 *fit_g0 = 0;
      TF1 *fit_g1 = 0;
      TF1 *fit_g2 = 0;

      double rangemin_g0;
      double rangemax_g0;
      double rangemin_g1;
      double rangemax_g1;
      double rangemin_g2;
      double rangemax_g2;

      if (r0_adc.size() > 1) {

	grap_g0 = new TGraphErrors(r0_adc.size(),&(r0_filter[0]),&(r0_adc[0]),&(r0_ferr[0]),&(r0_adcerr[0]));

	if (module_str == "003") {
	  rangemin_g0 = 2.0;
	} else {
	  rangemin_g0 = 0.15;
	}
	rangemax_g0 = highestFullySwitchedPoint(r0_filter, r1_filter);
	fit_g0 = new TF1("fit_g0","[0]+[1]*x",rangemin_g0, rangemax_g0);
	fit_g0->SetParameter(0, 3000.);
	fit_g0->SetParameter(1, 30000.);
	fit_g0->SetLineColor(kBlue);
	fit_g0->SetParName(0,"G0 const");
	fit_g0->SetParName(1,"G0 grad");
	grap_g0->Fit(fit_g0,"QR+","");

	g0hist->Fill(fit_g0->GetParameter(1));
	g0map->Fill(i%NC,i/NC,fit_g0->GetParameter(1));
	g0erhist->Fill(fit_g0->GetParError(1));
	g0ermap->Fill(i%NC,i/NC,fit_g0->GetParError(1));

	if ((i >= 58000 && i < 58000+10) || // bulk
	    (i >= 10 && i < 10+10) || // edge
	    (i >= 1024+10 && i < 1024+10+10) || // inner edge
	    (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double
	    (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double
	    (i == (255*1024)+255) // quad
	    ) {
	  
	  string pixel_type = "x";
	  if (i >= 58000 && i < 58000+10) {
	    pixel_type = "b";
	  } else if (i >= 10 && i < 10+10) {
	    pixel_type = "e";
	  } else if (i >= 1024+10 && i < 1024+10+10) {
	    pixel_type = "ie";
	  } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) {
	    pixel_type = "d";
	  } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) {
	    pixel_type = "ntd";
	  } else if (i == (255*1024)+255) {
	    pixel_type = "q";
	  }
	  
	  grap_g0->SetMarkerStyle(20);
	  grap_g0->SetMarkerColor(kBlue);
	  grap_g0->SetLineColor(kBlue);
	  
	  TF1 *extended_g0 = new TF1("extended_g0","[0]+[1]*x",0.009,1.1E3);
	  extended_g0->SetParameters(fit_g0->GetParameter(0),fit_g0->GetParameter(1));
	  extended_g0->SetLineColor(kBlue);
	  extended_g0->SetLineStyle(2);
	  
	  grap_g0->SetMinimum(0);
	  grap_g0->SetMaximum(16000);
	  grap_g0->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g0->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g0->GetYaxis()->SetTitleOffset(0.9);
	  grap_g0->Draw("AP");
	  fit_g0->Draw("same");
	  mapcanvas->Update();
	  TPaveStats *st0 = (TPaveStats*)grap_g0->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.71);
	  st0->SetY2NDC(0.90);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kBlue);
	  extended_g0->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g0_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);
	  
	  vector<double> r0_adc_norm;
	  for (size_t j = 0; j < r0_adc.size(); j++) {
	    r0_adc_norm.push_back(r0_adc[j] - fit_g0->Eval(r0_filter[j]));
	  }

	  TGraphErrors *norm_g0 = new TGraphErrors(r0_adc.size(),&(r0_filter[0]),&(r0_adc_norm[0]),&(r0_ferr[0]),&(r0_adcerr[0]));
	  norm_g0->SetMarkerColor(kBlue);
	  norm_g0->SetLineColor(kBlue);
	  
	  TF1* flat_g0 = new TF1("flat_g0","0",rangemin_g0, rangemax_g0);
	  flat_g0->SetLineColor(kBlue);
	  
	  norm_g0->GetXaxis()->SetTitle("Integration time [#mus]");
	  norm_g0->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  norm_g0->GetYaxis()->SetTitleOffset(0.9);
	  norm_g0->SetMinimum(-100);
	  norm_g0->SetMaximum(100);
	  norm_g0->Draw("AP");
	  flat_g0->Draw("same");
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g0norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));

	  delete norm_g0;
	  delete extended_g0;
	  delete flat_g0;
	}
      }

      if (r1_adc.size() > 1) {

      	grap_g1 = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc[0]),&(r1_ferr[0]),&(r1_adcerr[0]));

      	rangemin_g1 = 2.;
      	if (module_str == "032") {
      	  rangemin_g1 = 0.75;
      	} else if (module_str == "003" || module_str == "008" || module_str == "040" || module_str == "044") {
	  rangemin_g1 = lowestFullySwitchedPoint(r1_filter, r0_filter);
      	}
	rangemax_g1 = highestFullySwitchedPoint(r1_filter, r2_filter);
      	fit_g1 = new TF1("fit_g1","[0]+[1]*x",rangemin_g1,rangemax_g1);
      	fit_g1->SetParameter(0, 10000.);
      	fit_g1->SetParameter(1, -0.1);
      	fit_g1->SetLineColor(kGreen+2);
      	fit_g1->SetParName(0,"G1 const");
      	fit_g1->SetParName(1,"G1 grad");
      	grap_g1->Fit(fit_g1,"QR","");

      	g1hist->Fill(fit_g1->GetParameter(1));
      	g1map->Fill(i%NC,i/NC,fit_g1->GetParameter(1));
      	g1erhist->Fill(fit_g1->GetParError(1));
      	g1ermap->Fill(i%NC,i/NC,fit_g1->GetParError(1));

	if ((i >= 58000 && i < 58000+10) || // bulk
	    (i >= 10 && i < 10+10) || // edge
	    (i >= 1024+10 && i < 1024+10+10) || // inner edge
	    (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double
	    (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double
	    (i == (255*1024)+255) // quad
	    ) {
	  
	  string pixel_type = "x";
	  if (i >= 58000 && i < 58000+10) {
	    pixel_type = "b";
	  } else if (i >= 10 && i < 10+10) {
	    pixel_type = "e";
	  } else if (i >= 1024+10 && i < 1024+10+10) {
	    pixel_type = "ie";
	  } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) {
	    pixel_type = "d";
	  } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) {
	    pixel_type = "ntd";
	  } else if (i == (255*1024)+255) {
	    pixel_type = "q";
	  }
	  
	  grap_g1->SetMarkerStyle(20);
	  grap_g1->SetMarkerColor(kGreen+2);
	  grap_g1->SetLineColor(kGreen+2);
	  
	  TF1 *extended_g1 = new TF1("extended_g1","[0]+[1]*x",0.009,1.1E3);
	  extended_g1->SetParameters(fit_g1->GetParameter(0),fit_g1->GetParameter(1));
	  extended_g1->SetLineColor(kGreen+2);
	  extended_g1->SetLineStyle(2);
	  
	  grap_g1->SetMinimum(0);
	  grap_g1->SetMaximum(16000);
	  grap_g1->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g1->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g1->GetYaxis()->SetTitleOffset(0.9);
	  grap_g1->Draw("AP");
	  fit_g1->Draw("same");
	  mapcanvas->Update();
	  TPaveStats *st0 = (TPaveStats*)grap_g1->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.17);
	  st0->SetY2NDC(0.36);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kGreen+2);
	  extended_g1->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g1_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);
	  
	  vector<double> r1_adc_norm;
	  for (size_t j = 0; j < r1_adc.size(); j++) {
	    r1_adc_norm.push_back(r1_adc[j] - fit_g1->Eval(r1_filter[j]));
	  }

	  TGraphErrors *norm_g1 = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc_norm[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	  norm_g1->SetMarkerColor(kGreen+2);
	  norm_g1->SetLineColor(kGreen+2);
	  
	  TF1* flat_g1 = new TF1("flat_g1","0",rangemin_g1, rangemax_g1);	  
	  flat_g1->SetLineColor(kGreen+2);

	  TF1* lin_g1_p02pc = new TF1("lin_g1_p02pc","[0]+[1]*x",rangemin_g1,rangemax_g1);
	  lin_g1_p02pc->SetParameter(0,fit_g1->GetParameter(0)/500.);
	  lin_g1_p02pc->SetParameter(1,fit_g1->GetParameter(1)/500.);
	  lin_g1_p02pc->SetLineColor(kOrange);

	  TF1* lin_g1_p05pc = new TF1("lin_g1_p05pc","[0]+[1]*x",rangemin_g1,rangemax_g1);
	  lin_g1_p05pc->SetParameter(0,fit_g1->GetParameter(0)/200.);
	  lin_g1_p05pc->SetParameter(1,fit_g1->GetParameter(1)/200.);
	  lin_g1_p05pc->SetLineColor(kOrange+1);

	  TF1* lin_g1_m02pc = new TF1("lin_g1_m02pc","[0]+[1]*x",rangemin_g1,rangemax_g1);
	  lin_g1_m02pc->SetParameter(0,fit_g1->GetParameter(0)/-500.);
	  lin_g1_m02pc->SetParameter(1,fit_g1->GetParameter(1)/-500.);
	  lin_g1_m02pc->SetLineColor(kOrange);

	  TF1* lin_g1_m05pc = new TF1("lin_g1_m05pc","[0]+[1]*x",rangemin_g1,rangemax_g1);
	  lin_g1_m05pc->SetParameter(0,fit_g1->GetParameter(0)/-200.);
	  lin_g1_m05pc->SetParameter(1,fit_g1->GetParameter(1)/-200.);
	  lin_g1_m05pc->SetLineColor(kOrange+1);

	  norm_g1->GetXaxis()->SetTitle("Integration time [#mus]");
	  norm_g1->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  norm_g1->GetYaxis()->SetTitleOffset(0.9);
	  norm_g1->GetXaxis()->SetRangeUser(r1_filter[0],rangemax_g1);
	  norm_g1->SetMinimum(1.5*lin_g1_m05pc->Eval(rangemin_g1));
	  norm_g1->SetMaximum(1.5*lin_g1_p05pc->Eval(rangemin_g1));
	  norm_g1->Draw("AP");
	  flat_g1->Draw("same");
	  lin_g1_p02pc->Draw("same");
	  lin_g1_p05pc->Draw("same");
	  lin_g1_m02pc->Draw("same");
	  lin_g1_m05pc->Draw("same");
	  norm_g1->Draw("P");
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g1norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));

	  delete norm_g1;
	  delete extended_g1;
	  delete flat_g1; 
	}
      }

      if (r2_adc.size() > 1) {
	
      	grap_g2 = new TGraphErrors(r2_adc.size(),&(r2_filter[0]),&(r2_adc[0]),&(r2_ferr[0]),&(r2_adcerr[0]));

      	rangemin_g2 = 0;
      	if (module_str == "032") {
      	  rangemin_g2 = 5;
      	} else {
	  rangemin_g2 = lowestFullySwitchedPoint(r2_filter, r1_filter);
      	}
      	rangemax_g2 = *max_element(r2_filter.begin(),r2_filter.end());
      	fit_g2 = new TF1("fit_g2","[0]+[1]*x",rangemin_g2, rangemax_g2);
      	fit_g2->SetParameter(0, 10000.);
      	fit_g2->SetParameter(1, -0.01);
      	fit_g2->SetLineColor(kRed);
      	fit_g2->SetParName(0,"G2 const");
      	fit_g2->SetParName(1,"G2 grad");
      	grap_g2->Fit(fit_g2,"QR+","");

      	g2hist->Fill(fit_g2->GetParameter(1));
      	g2map->Fill(i%NC,i/NC,fit_g2->GetParameter(1));
      	g2erhist->Fill(fit_g2->GetParError(1));
      	g2ermap->Fill(i%NC,i/NC,fit_g2->GetParError(1));

	if ((i >= 58000 && i < 58000+10) || // bulk
	    (i >= 10 && i < 10+10) || // edge
	    (i >= 1024+10 && i < 1024+10+10) || // inner edge
	    (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double
	    (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double
	    (i == (255*1024)+255) // quad
	    ) {
	  
	  string pixel_type = "x";
	  if (i >= 58000 && i < 58000+10) {
	    pixel_type = "b";
	  } else if (i >= 10 && i < 10+10) {
	    pixel_type = "e";
	  } else if (i >= 1024+10 && i < 1024+10+10) {
	    pixel_type = "ie";
	  } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) {
	    pixel_type = "d";
	  } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) {
	    pixel_type = "ntd";
	  } else if (i == (255*1024)+255) {
	    pixel_type = "q";
	  }
	  
	  grap_g2->SetMarkerStyle(20);
	  grap_g2->SetMarkerColor(kRed);
	  grap_g2->SetLineColor(kRed);
	  
	  TF1 *extended_g2 = new TF1("extended_g2","[0]+[1]*x",0.009,1.1E3);
	  extended_g2->SetParameters(fit_g2->GetParameter(0),fit_g2->GetParameter(1));
	  extended_g2->SetLineColor(kRed);
	  extended_g2->SetLineStyle(2);
	  
	  grap_g2->SetMinimum(0);
	  grap_g2->SetMaximum(16000);
	  grap_g2->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g2->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g2->GetYaxis()->SetTitleOffset(0.9);
	  grap_g2->Draw("AP");
	  fit_g2->Draw("same");
	  mapcanvas->Update();
	  TPaveStats *st0 = (TPaveStats*)grap_g2->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.17);
	  st0->SetY2NDC(0.36);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kRed);
	  extended_g2->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g2_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);
	  
	  vector<double> r2_adc_norm;
	  for (size_t j = 0; j < r2_adc.size(); j++) {
	    r2_adc_norm.push_back(r2_adc[j] - fit_g2->Eval(r2_filter[j]));
	  }

	  TGraphErrors *norm_g2 = new TGraphErrors(r2_adc.size(),&(r2_filter[0]),&(r2_adc_norm[0]),&(r2_ferr[0]),&(r2_adcerr[0]));
	  norm_g2->SetMarkerColor(kRed);
	  norm_g2->SetLineColor(kRed);
	  
	  TF1* flat_g2 = new TF1("flat_g2","0",rangemin_g2, rangemax_g2);	  
	  flat_g2->SetLineColor(kRed);

	  TF1* lin_g2_p02pc = new TF1("lin_g2_p02pc","[0]+[1]*x",rangemin_g2,rangemax_g2);
	  lin_g2_p02pc->SetParameter(0,fit_g2->GetParameter(0)/500.);
	  lin_g2_p02pc->SetParameter(1,fit_g2->GetParameter(1)/500.);
	  lin_g2_p02pc->SetLineColor(kOrange);

	  TF1* lin_g2_p05pc = new TF1("lin_g2_p05pc","[0]+[1]*x",rangemin_g2,rangemax_g2);
	  lin_g2_p05pc->SetParameter(0,fit_g2->GetParameter(0)/200.);
	  lin_g2_p05pc->SetParameter(1,fit_g2->GetParameter(1)/200.);
	  lin_g2_p05pc->SetLineColor(kOrange+1);

	  TF1* lin_g2_m02pc = new TF1("lin_g2_m02pc","[0]+[1]*x",rangemin_g2,rangemax_g2);
	  lin_g2_m02pc->SetParameter(0,fit_g2->GetParameter(0)/-500.);
	  lin_g2_m02pc->SetParameter(1,fit_g2->GetParameter(1)/-500.);
	  lin_g2_m02pc->SetLineColor(kOrange);

	  TF1* lin_g2_m05pc = new TF1("lin_g2_m05pc","[0]+[1]*x",rangemin_g2,rangemax_g2);
	  lin_g2_m05pc->SetParameter(0,fit_g2->GetParameter(0)/-200.);
	  lin_g2_m05pc->SetParameter(1,fit_g2->GetParameter(1)/-200.);
	  lin_g2_m05pc->SetLineColor(kOrange+1);

	  norm_g2->GetXaxis()->SetTitle("Integration time [#mus]");
	  norm_g2->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  norm_g2->GetYaxis()->SetTitleOffset(0.9);
	  norm_g2->GetXaxis()->SetRangeUser(rangemin_g2,rangemax_g2);
	  norm_g2->SetMinimum(1.5*lin_g2_m05pc->Eval(rangemin_g2));
	  norm_g2->SetMaximum(1.5*lin_g2_p05pc->Eval(rangemin_g2));
	  norm_g2->Draw("AP");
	  flat_g2->Draw("same");
	  lin_g2_p02pc->Draw("same");
	  lin_g2_p05pc->Draw("same");
	  lin_g2_m02pc->Draw("same");
	  lin_g2_m05pc->Draw("same");
	  norm_g2->Draw("P");
	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_g2norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
	  mapcanvas->SaveAs((const char *)(savename));

	  delete norm_g2;
	  delete extended_g2;
	  delete flat_g2;
	}
      }

      if (r0_adc.size() > 1 && r1_adc.size() > 1) {

      	g0overg1hist->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	g0overg1erhist->Fill(abs(fit_g0->GetParameter(1)/fit_g1->GetParameter(1))*sqrt(pow((fit_g0->GetParError(1)/fit_g0->GetParameter(1)),2) + pow((fit_g1->GetParError(1)/fit_g1->GetParameter(1)),2)));
      	g0overg1map->Fill(i%NC,i/NC,fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	g0overg1ermap->Fill(i%NC,i/NC,abs(fit_g0->GetParameter(1)/fit_g1->GetParameter(1))*sqrt(pow((fit_g0->GetParError(1)/fit_g0->GetParameter(1)),2) + pow((fit_g1->GetParError(1)/fit_g1->GetParameter(1)),2)));

      	if (isEdge(i)) {
      	  g0overg1_isEdge->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      	if (isInnerEdge(i)) {
      	  g0overg1_isInnerEdge->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      	if (isDouble(i)) {
      	  g0overg1_isDouble->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      	if (isNextToDouble(i)) {
      	  g0overg1_isNextToDouble->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      	if (isQuad(i)) {
      	  g0overg1_isQuad->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      	if (isBulk(i)) {
      	  g0overg1_isBulk->Fill(fit_g0->GetParameter(1) / fit_g1->GetParameter(1));
      	}
      }


      if (r1_adc.size() > 1 && r2_adc.size() > 1) {

      	g1overg2hist->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	g1overg2erhist->Fill(abs(fit_g1->GetParameter(1)/fit_g2->GetParameter(1))*sqrt(pow((fit_g1->GetParError(1)/fit_g1->GetParameter(1)),2) + pow((fit_g2->GetParError(1)/fit_g2->GetParameter(1)),2)));
      	g1overg2map->Fill(i%NC,i/NC,fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	g1overg2ermap->Fill(i%NC,i/NC,abs(fit_g1->GetParameter(1)/fit_g2->GetParameter(1))*sqrt(pow((fit_g1->GetParError(1)/fit_g1->GetParameter(1)),2) + pow((fit_g2->GetParError(1)/fit_g2->GetParameter(1)),2)));

      	if (isEdge(i)) {
      	  g1overg2_isEdge->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      	if (isInnerEdge(i)) {
      	  g1overg2_isInnerEdge->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      	if (isDouble(i)) {
      	  g1overg2_isDouble->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      	if (isNextToDouble(i)) {
      	  g1overg2_isNextToDouble->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      	if (isQuad(i)) {
      	  g1overg2_isQuad->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      	if (isBulk(i)) {
      	  g1overg2_isBulk->Fill(fit_g1->GetParameter(1) / fit_g2->GetParameter(1));
      	}
      }

      if ((r0_adc.size() > 1 && r1_adc.size() > 1) || (r1_adc.size() > 1 && r2_adc.size() > 1)) {
      	if ((i >= 58000 && i < 58000+10) || // bulk
      	    (i >= 10 && i < 10+10) || // edge
      	    (i >= 1024+10 && i < 1024+10+10) || // inner edge
      	    (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double
      	    (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double
      	    (i == (255*1024)+255) // quad
      	    ) {
	  
      	  string pixel_type = "x";
      	  if (i >= 58000 && i < 58000+10) {
      	    pixel_type = "b";
      	  } else if (i >= 10 && i < 10+10) {
      	    pixel_type = "e";
      	  } else if (i >= 1024+10 && i < 1024+10+10) {
      	    pixel_type = "ie";
      	  } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) {
      	    pixel_type = "d";
      	  } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) {
      	    pixel_type = "ntd";
      	  } else if (i == (255*1024)+255) {
      	    pixel_type = "q";
      	  }
	  
	  if (r0_adc.size() > 1) {
	    grap_g0->SetMarkerStyle(20);
	    grap_g0->SetMarkerColor(kBlue);
	    grap_g0->SetLineColor(kBlue);
	    grap_g0->GetFunction("fit_g0")->Delete();
	    grap_g0->FindObject("stats")->Delete();
	  }

      	  grap_g1->SetMarkerStyle(20);
      	  grap_g1->SetMarkerColor(kGreen+2);
      	  grap_g1->SetLineColor(kGreen+2);
	  grap_g1->GetFunction("fit_g1")->Delete();
	  grap_g1->FindObject("stats")->Delete();

	  if (r2_adc.size() > 1) {
	    grap_g2->SetMarkerStyle(20);
	    grap_g2->SetMarkerColor(kRed);
	    grap_g2->SetLineColor(kRed);
	    grap_g2->GetFunction("fit_g2")->Delete();
	    grap_g2->FindObject("stats")->Delete();
	  }

      	  if (find(scan_v6.begin(), scan_v6.end(), module_str) != scan_v6.end()) {
      	    grap_g1->GetXaxis()->SetLimits(0.009,5E2);
      	  } else if (find(scan_v1.begin(), scan_v1.end(), module_str) != scan_v1.end()) {
	    grap_g1->GetXaxis()->SetLimits(0.09,1.1E3);
	  } else {
      	    grap_g1->GetXaxis()->SetLimits(0.009,1.1E2);
      	  }
      	  grap_g1->SetMinimum(0);
      	  grap_g1->SetMaximum(16000);
      	  grap_g1->GetXaxis()->SetTitle("Integration time [#mus]");
      	  grap_g1->GetYaxis()->SetTitle("ADC [ADU]");
      	  grap_g1->GetYaxis()->SetTitleOffset(0.9);
      	  grap_g1->Draw("AP");
	  if (r2_adc.size() > 1) {
	    grap_g2->Draw("P");
	  }
	  if (r0_adc.size() > 1) {
	    grap_g0->Draw("P");
	  }
      	  mapcanvas->SetLogx();
      	  sprintf(savename,"plots/M%s/CurrentSource/pixel_%s_%d_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str());
      	  mapcanvas->SaveAs((const char *)(savename));
      	  mapcanvas->SetLogx(0);

      	}
      }

      delete fit_g0;
      delete fit_g1;
      delete fit_g2;
      delete grap_g0;
      delete grap_g1;
      delete grap_g2;
      
    }
  }

  mapcanvas->SetLeftMargin(0.1);
  mapcanvas->SetRightMargin(0.13);

  c1->cd();

  TPaveText *pave = new TPaveText(0.86,0.95,0.91,0.98,"blNDC");
  pave->SetBorderSize(0);
  pave->SetFillStyle(0);
  pave->SetTextSize(0.06);
  pave->SetTextAlign(32);

  g0hist->GetXaxis()->SetTitle("G0 gradient");
  g0hist->GetXaxis()->SetTitleOffset(1.1);
  g0hist->GetYaxis()->SetTitleOffset(1.5);
  g0hist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0hist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1hist->GetXaxis()->SetTitle("G1 gradient");
  g1hist->GetXaxis()->SetTitleOffset(1.1);
  g1hist->GetYaxis()->SetTitleOffset(1.5);
  g1hist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1hist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g2hist->GetXaxis()->SetTitle("G2 gradient");
  g2hist->GetXaxis()->SetTitleOffset(1.1);
  g2hist->GetYaxis()->SetTitleOffset(1.5);
  g2hist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g2hist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g0overg1hist->GetXaxis()->SetTitle("G0 / G1");
  g0overg1hist->GetXaxis()->SetTitleOffset(1.1);
  g0overg1hist->GetYaxis()->SetTitleOffset(1.5);
  g0overg1hist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1hist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  TPaveText *pave2 = new TPaveText(0.6,0.8,0.94,0.94,"blNDC");
  pave2->SetBorderSize(0);
  pave2->SetFillStyle(0);
  pave2->SetTextSize(0.04);
  pave2->SetTextAlign(32);
  g0overg1hist->Fit("gaus");
  g0overg1hist->Draw();
  c1->Update();
  TF1* g0overg1hist_gaus = g0overg1hist->GetFunction("gaus");
  if (g0overg1hist_gaus) {
    sprintf(savename,"Mean %0.4f #pm %0.4f", g0overg1hist_gaus->GetParameter(1), g0overg1hist_gaus->GetParError(1));
    pave2->AddText((const char *)(savename));
    sprintf(savename,"Sigma %0.4f #pm %0.4f", g0overg1hist_gaus->GetParameter(2), g0overg1hist_gaus->GetParError(2));
    pave2->AddText((const char *)(savename));
    pave2->Draw();
  }
  g0overg1hist->SetStats(kFALSE);
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1hist_fit_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g0overg1erhist->GetXaxis()->SetTitle("G0 / G1 uncert");
  g0overg1erhist->GetXaxis()->SetTitleOffset(1.1);
  g0overg1erhist->GetYaxis()->SetTitleOffset(1.5);
  g0overg1erhist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1erhist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1overg2hist->GetXaxis()->SetTitle("G1 / G2");
  g1overg2hist->GetXaxis()->SetTitleOffset(1.1);
  g1overg2hist->GetYaxis()->SetTitleOffset(1.5);
  g1overg2hist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2hist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1overg2hist->Fit("gaus");
  g1overg2hist->Draw();
  c1->Update();
  pave2->Clear();
  TF1* g1overg2hist_gaus = g1overg2hist->GetFunction("gaus");
  sprintf(savename,"Mean %0.4f #pm %0.4f", g1overg2hist_gaus->GetParameter(1), g1overg2hist_gaus->GetParError(1));
  pave2->AddText((const char *)(savename));
  sprintf(savename,"Sigma %0.4f #pm %0.4f", g1overg2hist_gaus->GetParameter(2), g1overg2hist_gaus->GetParError(2));
  pave2->AddText((const char *)(savename));
  pave2->Draw();
  g1overg2hist->SetStats(kFALSE);
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2hist_fit_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1overg2erhist->GetXaxis()->SetTitle("G1 / G2 uncert");
  g1overg2erhist->GetXaxis()->SetTitleOffset(1.1);
  g1overg2erhist->GetYaxis()->SetTitleOffset(1.5);
  g1overg2erhist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2erhist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g0erhist->GetXaxis()->SetTitle("Fitted G0 uncert");
  g0erhist->GetXaxis()->SetTitleOffset(1.1);
  g0erhist->GetYaxis()->SetTitleOffset(1.5);
  g0erhist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0erhist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1erhist->GetXaxis()->SetTitle("Fitted G1 uncert");
  g1erhist->GetXaxis()->SetTitleOffset(1.1);
  g1erhist->GetYaxis()->SetTitleOffset(1.5);
  g1erhist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1erhist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g2erhist->GetXaxis()->SetTitle("Fitted G2 uncert");
  g2erhist->GetXaxis()->SetTitleOffset(1.1);
  g2erhist->GetYaxis()->SetTitleOffset(1.5);
  g2erhist->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g2erhist_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g0overg1_isEdge->SetLineColor(kBlue);
  g0overg1_isInnerEdge->SetLineColor(kCyan);
  g0overg1_isDouble->SetLineColor(kGreen+2);
  g0overg1_isNextToDouble->SetLineColor(kRed);
  g0overg1_isQuad->SetLineColor(kOrange);

  g0overg1_isEdge->Scale(1./g0overg1_isEdge->GetEntries());
  g0overg1_isInnerEdge->Scale(1./g0overg1_isInnerEdge->GetEntries());
  g0overg1_isDouble->Scale(1./g0overg1_isDouble->GetEntries());
  g0overg1_isNextToDouble->Scale(1./g0overg1_isNextToDouble->GetEntries());
  g0overg1_isQuad->Scale(1./g0overg1_isQuad->GetEntries());
  g0overg1_isBulk->Scale(1./g0overg1_isBulk->GetEntries());

  TLegend *leg1 = new TLegend(0.62,0.6,0.93,0.93);
  leg1->AddEntry(g0overg1_isBulk, "Normal", "l");
  leg1->AddEntry(g0overg1_isDouble, "Double", "l");
  leg1->AddEntry(g0overg1_isNextToDouble, "Next to D", "l");
  leg1->AddEntry(g0overg1_isEdge, "Edge", "l");
  leg1->AddEntry(g0overg1_isInnerEdge, "Inner E", "l");

  g0overg1_isDouble->GetXaxis()->SetTitle("G0 / G1");
  g0overg1_isDouble->GetYaxis()->SetTitle("Normalised");
  g0overg1_isDouble->GetYaxis()->SetTitleOffset(1.3);
  g0overg1_isDouble->SetMinimum(0.0);
  g0overg1_isDouble->SetMaximum(0.16);
  g0overg1_isDouble->Draw();
  g0overg1_isEdge->Draw("same");
  g0overg1_isInnerEdge->Draw("same");
  g0overg1_isNextToDouble->Draw("same");
  g0overg1_isBulk->Draw("same");
  leg1->Draw("same");
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1_perType_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1overg2_isEdge->SetLineColor(kBlue);
  g1overg2_isInnerEdge->SetLineColor(kCyan);
  g1overg2_isDouble->SetLineColor(kGreen+2);
  g1overg2_isNextToDouble->SetLineColor(kRed);
  g1overg2_isQuad->SetLineColor(kOrange);

  g1overg2_isEdge->Scale(1./g1overg2_isEdge->GetEntries());
  g1overg2_isInnerEdge->Scale(1./g1overg2_isInnerEdge->GetEntries());
  g1overg2_isDouble->Scale(1./g1overg2_isDouble->GetEntries());
  g1overg2_isNextToDouble->Scale(1./g1overg2_isNextToDouble->GetEntries());
  g1overg2_isQuad->Scale(1./g1overg2_isQuad->GetEntries());
  g1overg2_isBulk->Scale(1./g1overg2_isBulk->GetEntries());

  TLegend *leg = new TLegend(0.62,0.6,0.93,0.93);
  leg->AddEntry(g1overg2_isBulk, "Normal", "l");
  leg->AddEntry(g1overg2_isDouble, "Double", "l");
  leg->AddEntry(g1overg2_isNextToDouble, "Next to D", "l");
  leg->AddEntry(g1overg2_isEdge, "Edge", "l");
  leg->AddEntry(g1overg2_isInnerEdge, "Inner E", "l");

  g1overg2_isDouble->GetXaxis()->SetTitle("G1 / G2");
  g1overg2_isDouble->GetYaxis()->SetTitle("Normalised");
  g1overg2_isDouble->GetYaxis()->SetTitleOffset(1.3);
  g1overg2_isDouble->SetMinimum(0.0);
  g1overg2_isDouble->SetMaximum(0.16);
  g1overg2_isDouble->Draw();
  g1overg2_isEdge->Draw("same");
  g1overg2_isInnerEdge->Draw("same");
  g1overg2_isNextToDouble->Draw("same");
  g1overg2_isBulk->Draw("same");
  leg->Draw("same");
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2_perType_M%s.png", module_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  mapcanvas->cd();

  g0map->GetXaxis()->SetTitle("Column");
  g0map->GetYaxis()->SetTitle("Row");
  g0map->GetYaxis()->SetTitleOffset(0.7);
  g0map->GetZaxis()->SetRangeUser(20000,40000);
  g0map->Draw("colz");
  pave->AddText("G0 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0map_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1map->GetXaxis()->SetTitle("Column");
  g1map->GetYaxis()->SetTitle("Row");
  g1map->GetYaxis()->SetTitleOffset(0.7);
  if (module_str == "032") {
    g1map->GetZaxis()->SetRangeUser(-12000,-4000);
  } else if (module_str == "002") {
    g1map->GetZaxis()->SetRangeUser(-400,-100);
  } else {
    g1map->GetZaxis()->SetRangeUser(-3000,0);
  }
  g1map->Draw("colz");
  pave->Clear();
  pave->AddText("G1 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1map_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g2map->GetXaxis()->SetTitle("Column");
  g2map->GetYaxis()->SetTitle("Row");
  g2map->GetYaxis()->SetTitleOffset(0.7);
  if (module_str == "032") {
    g2map->GetZaxis()->SetRangeUser(-800,-400);
  } else if (module_str == "002") {
    g2map->GetZaxis()->SetRangeUser(-35,-10);
  } else {
    g2map->GetZaxis()->SetRangeUser(-200,-50);
  }
  g2map->Draw("colz");
  pave->Clear();
  pave->AddText("G2 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g2map_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g0overg1map->GetXaxis()->SetTitle("Column");
  g0overg1map->GetYaxis()->SetTitle("Row");
  g0overg1map->GetYaxis()->SetTitleOffset(0.7);
  if (module_str == "003") {
    g0overg1map->GetZaxis()->SetRangeUser(-35,-30);
  } else {
    g0overg1map->GetZaxis()->SetRangeUser(-50,0);
  }
  g0overg1map->Draw("colz");
  pave->Clear();
  pave->AddText("G0/G1");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1map_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g0overg1ermap->GetXaxis()->SetTitle("Column");
  g0overg1ermap->GetYaxis()->SetTitle("Row");
  g0overg1ermap->GetYaxis()->SetTitleOffset(0.7);
  g0overg1ermap->GetZaxis()->SetRangeUser(0,0.5);
  g0overg1ermap->Draw("colz");
  pave->Clear();
  pave->AddText("#sigma_{G0/G1}");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g0overg1ermap_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1overg2map->GetXaxis()->SetTitle("Column");
  g1overg2map->GetYaxis()->SetTitle("Row");
  g1overg2map->GetYaxis()->SetTitleOffset(0.7);
  g1overg2map->GetZaxis()->SetRangeUser(12,13.2);
  g1overg2map->Draw("colz");
  pave->Clear();
  pave->AddText("G1/G2");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2map_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1overg2ermap->GetXaxis()->SetTitle("Column");
  g1overg2ermap->GetYaxis()->SetTitle("Row");
  g1overg2ermap->GetYaxis()->SetTitleOffset(0.7);
  g1overg2ermap->GetZaxis()->SetRangeUser(0,0.5);
  g1overg2ermap->Draw("colz");
  pave->Clear();
  pave->AddText("#sigma_{G1/G2}");
  pave->Draw();
  sprintf(savename,"plots/M%s/CurrentSource/g1overg2ermap_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g0ermap->GetXaxis()->SetTitle("Column");
  g0ermap->GetYaxis()->SetTitle("Row");
  g0ermap->GetYaxis()->SetTitleOffset(0.7);
  g0ermap->Draw("colz");
  pave->Clear();
  pave->AddText("#sigma_{G0}");
  pave->Draw();
  g0ermap->GetZaxis()->SetRangeUser(0,200);
  sprintf(savename,"plots/M%s/CurrentSource/g0ermap_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1ermap->GetXaxis()->SetTitle("Column");
  g1ermap->GetYaxis()->SetTitle("Row");
  g1ermap->GetYaxis()->SetTitleOffset(0.7);
  g1ermap->Draw("colz");
  pave->Clear();
  pave->AddText("#sigma_{G1}");
  pave->Draw();
  g1ermap->GetZaxis()->SetRangeUser(0,50);
  sprintf(savename,"plots/M%s/CurrentSource/g1ermap_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g2ermap->GetXaxis()->SetTitle("Column");
  g2ermap->GetYaxis()->SetTitle("Row");
  g2ermap->GetYaxis()->SetTitleOffset(0.7);
  g2ermap->Draw("colz");
  pave->Clear();
  pave->AddText("#sigma_{G2}");
  pave->Draw();
  g2ermap->GetZaxis()->SetRangeUser(0,5);
  sprintf(savename,"plots/M%s/CurrentSource/g2ermap_M%s.png", module_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  sprintf(savename,"data/M%s/CS_ratio_M%s.root", module_str.c_str(), module_str.c_str());
  TFile* saved_file2 = new TFile((const char *)(savename),"RECREATE");
  g1overg2map->Write();
  g1overg2ermap->Write();
  saved_file2->Close();

}