diff --git a/.gitignore b/.gitignore index 9c9a1bc..1a3f4c6 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ BP_analysis JFMC_CalibWriter_wBP JFMC_BadPixels LP_analysis +LC_analysis data/ plots/ diff --git a/LC_analysis.cpp b/LC_analysis.cpp new file mode 100644 index 0000000..cbb0ea3 --- /dev/null +++ b/LC_analysis.cpp @@ -0,0 +1,1143 @@ + +#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)); + +} diff --git a/LC_scan.sh b/LC_scan.sh new file mode 100644 index 0000000..3a47169 --- /dev/null +++ b/LC_scan.sh @@ -0,0 +1,89 @@ +#!/bin/bash + +# to run do: bash LC_scan.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 + +sls_detector_put powerchip 1 + +# set ADCINVERSionreg (by trial and error) +sls_detector_put reg 0x43 0x453b2a9c + +sls_detector_put period 1.0 +sls_detector_put vhighvoltage 200 +sls_detector_put frames 10 + +# configure for receiver on mpc2012 +sls_detector_put rx_udpport 32410 +sls_detector_put rx_udpip 10.1.3.105 +sls_detector_put rx_udpmac 3C:FD:FE:A2:14:D9 +sls_detector_put detectorip 10.1.3.9 +sls_detector_put detectormac 00:ab:be:cc:dd:e2 +sls_detector_put configuremac 0 + + +echo "The receiver should be waiting for data" +echo "Please check and press any key to continue, or press q to exit this script" +read -n 1 -s input +if [[ $input = "q" ]]; then + echo "Exiting script" + exit 1 +fi + + +for tint in {5..45..5} +do +tint_sec=$(printf %.6f $(echo "$tint/1000000" | bc -l)) +echo "setting integration time to (s) " $tint_sec +sls_detector_put exptime $tint_sec +sleep 1 +sls_detector_put status start +sleep 11 +done + +for tint in {5..45..5} +do +tint_sec=$(printf %.6f $(echo "$tint/100000" | bc -l)) +echo "setting integration time to (s) " $tint_sec +sls_detector_put exptime $tint_sec +sleep 1 +sls_detector_put status start +sleep 11 +done + +for tint in {5..45..5} +do +tint_sec=$(printf %.6f $(echo "$tint/10000" | bc -l)) +echo "setting integration time to (s) " $tint_sec +sls_detector_put exptime $tint_sec +sleep 1 +sls_detector_put status start +sleep 11 +done + +for tint in {5..45..5} +do +tint_sec=$(printf %.6f $(echo "$tint/1000" | bc -l)) +echo "setting integration time to (s) " $tint_sec +sls_detector_put exptime $tint_sec +sleep 1 +sls_detector_put status start +sleep 11 +done + +for tint in {5..45..5} +do +tint_sec=$(printf %.6f $(echo "$tint/100" | bc -l)) +echo "setting integration time to (s) " $tint_sec +sls_detector_put exptime $tint_sec +sleep 1 +sls_detector_put status start +sleep 11 +done + +echo "Finished scan" +echo "Script finished" diff --git a/makefile b/makefile index ab357c4..216e714 100644 --- a/makefile +++ b/makefile @@ -30,4 +30,7 @@ JFMC_BadPixels: JFMC_BadPixels.cpp g++ -Wall -O3 -m64 -I$(ROOTSYS)/include -L$(ROOTSYS)/lib -lGui -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lMathCore -lThread -pthread -lm -ldl -rdynamic JFMC_BadPixels.cpp -o JFMC_BadPixels LP_analysis: LP_analysis.cpp - g++ -Wall -O3 -m64 -I$(ROOTSYS)/include -L$(ROOTSYS)/lib -lGui -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lMathCore -lThread -pthread -lm -ldl -rdynamic LP_analysis.cpp -o LP_analysis \ No newline at end of file + g++ -Wall -O3 -m64 -I$(ROOTSYS)/include -L$(ROOTSYS)/lib -lGui -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lMathCore -lThread -pthread -lm -ldl -rdynamic LP_analysis.cpp -o LP_analysis + +LC_analysis: LC_analysis.cpp + g++ -Wall -O3 -m64 -I$(ROOTSYS)/include -L$(ROOTSYS)/lib -lGui -lCore -lCint -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix -lPhysics -lMathCore -lThread -pthread -lm -ldl -rdynamic LC_analysis.cpp -o LC_analysis \ No newline at end of file diff --git a/run_JFCalibration.txt b/run_JFCalibration.txt index 541d718..7ba3056 100644 --- a/run_JFCalibration.txt +++ b/run_JFCalibration.txt @@ -1054,6 +1054,7 @@ Module 250 ./CuFluo_analysis 250 HG0 /mnt/pcmoench_jungfrau_calib/data/Module_250_Calib pedeHG0_M250_2019-02-15 CuFluoHG0_M250_2019-02-15 ./BP_analysis 250 /mnt/pcmoench_jungfrau_calib/data/Module_250_Calib/BP_M250_2019-02-14 ./CS_analysis 250 /mnt/pcmoench_jungfrau_calib/data/Module_250_Calib CS_M250_2019-02-14 +./LC_analysis 250 /mnt/pcmoench_jungfrau_calib/data/Module_250_Calib/LC_M250_2019-02-19 ./JFMC_CalibWriter_wBP 250