#include "../sls_detector_calibration/jungfrauCommonHeader.h" #include "../sls_detector_calibration/jungfrauCommonFunctions.h" #include "../sls_detector_calibration/jungfrauFile.C" #include "../sls_detector_calibration/jungfrauPedestal.C" #include "TGraphErrors.h" #include "TF1.h" #include "TPaveStats.h" #include "TFile.h" #include "TPaveText.h" int main(int argc, char* argv[]) { jungfrauStyle(); gROOT->SetBatch(1); gStyle->SetOptFit(11); if (argc != 3) { cout << "Correct usage:" << endl; cout << "arg 1: specify module number" << endl; cout << "arg 2: specify data location" << endl; exit(1); } string module_str = argv[1]; string data_loc = argv[2]; int createHistos = 0; int createPerStepHistos = 0; jungfrauFile *thisfile = new jungfrauFile(); jungfrauPedestal *pedestalObjectG0 = new jungfrauPedestal(); pedestalObjectG0->pedestalSetNFrames(10); jungfrauPedestal *pedestalObjectG1 = new jungfrauPedestal(); pedestalObjectG1->pedestalSetNFrames(10); jungfrauPedestal *pedestalObjectG2 = new jungfrauPedestal(); pedestalObjectG2->pedestalSetNFrames(10); const int nSteps = 45; const int framesPerStep = 10; TH2F* avg_adcG0_map [nSteps]; TH2F* avg_adcG0er_map [nSteps]; TH2F* avg_adcG1_map [nSteps]; TH2F* avg_adcG1er_map [nSteps]; TH2F* avg_adcG2_map [nSteps]; TH2F* avg_adcG2er_map [nSteps]; char savename[128]; char filename[128]; double xs[nSteps]; for (int i = 0; i < 9; i++) { xs[i] = 5+(i*5); } for (int i = 0; i < 9; i++) { xs[i+9] = 50+(i*50); } for (int i = 0; i < 9; i++) { xs[i+18] = 500+(i*500); } for (int i = 0; i < 9; i++) { xs[i+27] = 5000+(i*5000); } for (int i = 0; i < 9; i++) { xs[i+36] = 50000+(i*50000); } 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",""); mapcanvas->cd(); TH1F* g0_grad_hist = new TH1F("g0_grad_hist","",100,0,3); TH1F* g0_grader_hist = new TH1F("g0_grader_hist","",100,0,0.002); TH1F* g1_grad_hist = new TH1F("g1_grad_hist","",100,-0.3,0.); TH1F* g1_grader_hist = new TH1F("g1_grader_hist","",100,0,0.005); TH1F* g2_grad_hist = new TH1F("g2_grad_hist","",100,-0.05,0.); TH1F* g2_grader_hist = new TH1F("g2_grader_hist","",100,0,0.0001); TH2F* no_g0g1_calib_map = new TH2F("no_g0g1_calib_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* no_g1g2_calib_map = new TH2F("no_g1g2_calib_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g0_grad_map = new TH2F("g0_grad_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g0_grader_map = new TH2F("g0_grader_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1_grad_map = new TH2F("g1_grad_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1_grader_map = new TH2F("g1_grader_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g2_grad_map = new TH2F("g2_grad_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g2_grader_map = new TH2F("g2_grader_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH1F* g0_const_hist = new TH1F("g0_const_hist","",100,1000,4000); TH1F* g0_conster_hist = new TH1F("g0_conster_hist","",100,0,2); TH1F* g1_const_hist = new TH1F("g1_const_hist","",100,10000,25000); TH1F* g1_conster_hist = new TH1F("g1_conster_hist","",100,0,100); TH1F* g2_const_hist = new TH1F("g2_const_hist","",100,10000,17000); TH1F* g2_conster_hist = new TH1F("g2_conster_hist","",100,0,20); TH2F* g0_const_map = new TH2F("g0_const_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g0_conster_map = new TH2F("g0_conster_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1_const_map = new TH2F("g1_const_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1_conster_map = new TH2F("g1_conster_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g2_const_map = new TH2F("g2_const_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g2_conster_map = new TH2F("g2_conster_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH1F* g0overg1_hist = new TH1F("g0overg1_hist","",100,-15,0); TH1F* g0overg1er_hist = new TH1F("g0overg1er_hist","",100,0,0.03); TH1F* g1overg2_hist = new TH1F("g1overg2_hist","",100,5,15); TH1F* g1overg2er_hist = new TH1F("g1overg2er_hist","",100,0,0.03); TH2F* g0overg1_map = new TH2F("g0overg1_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g0overg1er_map = new TH2F("g0overg1er_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1overg2_map = new TH2F("g1overg2_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); TH2F* g1overg2er_map = new TH2F("g1overg2er_map","",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); if (createHistos == 1) { for (int j = 0; j < nSteps; j++) { sprintf(savename,"avg_adcG0_map_%d", j); avg_adcG0_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); sprintf(savename,"avg_adcG0er_map_%d", j); avg_adcG0er_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); sprintf(savename,"avg_adcG1_map_%d", j); avg_adcG1_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); sprintf(savename,"avg_adcG1er_map_%d", j); avg_adcG1er_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); sprintf(savename,"avg_adcG2_map_%d", j); avg_adcG2_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); sprintf(savename,"avg_adcG2er_map_%d", j); avg_adcG2er_map[j] = new TH2F(savename,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5); } // data file sprintf(filename,"%s_%%6.6d.dat", data_loc.c_str()); // total frame number check int totalFrames = 0; for (int filei = 0; filei < 1; filei++) { thisfile->open((char*)filename, filei); while(thisfile->readNextFrame()) { totalFrames++; } thisfile->close(); } if (totalFrames == nSteps*framesPerStep) { cout << "expected number of frames " << totalFrames << endl; } else { cout << "unexpected number of frames " << totalFrames << endl; cout << "code expected frames " << nSteps*framesPerStep << endl; cout << "exiting to make sure you notice" << endl; exit(1); } int framecounter = 0; for (int filei = 0; filei < 1; filei++) { thisfile->open((char*)filename, filei); while(thisfile->readNextFrame()) { pedestalObjectG0->addG0FrameToPedestalCalculation(thisfile->getFrameDataHandle()); pedestalObjectG1->addG1FrameToPedestalCalculation(thisfile->getFrameDataHandle()); pedestalObjectG2->addG2FrameToPedestalCalculation(thisfile->getFrameDataHandle()); if ((framecounter+1)%framesPerStep == 0) { for (int i = 0; i < NCH; i++) { avg_adcG0_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG0->pedestalOfChannel(i)); avg_adcG0er_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG0->semOfChannel(i)); avg_adcG1_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG1->pedestalOfChannel(i)); avg_adcG1er_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG1->semOfChannel(i)); avg_adcG2_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG2->pedestalOfChannel(i)); avg_adcG2er_map[framecounter/framesPerStep]->SetBinContent((i%NC)+1,(i/NC)+1,pedestalObjectG2->semOfChannel(i)); } pedestalObjectG0->pedestalClear(); pedestalObjectG1->pedestalClear(); pedestalObjectG2->pedestalClear(); if (createPerStepHistos == 1) { avg_adcG0_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG0_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG0_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG0_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,17000); avg_adcG0_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adc_g0_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); avg_adcG0er_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG0er_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG0er_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG0er_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,5); avg_adcG0er_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adcer_g0_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); avg_adcG1_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG1_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG1_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG1_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,17000); avg_adcG1_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adc_g1_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); avg_adcG1er_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG1er_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG1er_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG1er_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,20); avg_adcG1er_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adcer_g1_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); avg_adcG2_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG2_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG2_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG2_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,17000); avg_adcG2_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adc_g2_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); avg_adcG2er_map[framecounter/framesPerStep]->GetXaxis()->SetTitle("Column"); avg_adcG2er_map[framecounter/framesPerStep]->GetYaxis()->SetTitle("Row"); avg_adcG2er_map[framecounter/framesPerStep]->GetYaxis()->SetTitleOffset(0.7); avg_adcG2er_map[framecounter/framesPerStep]->GetZaxis()->SetRangeUser(0,20); avg_adcG2er_map[framecounter/framesPerStep]->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/perStep/adcer_g2_map_%d_M%s.png", module_str.c_str(), framecounter/framesPerStep, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); } } framecounter++; } thisfile->close(); } // end of files // save histograms sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/LC_histos_M%s.root", module_str.c_str(), module_str.c_str()); TFile* saved_file = new TFile((const char *)(savename),"RECREATE"); for (int i = 0; i < nSteps; i++) { avg_adcG0_map[i]->Write(); avg_adcG1_map[i]->Write(); avg_adcG2_map[i]->Write(); avg_adcG0er_map[i]->Write(); avg_adcG1er_map[i]->Write(); avg_adcG2er_map[i]->Write(); } saved_file->Close(); } else { // load histos cout << "LOADING HISTOS" << endl; sprintf(savename,"/mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/M%s_CalibAna/LC_histos_M%s.root", module_str.c_str(), module_str.c_str()); TFile* saved_file = new TFile((const char *)(savename),"READ"); for (int i = 0; i < nSteps; i++) { sprintf(savename,"avg_adcG0_map_%d", i); avg_adcG0_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); sprintf(savename,"avg_adcG1_map_%d", i); avg_adcG1_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); sprintf(savename,"avg_adcG2_map_%d", i); avg_adcG2_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); sprintf(savename,"avg_adcG0er_map_%d", i); avg_adcG0er_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); sprintf(savename,"avg_adcG1er_map_%d", i); avg_adcG1er_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); sprintf(savename,"avg_adcG2er_map_%d", i); avg_adcG2er_map[i] = (TH2F*)saved_file->Get((const char *)(savename)); } } mapcanvas->SetLeftMargin(0.13); mapcanvas->SetRightMargin(0.05); mapcanvas->SetLogx(); for (int i = 0; i < NCH; i++) { vector r0_adc; vector r0_filter; vector r0_adcerr; vector r0_ferr; vector r1_adc; vector r1_filter; vector r1_adcerr; vector r1_ferr; vector r2_adc; vector r2_filter; vector r2_adcerr; vector r2_ferr; for (int j = 0; j < nSteps; j++) { double this_g0avg = avg_adcG0_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); double this_g1avg = avg_adcG1_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); double this_g2avg = avg_adcG2_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); double this_g0avger = avg_adcG0er_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); double this_g1avger = avg_adcG1er_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); double this_g2avger = avg_adcG2er_map[j]->GetBinContent((i%NC)+1,(i/NC)+1); if (this_g0avg != 0) { r0_filter.push_back(xs[j]); r0_ferr.push_back(0.); r0_adc.push_back(this_g0avg); r0_adcerr.push_back(this_g0avger); } if (this_g1avg != 0) { r1_filter.push_back(xs[j]); r1_ferr.push_back(0.); r1_adc.push_back(this_g1avg); r1_adcerr.push_back(this_g1avger); } if (this_g2avg != 0) { r2_filter.push_back(xs[j]); r2_ferr.push_back(0.); r2_adc.push_back(this_g2avg); r2_adcerr.push_back(this_g2avger); } } TGraphErrors *grap_g0 = 0; TGraphErrors *grap_g1 = 0; TGraphErrors *grap_g2 = 0; TF1 *fit_g0 = 0; TF1 *fit_g1 = 0; TF1 *fit_g2 = 0; double rangemin_g0 = 0; double rangemax_g0 = 0; double rangemin_g1 = 0; double rangemax_g1 = 0; double rangemin_g2 = 0; double rangemax_g2 = 0; // define graphs if (r0_adc.size() > 1) { grap_g0 = new TGraphErrors(r0_adc.size(),&(r0_filter[0]),&(r0_adc[0]),&(r0_ferr[0]),&(r0_adcerr[0])); grap_g0->SetMarkerStyle(20); grap_g0->SetMarkerColor(kBlue); grap_g0->SetLineColor(kBlue); } if (r1_adc.size() > 1) { grap_g1 = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc[0]),&(r1_ferr[0]),&(r1_adcerr[0])); grap_g1->SetMarkerStyle(20); grap_g1->SetMarkerColor(kGreen+2); grap_g1->SetLineColor(kGreen+2); } if (r2_adc.size() > 1) { grap_g2 = new TGraphErrors(r2_adc.size(),&(r2_filter[0]),&(r2_adc[0]),&(r2_ferr[0]),&(r2_adcerr[0])); grap_g2->SetMarkerStyle(20); grap_g2->SetMarkerColor(kRed); grap_g2->SetLineColor(kRed); } // plot the datapoints if (r0_adc.size() > 1) { if ((i >= 58000 && i < 58000+10) || // bulk (i >= 10 && i < 10+10) || // edge (i >= 1024+10 && i < 1024+10+10) || // inner edge (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double (i == (255*1024)+255) // quad ) { string pixel_type = "x"; if (i >= 58000 && i < 58000+10) { pixel_type = "b"; } else if (i >= 10 && i < 10+10) { pixel_type = "e"; } else if (i >= 1024+10 && i < 1024+10+10) { pixel_type = "ie"; } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) { pixel_type = "d"; } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) { pixel_type = "ntd"; } else if (i == (255*1024)+255) { pixel_type = "q"; } grap_g0->GetXaxis()->SetTitle("Integration time [#mus]"); grap_g0->GetYaxis()->SetTitle("ADC [ADU]"); grap_g0->GetYaxis()->SetTitleOffset(0.9); grap_g0->SetMinimum(1000); grap_g0->SetMaximum(15000); grap_g0->GetXaxis()->SetLimits(2,500000); grap_g0->Draw("AP"); if (r1_adc.size() > 1) { grap_g1->Draw("P"); } if (r2_adc.size() > 1) { grap_g2->Draw("P"); } mapcanvas->Update(); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); } } // define fit ranges and fit if (r0_adc.size() > 1) { rangemin_g0 = *min_element(r0_filter.begin(),r0_filter.end()); rangemax_g0 = highestPointBeforeSwitching(r0_filter,r1_filter); if (rangemax_g0 > rangemin_g0) { grap_g0->Fit("pol1","QRC","",rangemin_g0,rangemax_g0); fit_g0 = (TF1*) grap_g0->GetFunction("pol1"); fit_g0->SetLineColor(kBlue); fit_g0->SetParName(0,"G0 const"); fit_g0->SetParName(1,"G0 grad"); g0_grad_hist->Fill(fit_g0->GetParameter(1)); g0_grader_hist->Fill(fit_g0->GetParError(1)); g0_grad_map->Fill(i%NC,i/NC,fit_g0->GetParameter(1)); g0_grader_map->Fill(i%NC,i/NC,fit_g0->GetParError(1)); g0_const_hist->Fill(fit_g0->GetParameter(0)); g0_conster_hist->Fill(fit_g0->GetParError(0)); g0_const_map->Fill(i%NC,i/NC,fit_g0->GetParameter(0)); g0_conster_map->Fill(i%NC,i/NC,fit_g0->GetParError(0)); if ((i >= 58000 && i < 58000+10) || // bulk (i >= 10 && i < 10+10) || // edge (i >= 1024+10 && i < 1024+10+10) || // inner edge (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double (i == (255*1024)+255) // quad ) { string pixel_type = "x"; if (i >= 58000 && i < 58000+10) { pixel_type = "b"; } else if (i >= 10 && i < 10+10) { pixel_type = "e"; } else if (i >= 1024+10 && i < 1024+10+10) { pixel_type = "ie"; } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) { pixel_type = "d"; } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) { pixel_type = "ntd"; } else if (i == (255*1024)+255) { pixel_type = "q"; } grap_g0->GetXaxis()->SetTitle("Integration time [#mus]"); grap_g0->GetYaxis()->SetTitle("ADC [ADU]"); grap_g0->GetYaxis()->SetTitleOffset(0.9); grap_g0->SetMinimum(1000); grap_g0->SetMaximum(15000); grap_g0->GetXaxis()->SetLimits(*min_element(r0_filter.begin(),r0_filter.end()),*max_element(r0_filter.begin(),r0_filter.end())); grap_g0->Draw("AP"); fit_g0->Draw("same"); mapcanvas->Update(); TPaveStats *st0 = (TPaveStats*)grap_g0->FindObject("stats"); st0->SetX1NDC(0.2); st0->SetX2NDC(0.54); st0->SetY1NDC(0.18); st0->SetY2NDC(0.37); st0->SetBorderSize(0); st0->SetTextColor(kBlue); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g0_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); vector r0_adc_norm; for (size_t j = 0; j < r0_adc.size(); j++) { r0_adc_norm.push_back(r0_adc[j] - fit_g0->Eval(r0_filter[j])); } TGraphErrors *norm_g0 = new TGraphErrors(r0_adc.size(),&(r0_filter[0]),&(r0_adc_norm[0]),&(r0_ferr[0]),&(r0_adcerr[0])); norm_g0->SetMarkerColor(kBlue); norm_g0->SetLineColor(kBlue); TF1* flat_g0 = new TF1("flat_g0","0",rangemin_g0,rangemax_g0); flat_g0->SetLineColor(kBlue); TF1* lin_g0_p1pc = new TF1("lin_g0_p1pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_p1pc->SetParameter(0,fit_g0->GetParameter(0)/100.); lin_g0_p1pc->SetParameter(1,fit_g0->GetParameter(1)/100.); lin_g0_p1pc->SetLineColor(kRed); TF1* lin_g0_p05pc = new TF1("lin_g0_p05pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_p05pc->SetParameter(0,fit_g0->GetParameter(0)/200.); lin_g0_p05pc->SetParameter(1,fit_g0->GetParameter(1)/200.); lin_g0_p05pc->SetLineColor(kOrange+1); TF1* lin_g0_p02pc = new TF1("lin_g0_p02pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_p02pc->SetParameter(0,fit_g0->GetParameter(0)/500.); lin_g0_p02pc->SetParameter(1,fit_g0->GetParameter(1)/500.); lin_g0_p02pc->SetLineColor(kOrange); TF1* lin_g0_m1pc = new TF1("lin_g0_m1pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_m1pc->SetParameter(0,fit_g0->GetParameter(0)/-100.); lin_g0_m1pc->SetParameter(1,fit_g0->GetParameter(1)/-100.); lin_g0_m1pc->SetLineColor(kRed); TF1* lin_g0_m05pc = new TF1("lin_g0_m05pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_m05pc->SetParameter(0,fit_g0->GetParameter(0)/-200.); lin_g0_m05pc->SetParameter(1,fit_g0->GetParameter(1)/-200.); lin_g0_m05pc->SetLineColor(kOrange+1); TF1* lin_g0_m02pc = new TF1("lin_g0_m02pc","[0]+[1]*x",rangemin_g0,rangemax_g0); lin_g0_m02pc->SetParameter(0,fit_g0->GetParameter(0)/-500.); lin_g0_m02pc->SetParameter(1,fit_g0->GetParameter(1)/-500.); lin_g0_m02pc->SetLineColor(kOrange); norm_g0->GetXaxis()->SetRangeUser(*min_element(r0_filter.begin(),r0_filter.end()),*max_element(r0_filter.begin(),r0_filter.end())); norm_g0->SetMinimum(1.5*lin_g0_m02pc->Eval(rangemax_g0)); norm_g0->SetMaximum(1.5*lin_g0_p02pc->Eval(rangemax_g0)); norm_g0->GetXaxis()->SetTitle("Integration time [#mus]"); norm_g0->GetYaxis()->SetTitle("Normalised ADC [ADU]"); norm_g0->GetYaxis()->SetTitleOffset(0.9); norm_g0->Draw("AP"); flat_g0->Draw("same"); lin_g0_p1pc->Draw("same"); lin_g0_p05pc->Draw("same"); lin_g0_p02pc->Draw("same"); lin_g0_m1pc->Draw("same"); lin_g0_m05pc->Draw("same"); lin_g0_m02pc->Draw("same"); norm_g0->Draw("P"); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g0norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); delete norm_g0; } } } if (r1_adc.size() > 1) { rangemin_g1 = lowestPointAfterSwitching(r1_filter,r0_filter); rangemax_g1 = highestPointBeforeSwitching(r1_filter,r2_filter); if (rangemax_g1 > rangemin_g1) { grap_g1->Fit("pol1","QRC","",rangemin_g1,rangemax_g1); fit_g1 = (TF1*) grap_g1->GetFunction("pol1"); fit_g1->SetLineColor(kGreen+2); fit_g1->SetParName(0,"G1 const"); fit_g1->SetParName(1,"G1 grad"); g1_grad_hist->Fill(fit_g1->GetParameter(1)); g1_grader_hist->Fill(fit_g1->GetParError(1)); g1_grad_map->Fill(i%NC,i/NC,fit_g1->GetParameter(1)); g1_grader_map->Fill(i%NC,i/NC,fit_g1->GetParError(1)); g1_const_hist->Fill(fit_g1->GetParameter(0)); g1_conster_hist->Fill(fit_g1->GetParError(0)); g1_const_map->Fill(i%NC,i/NC,fit_g1->GetParameter(0)); g1_conster_map->Fill(i%NC,i/NC,fit_g1->GetParError(0)); if ((i >= 58000 && i < 58000+10) || // bulk (i >= 10 && i < 10+10) || // edge (i >= 1024+10 && i < 1024+10+10) || // inner edge (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double (i == (255*1024)+255) // quad ) { string pixel_type = "x"; if (i >= 58000 && i < 58000+10) { pixel_type = "b"; } else if (i >= 10 && i < 10+10) { pixel_type = "e"; } else if (i >= 1024+10 && i < 1024+10+10) { pixel_type = "ie"; } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) { pixel_type = "d"; } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) { pixel_type = "ntd"; } else if (i == (255*1024)+255) { pixel_type = "q"; } grap_g1->GetXaxis()->SetTitle("Integration time [#mus]"); grap_g1->GetYaxis()->SetTitle("ADC [ADU]"); grap_g1->GetYaxis()->SetTitleOffset(0.9); grap_g1->SetMinimum(1000); grap_g1->SetMaximum(15000); grap_g1->GetXaxis()->SetLimits(*min_element(r1_filter.begin(),r1_filter.end()),*max_element(r1_filter.begin(),r1_filter.end())); grap_g1->Draw("AP"); fit_g1->Draw("same"); mapcanvas->Update(); TPaveStats *st0 = (TPaveStats*)grap_g1->FindObject("stats"); st0->SetX1NDC(0.6); st0->SetX2NDC(0.94); st0->SetY1NDC(0.18); st0->SetY2NDC(0.37); st0->SetBorderSize(0); st0->SetTextColor(kGreen+2); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g1_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); vector r1_adc_norm; for (size_t j = 0; j < r1_adc.size(); j++) { r1_adc_norm.push_back(r1_adc[j] - fit_g1->Eval(r1_filter[j])); } TGraphErrors *norm_g1 = new TGraphErrors(r1_adc.size(),&(r1_filter[0]),&(r1_adc_norm[0]),&(r1_ferr[0]),&(r1_adcerr[0])); norm_g1->SetMarkerColor(kGreen+2); norm_g1->SetLineColor(kGreen+2); TF1* flat_g1 = new TF1("flat_gi","0",rangemin_g1,rangemax_g1); flat_g1->SetLineColor(kGreen+2); TF1* lin_g1_p02pc = new TF1("lin_g1_p02pc","[0]+[1]*x",rangemin_g1,rangemax_g1); lin_g1_p02pc->SetParameter(0,fit_g1->GetParameter(0)/500.); lin_g1_p02pc->SetParameter(1,fit_g1->GetParameter(1)/500.); lin_g1_p02pc->SetLineColor(kOrange); TF1* lin_g1_p01pc = new TF1("lin_g1_p01pc","[0]+[1]*x",rangemin_g1,rangemax_g1); lin_g1_p01pc->SetParameter(0,fit_g1->GetParameter(0)/1000.); lin_g1_p01pc->SetParameter(1,fit_g1->GetParameter(1)/1000.); lin_g1_p01pc->SetLineColor(kYellow); TF1* lin_g1_m02pc = new TF1("lin_g1_m02pc","[0]+[1]*x",rangemin_g1,rangemax_g1); lin_g1_m02pc->SetParameter(0,fit_g1->GetParameter(0)/-500.); lin_g1_m02pc->SetParameter(1,fit_g1->GetParameter(1)/-500.); lin_g1_m02pc->SetLineColor(kOrange); TF1* lin_g1_m01pc = new TF1("lin_g1_m01pc","[0]+[1]*x",rangemin_g1,rangemax_g1); lin_g1_m01pc->SetParameter(0,fit_g1->GetParameter(0)/-1000.); lin_g1_m01pc->SetParameter(1,fit_g1->GetParameter(1)/-1000.); lin_g1_m01pc->SetLineColor(kYellow); norm_g1->GetXaxis()->SetRangeUser(*min_element(r1_filter.begin(),r1_filter.end()),*max_element(r1_filter.begin(),r1_filter.end())); norm_g1->SetMinimum(1.5*lin_g1_m02pc->Eval(rangemin_g1)); norm_g1->SetMaximum(1.5*lin_g1_p02pc->Eval(rangemin_g1)); norm_g1->GetXaxis()->SetTitle("Integration time [#mus]"); norm_g1->GetYaxis()->SetTitle("Normalised ADC [ADU]"); norm_g1->GetYaxis()->SetTitleOffset(0.9); norm_g1->Draw("AP"); flat_g1->Draw("same"); lin_g1_p02pc->Draw("same"); lin_g1_p01pc->Draw("same"); lin_g1_m02pc->Draw("same"); lin_g1_m01pc->Draw("same"); norm_g1->Draw("P"); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g1norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); delete norm_g1; } } } if (r2_adc.size() > 1) { rangemin_g2 = lowestPointAfterSwitching(r2_filter,r1_filter); rangemax_g2 = *max_element(r2_filter.begin(),r2_filter.end()); if (rangemax_g2 > rangemin_g2) { grap_g2->Fit("pol1","QRC","",rangemin_g2,rangemax_g2); fit_g2 = (TF1*) grap_g2->GetFunction("pol1"); fit_g2->SetLineColor(kRed); fit_g2->SetParName(0,"G2 const"); fit_g2->SetParName(1,"G2 grad"); g2_grad_hist->Fill(fit_g2->GetParameter(1)); g2_grader_hist->Fill(fit_g2->GetParError(1)); g2_grad_map->Fill(i%NC,i/NC,fit_g2->GetParameter(1)); g2_grader_map->Fill(i%NC,i/NC,fit_g2->GetParError(1)); g2_const_hist->Fill(fit_g2->GetParameter(0)); g2_conster_hist->Fill(fit_g2->GetParError(0)); g2_const_map->Fill(i%NC,i/NC,fit_g2->GetParameter(0)); g2_conster_map->Fill(i%NC,i/NC,fit_g2->GetParError(0)); if ((i >= 58000 && i < 58000+10) || // bulk (i >= 10 && i < 10+10) || // edge (i >= 1024+10 && i < 1024+10+10) || // inner edge (i >= (256*1024)+10 && i < (256*1024)+10+10) || // double (i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double (i == (255*1024)+255) // quad ) { string pixel_type = "x"; if (i >= 58000 && i < 58000+10) { pixel_type = "b"; } else if (i >= 10 && i < 10+10) { pixel_type = "e"; } else if (i >= 1024+10 && i < 1024+10+10) { pixel_type = "ie"; } else if (i >= (256*1024)+10 && i < (256*1024)+10+10) { pixel_type = "d"; } else if (i >= (257*1024)+10 && i < (257*1024)+10+10) { pixel_type = "ntd"; } else if (i == (255*1024)+255) { pixel_type = "q"; } grap_g2->GetXaxis()->SetTitle("Integration time [#mus]"); grap_g2->GetYaxis()->SetTitle("ADC [ADU]"); grap_g2->GetYaxis()->SetTitleOffset(0.9); grap_g2->SetMinimum(1000); grap_g2->SetMaximum(15000); grap_g2->GetXaxis()->SetLimits(*min_element(r2_filter.begin(),r2_filter.end()),*max_element(r2_filter.begin(),r2_filter.end())); grap_g2->Draw("AP"); fit_g2->Draw("same"); mapcanvas->Update(); TPaveStats *st0 = (TPaveStats*)grap_g2->FindObject("stats"); st0->SetX1NDC(0.6); st0->SetX2NDC(0.94); st0->SetY1NDC(0.18); st0->SetY2NDC(0.37); st0->SetBorderSize(0); st0->SetTextColor(kRed); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g2_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); vector r2_adc_norm; for (size_t j = 0; j < r2_adc.size(); j++) { r2_adc_norm.push_back(r2_adc[j] - fit_g2->Eval(r2_filter[j])); } TGraphErrors *norm_g2 = new TGraphErrors(r2_adc.size(),&(r2_filter[0]),&(r2_adc_norm[0]),&(r2_ferr[0]),&(r2_adcerr[0])); norm_g2->SetMarkerColor(kRed); norm_g2->SetLineColor(kRed); TF1* flat_g2 = new TF1("flat_g2","0",rangemin_g2,rangemax_g2); flat_g2->SetLineColor(kRed); TF1* lin_g2_p02pc = new TF1("lin_g2_p02pc","[0]+[1]*x",rangemin_g2,rangemax_g2); lin_g2_p02pc->SetParameter(0,fit_g2->GetParameter(0)/500.); lin_g2_p02pc->SetParameter(1,fit_g2->GetParameter(1)/500.); lin_g2_p02pc->SetLineColor(kOrange); TF1* lin_g2_p01pc = new TF1("lin_g2_p01pc","[0]+[1]*x",rangemin_g2,rangemax_g2); lin_g2_p01pc->SetParameter(0,fit_g2->GetParameter(0)/1000.); lin_g2_p01pc->SetParameter(1,fit_g2->GetParameter(1)/1000.); lin_g2_p01pc->SetLineColor(kYellow); TF1* lin_g2_m02pc = new TF1("lin_g2_m02pc","[0]+[1]*x",rangemin_g2,rangemax_g2); lin_g2_m02pc->SetParameter(0,fit_g2->GetParameter(0)/-500.); lin_g2_m02pc->SetParameter(1,fit_g2->GetParameter(1)/-500.); lin_g2_m02pc->SetLineColor(kOrange); TF1* lin_g2_m01pc = new TF1("lin_g2_m01pc","[0]+[1]*x",rangemin_g2,rangemax_g2); lin_g2_m01pc->SetParameter(0,fit_g2->GetParameter(0)/-1000.); lin_g2_m01pc->SetParameter(1,fit_g2->GetParameter(1)/-1000.); lin_g2_m01pc->SetLineColor(kYellow); norm_g2->GetXaxis()->SetRangeUser(*min_element(r2_filter.begin(),r2_filter.end()),*max_element(r2_filter.begin(),r2_filter.end())); norm_g2->SetMinimum(1.5*lin_g2_m02pc->Eval(rangemin_g2)); norm_g2->SetMaximum(1.5*lin_g2_p02pc->Eval(rangemin_g2)); norm_g2->GetXaxis()->SetTitle("Integration time [#mus]"); norm_g2->GetYaxis()->SetTitle("Normalised ADC [ADU]"); norm_g2->GetYaxis()->SetTitleOffset(0.9); norm_g2->Draw("AP"); flat_g2->Draw("same"); lin_g2_p02pc->Draw("same"); lin_g2_p01pc->Draw("same"); lin_g2_m02pc->Draw("same"); lin_g2_m01pc->Draw("same"); norm_g2->Draw("P"); sprintf(savename,"plots/M%s/LeakageCurrent/pixel_%s_%d_g2norm_M%s.png", module_str.c_str(), pixel_type.c_str(), i, module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); delete norm_g2; } } } // get ratio measurements if (rangemax_g0 > rangemin_g0 && rangemax_g1 > rangemin_g1) { double this_g0overg1 = fit_g0->GetParameter(1)/fit_g1->GetParameter(1); double this_g0overg1er = sqrt(pow(fit_g0->GetParError(1)/fit_g0->GetParameter(1),2) + pow(fit_g1->GetParError(1)/fit_g1->GetParameter(1),2)); g0overg1_map->Fill(i%NC,i/NC,this_g0overg1); g0overg1_hist->Fill(this_g0overg1); g0overg1er_map->Fill(i%NC,i/NC,this_g0overg1er); g0overg1er_hist->Fill(this_g0overg1er); } else { no_g0g1_calib_map->Fill(i%NC,i/NC,1); } if (rangemax_g1 > rangemin_g1 && rangemax_g2 > rangemin_g2) { double this_g1overg2 = fit_g1->GetParameter(1)/fit_g2->GetParameter(1); double this_g1overg2er = sqrt(pow(fit_g1->GetParError(1)/fit_g1->GetParameter(1),2) + pow(fit_g2->GetParError(1)/fit_g2->GetParameter(1),2)); g1overg2_map->Fill(i%NC,i/NC,this_g1overg2); g1overg2_hist->Fill(this_g1overg2); g1overg2er_map->Fill(i%NC,i/NC,this_g1overg2er); g1overg2er_hist->Fill(this_g1overg2er); } else { no_g1g2_calib_map->Fill(i%NC,i/NC,1); } delete grap_g0; delete grap_g1; delete grap_g2; } mapcanvas->SetLeftMargin(0.1); mapcanvas->SetRightMargin(0.13); mapcanvas->SetLogx(0); c1->cd(); g0_grad_hist->GetXaxis()->SetTitle("G0 gradient"); g0_grad_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0_grad_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g0_grader_hist->GetXaxis()->SetTitle("#sigma_{G0 gradient}"); g0_grader_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0_grader_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1_grad_hist->GetXaxis()->SetTitle("G1 gradient"); g1_grad_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1_grad_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1_grader_hist->GetXaxis()->SetTitle("#sigma_{G1 gradient}"); g1_grader_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1_grader_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g2_grad_hist->GetXaxis()->SetTitle("G2 gradient"); g2_grad_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g2_grad_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g2_grader_hist->GetXaxis()->SetTitle("#sigma_{G2 gradient}"); g2_grader_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g2_grader_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g0_const_hist->GetXaxis()->SetTitle("G0 intercept"); g0_const_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0_const_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g0_conster_hist->GetXaxis()->SetTitle("#sigma_{G0 intercept}"); g0_conster_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0_conster_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1_const_hist->GetXaxis()->SetTitle("G1 intercept"); g1_const_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1_const_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1_conster_hist->GetXaxis()->SetTitle("#sigma_{G1 intercept}"); g1_conster_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1_conster_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g2_const_hist->GetXaxis()->SetTitle("G2 intercept"); g2_const_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g2_const_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g2_conster_hist->GetXaxis()->SetTitle("#sigma_{G2 intercept}"); g2_conster_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g2_conster_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); mapcanvas->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); g0_grad_map->GetXaxis()->SetTitle("Column"); g0_grad_map->GetYaxis()->SetTitle("Row"); g0_grad_map->GetYaxis()->SetTitleOffset(0.7); g0_grad_map->Draw("colz"); pave->AddText("G0 [ADU/mV]"); pave->Draw(); g0_grad_map->GetZaxis()->SetRangeUser(0.0,3.0); sprintf(savename,"plots/M%s/LeakageCurrent/g0_grad_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g0_grader_map->GetXaxis()->SetTitle("Column"); g0_grader_map->GetYaxis()->SetTitle("Row"); g0_grader_map->GetYaxis()->SetTitleOffset(0.7); g0_grader_map->Draw("colz"); pave->Clear(); pave->AddText("#sigma_{G0}"); pave->Draw(); g0_grader_map->GetZaxis()->SetRangeUser(0.0,0.002); sprintf(savename,"plots/M%s/LeakageCurrent/g0_grader_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1_grad_map->GetXaxis()->SetTitle("Column"); g1_grad_map->GetYaxis()->SetTitle("Row"); g1_grad_map->GetYaxis()->SetTitleOffset(0.7); g1_grad_map->Draw("colz"); pave->Clear(); pave->AddText("G1 [ADU/mV]"); pave->Draw(); g1_grad_map->GetZaxis()->SetRangeUser(-0.25,0.); sprintf(savename,"plots/M%s/LeakageCurrent/g1_grad_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1_grader_map->GetXaxis()->SetTitle("Column"); g1_grader_map->GetYaxis()->SetTitle("Row"); g1_grader_map->GetYaxis()->SetTitleOffset(0.7); g1_grader_map->Draw("colz"); pave->Clear(); pave->AddText("#sigma_{G1}"); pave->Draw(); g1_grader_map->GetZaxis()->SetRangeUser(0.0,0.005); sprintf(savename,"plots/M%s/LeakageCurrent/g1_grader_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g2_grad_map->GetXaxis()->SetTitle("Column"); g2_grad_map->GetYaxis()->SetTitle("Row"); g2_grad_map->GetYaxis()->SetTitleOffset(0.7); g2_grad_map->Draw("colz"); pave->Clear(); pave->AddText("G2 [ADU/mV]"); pave->Draw(); g2_grad_map->GetZaxis()->SetRangeUser(-0.05,0.); sprintf(savename,"plots/M%s/LeakageCurrent/g2_grad_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g2_grader_map->GetXaxis()->SetTitle("Column"); g2_grader_map->GetYaxis()->SetTitle("Row"); g2_grader_map->GetYaxis()->SetTitleOffset(0.7); g2_grader_map->Draw("colz"); pave->Clear(); pave->AddText("#sigma_{G2}"); pave->Draw(); g2_grader_map->GetZaxis()->SetRangeUser(0.0,0.0001); sprintf(savename,"plots/M%s/LeakageCurrent/g2_grader_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g0_const_map->GetXaxis()->SetTitle("Column"); g0_const_map->GetYaxis()->SetTitle("Row"); g0_const_map->GetYaxis()->SetTitleOffset(0.7); g0_const_map->Draw("colz"); g0_const_map->GetZaxis()->SetRangeUser(1500,3500); sprintf(savename,"plots/M%s/LeakageCurrent/g0_const_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g0_conster_map->GetXaxis()->SetTitle("Column"); g0_conster_map->GetYaxis()->SetTitle("Row"); g0_conster_map->GetYaxis()->SetTitleOffset(0.7); g0_conster_map->Draw("colz"); g0_conster_map->GetZaxis()->SetRangeUser(0.0,2.0); sprintf(savename,"plots/M%s/LeakageCurrent/g0_conster_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1_const_map->GetXaxis()->SetTitle("Column"); g1_const_map->GetYaxis()->SetTitle("Row"); g1_const_map->GetYaxis()->SetTitleOffset(0.7); g1_const_map->Draw("colz"); g1_const_map->GetZaxis()->SetRangeUser(13000,25000); sprintf(savename,"plots/M%s/LeakageCurrent/g1_const_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1_conster_map->GetXaxis()->SetTitle("Column"); g1_conster_map->GetYaxis()->SetTitle("Row"); g1_conster_map->GetYaxis()->SetTitleOffset(0.7); g1_conster_map->Draw("colz"); g1_conster_map->GetZaxis()->SetRangeUser(0.0,100.); sprintf(savename,"plots/M%s/LeakageCurrent/g1_conster_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g2_const_map->GetXaxis()->SetTitle("Column"); g2_const_map->GetYaxis()->SetTitle("Row"); g2_const_map->GetYaxis()->SetTitleOffset(0.7); g2_const_map->Draw("colz"); g2_const_map->GetZaxis()->SetRangeUser(13000,15000); sprintf(savename,"plots/M%s/LeakageCurrent/g2_const_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g2_conster_map->GetXaxis()->SetTitle("Column"); g2_conster_map->GetYaxis()->SetTitle("Row"); g2_conster_map->GetYaxis()->SetTitleOffset(0.7); g2_conster_map->Draw("colz"); g2_conster_map->GetZaxis()->SetRangeUser(0.0,20.); sprintf(savename,"plots/M%s/LeakageCurrent/g2_conster_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); c1->cd(); g0overg1_hist->GetXaxis()->SetTitle("G0 / G1"); g0overg1_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0overg1_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); TPaveText *pave2 = new TPaveText(0.6,0.8,0.94,0.94,"blNDC"); pave2->SetBorderSize(0); pave2->SetFillStyle(0); pave2->SetTextSize(0.04); pave2->SetTextAlign(32); g0overg1_hist->Fit("gaus"); g0overg1_hist->Draw(); c1->Update(); TF1* g0overg1hist_gaus = g0overg1_hist->GetFunction("gaus"); if (g0overg1hist_gaus) { sprintf(savename,"Mean %0.4f #pm %0.4f", g0overg1hist_gaus->GetParameter(1), g0overg1hist_gaus->GetParError(1)); pave2->AddText((const char *)(savename)); sprintf(savename,"Sigma %0.4f #pm %0.4f", g0overg1hist_gaus->GetParameter(2), g0overg1hist_gaus->GetParError(2)); pave2->AddText((const char *)(savename)); pave2->Draw(); } g0overg1_hist->SetStats(kFALSE); sprintf(savename,"plots/M%s/LeakageCurrent/g0overg1_histfit_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g0overg1er_hist->GetXaxis()->SetTitle("#sigma_{G0 / G1}"); g0overg1er_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g0overg1er_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1overg2_hist->GetXaxis()->SetTitle("G1 / G2"); g1overg2_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1overg2_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); TPaveText *pave3 = new TPaveText(0.6,0.8,0.94,0.94,"blNDC"); pave3->SetBorderSize(0); pave3->SetFillStyle(0); pave3->SetTextSize(0.04); pave3->SetTextAlign(32); g1overg2_hist->Fit("gaus"); g1overg2_hist->Draw(); c1->Update(); TF1* g1overg2hist_gaus = g1overg2_hist->GetFunction("gaus"); if (g1overg2hist_gaus) { sprintf(savename,"Mean %0.4f #pm %0.4f", g1overg2hist_gaus->GetParameter(1), g1overg2hist_gaus->GetParError(1)); pave3->AddText((const char *)(savename)); sprintf(savename,"Sigma %0.4f #pm %0.4f", g1overg2hist_gaus->GetParameter(2), g1overg2hist_gaus->GetParError(2)); pave3->AddText((const char *)(savename)); pave3->Draw(); } g1overg2_hist->SetStats(kFALSE); sprintf(savename,"plots/M%s/LeakageCurrent/g1overg2_histfit_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); g1overg2er_hist->GetXaxis()->SetTitle("#sigma_{G1 / G2}"); g1overg2er_hist->Draw(); sprintf(savename,"plots/M%s/LeakageCurrent/g1overg2er_hist_M%s.png", module_str.c_str(), module_str.c_str()); c1->SaveAs((const char *)(savename)); mapcanvas->cd(); g0overg1_map->GetXaxis()->SetTitle("Column"); g0overg1_map->GetYaxis()->SetTitle("Row"); g0overg1_map->GetYaxis()->SetTitleOffset(0.7); g0overg1_map->Draw("colz"); pave->Clear(); pave->AddText("G0/G1"); pave->Draw(); g0overg1_map->GetZaxis()->SetRangeUser(-15,0); sprintf(savename,"plots/M%s/LeakageCurrent/g0overg1_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g0overg1er_map->GetXaxis()->SetTitle("Column"); g0overg1er_map->GetYaxis()->SetTitle("Row"); g0overg1er_map->GetYaxis()->SetTitleOffset(0.7); g0overg1er_map->Draw("colz"); pave->Clear(); pave->AddText("#sigma_{G0/G1}"); pave->Draw(); g0overg1er_map->GetZaxis()->SetRangeUser(0,0.03); sprintf(savename,"plots/M%s/LeakageCurrent/g0overg1er_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1overg2_map->GetXaxis()->SetTitle("Column"); g1overg2_map->GetYaxis()->SetTitle("Row"); g1overg2_map->GetYaxis()->SetTitleOffset(0.7); g1overg2_map->Draw("colz"); pave->Clear(); pave->AddText("G1/G2"); pave->Draw(); g1overg2_map->GetZaxis()->SetRangeUser(5,15); sprintf(savename,"plots/M%s/LeakageCurrent/g1overg2_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); g1overg2er_map->GetXaxis()->SetTitle("Column"); g1overg2er_map->GetYaxis()->SetTitle("Row"); g1overg2er_map->GetYaxis()->SetTitleOffset(0.7); g1overg2er_map->Draw("colz"); pave->Clear(); pave->AddText("#sigma_{G1/G2}"); pave->Draw(); g1overg2er_map->GetZaxis()->SetRangeUser(0,0.03); sprintf(savename,"plots/M%s/LeakageCurrent/g1overg2er_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); no_g0g1_calib_map->GetXaxis()->SetTitle("Column"); no_g0g1_calib_map->GetYaxis()->SetTitle("Row"); no_g0g1_calib_map->GetYaxis()->SetTitleOffset(0.7); no_g0g1_calib_map->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/no_g0g1_calib_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); no_g1g2_calib_map->GetXaxis()->SetTitle("Column"); no_g1g2_calib_map->GetYaxis()->SetTitle("Row"); no_g1g2_calib_map->GetYaxis()->SetTitleOffset(0.7); no_g1g2_calib_map->Draw("colz"); sprintf(savename,"plots/M%s/LeakageCurrent/no_g1g2_calib_map_M%s.png", module_str.c_str(), module_str.c_str()); mapcanvas->SaveAs((const char *)(savename)); }