// file to check the integration time alone doesn't alter the baseline

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

#include "../sls_detector_calibration/jungfrauFile.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>

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

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

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

  string module_str = argv[1];
  string data_loc = argv[2];
  string data_file = argv[3];
  string base1_file = argv[4];
  string base2_file = argv[5];

  jungfrauFile *thisfile = new jungfrauFile();

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

  char savename[128];

  int createHistoFile = 0;
  // default pixel mask
  pixelMaskObject->initialisePixelMask(pixel_mask);
  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 == "065") {
    pixelMaskObject->maskChip(5,pixel_mask);
  }

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

  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);

  TH2F *adcmap_avg_g1 [3][51];
  TH2F *adcmap_avg_g2 [3][51];
  TH2F *adcermap_avg_g1 [3][51];
  TH2F *adcermap_avg_g2 [3][51];

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

  // creating the histograms
  if (createHistoFile) {

    for (int k = 0; k < 3; k++) {
      for(int i = 0; i < 51; i++) {
	ostringstream histogramNameStreamg1;
	histogramNameStreamg1 << "adcmap_avg_g1_" << k << "_" << i;
	adcmap_avg_g1[k][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_" << k << "_" << i;
	adcmap_avg_g2[k][i] = new TH2F(histogramNameStreamg2.str().c_str(),"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
	ostringstream histogramNameStreamg3;
	histogramNameStreamg3 << "adcermap_avg_g1_" << k << "_" << i;
	adcermap_avg_g1[k][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_" << k << "_" << i;
	adcermap_avg_g2[k][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_g1 = new TH1F("adc_avg_g1","",100,0,17000);
    TH1F *adc_avg_g2 = new TH1F("adc_avg_g2","",100,0,17000);

    for (int typeOfScan = 0; typeOfScan < 3; typeOfScan++) {

      int frame_counter = 0;
      int j = 0;
      int nfiles = 4;

      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 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);
      }

      string typeOfScanStr;
      if (typeOfScan == 0) {
	typeOfScanStr = "CS";
      } else if (typeOfScan == 1) {
	typeOfScanStr = "BG1";
      } else if (typeOfScan == 2) {
	typeOfScanStr = "BG2";
      }

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

	if (typeOfScan == 0) {
	  sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), data_file.c_str());
	} else if (typeOfScan == 1) {
	  sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), base1_file.c_str());
	} else if (typeOfScan == 2) {
	  sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), base2_file.c_str());
	}
	thisfile->open((char*)savename, filei);

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

	while (thisfile->readNextFrame()) {
	  frame_counter++;
	  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 == 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 ((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/CS_BaselineTest/adcmap_%s_%i_sel.png", module_str.c_str(), typeOfScanStr.c_str(), j-1);
	    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/CS_BaselineTest/adcmap_%s_%i_all.png", module_str.c_str(), typeOfScanStr.c_str(), j-1);
	    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/CS_BaselineTest/gainmap_%s_%i_sel.png", module_str.c_str(), typeOfScanStr.c_str(), j-1);
	    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/CS_BaselineTest/gainmap_%s_%i_all.png", module_str.c_str(), typeOfScanStr.c_str(), j-1);
	    mapcanvas->SaveAs((const char *)(savename));
      
	    adcmap_sel->Reset();
	    adcmap_all->Reset();
	    gainmap_sel->Reset();
	    gainmap_all->Reset();
	  }

 

	  if (j%640 == 0) {
	
	    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_g1[typeOfScan][j/640-1]->Fill(i%NC,i/NC,adc_histos_g1[i]->GetMean());
		adcermap_avg_g1[typeOfScan][j/640-1]->Fill(i%NC,i/NC,adc_histos_g1[i]->GetMeanError());
		adcmap_avg_g2[typeOfScan][j/640-1]->Fill(i%NC,i/NC,adc_histos_g2[i]->GetMean());
		adcermap_avg_g2[typeOfScan][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_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_g1[i]->Reset();
		adc_histos_g2[i]->Reset();
	      }
	    }
	    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/CS_BaselineTest/perStep/gain_avg_%s_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    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/CS_BaselineTest/perStep/gainmap_avg_%s_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    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/CS_BaselineTest/perStep/adc_avg_g1_%s_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    adcmap_avg_g1[typeOfScan][j/640-1]->GetXaxis()->SetTitle("Column");
	    adcmap_avg_g1[typeOfScan][j/640-1]->GetYaxis()->SetTitle("Row");
	    adcmap_avg_g1[typeOfScan][j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcmap_avg_g1[typeOfScan][j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CS_BaselineTest/perStep/adcmap_avg_%s_g1_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    mapcanvas->SaveAs((const char *)(savename));
	    adcermap_avg_g1[typeOfScan][j/640-1]->GetXaxis()->SetTitle("Column");
	    adcermap_avg_g1[typeOfScan][j/640-1]->GetYaxis()->SetTitle("Row");
	    adcermap_avg_g1[typeOfScan][j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcermap_avg_g1[typeOfScan][j/640-1]->Draw("colz");
	    mapcanvas->Update();
	    sprintf(savename,"plots/M%s/CS_BaselineTest/perStep/adcermap_avg_%s_g1_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    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/CS_BaselineTest/perStep/adc_avg_g2_%s_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    c1->SaveAs((const char *)(savename));
	    mapcanvas->cd();
	    adcmap_avg_g2[typeOfScan][j/640-1]->GetXaxis()->SetTitle("Column");
	    adcmap_avg_g2[typeOfScan][j/640-1]->GetYaxis()->SetTitle("Row");
	    adcmap_avg_g2[typeOfScan][j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcmap_avg_g2[typeOfScan][j/640-1]->Draw("colz");
	    sprintf(savename,"plots/M%s/CS_BaselineTest/perStep/adcmap_avg_%s_g2_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    mapcanvas->SaveAs((const char *)(savename));
	    adcermap_avg_g2[typeOfScan][j/640-1]->GetXaxis()->SetTitle("Column");
	    adcermap_avg_g2[typeOfScan][j/640-1]->GetYaxis()->SetTitle("Row");
	    adcermap_avg_g2[typeOfScan][j/640-1]->GetYaxis()->SetTitleOffset(0.7);
	    adcermap_avg_g2[typeOfScan][j/640-1]->Draw("colz");
	    sprintf(savename,"plots/M%s/CS_BaselineTest/perStep/adcermap_avg_%s_g2_%i.png", module_str.c_str(), typeOfScanStr.c_str(), j/640);
	    mapcanvas->SaveAs((const char *)(savename));

	    gain_avg->Reset();
	    gainmap_avg->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_g1[i];
	delete adc_histos_g2[i];
      }
      
      cout << "frame_counter " << frame_counter << endl;
      
    } // ends type of scan
    
    // save histograms
    sprintf(savename,"/mnt/pcmoench_jungfrau_data1_ib/jungfrau_ana_sophie/M%s_CalibAna/CS_BaselineTest_histos.root", module_str.c_str());
    TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
    
    for (int k = 0; k < 3; k++) {
      for (int i = 0; i < 51; i++) {
	adcmap_avg_g1[k][i]->Write();
	adcmap_avg_g2[k][i]->Write();
	adcermap_avg_g1[k][i]->Write();
	adcermap_avg_g2[k][i]->Write();
      }
    }
    saved_file->Close();
    
  } else {

    // load histos
    cout << "LOADING HISTOS" << endl;
    sprintf(savename,"/mnt/pcmoench_jungfrau_data1_ib/jungfrau_ana_sophie/M%s_CalibAna/CS_BaselineTest_histos.root", module_str.c_str());
    TFile* saved_file = new TFile((const char *)(savename),"READ");
    
    for (int k = 0; k < 3; k++) {
      for (int i = 0; i < 51; i++) {
	sprintf(savename,"adcmap_avg_g1_%d_%d", k, i);
	adcmap_avg_g1[k][i] = (TH2F*)saved_file->Get((const char *)(savename));
	sprintf(savename,"adcmap_avg_g2_%d_%d", k, i);
	adcmap_avg_g2[k][i] = (TH2F*)saved_file->Get((const char *)(savename));
	
	sprintf(savename,"adcermap_avg_g1_%d_%d", k, i);
	adcermap_avg_g1[k][i] = (TH2F*)saved_file->Get((const char *)(savename));
	sprintf(savename,"adcermap_avg_g2_%d_%d", k, i);
	adcermap_avg_g2[k][i] = (TH2F*)saved_file->Get((const char *)(savename));
      }
    }
  }
  
  TH2F *g1map = new TH2F("g1map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g1map_b = new TH2F("g1map_b","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g1map_csmb = new TH2F("g1map_csmb","",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 *g2map_b = new TH2F("g2map_b","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g2map_csmb = new TH2F("g2map_csmb","",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 *g1overg2map = new TH2F("g1overg2map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F *g1overg2map_csmb = new TH2F("g1overg2map_csmb","",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 *g1hist = new TH1F("g1hist","",100,-3000,0);
  TH1F *g1hist_b = new TH1F("g1hist_b","",100,-15,15);
  TH1F *g1hist_csmb = new TH1F("g1hist_csmb","",100,0,3000);
  TH1F *g1erhist = new TH1F("g1erhist","",100,0,50);

  TH1F *g2hist = new TH1F("g2hist","",100,-300,0);
  TH1F *g2hist_b = new TH1F("g2hist_b","",100,-5,5);
  TH1F *g2hist_csmb = new TH1F("g2hist_csmb","",100,0,300);
  TH1F *g2erhist = new TH1F("g2erhist","",100,0,10);

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


  TH2F *cs_csmb_diffmap = new TH2F("cs_csmb_diffmap","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH1F *cs_csmb_diffhist = new TH1F("cs_csmb_diffhist","",100,-1,1);

  double filter[51];
  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.);
  }

  for (int i = 0; i < NCH; i++) {
    if (pixel_mask[i] == true) {

      // original CS
      vector<double> r1_adc;
      vector<double> r1_filter;
      vector<double> r1_adcerr;
      vector<double> r1_ferr;

      vector<double> r3_adc;
      vector<double> r3_filter;
      vector<double> r3_adcerr;
      vector<double> r3_ferr;

      // CS - baseline
      vector<double> r1_adc_csmb;
      vector<double> r3_adc_csmb;

      // baselines
      vector<double> r1_adc_b;
      vector<double> r3_adc_b;

      // filter out points at zero and points with 0 error (mean taken from one entry in hist)
      int m_max = 51;

      for (int m = 0; m < m_max; m++) {
	if (adcmap_avg_g1[0][m]->GetBinContent((i%NC)+1,(i/NC)+1) != 0 && adcermap_avg_g1[0][m]->GetBinContent((i%NC)+1,(i/NC)+1) > 0) {
	  // original
	  r1_adc.push_back(adcmap_avg_g1[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r1_filter.push_back(filter[m]);
	  r1_adcerr.push_back(adcermap_avg_g1[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r1_ferr.push_back(0.);

	  // cs - baseline
	  r1_adc_csmb.push_back(adcmap_avg_g1[1][m]->GetBinContent((i%NC)+1,(i/NC)+1) - adcmap_avg_g1[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));

	  // baseline
	  r1_adc_b.push_back(adcmap_avg_g1[1][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	}
	if (adcmap_avg_g2[0][m]->GetBinContent((i%NC)+1,(i/NC)+1) != 0 && adcermap_avg_g2[0][m]->GetBinContent((i%NC)+1,(i/NC)+1) > 0) {
	  // original
	  r3_adc.push_back(adcmap_avg_g2[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r3_filter.push_back(filter[m]);
	  r3_adcerr.push_back(adcermap_avg_g2[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	  r3_ferr.push_back(0.);

	  // cs - baseline
	  r3_adc_csmb.push_back(adcmap_avg_g2[2][m]->GetBinContent((i%NC)+1,(i/NC)+1) - adcmap_avg_g2[0][m]->GetBinContent((i%NC)+1,(i/NC)+1));

	  // baseline
	  r3_adc_b.push_back(adcmap_avg_g2[2][m]->GetBinContent((i%NC)+1,(i/NC)+1));
	}
      }

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

	// original
	TGraphErrors *grap_g1 = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	TGraphErrors *grap_g2 = new TGraphErrors(r3_adc.size(),&(r3_filter[0]),&(r3_adc[0]),&(r3_ferr[0]),&(r3_adcerr[0]));

	double rangemin2 = 2;
	double rangemax2 = *max_element(r1_filter.begin(),r1_filter.end());
	TF1 *fit2 = new TF1("fit2","[0]+[1]*x",rangemin2,rangemax2);
	fit2->SetParameter(0, 10000.);
	fit2->SetParameter(1, -2000);
	fit2->SetLineColor(kGreen+2);
	fit2->SetParName(0,"G1 const");
	fit2->SetParName(1,"G1 grad");
	grap_g1->Fit(fit2,"QR","");

	g1hist->Fill(fit2->GetParameter(1));
	g1map->Fill(i%NC,i/NC,fit2->GetParameter(1));
	g1erhist->Fill(fit2->GetParError(1));
	g1ermap->Fill(i%NC,i/NC,fit2->GetParError(1));
      
	double rangemin3 = *min_element(r3_filter.begin(),r3_filter.end());
	double rangemax3 = *max_element(r3_filter.begin(),r3_filter.end());
	TF1 *fit3 = new TF1("fit3","[0]+[1]*x",rangemin3, rangemax3);
	fit3->SetParameter(0, 7000.);
	fit3->SetParameter(1, -150);
	fit3->SetLineColor(kRed);
	fit3->SetParName(0,"G2 const");
	fit3->SetParName(1,"G2 grad");
	grap_g2->Fit(fit3,"QR+","");

	g2hist->Fill(fit3->GetParameter(1));
	g2map->Fill(i%NC,i/NC,fit3->GetParameter(1));
	g2erhist->Fill(fit3->GetParError(1));
	g2ermap->Fill(i%NC,i/NC,fit3->GetParError(1));
      
	g1overg2hist->Fill(fit2->GetParameter(1) / fit3->GetParameter(1));
	g1overg2erhist->Fill(abs(fit2->GetParameter(1)/fit3->GetParameter(1))*sqrt(pow((fit2->GetParError(1)/fit2->GetParameter(1)),2) + pow((fit3->GetParError(1)/fit3->GetParameter(1)),2)));
	g1overg2map->Fill(i%NC,i/NC,fit2->GetParameter(1) / fit3->GetParameter(1));
	g1overg2ermap->Fill(i%NC,i/NC,abs(fit2->GetParameter(1)/fit3->GetParameter(1))*sqrt(pow((fit2->GetParError(1)/fit2->GetParameter(1)),2) + pow((fit3->GetParError(1)/fit3->GetParameter(1)),2)));

	// cs - baseline
	TGraphErrors *grap_g1_csmb = new TGraphErrors(r1_adc_csmb.size(),&(r1_filter[0]),&(r1_adc_csmb[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	TGraphErrors *grap_g2_csmb = new TGraphErrors(r3_adc_csmb.size(),&(r3_filter[0]),&(r3_adc_csmb[0]),&(r3_ferr[0]),&(r3_adcerr[0]));

	TF1 *fit2_csmb = new TF1("fit2_csmb","[0]+[1]*x",rangemin2,rangemax2);
	fit2_csmb->SetParameter(0, 2000.);
	fit2_csmb->SetParameter(1, 2000);
	fit2_csmb->SetLineColor(kGreen+2);
	fit2_csmb->SetParName(0,"G1 const");
	fit2_csmb->SetParName(1,"G1 grad");
	grap_g1_csmb->Fit(fit2_csmb,"QR","");

	g1hist_csmb->Fill(fit2_csmb->GetParameter(1));
	g1map_csmb->Fill(i%NC,i/NC,fit2_csmb->GetParameter(1));
      
	TF1 *fit3_csmb = new TF1("fit3_csmb","[0]+[1]*x",rangemin3, rangemax3);
	fit3_csmb->SetParameter(0, 50.);
	fit3_csmb->SetParameter(1, 150);
	fit3_csmb->SetLineColor(kRed);
	fit3_csmb->SetParName(0,"G2 const");
	fit3_csmb->SetParName(1,"G2 grad");
	grap_g2_csmb->Fit(fit3_csmb,"QR+","");

	g2hist_csmb->Fill(fit3_csmb->GetParameter(1));
	g2map_csmb->Fill(i%NC,i/NC,fit3_csmb->GetParameter(1));
      
	g1overg2hist_csmb->Fill(fit2_csmb->GetParameter(1) / fit3_csmb->GetParameter(1));
	g1overg2map_csmb->Fill(i%NC,i/NC,fit2_csmb->GetParameter(1) / fit3_csmb->GetParameter(1));

	cs_csmb_diffmap->Fill(i%NC,i/NC,(fit2_csmb->GetParameter(1) / fit3_csmb->GetParameter(1))-(fit2->GetParameter(1) / fit3->GetParameter(1)));
	cs_csmb_diffhist->Fill((fit2_csmb->GetParameter(1) / fit3_csmb->GetParameter(1))-(fit2->GetParameter(1) / fit3->GetParameter(1)));

	// baseline
	TGraphErrors *grap_g1_b = new TGraphErrors(r1_adc_b.size(),&(r1_filter[0]),&(r1_adc_b[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	TGraphErrors *grap_g2_b = new TGraphErrors(r3_adc_b.size(),&(r3_filter[0]),&(r3_adc_b[0]),&(r3_ferr[0]),&(r3_adcerr[0]));

	TF1 *fit2_b = new TF1("fit2_b","[0]+[1]*x",rangemin2,rangemax2);
	fit2_b->SetParameter(0, 10000.);
	fit2_b->SetParameter(1, 0);
	fit2_b->SetLineColor(kGreen+2);
	fit2_b->SetParName(0,"G1 const");
	fit2_b->SetParName(1,"G1 grad");
	grap_g1_b->Fit(fit2_b,"QR","");
      
	g1hist_b->Fill(fit2_b->GetParameter(1));
	g1map_b->Fill(i%NC,i/NC,fit2_b->GetParameter(1));

	TF1 *fit3_b = new TF1("fit3_b","[0]+[1]*x",rangemin3, rangemax3);
	fit3_b->SetParameter(0, 7000.);
	fit3_b->SetParameter(1, 0);
	fit3_b->SetLineColor(kRed);
	fit3_b->SetParName(0,"G2 const");
	fit3_b->SetParName(1,"G2 grad");
	grap_g2_b->Fit(fit3_b,"QR+","");

	g2hist_b->Fill(fit3_b->GetParameter(1));
	g2map_b->Fill(i%NC,i/NC,fit3_b->GetParameter(1));

	if (i >= 58000 && i < 58000+10) {
	  
	  string pixel_type = "b";
	  
	  mapcanvas->cd();
	  mapcanvas->SetLeftMargin(0.13);
	  mapcanvas->SetRightMargin(0.05);
	  
	  grap_g1->SetMarkerStyle(20);
	  grap_g2->SetMarkerStyle(20);
	  grap_g1->SetMarkerColor(kGreen+2);
	  grap_g2->SetMarkerColor(kRed);
	  grap_g1->SetLineColor(kGreen+2);
	  grap_g2->SetLineColor(kRed);

	  TF1 *fit2_e = new TF1("fit2_e","[0]+[1]*x",0.009,1.1E3);
	  TF1 *fit3_e = new TF1("fit3_e","[0]+[1]*x",0.009,1.1E3);

	  fit2_e->SetParameters(fit2->GetParameter(0),fit2->GetParameter(1));
	  fit2_e->SetLineColor(kGreen+2);
	  fit2_e->SetLineStyle(2);
	  fit3_e->SetParameters(fit3->GetParameter(0),fit3->GetParameter(1));
	  fit3_e->SetLineColor(kRed);
	  fit3_e->SetLineStyle(2);
	  
	  grap_g1->GetXaxis()->SetLimits(0.05,5.1E1);
	  grap_g1->SetMinimum(0);
	  grap_g1->SetMaximum(20000);
	  grap_g1->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g1->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g1->GetYaxis()->SetTitleOffset(0.9);
	  grap_g1->Draw("AP");
	  fit2->Draw("same");
	  mapcanvas->Update();
	  TPaveStats *st0 = (TPaveStats*)grap_g1->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.71);
	  st0->SetY2NDC(0.90);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kGreen+2);
	  grap_g2->Draw("P");
	  fit3->Draw("same");
	  mapcanvas->Update();
	  TPaveStats *st1 = (TPaveStats*)grap_g2->FindObject("stats");
	  st1->SetX1NDC(0.6);
	  st1->SetX2NDC(0.94);
	  st1->SetY1NDC(0.71);
	  st1->SetY2NDC(0.90);
	  st1->SetBorderSize(0);
	  st1->SetTextColor(kRed);
	  
	  fit2_e->Draw("same");
	  fit3_e->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);
	  
	  // normalise
	  vector<double> r1_adc_norm;
	  vector<double> r3_adc_norm;
	  for (size_t j = 0; j < r1_adc.size(); j++) {
	    r1_adc_norm.push_back(r1_adc[j] - fit2->Eval(r1_filter[j]));
	  }
	  for (size_t j = 0; j < r3_adc.size(); j++) {
	    r3_adc_norm.push_back(r3_adc[j] - fit3->Eval(r3_filter[j]));
	  }
	  TGraphErrors *grap1_norm = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc_norm[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	  TGraphErrors *grap2_norm = new TGraphErrors(r3_adc.size(),&(r3_filter[0]),&(r3_adc_norm[0]),&(r3_ferr[0]),&(r3_adcerr[0]));
	  
	  TF1* flat_g1 = new TF1("flat_g1","0",rangemin2, rangemax2);
	  TF1* flat_g2 = new TF1("flat_g2","0",rangemin3, rangemax3);
	  
	  grap1_norm->SetMarkerColor(kGreen+2);
	  grap1_norm->SetLineColor(kGreen+2);
	  flat_g1->SetLineColor(kGreen+2);
	  grap1_norm->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap1_norm->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap1_norm->GetYaxis()->SetTitleOffset(0.9);
	  grap1_norm->SetMinimum(-100);
	  grap1_norm->SetMaximum(100);
	  grap1_norm->Draw("AP");
	  flat_g1->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g1norm.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));

	  grap2_norm->SetMarkerColor(kRed);
	  grap2_norm->SetLineColor(kRed);
	  flat_g2->SetLineColor(kRed);
	  grap2_norm->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap2_norm->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap2_norm->GetYaxis()->SetTitleOffset(0.9);
	  grap2_norm->SetMinimum(-100);
	  grap2_norm->SetMaximum(100);
	  grap2_norm->Draw("AP");
	  flat_g2->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g2norm.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));

	  delete fit2_e;
	  delete fit3_e;
	  delete grap1_norm;
	  delete grap2_norm;

	  // cs - b
	  mapcanvas->SetLeftMargin(0.13);
	  mapcanvas->SetRightMargin(0.05);

	  grap_g1_csmb->SetMarkerStyle(20);
	  grap_g2_csmb->SetMarkerStyle(20);
	  grap_g1_csmb->SetMarkerColor(kGreen+2);
	  grap_g2_csmb->SetMarkerColor(kRed);
	  grap_g1_csmb->SetLineColor(kGreen+2);
	  grap_g2_csmb->SetLineColor(kRed);

	  TF1 *fit2_e_csmb = new TF1("fit2_e_csmb","[0]+[1]*x",0.009,1.1E3);
	  TF1 *fit3_e_csmb = new TF1("fit3_e_csmb","[0]+[1]*x",0.009,1.1E3);

	  fit2_e_csmb->SetParameters(fit2_csmb->GetParameter(0),fit2_csmb->GetParameter(1));
	  fit2_e_csmb->SetLineColor(kGreen+2);
	  fit2_e_csmb->SetLineStyle(2);
	  fit3_e_csmb->SetParameters(fit3_csmb->GetParameter(0),fit3_csmb->GetParameter(1));
	  fit3_e_csmb->SetLineColor(kRed);
	  fit3_e_csmb->SetLineStyle(2);
	  
	  grap_g1_csmb->GetXaxis()->SetLimits(0.05,5.1E1);
	  grap_g1_csmb->SetMinimum(0);
	  grap_g1_csmb->SetMaximum(20000);
	  grap_g1_csmb->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g1_csmb->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g1_csmb->GetYaxis()->SetTitleOffset(0.9);
	  grap_g1_csmb->Draw("AP");
	  fit2_csmb->Draw("same");
	  mapcanvas->Update();
	  st0 = (TPaveStats*)grap_g1_csmb->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.71);
	  st0->SetY2NDC(0.90);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kGreen+2);
	  grap_g2_csmb->Draw("P");
	  fit3_csmb->Draw("same");
	  mapcanvas->Update();
	  st1 = (TPaveStats*)grap_g2_csmb->FindObject("stats");
	  st1->SetX1NDC(0.6);
	  st1->SetX2NDC(0.94);
	  st1->SetY1NDC(0.71);
	  st1->SetY2NDC(0.90);
	  st1->SetBorderSize(0);
	  st1->SetTextColor(kRed);
	  
	  fit2_e_csmb->Draw("same");
	  fit3_e_csmb->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_csmb.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);
	  
	  // normalise
	  vector<double> r1_adc_norm_csmb;
	  vector<double> r3_adc_norm_csmb;
	  for (size_t j = 0; j < r1_adc_csmb.size(); j++) {
	    r1_adc_norm_csmb.push_back(r1_adc_csmb[j] - fit2_csmb->Eval(r1_filter[j]));
	  }
	  for (size_t j = 0; j < r3_adc_csmb.size(); j++) {
	    r3_adc_norm_csmb.push_back(r3_adc_csmb[j] - fit3_csmb->Eval(r3_filter[j]));
	  }
	  TGraphErrors *grap1_norm_csmb = new TGraphErrors(r1_adc_csmb.size(),&(r1_filter[0]),&(r1_adc_norm_csmb[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	  TGraphErrors *grap2_norm_csmb = new TGraphErrors(r3_adc_csmb.size(),&(r3_filter[0]),&(r3_adc_norm_csmb[0]),&(r3_ferr[0]),&(r3_adcerr[0]));
	  
	  TF1* flat_g1_csmb = new TF1("flat_g1_csmb","0",rangemin2, rangemax2);
	  TF1* flat_g2_csmb = new TF1("flat_g2_csmb","0",rangemin3, rangemax3);
	  
	  grap1_norm_csmb->SetMarkerColor(kGreen+2);
	  grap1_norm_csmb->SetLineColor(kGreen+2);
	  flat_g1_csmb->SetLineColor(kGreen+2);
	  grap1_norm_csmb->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap1_norm_csmb->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap1_norm_csmb->GetYaxis()->SetTitleOffset(0.9);
	  grap1_norm_csmb->SetMinimum(-100);
	  grap1_norm_csmb->SetMaximum(100);
	  grap1_norm_csmb->Draw("AP");
	  flat_g1_csmb->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g1norm_csmb.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));

	  grap2_norm_csmb->SetMarkerColor(kRed);
	  grap2_norm_csmb->SetLineColor(kRed);
	  flat_g2_csmb->SetLineColor(kRed);
	  grap2_norm_csmb->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap2_norm_csmb->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap2_norm_csmb->GetYaxis()->SetTitleOffset(0.9);
	  grap2_norm_csmb->SetMinimum(-100);
	  grap2_norm_csmb->SetMaximum(100);
	  grap2_norm_csmb->Draw("AP");
	  flat_g2_csmb->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g2norm_csmb.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));

	  // b
	  mapcanvas->SetLeftMargin(0.13);
	  mapcanvas->SetRightMargin(0.05);

	  grap_g1_b->SetMarkerStyle(20);
	  grap_g2_b->SetMarkerStyle(20);
	  grap_g1_b->SetMarkerColor(kGreen+2);
	  grap_g2_b->SetMarkerColor(kRed);
	  grap_g1_b->SetLineColor(kGreen+2);
	  grap_g2_b->SetLineColor(kRed);

	  TF1 *fit2_e_b = new TF1("fit2_e_b","[0]+[1]*x",0.009,1.1E3);
	  TF1 *fit3_e_b = new TF1("fit3_e_b","[0]+[1]*x",0.009,1.1E3);

	  fit2_e_b->SetParameters(fit2_b->GetParameter(0),fit2_b->GetParameter(1));
	  fit2_e_b->SetLineColor(kGreen+2);
	  fit2_e_b->SetLineStyle(2);
	  fit3_e_b->SetParameters(fit3_b->GetParameter(0),fit3_b->GetParameter(1));
	  fit3_e_b->SetLineColor(kRed);
	  fit3_e_b->SetLineStyle(2);
	  
	  grap_g1_b->GetXaxis()->SetLimits(0.05,5.1E1);
	  grap_g1_b->SetMinimum(0);
	  grap_g1_b->SetMaximum(20000);
	  grap_g1_b->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap_g1_b->GetYaxis()->SetTitle("ADC [ADU]");
	  grap_g1_b->GetYaxis()->SetTitleOffset(0.9);
	  grap_g1_b->Draw("AP");
	  fit2_b->Draw("same");
	  mapcanvas->Update();
	  st0 = (TPaveStats*)grap_g1_b->FindObject("stats");
	  st0->SetX1NDC(0.2);
	  st0->SetX2NDC(0.54);
	  st0->SetY1NDC(0.71);
	  st0->SetY2NDC(0.90);
	  st0->SetBorderSize(0);
	  st0->SetTextColor(kGreen+2);
	  grap_g2_b->Draw("P");
	  fit3_b->Draw("same");
	  mapcanvas->Update();
	  st1 = (TPaveStats*)grap_g2_b->FindObject("stats");
	  st1->SetX1NDC(0.6);
	  st1->SetX2NDC(0.94);
	  st1->SetY1NDC(0.71);
	  st1->SetY2NDC(0.90);
	  st1->SetBorderSize(0);
	  st1->SetTextColor(kRed);
	  
	  fit2_e_b->Draw("same");
	  fit3_e_b->Draw("same");
	  mapcanvas->SetLogx();
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_b.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));
	  mapcanvas->SetLogx(0);

	  // normalise
	  vector<double> r1_adc_norm_b;
	  vector<double> r3_adc_norm_b;
	  for (size_t j = 0; j < r1_adc_b.size(); j++) {
	    r1_adc_norm_b.push_back(r1_adc_b[j] - fit2_b->Eval(r1_filter[j]));
	  }
	  for (size_t j = 0; j < r3_adc_b.size(); j++) {
	    r3_adc_norm_b.push_back(r3_adc_b[j] - fit3_b->Eval(r3_filter[j]));
	  }
	  TGraphErrors *grap1_norm_b = new TGraphErrors(r1_adc_b.size(),&(r1_filter[0]),&(r1_adc_norm_b[0]),&(r1_ferr[0]),&(r1_adcerr[0]));
	  TGraphErrors *grap2_norm_b = new TGraphErrors(r3_adc_b.size(),&(r3_filter[0]),&(r3_adc_norm_b[0]),&(r3_ferr[0]),&(r3_adcerr[0]));
	  
	  TF1* flat_g1_b = new TF1("flat_g1_b","0",rangemin2, rangemax2);
	  TF1* flat_g2_b = new TF1("flat_g2_b","0",rangemin3, rangemax3);
	  
	  grap1_norm_b->SetMarkerColor(kGreen+2);
	  grap1_norm_b->SetLineColor(kGreen+2);
	  flat_g1_b->SetLineColor(kGreen+2);
	  grap1_norm_b->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap1_norm_b->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap1_norm_b->GetYaxis()->SetTitleOffset(0.9);
	  grap1_norm_b->SetMinimum(-100);
	  grap1_norm_b->SetMaximum(100);
	  grap1_norm_b->Draw("AP");
	  flat_g1_b->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g1norm_b.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));

	  grap2_norm_b->SetMarkerColor(kRed);
	  grap2_norm_b->SetLineColor(kRed);
	  flat_g2_b->SetLineColor(kRed);
	  grap2_norm_b->GetXaxis()->SetTitle("Integration time [#mus]");
	  grap2_norm_b->GetYaxis()->SetTitle("Normalised ADC [ADU]");
	  grap2_norm_b->GetYaxis()->SetTitleOffset(0.9);
	  grap2_norm_b->SetMinimum(-100);
	  grap2_norm_b->SetMaximum(100);
	  grap2_norm_b->Draw("AP");
	  flat_g2_b->Draw("same");
	  sprintf(savename,"plots/M%s/CS_BaselineTest/pixel_%s_%d_g2norm_b.png", module_str.c_str(), pixel_type.c_str(), i);
	  mapcanvas->SaveAs((const char *)(savename));




	  mapcanvas->SetLeftMargin(0.1);
	  mapcanvas->SetRightMargin(0.13);
	  delete fit2_e_csmb;
	  delete fit3_e_csmb;
	  delete grap1_norm_csmb;
	  delete grap2_norm_csmb;

	}

	delete grap_g1;
	delete grap_g2;
	delete fit2;
	delete fit3;

	delete grap_g1_csmb;
	delete grap_g2_csmb;
	delete fit2_csmb;
	delete fit3_csmb;

      }
    }
  }

  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);

  g1hist->GetXaxis()->SetTitle("G1 gradient");
  g1hist->GetXaxis()->SetTitleOffset(1.1);
  g1hist->GetYaxis()->SetTitleOffset(1.5);
  g1hist->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1hist.png", 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/CS_BaselineTest/g2hist.png", 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/CS_BaselineTest/g1overg2hist.png", module_str.c_str());
  c1->SaveAs((const char *)(savename));

  g1overg2hist->Fit("gaus");
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1overg2hist_fit.png", 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/CS_BaselineTest/g1overg2erhist.png", 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/CS_BaselineTest/g1erhist.png", 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/CS_BaselineTest/g2erhist.png", module_str.c_str());
  c1->SaveAs((const char *)(savename));

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

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

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

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

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

  g1overg2hist_csmb->Fit("gaus");
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1overg2hist_fit_csmb.png", module_str.c_str());
  c1->SaveAs((const char *)(savename));

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

  mapcanvas->cd();

  g1map->GetXaxis()->SetTitle("Column");
  g1map->GetYaxis()->SetTitle("Row");
  g1map->GetYaxis()->SetTitleOffset(0.7);
  g1map->GetZaxis()->SetRangeUser(-3000,0);
  g1map->Draw("colz");
  pave->AddText("G1 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1map.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g2map->GetXaxis()->SetTitle("Column");
  g2map->GetYaxis()->SetTitle("Row");
  g2map->GetYaxis()->SetTitleOffset(0.7);
  g2map->GetZaxis()->SetRangeUser(-200,-50);
  g2map->Draw("colz");
  pave->Clear();
  pave->AddText("G2 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g2map.png", 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(11,15);
  g1overg2map->Draw("colz");
  pave->Clear();
  pave->AddText("G1/G2");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1overg2map.png", 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/CS_BaselineTest/g1overg2ermap.png", 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/CS_BaselineTest/g1ermap.png", 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/CS_BaselineTest/g2ermap.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1map_csmb->GetXaxis()->SetTitle("Column");
  g1map_csmb->GetYaxis()->SetTitle("Row");
  g1map_csmb->GetYaxis()->SetTitleOffset(0.7);
  g1map_csmb->GetZaxis()->SetRangeUser(0,3000);
  g1map_csmb->Draw("colz");
  pave->Clear();
  pave->AddText("G1 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1map_csmb.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g2map_csmb->GetXaxis()->SetTitle("Column");
  g2map_csmb->GetYaxis()->SetTitle("Row");
  g2map_csmb->GetYaxis()->SetTitleOffset(0.7);
  g2map_csmb->GetZaxis()->SetRangeUser(50,200);
  g2map_csmb->Draw("colz");
  pave->Clear();
  pave->AddText("G2 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g2map_csmb.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g1map_b->GetXaxis()->SetTitle("Column");
  g1map_b->GetYaxis()->SetTitle("Row");
  g1map_b->GetYaxis()->SetTitleOffset(0.7);
  g1map_b->GetZaxis()->SetRangeUser(-15,15);
  g1map_b->Draw("colz");
  pave->Clear();
  pave->AddText("G1 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g1map_b.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  g2map_b->GetXaxis()->SetTitle("Column");
  g2map_b->GetYaxis()->SetTitle("Row");
  g2map_b->GetYaxis()->SetTitleOffset(0.7);
  g2map_b->GetZaxis()->SetRangeUser(-5,5);
  g2map_b->Draw("colz");
  pave->Clear();
  pave->AddText("G2 [ADU/#mus]");
  pave->Draw();
  sprintf(savename,"plots/M%s/CS_BaselineTest/g2map_b.png", module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

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

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

}