// file to calculate pedestal correction of fluo data
// make correction and save spectrum per pixel
// then fit fluo spectrum per pixel
// and save peak position and uncertainty

#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 "../sls_detector_calibration/jungfrauPedestal.C"

#include "../sls_detector_calibration/energyCalibration.h"
#include "../sls_detector_calibration/energyCalibration.cpp"

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

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

  jungfrauStyle();
  gStyle->SetOptFit(11);

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

  string module_str = argv[1];
  string gain_str = argv[2];
  string data_loc = argv[3];
  string pede_file = argv[4];
  string data_file = argv[5];

  int createHistoFile = 0;

  char histoname[128];
  char savename[128];
  int filen = 20;

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

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

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

  if (createHistoFile) {

    jungfrauFile *thisfile = new jungfrauFile();

    jungfrauPedestal *pedestalObject = new jungfrauPedestal();
    pedestalObject->pedestalSetNFrames(100);
    static uint16_t pedestals16_G0_start[NCH];
    static double pedeRMS16_G0[NCH];

    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);
    
    // open pede file
    sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), pede_file.c_str());
    thisfile->open((char*)savename, 0);

    // calculate pixel mask
    pixelMaskObject->initialisePixelMask(pixel_mask);
    if (module_str == "004") {
      pixelMaskObject->maskChip(2, pixel_mask);
      pixelMaskObject->maskSupercolumn(3,2, 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->maskChip(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 == "223") {
      pixelMaskObject->maskChip(2,pixel_mask);
    } else if (module_str == "233") {
      pixelMaskObject->maskChip(7,pixel_mask);
    }

    int nevents = 0;
    while (thisfile->readNextFrame()) {
      nevents++;
    }
    thisfile->rewind();
    cout << "read " << nevents << " events" << endl;
    
    if (nevents == 2999 || nevents == 3000) {
      
      for (int i = 0; i < 1000; i++) {
	thisfile->readNextFrame();
	pixelMaskObject->maskIfGainNot(0, thisfile->getFrameDataHandle(), pixel_mask);
      }
      for (int i = 0; i < 1000; i++) {
	thisfile->readNextFrame();
	pixelMaskObject->maskIfGainNot(1, thisfile->getFrameDataHandle(), pixel_mask);
      }
      for (int i = 0; i < 999; i++) {
	thisfile->readNextFrame();
	pixelMaskObject->maskIfGainNot(3, thisfile->getFrameDataHandle(), pixel_mask);
      }
      
    } else {
      
      while (thisfile->readNextFrame()) {
	pixelMaskObject->maskIfGainNot(0, thisfile->getFrameDataHandle(), pixel_mask);
      }
    }
    
    thisfile->rewind();
  
    sprintf(savename,"plots/M%s/CuFluo/%s/pixelmask_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_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;
  
    // caluclate pedestals
    if (nevents == 2999 || nevents == 3000) {
      
      for (int i = 0; i < 1000; i++) {
	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 i = 0; i < 1000; i++) {
	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 i = 0; i < 999; i++) {
	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();
      
      // G0 again for pede tracking
      thisfile->rewind();
      for (int i = 0; i < 1000; i++) {
	thisfile->readNextFrame();
	pedestalObject->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
      }
      pedestalObject->pedestalData((uint16_t*)(&pedestals16_G0_start));
      pedestalObject->pedestalRMSData(pedeRMS16_G0);
      pedestalObject->pedestalResetUpdates();

    } else {
      
      while (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->pedestalData((uint16_t*)(&pedestals16_G0_start));
      pedestalObject->pedestalRMSData(pedeRMS16_G0);
      pedestalObject->pedestalResetUpdates();
    }
  
    thisfile->close();
  
    mapcanvas->cd();

    pedestalsG0->GetXaxis()->SetTitle("Column");
    pedestalsG0->GetYaxis()->SetTitle("Row");
    pedestalsG0->GetYaxis()->SetTitleOffset(0.7);
    pedestalsG0->Draw("colz");
    sprintf(savename,"plots/M%s/CuFluo/%s/pedeG0_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_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/CuFluo/%s/pedeG1_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_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/CuFluo/%s/pedeG2_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_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);
    pedeRMSG0->GetZaxis()->SetRangeUser(0,30);
    pedeRMSG0->Draw("colz");
    sprintf(savename,"plots/M%s/CuFluo/%s/pedeRMSG0_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
    mapcanvas->SaveAs((const char *)(savename));
    
    TH2I* adc2d_1 = new TH2I("adc2d_1","",1200,-200-0.5,1000-0.5,65536,(65536*0-0.5),(65536*1-0.5));
    TH2I* adc2d_2 = new TH2I("adc2d_2","",1200,-200-0.5,1000-0.5,65536,(65536*1-0.5),(65536*2-0.5));
    TH2I* adc2d_3 = new TH2I("adc2d_3","",1200,-200-0.5,1000-0.5,65536,(65536*2-0.5),(65536*3-0.5));
    TH2I* adc2d_4 = new TH2I("adc2d_4","",1200,-200-0.5,1000-0.5,65536,(65536*3-0.5),(65536*4-0.5));
    TH2I* adc2d_5 = new TH2I("adc2d_5","",1200,-200-0.5,1000-0.5,65536,(65536*4-0.5),(65536*5-0.5));
    TH2I* adc2d_6 = new TH2I("adc2d_6","",1200,-200-0.5,1000-0.5,65536,(65536*5-0.5),(65536*6-0.5));
    TH2I* adc2d_7 = new TH2I("adc2d_7","",1200,-200-0.5,1000-0.5,65536,(65536*6-0.5),(65536*7-0.5));
    TH2I* adc2d_8 = new TH2I("adc2d_8","",1200,-200-0.5,1000-0.5,65536,(65536*7-0.5),(65536*8-0.5));
    
    TH1D* adcpc_spec = new TH1D("adcpc_spec","",300,0,3000);

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

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

      // open data file
      sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), data_file.c_str());
      thisfile->open((char*)savename, filei);
      
      while (thisfile->readNextFrame()) {
	
	uint16_t* imagedptr = thisfile->getFrameDataHandle();
	
	pedestalObject->addG0FrameToPedestalCalculationWThreshold(imagedptr, pedestalObject, pedeRMS16_G0);

	for (int i = 0; i < NCH; i++) {
	  if (pixel_mask[i] == true) {
	    
	    uint16_t gain = (imagedptr[i]&0xc000) >> 14;
	    
	    if (gain == 0) {
	      
	      int adcpc = (imagedptr[i]&0x3fff) - pedestalObject->pedestalOfChannel(i);
	      adcpc_spec->Fill(adcpc);
	      
	      if (i < (65536*1)) {
		adc2d_1->Fill(adcpc,i);
	      } else if (i < (65536*2)) {
		adc2d_2->Fill(adcpc,i);
	      } else if (i < (65536*3)) {
		adc2d_3->Fill(adcpc,i);
	      } else if (i < (65536*4)) {
		adc2d_4->Fill(adcpc,i);
	      } else if (i < (65536*5)) {
		adc2d_5->Fill(adcpc,i);
	      } else if (i < (65536*6)) {
		adc2d_6->Fill(adcpc,i);
	      } else if (i < (65536*7)) {
		adc2d_7->Fill(adcpc,i);
	      } else if (i < (65536*8)) {
		adc2d_8->Fill(adcpc,i);
	      }
	    }
	  }
	}
      }
      thisfile->close();
      
      adcpc_spec->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
      adcpc_spec->Draw();
      mapcanvas->SetLogy();
      sprintf(savename,"plots/M%s/CuFluo/%s/adcpc_spec_file%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), filei, gain_str.c_str(), module_str.c_str());
      mapcanvas->SaveAs((const char *)(savename));
      mapcanvas->SetLogy(0);
      adcpc_spec->Reset();
      
      pede_updates->Reset();
      pede_diff->Reset();
      for (int i = 0; i < NCH; i++) {
	pede_updates->Fill(i%NC,i/NC,pedestalObject->pedestalUpdates(i));
	pede_diff->Fill(i%NC,i/NC,pedestalObject->pedestalOfChannel(i) - pedestals16_G0_start[i]);
	pedestals16_G0_start[i] = pedestalObject->pedestalOfChannel(i);
      }

      pede_updates->GetXaxis()->SetTitle("Column");
      pede_updates->GetYaxis()->SetTitle("Row");
      pede_updates->GetYaxis()->SetTitleOffset(0.7);
      pede_updates->GetZaxis()->SetRangeUser(0,10000);
      pede_updates->Draw("colz");
      sprintf(savename,"plots/M%s/CuFluo/%s/pede_updates_file%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), filei, gain_str.c_str(), module_str.c_str());
      mapcanvas->SaveAs((const char *)(savename));

      pede_diff->GetXaxis()->SetTitle("Column");
      pede_diff->GetYaxis()->SetTitle("Row");
      pede_diff->GetYaxis()->SetTitleOffset(0.7);
      pede_diff->GetZaxis()->SetRangeUser(-40,40);
      pede_diff->Draw("colz");
      sprintf(savename,"plots/M%s/CuFluo/%s/pede_diff_file%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), filei, gain_str.c_str(), module_str.c_str());
      mapcanvas->SaveAs((const char *)(savename));

      pedestalObject->pedestalResetUpdates();

    } // end of file loop

    sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
    TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
    adc2d_1->Write();
    adc2d_2->Write();
    adc2d_3->Write();
    adc2d_4->Write();
    adc2d_5->Write();
    adc2d_6->Write();
    adc2d_7->Write();
    adc2d_8->Write();
    saved_file->Close();
    
  }

  c1->cd();

  sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
  TFile* comb_file = new TFile((const char *)(savename),"READ");

  pixelMaskObject->initialisePixelMask(pixel_mask);

  int low_ADU_peak = 0;
  int high_ADU_peak = 0;
  if (gain_str == "HG0") {
    low_ADU_peak = 700;
    high_ADU_peak = 900;
  } else if (gain_str == "G0") {
    low_ADU_peak = 250;
    high_ADU_peak = 400;
  }

  TH1F* fit_par3 = new TH1F("fit_par3","",100,0,50);
  TH1F* fit_par4 = new TH1F("fit_par4","",100,0,500);
  TH1F* fit_par5 = new TH1F("fit_par5","",100,0,0.5);
  TH1F* fit_par6 = new TH1F("fit_par6","",100,1.05,1.25);
  TH1F* fit_par7 = new TH1F("fit_par7","",100,0,0.4);

  TH2F* fit_par3_2d = new TH2F("fit_par3_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* fit_par4_2d = new TH2F("fit_par4_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* fit_par5_2d = new TH2F("fit_par5_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* fit_par6_2d = new TH2F("fit_par6_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* fit_par7_2d = new TH2F("fit_par7_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH1F* peak_fit_pos = new TH1F("peak_fit_pos","",100,low_ADU_peak,high_ADU_peak);
  TH1F* peak_fit_poserr = new TH1F("peak_fit_poserr","",100,0,2);
  TH2F* peak_fit_pos_2d = new TH2F("peak_fit_pos_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* peak_fit_poserr_2d = new TH2F("peak_fit_poserr_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH1F* noise_fit_pos = new TH1F("noise_fit_pos","",100,-10,10);
  TH1F* noise_fit_poserr = new TH1F("noise_fit_poserr","",100,0,0.1);
  TH2F* noise_fit_pos_2d = new TH2F("noise_fit_pos_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* noise_fit_poserr_2d = new TH2F("noise_fit_poserr_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH1F* gain_fit = new TH1F("gain_fit","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fiterr = new TH1F("gain_fiterr","",100,0,2);
  TH2F* gain_fit_2d = new TH2F("gain_fit_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
  TH2F* gain_fiterr_2d = new TH2F("gain_fiterr_2d","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);

  TH1F* gain_fit_isEdge = new TH1F("gain_fit_isEdge","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fit_isInnerEdge = new TH1F("gain_fit_isInnerEdge","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fit_isDouble = new TH1F("gain_fit_isDouble","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fit_isNextToDouble = new TH1F("gain_fit_isNextToDouble","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fit_isQuad = new TH1F("gain_fit_isQuad","",100,low_ADU_peak,high_ADU_peak);
  TH1F* gain_fit_isBulk = new TH1F("gain_fit_isBulk","",100,low_ADU_peak,high_ADU_peak);

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

  int low_bin_noise = 101;
  int high_bin_noise = 301;
  int low_bin_peak = 0;
  int high_bin_peak = 0;
  if (gain_str == "HG0") {
    low_bin_peak = 701;
    high_bin_peak = 1200;
  } else if (gain_str == "G0") {
    low_bin_peak = 301;
    high_bin_peak = 651;
  }

  for (int j=1; j<9; j++) {
    cout << "slice " << j << endl;
    sprintf(histoname,"adc2d_%i",j);
    TH2I* adc2d_j = (TH2I*)(comb_file->Get((const char *)(histoname)));
    cout << adc2d_j->GetEntries() << endl;
    adc2d_j->Draw("colz");
    c1->Update();

    for (int i=(65536*(j-1)); i<(65536*(j)); i++) {

      if (i%10000==0){cout << "another 10k" << endl;}

      TH1D* proj = adc2d_j->ProjectionX("bin1",i-(65536*(j-1))+1,i-(65536*(j-1))+1);

      if (proj->Integral(low_bin_noise,high_bin_noise)!=0 && proj->Integral(low_bin_peak,high_bin_peak)!=0) {

	// noise
	TH1D *proj_noise = dynamic_cast<TH1D*>(proj->Rebin(4,"proj_noise"));
	proj_noise->SetStats(kTRUE);
	proj_noise->GetXaxis()->SetRangeUser(proj->GetBinLowEdge(low_bin_noise),proj->GetBinLowEdge(high_bin_noise+1));
	proj_noise->Fit("gaus","Q");
	TF1 *fit = proj_noise->GetFunction("gaus");

	noise_fit_pos->Fill(fit->GetParameter(1));
	noise_fit_pos_2d->Fill(i%NC,i/NC,fit->GetParameter(1));
	noise_fit_poserr->Fill(fit->GetParError(1));
	noise_fit_poserr_2d->Fill(i%NC,i/NC,fit->GetParError(1));

	// peak
	TH1D *proj_peak = dynamic_cast<TH1D*>(proj->Rebin(4,"proj_peak"));
	proj_peak->SetStats(kTRUE);
	proj_peak->GetXaxis()->SetRangeUser(proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));

	Double_t mypar[8];
	mypar[0] = 0.0;
	mypar[1] = 0.0;
	mypar[2] = proj_peak->GetBinCenter(proj_peak->GetMaximumBin());
	if (gain_str == "G0") {
	  mypar[3] = 16.;
	} else if (gain_str == "HG0") {
	  mypar[3] = 29.;
	}
	mypar[4] = proj_peak->GetBinContent(proj_peak->GetMaximumBin());
	if (gain_str == "G0") {
	  mypar[5] = 0.17;
	} else if (gain_str == "HG0") {
	  mypar[5] = 0.14;
	}
	mypar[6] = 1.12;
	if (gain_str == "G0") {
	  mypar[7] = 0.12;
	} else if (gain_str == "HG0") {
	  mypar[7] = 0.14;
	}

	Double_t emypar[8];
	energyCalibration *thiscalibration = new energyCalibration();
	thiscalibration->setScanSign(1);
	thiscalibration->setStartParametersKb(mypar);
	thiscalibration->fixParameter(0,0.); // no background
	thiscalibration->fixParameter(1,0.);
	TF1* fittedfun = thiscalibration->fitSpectrumKb(proj_peak,mypar,emypar);

	fit_par3->Fill(mypar[3]);
	fit_par4->Fill(mypar[4]);
	fit_par5->Fill(mypar[5]);
	fit_par6->Fill(mypar[6]);
	fit_par7->Fill(mypar[7]);

	fit_par3_2d->Fill(i%NC,i/NC,mypar[3]);
	fit_par4_2d->Fill(i%NC,i/NC,mypar[4]);
	fit_par5_2d->Fill(i%NC,i/NC,mypar[5]);
	fit_par6_2d->Fill(i%NC,i/NC,mypar[6]);
	fit_par7_2d->Fill(i%NC,i/NC,mypar[7]);

	peak_fit_pos->Fill(mypar[2]);
	peak_fit_poserr->Fill(emypar[2]);
	peak_fit_pos_2d->Fill(i%NC,i/NC,mypar[2]);
	peak_fit_poserr_2d->Fill(i%NC,i/NC,emypar[2]);

	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";
	  }
	    
	  proj_noise->Draw();
	  c1->Update();
	  proj_noise->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
	  proj_noise->GetXaxis()->SetRangeUser(-100,150);
	  fit->SetParNames("N_{#gamma}", "Peak pos", "Noise RMS");
	  TPaveStats *st0 = (TPaveStats*)proj_noise->FindObject("stats");
	  st0->SetX1NDC(0.53);
	  st0->SetX2NDC(0.94);
	  st0->SetY1NDC(0.75);
	  st0->SetY2NDC(0.94);
	  st0->SetBorderSize(0);
	  st0->SetTextSize(0.04);
	  sprintf(savename,"plots/M%s/CuFluo/%s/noise_%s_%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), pixel_type.c_str(), i, gain_str.c_str(), module_str.c_str());
	  c1->SaveAs((const char *)(savename));

	  TF1 *gaus_Ka = new TF1("gaus_Ka","gaus",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
	  gaus_Ka->SetParameters(mypar[4],mypar[2],mypar[3]);
	  gaus_Ka->SetLineColor(kBlue);
	
	  TF1 *erfc_Ka = new TF1("erfc_Ka","[0]/2.*(TMath::Erfc(([1]*(x-[2])/[3])/(TMath::Sqrt(2.))))",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
	  erfc_Ka->SetParameters(mypar[4]*mypar[5], 1, mypar[2], mypar[3]);
	  erfc_Ka->SetLineColor(kOrange);

	  TF1 *gaus_Kb = new TF1("gaus_Kb","gaus",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
	  gaus_Kb->SetParameters(mypar[4]*mypar[7],mypar[6]*mypar[2],mypar[3]);
	  gaus_Kb->SetLineColor(kGreen+2);

	  TF1 *erfc_Kb = new TF1("erfc_Kb","[0]/2.*(TMath::Erfc(([1]*(x-[2])/[3])/(TMath::Sqrt(2.))))",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
	  erfc_Kb->SetParameters(mypar[4]*mypar[7]*mypar[5], 1, mypar[6]*mypar[2], mypar[3]);
	  erfc_Kb->SetLineColor(kOrange+7);

	  proj_peak->Draw();
	  erfc_Kb->Draw("same");
	  erfc_Ka->Draw("same");
	  gaus_Kb->Draw("same");
	  gaus_Ka->Draw("same");
	  fittedfun->Draw("same");
	  c1->Update();
	  proj_peak->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
	  fittedfun->SetParNames("Bkg height", "Bkg grad", "K_{#alpha} pos", "Noise RMS", "K_{#alpha} height", "CS", "K_{#beta}/K_{#alpha} pos", "K_{#beta} frac");
	  TPaveStats *st = (TPaveStats*)proj_peak->FindObject("stats");
	  st->SetX1NDC(0.22);
	  st->SetX2NDC(0.62);
	  st->SetY1NDC(0.7);
	  st->SetY2NDC(0.94);
	  st->SetBorderSize(0);
	  st->SetTextSize(0.04);
	  sprintf(savename,"plots/M%s/CuFluo/%s/peak_%s_%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), pixel_type.c_str(), i, gain_str.c_str(), module_str.c_str());
	  c1->SaveAs((const char *)(savename));
	}

	// gain
	gain_fit->Fill(mypar[2] - fit->GetParameter(1));
	gain_fiterr->Fill(sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)));
	gain_fit_2d->Fill(i%NC,i/NC,mypar[2] - fit->GetParameter(1));
	gain_fiterr_2d->Fill(i%NC,i/NC,sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)));
	gain_ADUper1keV_2d->Fill(i%NC,i/NC,(mypar[2] - fit->GetParameter(1)) / 8.0);
	gainerr_ADUper1keV_2d->Fill(i%NC,i/NC,sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)) / 8.0);

	if (isEdge(i)) {
	  gain_fit_isEdge->Fill(mypar[2] - fit->GetParameter(1));
	}
	if (isInnerEdge(i)) {
	  gain_fit_isInnerEdge->Fill(mypar[2] - fit->GetParameter(1));
	}
	if (isDouble(i)) {
	  gain_fit_isDouble->Fill(mypar[2] - fit->GetParameter(1));
	}
	if (isNextToDouble(i)) {
	  gain_fit_isNextToDouble->Fill(mypar[2] - fit->GetParameter(1));
	}
	if (isQuad(i)) {
	  gain_fit_isQuad->Fill(mypar[2] - fit->GetParameter(1));
	}
	if (isBulk(i)) {
	  gain_fit_isBulk->Fill(mypar[2] - fit->GetParameter(1));
	}

	delete thiscalibration;
	delete proj_noise;
	delete proj_peak;
	delete proj;

      } else {
	pixel_mask[i] = false;
      }
    }
  }

  sprintf(savename,"plots/M%s/CuFluo/%s/pixelmask_afterfit_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  pixelMaskObject->plotPixelMask(pixel_mask,savename);

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

  mapcanvas->cd();

  fit_par3_2d->GetXaxis()->SetTitle("Column");
  fit_par3_2d->GetYaxis()->SetTitle("Row");
  fit_par3_2d->GetYaxis()->SetTitleOffset(0.7);
  fit_par3_2d->Draw("colz");
  fit_par3_2d->GetZaxis()->SetRangeUser(0,50);
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par3_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  fit_par4_2d->GetXaxis()->SetTitle("Column");
  fit_par4_2d->GetYaxis()->SetTitle("Row");
  fit_par4_2d->GetYaxis()->SetTitleOffset(0.7);
  fit_par4_2d->Draw("colz");
  fit_par4_2d->GetZaxis()->SetRangeUser(0,500);
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par4_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  fit_par5_2d->GetXaxis()->SetTitle("Column");
  fit_par5_2d->GetYaxis()->SetTitle("Row");
  fit_par5_2d->GetYaxis()->SetTitleOffset(0.7);
  fit_par5_2d->Draw("colz");
  fit_par5_2d->GetZaxis()->SetRangeUser(0,0.5);
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par5_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  fit_par6_2d->GetXaxis()->SetTitle("Column");
  fit_par6_2d->GetYaxis()->SetTitle("Row");
  fit_par6_2d->GetYaxis()->SetTitleOffset(0.7);
  fit_par6_2d->Draw("colz");
  fit_par6_2d->GetZaxis()->SetRangeUser(1.0,1.25);
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par6_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  fit_par7_2d->GetXaxis()->SetTitle("Column");
  fit_par7_2d->GetYaxis()->SetTitle("Row");
  fit_par7_2d->GetYaxis()->SetTitleOffset(0.7);
  fit_par7_2d->Draw("colz");
  fit_par7_2d->GetZaxis()->SetRangeUser(0.,0.4);
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par7_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  peak_fit_pos_2d->GetXaxis()->SetTitle("Column");
  peak_fit_pos_2d->GetYaxis()->SetTitle("Row");
  peak_fit_pos_2d->GetYaxis()->SetTitleOffset(0.7);
  peak_fit_pos_2d->Draw("colz");
  peak_fit_pos_2d->GetZaxis()->SetRangeUser(low_ADU_peak,high_ADU_peak);
  sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_pos_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  peak_fit_poserr_2d->GetXaxis()->SetTitle("Column");
  peak_fit_poserr_2d->GetYaxis()->SetTitle("Row");
  peak_fit_poserr_2d->GetYaxis()->SetTitleOffset(0.7);
  peak_fit_poserr_2d->Draw("colz");
  peak_fit_poserr_2d->GetZaxis()->SetRangeUser(0,2);
  sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_poserr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  noise_fit_pos_2d->GetXaxis()->SetTitle("Column");
  noise_fit_pos_2d->GetYaxis()->SetTitle("Row");
  noise_fit_pos_2d->GetYaxis()->SetTitleOffset(0.7);
  noise_fit_pos_2d->Draw("colz");
  noise_fit_pos_2d->GetZaxis()->SetRangeUser(-5,5);
  sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_pos_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  noise_fit_poserr_2d->GetXaxis()->SetTitle("Column");
  noise_fit_poserr_2d->GetYaxis()->SetTitle("Row");
  noise_fit_poserr_2d->GetYaxis()->SetTitleOffset(0.7);
  noise_fit_poserr_2d->Draw("colz");
  if (gain_str == "HG0") {
    noise_fit_poserr_2d->GetZaxis()->SetRangeUser(0,0.1);
  } else if (gain_str == "G0") {
    noise_fit_poserr_2d->GetZaxis()->SetRangeUser(0,0.05);
  }
  sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_poserr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  gain_fit_2d->GetXaxis()->SetTitle("Column");
  gain_fit_2d->GetYaxis()->SetTitle("Row");
  gain_fit_2d->GetYaxis()->SetTitleOffset(0.7);
  gain_fit_2d->Draw("colz");
  sprintf(savename,"%s [ADU/8 keV]", gain_str.c_str());
  pave->AddText((const char *)(savename));
  pave->Draw();
  gain_fit_2d->GetZaxis()->SetRangeUser(low_ADU_peak,high_ADU_peak);
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  gain_fiterr_2d->GetXaxis()->SetTitle("Column");
  gain_fiterr_2d->GetYaxis()->SetTitle("Row");
  gain_fiterr_2d->GetYaxis()->SetTitleOffset(0.7);
  gain_fiterr_2d->Draw("colz");
  gain_fiterr_2d->GetZaxis()->SetRangeUser(0,2);
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fiterr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  gain_ADUper1keV_2d->GetXaxis()->SetTitle("Column");
  gain_ADUper1keV_2d->GetYaxis()->SetTitle("Row");
  gain_ADUper1keV_2d->GetYaxis()->SetTitleOffset(0.7);
  gain_ADUper1keV_2d->Draw("colz");
  if (gain_str == "HG0") {
    gain_ADUper1keV_2d->GetZaxis()->SetRangeUser(80,120);
  } else if (gain_str == "G0") {
    gain_ADUper1keV_2d->GetZaxis()->SetRangeUser(35,50);
  }
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_ADUper1keV_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  gainerr_ADUper1keV_2d->GetXaxis()->SetTitle("Column");
  gainerr_ADUper1keV_2d->GetYaxis()->SetTitle("Row");
  gainerr_ADUper1keV_2d->GetYaxis()->SetTitleOffset(0.7);
  gainerr_ADUper1keV_2d->Draw("colz");
  if (gain_str == "HG0") {
    gainerr_ADUper1keV_2d->GetZaxis()->SetRangeUser(0,0.5);
  } else if (gain_str == "G0") {
    gainerr_ADUper1keV_2d->GetZaxis()->SetRangeUser(0,0.25);
  }
  sprintf(savename,"plots/M%s/CuFluo/%s/gainerr_ADUper1keV_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  mapcanvas->SaveAs((const char *)(savename));

  c1->cd();

  fit_par3->GetXaxis()->SetTitle("Fit par 3");
  fit_par3->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par3_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  fit_par4->GetXaxis()->SetTitle("Fit par 4");
  fit_par4->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par4_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  fit_par5->GetXaxis()->SetTitle("Fit par 5");
  fit_par5->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par5_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  fit_par6->GetXaxis()->SetTitle("Fit par 6");
  fit_par6->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par6_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  fit_par7->GetXaxis()->SetTitle("Fit par 7");
  fit_par7->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/fit_par7_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  peak_fit_pos->GetXaxis()->SetTitle("Peak position [ADU]");
  peak_fit_pos->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_pos_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  peak_fit_poserr->GetXaxis()->SetTitle("Peak position uncert [ADU]");
  peak_fit_poserr->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_poserr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  noise_fit_pos->GetXaxis()->SetTitle("Noise position [ADU]");
  noise_fit_pos->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_pos_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  noise_fit_poserr->GetXaxis()->SetTitle("Noise position uncert [ADU]");
  noise_fit_poserr->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_poserr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  sprintf(savename,"Gain %s [ADU / 8 keV]", gain_str.c_str());
  gain_fit->GetXaxis()->SetTitle((const char *)(savename));
  gain_fit->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  gain_fit->GetXaxis()->SetRangeUser(low_ADU_peak+30, high_ADU_peak);
  gain_fit->Fit("gaus");
  gain_fit->Draw();
  c1->Update();
  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);
  TF1* gain_fit_gaus = gain_fit->GetFunction("gaus");
  sprintf(savename,"Mean %0.2f #pm %0.2f", gain_fit_gaus->GetParameter(1), gain_fit_gaus->GetParError(1));
  pave2->AddText((const char *)(savename));
  sprintf(savename,"Sigma %0.2f #pm %0.2f", gain_fit_gaus->GetParameter(2), gain_fit_gaus->GetParError(2));
  pave2->AddText((const char *)(savename));
  pave2->Draw();
  gain_fit->SetStats(kFALSE);
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_fit_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  gain_fiterr->GetXaxis()->SetTitle("Gain uncert [ADU / 8 keV]");
  gain_fiterr->Draw();
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fiterr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  gain_fit_isEdge->SetLineColor(kBlue);
  gain_fit_isInnerEdge->SetLineColor(kCyan);
  gain_fit_isDouble->SetLineColor(kGreen+2);
  gain_fit_isNextToDouble->SetLineColor(kRed);
  gain_fit_isQuad->SetLineColor(kOrange);

  gain_fit_isEdge->Scale(1./gain_fit_isEdge->GetEntries());
  gain_fit_isInnerEdge->Scale(1./gain_fit_isInnerEdge->GetEntries());
  gain_fit_isDouble->Scale(1./gain_fit_isDouble->GetEntries());
  gain_fit_isNextToDouble->Scale(1./gain_fit_isNextToDouble->GetEntries());
  gain_fit_isQuad->Scale(1./gain_fit_isQuad->GetEntries());
  gain_fit_isBulk->Scale(1./gain_fit_isBulk->GetEntries());

  TLegend *leg = new TLegend(0.62,0.6,0.93,0.93);
  leg->AddEntry(gain_fit_isBulk, "Normal", "l");
  leg->AddEntry(gain_fit_isDouble, "Double", "l");
  leg->AddEntry(gain_fit_isNextToDouble, "Next to D", "l");
  leg->AddEntry(gain_fit_isEdge, "Edge", "l");
  leg->AddEntry(gain_fit_isInnerEdge, "Inner E", "l");

  sprintf(savename,"Gain %s [ADU / 8 keV]", gain_str.c_str());
  gain_fit_isDouble->GetXaxis()->SetTitle((const char *)(savename));
  gain_fit_isDouble->GetYaxis()->SetTitle("Normalised");
  gain_fit_isDouble->GetYaxis()->SetTitleOffset(1.3);
  gain_fit_isDouble->SetMinimum(0.0);
  gain_fit_isDouble->SetMaximum(0.16);
  gain_fit_isDouble->Draw();
  gain_fit_isEdge->Draw("same");
  gain_fit_isInnerEdge->Draw("same");
  gain_fit_isNextToDouble->Draw("same");
  gain_fit_isBulk->Draw("same");
  leg->Draw("same");
  sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_perType_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
  c1->SaveAs((const char *)(savename));

  sprintf(savename,"data/M%s/CuFluo_gain_%s_M%s.root", module_str.c_str(), gain_str.c_str(), module_str.c_str());
  TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
  gain_ADUper1keV_2d->Write();
  gainerr_ADUper1keV_2d->Write();
  saved_file->Close();

}