From 540695ba3cfdd0aa24118f6f5e9f3fc08a004f7d Mon Sep 17 00:00:00 2001 From: redford_s Date: Wed, 13 Dec 2017 15:21:25 +0100 Subject: [PATCH] Adding code to test the effect of the increasing integration time on the current source measurement. --- .gitignore | 1 + CS_BaselineTest.cpp | 1127 +++++++++++++++++++++++++++++++++ run_JFModuleCalib_CuFBDCS.txt | 2 + 3 files changed, 1130 insertions(+) create mode 100644 CS_BaselineTest.cpp diff --git a/.gitignore b/.gitignore index 1246fa2..f2c67f3 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ JFMC_CuFluoPeakFit JFMC_CurrentSourceScan JFMC_DirectBeamScan BP_DB_Comp +CS_BaselineTest JFMC_ModuleComp data/ diff --git a/CS_BaselineTest.cpp b/CS_BaselineTest.cpp new file mode 100644 index 0000000..5d03cb5 --- /dev/null +++ b/CS_BaselineTest.cpp @@ -0,0 +1,1127 @@ +// file to check the integration time alone doesn't alter the baseline + +#include "/afs/psi.ch/project/mythen/sophie/sls_detector_calibration/jungfrauCommonHeader.h" +#include "/afs/psi.ch/project/mythen/sophie/sls_detector_calibration/jungfrauCommonFunctions.h" + +#include "/afs/psi.ch/project/mythen/sophie/sls_detector_calibration/jungfrauFile.C" +#include "/afs/psi.ch/project/mythen/sophie/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 +#include + +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 << "eg: ./JFMC_CurrentSourceScan 006 ..." << 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(); + static int 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] == 1) { + 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] == 1) { + 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] == 1) { + + 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] == 1) { + + // original CS + vector r1_adc; + vector r1_filter; + vector r1_adcerr; + vector r1_ferr; + + vector r3_adc; + vector r3_filter; + vector r3_adcerr; + vector r3_ferr; + + // CS - baseline + vector r1_adc_csmb; + vector r3_adc_csmb; + + // baselines + vector r1_adc_b; + vector 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(15000); + 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 r1_adc_norm; + vector 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(-10000); + grap_g1_csmb->SetMaximum(10000); + 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.21); + st0->SetY2NDC(0.40); + 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.21); + st1->SetY2NDC(0.40); + 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 r1_adc_norm_csmb; + vector 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(13000); + 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.21); + st0->SetY2NDC(0.40); + 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.21); + st1->SetY2NDC(0.40); + 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 r1_adc_norm_b; + vector 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->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->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->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(-1,1); + cs_csmb_diffmap->Draw("colz"); + sprintf(savename,"plots/M%s/CS_BaselineTest/cs_csmb_diffmap.png", module_str.c_str()); + mapcanvas->SaveAs((const char *)(savename)); + +} diff --git a/run_JFModuleCalib_CuFBDCS.txt b/run_JFModuleCalib_CuFBDCS.txt index e509b62..6e55020 100644 --- a/run_JFModuleCalib_CuFBDCS.txt +++ b/run_JFModuleCalib_CuFBDCS.txt @@ -8,6 +8,7 @@ Module 006 ./JFMC_DirectBeamScan 006 /mnt/pcmoench_jungfrau_data/Module_006_161116 100us_500Hz_QS_allgain_pede_1055 100us_500Hz_QS_beam_scan_a ./BP_DB_Comp 006 ./JFMC_CurrentSourceScan 006 /mnt/pcmoench_jungfrau_data1_ib/Module_006_2017-08-21_CSBaselineTest CurrentSource_scan12 +./CS_BaselineTest 006 /mnt/pcmoench_jungfrau_data1_ib/Module_006_2017-08-21_CSBaselineTest CurrentSource_scan12 BaselineG1_scan12 BaselineG2_scan12 Module 008 @@ -118,6 +119,7 @@ Module 065 ./JFMC_CuFluoPeak 065 G0 /mnt/pcmoench_jungfrau_data1_ib/Module_065_2017-08-29_Calib AllPede_1621 CuFluo_10us_500Hz ./JFMC_CuFluoPeakFit 065 G0 ./JFMC_CurrentSourceScan 065 /mnt/pcmoench_jungfrau_data1_ib/Module_065_2017-08-29_Calib CurrentSource_scan1 +./CS_BaselineTest 065 /mnt/pcmoench_jungfrau_data1_ib/Module_065_2017-08-29_Calib CurrentSource_scan1 BaselineG1_scan1 BaselineG2_scan1 Module 066