diff --git a/CuFluo_analysis_sc.cpp b/CuFluo_analysis_sc.cpp
new file mode 100644
index 0000000..a19384c
--- /dev/null
+++ b/CuFluo_analysis_sc.cpp
@@ -0,0 +1,927 @@
+// file to calculate pedestal correction of fluo data for all storage cells, only G0
+// make correction and save spectrum per pixel
+// then fit fluo spectrum per pixel
+// and save peak position and uncertainty
+// changes by VH 210906: to eliminate hardcoded absolute paths, uses location of the analysis root files as additional input argument (accordingly changed in filename_creator.sh)
+
+#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"
+
+#include <sys/stat.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);
+  }
+  */ //uncomment for SR
+
+  if (argc != 7) {
+    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 folder" << endl;
+    cout << "arg 4: specify pede file prefix" << endl;
+    cout << "arg 5: specify data file prefix" << endl;
+    cout << "arg 6: specify location of analysis root files" << endl;
+    cout << " " << endl;
+    exit(1);
+  } //uncomment for VH 210906
+
+  string module_str = argv[1];
+  string gain_str = argv[2];
+  bool isJF11=false;
+  if (gain_str == "HG0JF11") {
+    gain_str = "HG0";
+    isJF11=true;
+    }
+
+  string data_loc = argv[3];
+  string pede_file = argv[4];
+  string data_file = argv[5];
+  string anadata_loc = argv[6]; //uncomment for VH 210906
+
+  int createHistoFile = 1;
+
+  //char histoname[128];
+  //char savename[128];
+  char histoname[256]; // VH 210902
+  char savename[256];  // VH 210902
+  int filen = 352;
+  int pedefilen = 5;
+
+  // create necessary directories with permissions drwxrwxr-x
+  // data/Mxxx
+  sprintf(savename,"data/M%s", module_str.c_str());
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  // plots/Mxxx
+  sprintf(savename,"plots/M%s", module_str.c_str());
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  // plots/Mxxx/CuFluo
+  sprintf(savename,"plots/M%s/CuFluo", module_str.c_str());
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  // plots/Mxxx/CuFluo/G0
+  sprintf(savename,"plots/M%s/CuFluo/G0", module_str.c_str());
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  // plots/Mxxx/CuFluo/HG0
+  sprintf(savename,"plots/M%s/CuFluo/HG0", module_str.c_str());
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+  // /mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/Mxxx_CalibAna
+  //sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna", module_str.c_str()); //uncomment for SR
+  sprintf(savename,"%s", anadata_loc.c_str()); //uncomment for VH 210906
+  mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+
+  jungfrauPixelMask *pixelMaskObject = new jungfrauPixelMask();
+  bool pixel_mask [NCH];
+  pixelMaskObject->initialisePixelMask(pixel_mask);
+
+  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_SC[16];
+    TH2F *pedestalsG0[16];
+    TH2F *pedeRMSG0[16];
+    for (int sci = 0; sci < 16; ++sci) {
+      pedestalObject_SC[sci] = new jungfrauPedestal();
+      pedestalObject_SC[sci]->pedestalSetNFrames(100);
+
+      Char_t *pedhistoname = new Char_t[50];
+      snprintf( pedehistoname, 50, "pedestalsG0_sc%d", sci );
+      pedestalsG0[sci] = new TH2F(pedehistoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
+      snprintf( pedehistoname, 50, "pedeRMSG0_sc%d", sci );
+      pedeRMSG0[sci] = = new TH2F(pedehistoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
+    }
+    static uint16_t pedestals16_G0_start[16][NCH]{}; //I suppose, this is to track pedestal shifting over the course of data taking
+    static double pedeRMS16_G0[16][NCH]{};
+
+    for (int pedefilei = 0; filei < pedefilen; ++pedefilei) {
+    
+      // open pede file
+      sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), pede_file.c_str()); //VH: note, this adds a double slash in the filepath
+      thisfile->open((char*)savename, pedefilei);
+      
+      //count events in file
+      int nevents = 0;
+      while (thisfile->readNextFrame()) {
+	nevents++;
+      }
+      thisfile->rewind();
+      cout << "read " << nevents << " events" << endl;
+	
+      while (thisfile->readNextFrame()) {
+	// calculate pixel mask
+	pixelMaskObject->maskIfGainNot(0, thisfile->getFrameDataHandle(), pixel_mask);
+	// caluclate pedestals
+	pedestalObject[thisfile->currentSCnumber()]->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
+      }
+      
+      thisfile->close();
+      
+    } // end of loops over files
+
+    for (int sci = 0; sci < 16; ++sci) {
+      for (int i = 0; i < NCH; ++i) {
+	if (pixel_mask[i] == true) {
+	  pedestalsG0[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalOfChannel(i));
+	  pedeRMSG0[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->rmsOfChannel(i));
+	}
+      }
+      pedestalObject[sci]->pedestalData((uint16_t*)(&pedestals16_G0_start[sci])); //this loads the pedestal data into the array pedestals16_G0_start
+      pedestalObject[sci]->pedestalRMSData(pedeRMS16_G0[sci]); //same here
+      pedestalObject[sci]->pedestalResetUpdates();
+      //pedestalObject[sci]->pedestalClear(); //I don't need to clear if I only calculate pedestal once.
+    }
+
+    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;
+  
+    mapcanvas->cd();
+
+    for (int sci = 0; sci < 16; ++sci) {
+      
+      pedestalsG0[sci]->GetXaxis()->SetTitle("Column");
+      pedestalsG0[sci]->GetYaxis()->SetTitle("Row");
+      pedestalsG0[sci]->GetYaxis()->SetTitleOffset(0.7);
+      pedestalsG0[sci]->Draw("colz");
+      sprintf(savename,"plots/M%s/CuFluo/%s/pedeG0_sc%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, 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_sc%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, gain_str.c_str(), module_str.c_str());
+      mapcanvas->SaveAs((const char *)(savename));
+
+    }
+    
+    int adc2d_nbin= 1200;
+    if (isJF11) adc2d_nbin= 1600;
+      
+
+    TH2I *adc2d[8][16];
+    /*
+    TH2I *adc2d_2[16]; = new TH2I("adc2d_2","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*1-0.5),(65536*2-0.5));
+    TH2I *adc2d_3[16]; = new TH2I("adc2d_3","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*2-0.5),(65536*3-0.5));
+    TH2I *adc2d_4[16]; = new TH2I("adc2d_4","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*3-0.5),(65536*4-0.5));
+    TH2I *adc2d_5[14]; = new TH2I("adc2d_5","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*4-0.5),(65536*5-0.5));
+    TH2I *adc2d_6[16]; = new TH2I("adc2d_6","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*5-0.5),(65536*6-0.5));
+    TH2I *adc2d_7[16]; = new TH2I("adc2d_7","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*6-0.5),(65536*7-0.5));
+    TH2I *adc2d_8[16]; = new TH2I("adc2d_8","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*7-0.5),(65536*8-0.5));
+    */
+    TH1D *adcpc_spec[16];
+    TH2F *pede_updates[16];
+    TH2F *pede_diff[16];
+
+    for ( int sci = 0; sci < 16; ++sci ) {
+      Char_t *_histoname = new Char_t[50];
+      for ( int adci = 0; adci < 8; ++adci ) {
+	snprintf( _histoname, 50, "adc2d_%d_sc%d", (adci+1), sci );
+	adc2d[adci][sci] = new TH2I( _histoname,"",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,( 65536*adci-0.5 ),( 65536*( adci+1 )-0.5 ) );
+      }
+      
+      snprintf( _histoname, 50, "adcpc_spec_sc%d", sci );
+      adcpc_spec[sci] = new TH1D( _histoname,"",300,0,3000 ); //spectrum for every sc, every 10000 frames
+      snprintf( _histoname, 50, "pede_updates_sc%d", sci );
+      pede_updates[sci] = new TH2F( _histoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5 );
+      snprintf( _histoname, 50, "pede_diff_sc%d", sci );
+      pede_diff[sci] = new TH2F( _histoname,"",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()); //VH: note, this adds a double slash in the filepath
+      thisfile->open((char*)savename, filei);
+      
+      while (thisfile->readNextFrame()) {
+	
+	uint16_t* imagedptr = thisfile->getFrameDataHandle();
+	uint64_t scnumber = thisfile->currentSCnumber();
+	
+	pedestalObject[scnumber]->addG0FrameToPedestalCalculationWThreshold(imagedptr, pedestalObject[scnumber], pedeRMS16_G0[scnumber]);
+
+	for (int i = 0; i < NCH; i++) {
+	    
+	  uint16_t gain = (imagedptr[i]&0xc000) >> 14;
+	    
+	  if (gain == 0) {
+	      
+	    int adcpc = (imagedptr[i]&0x3fff) - pedestalObject[scnumber]->pedestalOfChannel(i);
+	    adcpc_spec->Fill(adcpc);
+	      
+	    if (i < (65536*1)) {
+	      adc2d[0][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*2)) {
+	      adc2d[1][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*3)) {
+	      adc2d[2][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*4)) {
+	      adc2d[3][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*5)) {
+	      adc2d[4][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*6)) {
+	      adc2d[5][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*7)) {
+	      adc2d[6][scnumber]->Fill(adcpc,i);
+	    } else if (i < (65536*8)) {
+	      adc2d[7][scnumber]->Fill(adcpc,i);
+	    }
+	  }
+	}
+      }
+      thisfile->close();
+
+      if ( filei%16 == 0 ) {
+      
+	for ( int sci = 0; sci < 16; ++sci ) {
+
+	  adcpc_spec[sci]->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
+	  adcpc_spec[sci]->Draw();
+	  mapcanvas->SetLogy();
+	  sprintf(savename,"plots/M%s/CuFluo/%s/adcpc_spec_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
+	  mapcanvas->SaveAs((const char *)(savename));
+	  mapcanvas->SetLogy(0);
+	  adcpc_spec[sci]->Reset();
+
+	  pede_updates[sci]->Reset();
+	  pede_diff[sci]->Reset();
+	  for (int i = 0; i < NCH; i++) {
+	    pede_updates[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalUpdates(i));
+	    pede_diff[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalOfChannel(i) - pedestals16_G0_start[sci][i]);
+	    pedestals16_G0_start[sci][i] = pedestalObject[sci]->pedestalOfChannel(i);
+	  }
+
+	  pede_updates[sci]->GetXaxis()->SetTitle("Column");
+	  pede_updates[sci]->GetYaxis()->SetTitle("Row");
+	  pede_updates[sci]->GetYaxis()->SetTitleOffset(0.7);
+	  pede_updates[sci]->GetZaxis()->SetRangeUser(0,10000);
+	  pede_updates[sci]->Draw("colz");
+	  sprintf(savename,"plots/M%s/CuFluo/%s/pede_updates_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
+	  mapcanvas->SaveAs((const char *)(savename));
+
+	  pede_diff[sci]->GetXaxis()->SetTitle("Column");
+	  pede_diff[sci]->GetYaxis()->SetTitle("Row");
+	  pede_diff[sci]->GetYaxis()->SetTitleOffset(0.7);
+	  pede_diff[sci]->GetZaxis()->SetRangeUser(-40,40);
+	  pede_diff[sci]->Draw("colz");
+	  sprintf(savename,"plots/M%s/CuFluo/%s/pede_diff_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
+	  mapcanvas->SaveAs((const char *)(savename));
+	  
+	  pedestalObject[sci]->pedestalResetUpdates();
+	
+	} //end of storage cell loop
+      
+      } //end of if filei%16
+
+    } // end of file loop
+
+    //sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
+    sprintf(savename,"%s/CuFluo_%s_file0to%d.root", anadata_loc.c_str(), gain_str.c_str(), filen-1); //uncomment for VH 210906
+    TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
+    for ( int adci = 0; adci < 8; ++adci ) {
+      for ( int sci = 0; sci < 16; ++sci ) {
+	adc2d[adci][sci]->Write();
+      }
+    }
+    saved_file->Close();
+    
+  } // end if i creatHistoFile
+
+  // We have saved the data into root-file. Now, we read from that same root-file and perform the fitting.
+
+  c1->cd();
+
+  //sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
+  sprintf(savename,"%s/CuFluo_%s_file0to%d.root", anadata_loc.c_str(), gain_str.c_str(), filen-1); //uncomment for VH 210906
+  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;
+    if  (isJF11) {
+        low_ADU_peak = 850;
+    high_ADU_peak = 1350;
+
+    }
+
+  } else if (gain_str == "G0") {
+    low_ADU_peak = 250;
+    high_ADU_peak = 400;
+  }
+
+  TH1F* fit_par3[16];
+  TH1F* fit_par4[16];
+  TH1F* fit_par5[16];
+  TH1F* fit_par6[16];
+  TH1F* fit_par7[16];
+
+  TH2F* fit_par3_2d[16];
+  TH2F* fit_par4_2d[16];
+  TH2F* fit_par5_2d[16];
+  TH2F* fit_par6_2d[16];
+  TH2F* fit_par7_2d[16];
+
+  TH1F* peak_fit_pos[16];
+  TH1F* peak_fit_poserr[16];
+  TH2F* peak_fit_pos_2d[16];
+  TH2F* peak_fit_poserr_2d[16];
+
+  TH1F* noise_fit_pos[16];
+  TH1F* noise_fit_poserr[16];
+  TH2F* noise_fit_pos_2d[16];
+  TH2F* noise_fit_poserr_2d[16];
+
+  TH1F* gain_fit[16];
+  TH1F* gain_fiterr[16];
+  TH2F* gain_fit_2d[16];
+  TH2F* gain_fiterr_2d[16];
+
+  TH1F* gain_fit_isEdge[16];
+  TH1F* gain_fit_isInnerEdge[16];
+  TH1F* gain_fit_isDouble[16];
+  TH1F* gain_fit_isNextToDouble[16];
+  TH1F* gain_fit_isQuad[16];
+  TH1F* gain_fit_isBulk[16];
+
+  TH2F* gain_ADUper1keV_2d[16];
+  TH2F* gainerr_ADUper1keV_2d[16];
+
+  for ( int sci = 0; sci < 16; ++sci ) {
+
+    Char_t *fithistoname = new Char_t[50];
+    snprintf( fithistoname, 50, "fit_par3_sc%d", sci );
+    fit_par3[sci] = new TH1F( fithistoname, "", 100, 0, 50 );
+    snprintf( fithistoname, 50, "fit_par4_sc%d", sci );
+    fit_par4[sci] = new TH1F( fithistoname, "", 100, 0, 500 );
+    snprintf( fithistoname, 50, "fit_par5_sc%d", sci );
+    fit_par5[sci] = new TH1F( fithistoname, "", 100, 0, 0.5 );
+    snprintf( fithistoname, 50, "fit_par6_sc%d", sci );
+    fit_par6[sci] = new TH1F( fithistoname, "", 100, 1.05, 1.25 );
+    snprintf( fithistoname, 50, "fit_par7_sc%d", sci );
+    fit_par7[sci] = new TH1F( fithistoname, "", 100, 0, 0.4 );
+
+    snprintf( fithistoname, 50, "fit_par3_2d_sc%d", sci );
+    fit_par3_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "fit_par4_2d_sc%d", sci );
+    fit_par4_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "fit_par5_2d_sc%d", sci );
+    fit_par5_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "fit_par6_2d_sc%d", sci );
+    fit_par6_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "fit_par7_2d_sc%d", sci );
+    fit_par7_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+   
+    snprintf( fithistoname, 50, "peak_fit_pos_sc%d", sci );
+    peak_fit_pos[sci]       = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "peak_fit_poserr_sc%d", sci );
+    peak_fit_poserr[sci]    = new TH1F( fithistoname, "", 100, 0, 2 );
+    snprintf( fithistoname, 50, "peak_fit_pos_2d_sc%d", sci );
+    peak_fit_pos_2d[sci]    = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "peak_fit_poserr_2d_sc%d", sci );
+    peak_fit_poserr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+
+    snprintf( fithistoname, 50, "noise_fit_pos_sc%d", sci );
+    noise_fit_pos[sci]       = new TH1F( fithistoname, "", 100, -10, 10 );
+    snprintf( fithistoname, 50, "noise_fit_poserr_sc%d", sci );
+    noise_fit_poserr[sci]    = new TH1F( fithistoname, "", 100, 0, 0.1 );
+    snprintf( fithistoname, 50, "noise_fit_pos_2d_sc%d", sci );
+    noise_fit_pos_2d[sci]    = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "noise_fit_poserr_2d_sc%d", sci );
+    noise_fit_poserr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+
+    snprintf( fithistoname, 50, "gain_fit_sc%d", sci );
+    gain_fit[sci]       = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fiterr_sc%d", sci );
+    gain_fiterr[sci]    = new TH1F( fithistoname, "", 100, 0, 2 );
+    snprintf( fithistoname, 50, "gain_fit_2d_sc%d", sci );
+    gain_fit_2d[sci]    = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "gain_fiterr_2d_sc%d", sci ); 
+    gain_fiterr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+
+    snprintf( fithistoname, 50, "gain_fit_isEdge_sc%d", sci );
+    gain_fit_isEdge[sci]         = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fit_isInnerEdge_sc%d", sci );
+    gain_fit_isInnerEdge[sci]    = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fit_isDouble_sc%d", sci );
+    gain_fit_isDouble[sci]       = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fit_isNextToDouble_sc%d", sci );
+    gain_fit_isNextToDouble[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fit_isQuad_sc%d", sci );
+    gain_fit_isQuad[sci]         = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+    snprintf( fithistoname, 50, "gain_fit_isBulk_sc%d", sci );
+    gain_fit_isBulk[sci]         = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
+
+    snprintf( fithistoname, 50, "gain_ADUper1keV_2d_sc%d", sci );
+    gain_ADUper1keV_2d[sci]    = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+    snprintf( fithistoname, 50, "gainerr_ADUper1keV_2d_sc%d", sci );
+    gainerr_ADUper1keV_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
+
+  } //end histo creating for loop
+
+  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;
+    if  (isJF11) {
+      low_bin_peak = 801;
+      high_bin_peak = 1451;
+    }
+
+  } else if (gain_str == "G0") {
+    low_bin_peak = 301;
+    high_bin_peak = 651;
+  }
+  
+  
+  for ( int sci = 0; sci < 16; ++sci ) {
+
+    for ( int j = 1; j < 9; ++j ) {
+      cout << "SC = " << sci << " slice " << j << endl;
+      sprintf( histoname, "adc2d_%d_sc%d", j, sci );
+      TH2I* adc2d_j = (TH2I*)( comb_file->Get( (const char *)(histoname) ) );
+      cout << adc2d_j->GetEntries() << endl;
+      adc2d_j->Draw("colz");
+      c1->Update();
+
+      //HERE!!!!!
+
+      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();
+
+}
diff --git a/CuFluo_exposure_sc.sh b/CuFluo_exposure_sc.sh
new file mode 100644
index 0000000..04b1b45
--- /dev/null
+++ b/CuFluo_exposure_sc.sh
@@ -0,0 +1,133 @@
+#!/bin/bash
+
+# to run do: bash CuFluo_exposure_sc.sh
+
+# prerequisites:
+# - the hostname is set
+# - export PATH=/afs/psi.ch/project/sls_det_software/latest_slsDetectorPackage/build/bin:$PATH
+# - export LD_LIBRARY_PATH=/afs/psi.ch/project/sls_det_software/latest_slsDetectorPackage/build/bin:$LD_LIBRARY_PATH
+# - detector is on
+# - xray tube is on and ramped for 40 kV, 60 mA, set to Cu
+
+sls_detector_put stop #just in case
+
+sls_detector_put powerchip 1
+
+
+sls_detector_put period 0.1 #0.03 #0.002
+sls_detector_put exptime 0.000007 #0.000010
+sls_detector_put extrastoragecells 15
+sls_detector_put storagecell_start 0
+sls_detector_put storagecell_delay 0.000025875 #to achieve effective sc period of 35us
+sls_detector_put highvoltage 200
+
+# configure for receiver on mpc2012
+sls_detector_put udp_dstport 32410
+sls_detector_put udp_dstip 10.1.4.105
+sls_detector_put udp_dstmac 3C:FD:FE:A2:14:D8
+sls_detector_put udp_srcip 10.1.4.9
+sls_detector_put udp_srcmac 00:ab:be:cc:dd:e2
+
+sls_detector_put readoutspeed 1
+#sls_detector_put reg 0x59 0x1310 #0001 0011 0001 0000
+
+#sls_detector_put readoutspeed 0 
+#sls_detector_put reg 0x59 0x0100 #0000 0001 0000 0000
+ 
+KILLRCV="killall ju_udp_receiver_3threads_2_0"
+$KILLRCV
+
+CLI=/afs/psi.ch/project/sls_det_software/bin/xrayClient_sl7 
+$CLI setv 40
+$CLI setc 60
+$CLI HV on
+
+sls_detector_put clearbit 0x5d 0
+
+$CLI shutter 1 off
+echo "warmin up the board"
+sls_detector_put frames 2500 #40000
+sls_detector_put start 
+sleep 260 #81 # 2500 * 30ms = 75s
+sls_detector_put stop 
+
+echo "end of board warm up"
+
+
+sls_detector_put frames 1000
+$KILLRCV 
+sleep 10 #1
+$TKPG0 &
+
+echo "recording G0 pede" 
+sls_detector_put start 
+sleep 105 #35 
+# 1000 frames (per sc) at 34 frames per second (period 30ms) takes 30s
+
+echo "recording G1 pede" 
+#sls_detector_put gainmode forceswitchg1 #consumes too much power
+sls_detector_put start 
+sleep 105 #35
+
+
+echo "recording G2 pede"
+#sls_detector_put gainmode forceswitchg2 #consumes too much power
+sls_detector_put start 
+sleep 105 #35
+
+
+sls_detector_put gainmode dynamic
+
+$KILLRCV
+echo "closed G0 pede file and open the G0 CuFluo file"
+sleep 10 #1 
+$TKFG0 &
+
+
+sls_detector_put frames 220000
+$CLI shutter 1 on
+sleep 10 #1
+sls_detector_put start 
+sleep 220100 #6800
+# 200k frames (per sc) at 34 frames per second (period 30ms) takes 6600s (1h 50min)
+$CLI shutter 1 off
+
+
+#We are not interested in HG0
+
+#$KILLRCV
+#echo "closed G0 CuFluo file and open HG0 pede file"
+#sleep 1 
+#$TKPHG0 &
+
+#sls_detector_put settings highgain0
+
+#sls_detector_put frames 1000
+
+#echo "recording HG0 pede" 
+#sls_detector_put start 
+#sleep 3 
+# 1000 frames at 500 frames per second takes 2s
+
+
+#$KILLRCV
+#echo "closed HG0 pede file and open the HG0 CuFluo file"
+#sleep 1 
+#$TKFHG0 &
+
+
+#sls_detector_put frames 220000
+#$CLI shutter 1 on
+#sleep 1
+#sls_detector_put start 
+#sleep 450
+# 200k frames at 500 frames per second takes 400s
+#$CLI shutter 1 off
+
+
+$CLI HV off
+
+$KILLRCV
+
+
+echo "Script finished"