1144 lines
45 KiB
C++
1144 lines
45 KiB
C++
|
|
#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<double> r0_adc;
|
|
vector<double> r0_filter;
|
|
vector<double> r0_adcerr;
|
|
vector<double> r0_ferr;
|
|
|
|
vector<double> r1_adc;
|
|
vector<double> r1_filter;
|
|
vector<double> r1_adcerr;
|
|
vector<double> r1_ferr;
|
|
|
|
vector<double> r2_adc;
|
|
vector<double> r2_filter;
|
|
vector<double> r2_adcerr;
|
|
vector<double> 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<double> 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<double> 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<double> 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));
|
|
|
|
}
|