detectors/JFCalibration
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adapt CuFluo scripts for storage cell operation, intermediate commit

Browse Source
This commit is contained in:
hinger_v
2022-05-06 14:52:17 +02:00
parent 3b5183da4b
commit 9d3c0544ce
2 changed files with 1060 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

927
CuFluo_analysis_sc.cpp Normal file
View File

@ -0,0 +1,927 @@
// file to calculate pedestal correction of fluo data for all storage cells, only G0
// make correction and save spectrum per pixel
// then fit fluo spectrum per pixel
// and save peak position and uncertainty
// changes by VH 210906: to eliminate hardcoded absolute paths, uses location of the analysis root files as additional input argument (accordingly changed in filename_creator.sh)
#include "../sls_detector_calibration/jungfrauCommonHeader.h"
#include "../sls_detector_calibration/jungfrauCommonFunctions.h"
#include "../sls_detector_calibration/jungfrauFile.C"
#include "../sls_detector_calibration/jungfrauPixelMask.C"
#include "../sls_detector_calibration/jungfrauPedestal.C"
#include "../sls_detector_calibration/energyCalibration.h"
#include "../sls_detector_calibration/energyCalibration.cpp"
#include "TGraph.h"
#include "TGraphErrors.h"
#include "TF1.h"
#include "TFile.h"
#include "TPaveStats.h"
#include "TLegend.h"
#include "TPaveText.h"
#include <sys/stat.h>
int main(int argc, char* argv[]) {
jungfrauStyle();
gStyle->SetOptFit(11);
/*
if (argc != 6) {
cout << "Correct usage:" << endl;
cout << "arg 1: specify module number" << endl;
cout << "arg 2: specify HG0 or G0" << endl;
cout << "arg 3: specify data location" << endl;
cout << "arg 4: specify pede file" << endl;
cout << "arg 5: specify data file" << endl;
cout << " " << endl;
exit(1);
}
*/ //uncomment for SR
if (argc != 7) {
cout << "Correct usage:" << endl;
cout << "arg 1: specify module number" << endl;
cout << "arg 2: specify HG0 or G0" << endl;
cout << "arg 3: specify data location folder" << endl;
cout << "arg 4: specify pede file prefix" << endl;
cout << "arg 5: specify data file prefix" << endl;
cout << "arg 6: specify location of analysis root files" << endl;
cout << " " << endl;
exit(1);
} //uncomment for VH 210906
string module_str = argv[1];
string gain_str = argv[2];
bool isJF11=false;
if (gain_str == "HG0JF11") {
gain_str = "HG0";
isJF11=true;
}
string data_loc = argv[3];
string pede_file = argv[4];
string data_file = argv[5];
string anadata_loc = argv[6]; //uncomment for VH 210906
int createHistoFile = 1;
//char histoname[128];
//char savename[128];
char histoname[256]; // VH 210902
char savename[256]; // VH 210902
int filen = 352;
int pedefilen = 5;
// create necessary directories with permissions drwxrwxr-x
// data/Mxxx
sprintf(savename,"data/M%s", module_str.c_str());
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
// plots/Mxxx
sprintf(savename,"plots/M%s", module_str.c_str());
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
// plots/Mxxx/CuFluo
sprintf(savename,"plots/M%s/CuFluo", module_str.c_str());
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
// plots/Mxxx/CuFluo/G0
sprintf(savename,"plots/M%s/CuFluo/G0", module_str.c_str());
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
// plots/Mxxx/CuFluo/HG0
sprintf(savename,"plots/M%s/CuFluo/HG0", module_str.c_str());
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
// /mnt/pcmoench_jungfrau_data/jungfrau_ana_sophie/Mxxx_CalibAna
//sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna", module_str.c_str()); //uncomment for SR
sprintf(savename,"%s", anadata_loc.c_str()); //uncomment for VH 210906
mkdir(savename, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
jungfrauPixelMask *pixelMaskObject = new jungfrauPixelMask();
bool pixel_mask [NCH];
pixelMaskObject->initialisePixelMask(pixel_mask);
TCanvas *mapcanvas = new TCanvas("mapcanvas","",150,10,800,400);
mapcanvas->SetLeftMargin(0.1);
mapcanvas->SetRightMargin(0.13);
mapcanvas->SetTopMargin(0.08);
mapcanvas->SetBottomMargin(0.15);
TCanvas* c1 = new TCanvas("c1","");
if (createHistoFile) {
jungfrauFile *thisfile = new jungfrauFile();
jungfrauPedestal *pedestalObject_SC[16];
TH2F *pedestalsG0[16];
TH2F *pedeRMSG0[16];
for (int sci = 0; sci < 16; ++sci) {
pedestalObject_SC[sci] = new jungfrauPedestal();
pedestalObject_SC[sci]->pedestalSetNFrames(100);
Char_t *pedhistoname = new Char_t[50];
snprintf( pedehistoname, 50, "pedestalsG0_sc%d", sci );
pedestalsG0[sci] = new TH2F(pedehistoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
snprintf( pedehistoname, 50, "pedeRMSG0_sc%d", sci );
pedeRMSG0[sci] = = new TH2F(pedehistoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5);
}
static uint16_t pedestals16_G0_start[16][NCH]{}; //I suppose, this is to track pedestal shifting over the course of data taking
static double pedeRMS16_G0[16][NCH]{};
for (int pedefilei = 0; filei < pedefilen; ++pedefilei) {
// open pede file
sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), pede_file.c_str()); //VH: note, this adds a double slash in the filepath
thisfile->open((char*)savename, pedefilei);
//count events in file
int nevents = 0;
while (thisfile->readNextFrame()) {
nevents++;
}
thisfile->rewind();
cout << "read " << nevents << " events" << endl;
while (thisfile->readNextFrame()) {
// calculate pixel mask
pixelMaskObject->maskIfGainNot(0, thisfile->getFrameDataHandle(), pixel_mask);
// caluclate pedestals
pedestalObject[thisfile->currentSCnumber()]->addFrameToPedestalCalculation(thisfile->getFrameDataHandle());
}
thisfile->close();
} // end of loops over files
for (int sci = 0; sci < 16; ++sci) {
for (int i = 0; i < NCH; ++i) {
if (pixel_mask[i] == true) {
pedestalsG0[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalOfChannel(i));
pedeRMSG0[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->rmsOfChannel(i));
}
}
pedestalObject[sci]->pedestalData((uint16_t*)(&pedestals16_G0_start[sci])); //this loads the pedestal data into the array pedestals16_G0_start
pedestalObject[sci]->pedestalRMSData(pedeRMS16_G0[sci]); //same here
pedestalObject[sci]->pedestalResetUpdates();
//pedestalObject[sci]->pedestalClear(); //I don't need to clear if I only calculate pedestal once.
}
sprintf(savename,"plots/M%s/CuFluo/%s/pixelmask_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
pixelMaskObject->plotPixelMask(pixel_mask,savename);
cout << "after chip mask, n masked pixels is " << pixelMaskObject->getNMasked(pixel_mask) << endl;
mapcanvas->cd();
for (int sci = 0; sci < 16; ++sci) {
pedestalsG0[sci]->GetXaxis()->SetTitle("Column");
pedestalsG0[sci]->GetYaxis()->SetTitle("Row");
pedestalsG0[sci]->GetYaxis()->SetTitleOffset(0.7);
pedestalsG0[sci]->Draw("colz");
sprintf(savename,"plots/M%s/CuFluo/%s/pedeG0_sc%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
pedeRMSG0->GetXaxis()->SetTitle("Column");
pedeRMSG0->GetYaxis()->SetTitle("Row");
pedeRMSG0->GetYaxis()->SetTitleOffset(0.7);
pedeRMSG0->GetZaxis()->SetRangeUser(0,30);
pedeRMSG0->Draw("colz");
sprintf(savename,"plots/M%s/CuFluo/%s/pedeRMSG0_sc%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
}
int adc2d_nbin= 1200;
if (isJF11) adc2d_nbin= 1600;
TH2I *adc2d[8][16];
/*
TH2I *adc2d_2[16]; = new TH2I("adc2d_2","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*1-0.5),(65536*2-0.5));
TH2I *adc2d_3[16]; = new TH2I("adc2d_3","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*2-0.5),(65536*3-0.5));
TH2I *adc2d_4[16]; = new TH2I("adc2d_4","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*3-0.5),(65536*4-0.5));
TH2I *adc2d_5[14]; = new TH2I("adc2d_5","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*4-0.5),(65536*5-0.5));
TH2I *adc2d_6[16]; = new TH2I("adc2d_6","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*5-0.5),(65536*6-0.5));
TH2I *adc2d_7[16]; = new TH2I("adc2d_7","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*6-0.5),(65536*7-0.5));
TH2I *adc2d_8[16]; = new TH2I("adc2d_8","",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,(65536*7-0.5),(65536*8-0.5));
*/
TH1D *adcpc_spec[16];
TH2F *pede_updates[16];
TH2F *pede_diff[16];
for ( int sci = 0; sci < 16; ++sci ) {
Char_t *_histoname = new Char_t[50];
for ( int adci = 0; adci < 8; ++adci ) {
snprintf( _histoname, 50, "adc2d_%d_sc%d", (adci+1), sci );
adc2d[adci][sci] = new TH2I( _histoname,"",adc2d_nbin,-200-0.5,adc2d_nbin-200-0.5,65536,( 65536*adci-0.5 ),( 65536*( adci+1 )-0.5 ) );
}
snprintf( _histoname, 50, "adcpc_spec_sc%d", sci );
adcpc_spec[sci] = new TH1D( _histoname,"",300,0,3000 ); //spectrum for every sc, every 10000 frames
snprintf( _histoname, 50, "pede_updates_sc%d", sci );
pede_updates[sci] = new TH2F( _histoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5 );
snprintf( _histoname, 50, "pede_diff_sc%d", sci );
pede_diff[sci] = new TH2F( _histoname,"",NC,-0.5,NC-0.5,NR,-0.5,NR-0.5 );
}
for (int filei = 0; filei < filen; filei++) {
// open data file
sprintf(savename,"%s/%s_%%6.6d.dat", data_loc.c_str(), data_file.c_str()); //VH: note, this adds a double slash in the filepath
thisfile->open((char*)savename, filei);
while (thisfile->readNextFrame()) {
uint16_t* imagedptr = thisfile->getFrameDataHandle();
uint64_t scnumber = thisfile->currentSCnumber();
pedestalObject[scnumber]->addG0FrameToPedestalCalculationWThreshold(imagedptr, pedestalObject[scnumber], pedeRMS16_G0[scnumber]);
for (int i = 0; i < NCH; i++) {
uint16_t gain = (imagedptr[i]&0xc000) >> 14;
if (gain == 0) {
int adcpc = (imagedptr[i]&0x3fff) - pedestalObject[scnumber]->pedestalOfChannel(i);
adcpc_spec->Fill(adcpc);
if (i < (65536*1)) {
adc2d[0][scnumber]->Fill(adcpc,i);
} else if (i < (65536*2)) {
adc2d[1][scnumber]->Fill(adcpc,i);
} else if (i < (65536*3)) {
adc2d[2][scnumber]->Fill(adcpc,i);
} else if (i < (65536*4)) {
adc2d[3][scnumber]->Fill(adcpc,i);
} else if (i < (65536*5)) {
adc2d[4][scnumber]->Fill(adcpc,i);
} else if (i < (65536*6)) {
adc2d[5][scnumber]->Fill(adcpc,i);
} else if (i < (65536*7)) {
adc2d[6][scnumber]->Fill(adcpc,i);
} else if (i < (65536*8)) {
adc2d[7][scnumber]->Fill(adcpc,i);
}
}
}
}
thisfile->close();
if ( filei%16 == 0 ) {
for ( int sci = 0; sci < 16; ++sci ) {
adcpc_spec[sci]->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
adcpc_spec[sci]->Draw();
mapcanvas->SetLogy();
sprintf(savename,"plots/M%s/CuFluo/%s/adcpc_spec_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
mapcanvas->SetLogy(0);
adcpc_spec[sci]->Reset();
pede_updates[sci]->Reset();
pede_diff[sci]->Reset();
for (int i = 0; i < NCH; i++) {
pede_updates[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalUpdates(i));
pede_diff[sci]->Fill(i%NC,i/NC,pedestalObject[sci]->pedestalOfChannel(i) - pedestals16_G0_start[sci][i]);
pedestals16_G0_start[sci][i] = pedestalObject[sci]->pedestalOfChannel(i);
}
pede_updates[sci]->GetXaxis()->SetTitle("Column");
pede_updates[sci]->GetYaxis()->SetTitle("Row");
pede_updates[sci]->GetYaxis()->SetTitleOffset(0.7);
pede_updates[sci]->GetZaxis()->SetRangeUser(0,10000);
pede_updates[sci]->Draw("colz");
sprintf(savename,"plots/M%s/CuFluo/%s/pede_updates_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
pede_diff[sci]->GetXaxis()->SetTitle("Column");
pede_diff[sci]->GetYaxis()->SetTitle("Row");
pede_diff[sci]->GetYaxis()->SetTitleOffset(0.7);
pede_diff[sci]->GetZaxis()->SetRangeUser(-40,40);
pede_diff[sci]->Draw("colz");
sprintf(savename,"plots/M%s/CuFluo/%s/pede_diff_sc%d_slice%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), sci, ( filei/16 ), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
pedestalObject[sci]->pedestalResetUpdates();
} //end of storage cell loop
} //end of if filei%16
} // end of file loop
//sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
sprintf(savename,"%s/CuFluo_%s_file0to%d.root", anadata_loc.c_str(), gain_str.c_str(), filen-1); //uncomment for VH 210906
TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
for ( int adci = 0; adci < 8; ++adci ) {
for ( int sci = 0; sci < 16; ++sci ) {
adc2d[adci][sci]->Write();
}
}
saved_file->Close();
} // end if i creatHistoFile
// We have saved the data into root-file. Now, we read from that same root-file and perform the fitting.
c1->cd();
//sprintf(savename,"/mnt/sls_det_storage/jungfrau_data1/jungfrau_ana_sophie/M%s_CalibAna/CuFluo_%s_file0to%d.root", module_str.c_str(), gain_str.c_str(), filen-1);
sprintf(savename,"%s/CuFluo_%s_file0to%d.root", anadata_loc.c_str(), gain_str.c_str(), filen-1); //uncomment for VH 210906
TFile* comb_file = new TFile((const char *)(savename),"READ");
pixelMaskObject->initialisePixelMask(pixel_mask);
int low_ADU_peak = 0;
int high_ADU_peak = 0;
if (gain_str == "HG0") {
low_ADU_peak = 700;
high_ADU_peak = 900;
if (isJF11) {
low_ADU_peak = 850;
high_ADU_peak = 1350;
}
} else if (gain_str == "G0") {
low_ADU_peak = 250;
high_ADU_peak = 400;
}
TH1F* fit_par3[16];
TH1F* fit_par4[16];
TH1F* fit_par5[16];
TH1F* fit_par6[16];
TH1F* fit_par7[16];
TH2F* fit_par3_2d[16];
TH2F* fit_par4_2d[16];
TH2F* fit_par5_2d[16];
TH2F* fit_par6_2d[16];
TH2F* fit_par7_2d[16];
TH1F* peak_fit_pos[16];
TH1F* peak_fit_poserr[16];
TH2F* peak_fit_pos_2d[16];
TH2F* peak_fit_poserr_2d[16];
TH1F* noise_fit_pos[16];
TH1F* noise_fit_poserr[16];
TH2F* noise_fit_pos_2d[16];
TH2F* noise_fit_poserr_2d[16];
TH1F* gain_fit[16];
TH1F* gain_fiterr[16];
TH2F* gain_fit_2d[16];
TH2F* gain_fiterr_2d[16];
TH1F* gain_fit_isEdge[16];
TH1F* gain_fit_isInnerEdge[16];
TH1F* gain_fit_isDouble[16];
TH1F* gain_fit_isNextToDouble[16];
TH1F* gain_fit_isQuad[16];
TH1F* gain_fit_isBulk[16];
TH2F* gain_ADUper1keV_2d[16];
TH2F* gainerr_ADUper1keV_2d[16];
for ( int sci = 0; sci < 16; ++sci ) {
Char_t *fithistoname = new Char_t[50];
snprintf( fithistoname, 50, "fit_par3_sc%d", sci );
fit_par3[sci] = new TH1F( fithistoname, "", 100, 0, 50 );
snprintf( fithistoname, 50, "fit_par4_sc%d", sci );
fit_par4[sci] = new TH1F( fithistoname, "", 100, 0, 500 );
snprintf( fithistoname, 50, "fit_par5_sc%d", sci );
fit_par5[sci] = new TH1F( fithistoname, "", 100, 0, 0.5 );
snprintf( fithistoname, 50, "fit_par6_sc%d", sci );
fit_par6[sci] = new TH1F( fithistoname, "", 100, 1.05, 1.25 );
snprintf( fithistoname, 50, "fit_par7_sc%d", sci );
fit_par7[sci] = new TH1F( fithistoname, "", 100, 0, 0.4 );
snprintf( fithistoname, 50, "fit_par3_2d_sc%d", sci );
fit_par3_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "fit_par4_2d_sc%d", sci );
fit_par4_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "fit_par5_2d_sc%d", sci );
fit_par5_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "fit_par6_2d_sc%d", sci );
fit_par6_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "fit_par7_2d_sc%d", sci );
fit_par7_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "peak_fit_pos_sc%d", sci );
peak_fit_pos[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "peak_fit_poserr_sc%d", sci );
peak_fit_poserr[sci] = new TH1F( fithistoname, "", 100, 0, 2 );
snprintf( fithistoname, 50, "peak_fit_pos_2d_sc%d", sci );
peak_fit_pos_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "peak_fit_poserr_2d_sc%d", sci );
peak_fit_poserr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "noise_fit_pos_sc%d", sci );
noise_fit_pos[sci] = new TH1F( fithistoname, "", 100, -10, 10 );
snprintf( fithistoname, 50, "noise_fit_poserr_sc%d", sci );
noise_fit_poserr[sci] = new TH1F( fithistoname, "", 100, 0, 0.1 );
snprintf( fithistoname, 50, "noise_fit_pos_2d_sc%d", sci );
noise_fit_pos_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "noise_fit_poserr_2d_sc%d", sci );
noise_fit_poserr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "gain_fit_sc%d", sci );
gain_fit[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fiterr_sc%d", sci );
gain_fiterr[sci] = new TH1F( fithistoname, "", 100, 0, 2 );
snprintf( fithistoname, 50, "gain_fit_2d_sc%d", sci );
gain_fit_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "gain_fiterr_2d_sc%d", sci );
gain_fiterr_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "gain_fit_isEdge_sc%d", sci );
gain_fit_isEdge[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fit_isInnerEdge_sc%d", sci );
gain_fit_isInnerEdge[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fit_isDouble_sc%d", sci );
gain_fit_isDouble[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fit_isNextToDouble_sc%d", sci );
gain_fit_isNextToDouble[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fit_isQuad_sc%d", sci );
gain_fit_isQuad[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_fit_isBulk_sc%d", sci );
gain_fit_isBulk[sci] = new TH1F( fithistoname, "", 100, low_ADU_peak, high_ADU_peak );
snprintf( fithistoname, 50, "gain_ADUper1keV_2d_sc%d", sci );
gain_ADUper1keV_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
snprintf( fithistoname, 50, "gainerr_ADUper1keV_2d_sc%d", sci );
gainerr_ADUper1keV_2d[sci] = new TH2F( fithistoname, "", NC, -0.5, NC-0.5, NR, -0.5, NR-0.5 );
} //end histo creating for loop
int low_bin_noise = 101;
int high_bin_noise = 301;
int low_bin_peak = 0;
int high_bin_peak = 0;
if (gain_str == "HG0") {
low_bin_peak = 701;
high_bin_peak = 1200;
if (isJF11) {
low_bin_peak = 801;
high_bin_peak = 1451;
}
} else if (gain_str == "G0") {
low_bin_peak = 301;
high_bin_peak = 651;
}
for ( int sci = 0; sci < 16; ++sci ) {
for ( int j = 1; j < 9; ++j ) {
cout << "SC = " << sci << " slice " << j << endl;
sprintf( histoname, "adc2d_%d_sc%d", j, sci );
TH2I* adc2d_j = (TH2I*)( comb_file->Get( (const char *)(histoname) ) );
cout << adc2d_j->GetEntries() << endl;
adc2d_j->Draw("colz");
c1->Update();
//HERE!!!!!
for (int i=(65536*(j-1)); i<(65536*(j)); i++) {
if (i%10000==0){cout << "another 10k" << endl;}
TH1D* proj = adc2d_j->ProjectionX("bin1",i-(65536*(j-1))+1,i-(65536*(j-1))+1);
if ( proj->Integral( low_bin_noise, high_bin_noise ) != 0 && proj->Integral( low_bin_peak, high_bin_peak ) != 0 ) {
// noise
TH1D *proj_noise = dynamic_cast<TH1D*>(proj->Rebin(4,"proj_noise"));
proj_noise->SetStats(kTRUE);
proj_noise->GetXaxis()->SetRangeUser(proj->GetBinLowEdge(low_bin_noise),proj->GetBinLowEdge(high_bin_noise+1));
proj_noise->Fit("gaus","Q");
TF1 *fit = proj_noise->GetFunction("gaus");
noise_fit_pos->Fill(fit->GetParameter(1));
noise_fit_pos_2d->Fill(i%NC,i/NC,fit->GetParameter(1));
noise_fit_poserr->Fill(fit->GetParError(1));
noise_fit_poserr_2d->Fill(i%NC,i/NC,fit->GetParError(1));
// peak
TH1D *proj_peak = dynamic_cast<TH1D*>(proj->Rebin(4,"proj_peak"));
proj_peak->SetStats(kTRUE);
proj_peak->GetXaxis()->SetRangeUser(proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
Double_t mypar[8];
mypar[0] = 0.0;
mypar[1] = 0.0;
mypar[2] = proj_peak->GetBinCenter(proj_peak->GetMaximumBin());
if (gain_str == "G0") {
mypar[3] = 16.;
} else if (gain_str == "HG0") {
mypar[3] = 29.;
}
mypar[4] = proj_peak->GetBinContent(proj_peak->GetMaximumBin());
if (gain_str == "G0") {
mypar[5] = 0.17;
} else if (gain_str == "HG0") {
mypar[5] = 0.14;
}
mypar[6] = 1.12;
if (gain_str == "G0") {
mypar[7] = 0.12;
} else if (gain_str == "HG0") {
mypar[7] = 0.14;
}
Double_t emypar[8];
energyCalibration *thiscalibration = new energyCalibration();
thiscalibration->setScanSign(1);
thiscalibration->setStartParametersKb(mypar);
thiscalibration->fixParameter(0,0.); // no background
thiscalibration->fixParameter(1,0.);
TF1* fittedfun = thiscalibration->fitSpectrumKb(proj_peak,mypar,emypar);
fit_par3->Fill(mypar[3]);
fit_par4->Fill(mypar[4]);
fit_par5->Fill(mypar[5]);
fit_par6->Fill(mypar[6]);
fit_par7->Fill(mypar[7]);
fit_par3_2d->Fill(i%NC,i/NC,mypar[3]);
fit_par4_2d->Fill(i%NC,i/NC,mypar[4]);
fit_par5_2d->Fill(i%NC,i/NC,mypar[5]);
fit_par6_2d->Fill(i%NC,i/NC,mypar[6]);
fit_par7_2d->Fill(i%NC,i/NC,mypar[7]);
peak_fit_pos->Fill(mypar[2]);
peak_fit_poserr->Fill(emypar[2]);
peak_fit_pos_2d->Fill(i%NC,i/NC,mypar[2]);
peak_fit_poserr_2d->Fill(i%NC,i/NC,emypar[2]);
if ((i >= 58000 && i < 58000+10) || // bulk
(i >= 10 && i < 10+10) || // edge
(i >= 1024+10 && i < 1024+10+10) || // inner edge
(i >= (256*1024)+10 && i < (256*1024)+10+10) || // double
(i >= (257*1024)+10 && i < (257*1024)+10+10) || // next to double
(i == (255*1024)+255) // quad
) {
string pixel_type = "x";
if (i >= 58000 && i < 58000+10) {
pixel_type = "b";
} else if (i >= 10 && i < 10+10) {
pixel_type = "e";
} else if (i >= 1024+10 && i < 1024+10+10) {
pixel_type = "ie";
} else if (i >= (256*1024)+10 && i < (256*1024)+10+10) {
pixel_type = "d";
} else if (i >= (257*1024)+10 && i < (257*1024)+10+10) {
pixel_type = "ntd";
} else if (i == (255*1024)+255) {
pixel_type = "q";
}
proj_noise->Draw();
c1->Update();
proj_noise->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
proj_noise->GetXaxis()->SetRangeUser(-100,150);
fit->SetParNames("N_{#gamma}", "Peak pos", "Noise RMS");
TPaveStats *st0 = (TPaveStats*)proj_noise->FindObject("stats");
st0->SetX1NDC(0.53);
st0->SetX2NDC(0.94);
st0->SetY1NDC(0.75);
st0->SetY2NDC(0.94);
st0->SetBorderSize(0);
st0->SetTextSize(0.04);
sprintf(savename,"plots/M%s/CuFluo/%s/noise_%s_%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), pixel_type.c_str(), i, gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
TF1 *gaus_Ka = new TF1("gaus_Ka","gaus",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
gaus_Ka->SetParameters(mypar[4],mypar[2],mypar[3]);
gaus_Ka->SetLineColor(kBlue);
TF1 *erfc_Ka = new TF1("erfc_Ka","[0]/2.*(TMath::Erfc(([1]*(x-[2])/[3])/(TMath::Sqrt(2.))))",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
erfc_Ka->SetParameters(mypar[4]*mypar[5], 1, mypar[2], mypar[3]);
erfc_Ka->SetLineColor(kOrange);
TF1 *gaus_Kb = new TF1("gaus_Kb","gaus",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
gaus_Kb->SetParameters(mypar[4]*mypar[7],mypar[6]*mypar[2],mypar[3]);
gaus_Kb->SetLineColor(kGreen+2);
TF1 *erfc_Kb = new TF1("erfc_Kb","[0]/2.*(TMath::Erfc(([1]*(x-[2])/[3])/(TMath::Sqrt(2.))))",proj->GetBinLowEdge(low_bin_peak),proj->GetBinLowEdge(high_bin_peak+1));
erfc_Kb->SetParameters(mypar[4]*mypar[7]*mypar[5], 1, mypar[6]*mypar[2], mypar[3]);
erfc_Kb->SetLineColor(kOrange+7);
proj_peak->Draw();
erfc_Kb->Draw("same");
erfc_Ka->Draw("same");
gaus_Kb->Draw("same");
gaus_Ka->Draw("same");
fittedfun->Draw("same");
c1->Update();
proj_peak->GetXaxis()->SetTitle("Pedestal corrected ADC [ADU]");
fittedfun->SetParNames("Bkg height", "Bkg grad", "K_{#alpha} pos", "Noise RMS", "K_{#alpha} height", "CS", "K_{#beta}/K_{#alpha} pos", "K_{#beta} frac");
TPaveStats *st = (TPaveStats*)proj_peak->FindObject("stats");
st->SetX1NDC(0.22);
st->SetX2NDC(0.62);
st->SetY1NDC(0.7);
st->SetY2NDC(0.94);
st->SetBorderSize(0);
st->SetTextSize(0.04);
sprintf(savename,"plots/M%s/CuFluo/%s/peak_%s_%d_%s_M%s.png", module_str.c_str(), gain_str.c_str(), pixel_type.c_str(), i, gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
}
// gain
gain_fit->Fill(mypar[2] - fit->GetParameter(1));
gain_fiterr->Fill(sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)));
gain_fit_2d->Fill(i%NC,i/NC,mypar[2] - fit->GetParameter(1));
gain_fiterr_2d->Fill(i%NC,i/NC,sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)));
gain_ADUper1keV_2d->Fill(i%NC,i/NC,(mypar[2] - fit->GetParameter(1)) / 8.0);
gainerr_ADUper1keV_2d->Fill(i%NC,i/NC,sqrt(pow(emypar[2],2) + pow(fit->GetParError(1),2)) / 8.0);
if (isEdge(i)) {
gain_fit_isEdge->Fill(mypar[2] - fit->GetParameter(1));
}
if (isInnerEdge(i)) {
gain_fit_isInnerEdge->Fill(mypar[2] - fit->GetParameter(1));
}
if (isDouble(i)) {
gain_fit_isDouble->Fill(mypar[2] - fit->GetParameter(1));
}
if (isNextToDouble(i)) {
gain_fit_isNextToDouble->Fill(mypar[2] - fit->GetParameter(1));
}
if (isQuad(i)) {
gain_fit_isQuad->Fill(mypar[2] - fit->GetParameter(1));
}
if (isBulk(i)) {
gain_fit_isBulk->Fill(mypar[2] - fit->GetParameter(1));
}
delete thiscalibration;
delete proj_noise;
delete proj_peak;
delete proj;
} else {
pixel_mask[i] = false;
}
}
}
sprintf(savename,"plots/M%s/CuFluo/%s/pixelmask_afterfit_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
pixelMaskObject->plotPixelMask(pixel_mask,savename);
TPaveText *pave = new TPaveText(0.86,0.95,0.91,0.98,"blNDC");
pave->SetBorderSize(0);
pave->SetFillStyle(0);
pave->SetTextSize(0.06);
pave->SetTextAlign(32);
mapcanvas->cd();
fit_par3_2d->GetXaxis()->SetTitle("Column");
fit_par3_2d->GetYaxis()->SetTitle("Row");
fit_par3_2d->GetYaxis()->SetTitleOffset(0.7);
fit_par3_2d->Draw("colz");
fit_par3_2d->GetZaxis()->SetRangeUser(0,50);
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par3_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
fit_par4_2d->GetXaxis()->SetTitle("Column");
fit_par4_2d->GetYaxis()->SetTitle("Row");
fit_par4_2d->GetYaxis()->SetTitleOffset(0.7);
fit_par4_2d->Draw("colz");
fit_par4_2d->GetZaxis()->SetRangeUser(0,500);
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par4_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
fit_par5_2d->GetXaxis()->SetTitle("Column");
fit_par5_2d->GetYaxis()->SetTitle("Row");
fit_par5_2d->GetYaxis()->SetTitleOffset(0.7);
fit_par5_2d->Draw("colz");
fit_par5_2d->GetZaxis()->SetRangeUser(0,0.5);
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par5_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
fit_par6_2d->GetXaxis()->SetTitle("Column");
fit_par6_2d->GetYaxis()->SetTitle("Row");
fit_par6_2d->GetYaxis()->SetTitleOffset(0.7);
fit_par6_2d->Draw("colz");
fit_par6_2d->GetZaxis()->SetRangeUser(1.0,1.25);
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par6_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
fit_par7_2d->GetXaxis()->SetTitle("Column");
fit_par7_2d->GetYaxis()->SetTitle("Row");
fit_par7_2d->GetYaxis()->SetTitleOffset(0.7);
fit_par7_2d->Draw("colz");
fit_par7_2d->GetZaxis()->SetRangeUser(0.,0.4);
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par7_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
peak_fit_pos_2d->GetXaxis()->SetTitle("Column");
peak_fit_pos_2d->GetYaxis()->SetTitle("Row");
peak_fit_pos_2d->GetYaxis()->SetTitleOffset(0.7);
peak_fit_pos_2d->Draw("colz");
peak_fit_pos_2d->GetZaxis()->SetRangeUser(low_ADU_peak,high_ADU_peak);
sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_pos_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
peak_fit_poserr_2d->GetXaxis()->SetTitle("Column");
peak_fit_poserr_2d->GetYaxis()->SetTitle("Row");
peak_fit_poserr_2d->GetYaxis()->SetTitleOffset(0.7);
peak_fit_poserr_2d->Draw("colz");
peak_fit_poserr_2d->GetZaxis()->SetRangeUser(0,2);
sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_poserr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
noise_fit_pos_2d->GetXaxis()->SetTitle("Column");
noise_fit_pos_2d->GetYaxis()->SetTitle("Row");
noise_fit_pos_2d->GetYaxis()->SetTitleOffset(0.7);
noise_fit_pos_2d->Draw("colz");
noise_fit_pos_2d->GetZaxis()->SetRangeUser(-5,5);
sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_pos_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
noise_fit_poserr_2d->GetXaxis()->SetTitle("Column");
noise_fit_poserr_2d->GetYaxis()->SetTitle("Row");
noise_fit_poserr_2d->GetYaxis()->SetTitleOffset(0.7);
noise_fit_poserr_2d->Draw("colz");
if (gain_str == "HG0") {
noise_fit_poserr_2d->GetZaxis()->SetRangeUser(0,0.1);
} else if (gain_str == "G0") {
noise_fit_poserr_2d->GetZaxis()->SetRangeUser(0,0.05);
}
sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_poserr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
gain_fit_2d->GetXaxis()->SetTitle("Column");
gain_fit_2d->GetYaxis()->SetTitle("Row");
gain_fit_2d->GetYaxis()->SetTitleOffset(0.7);
gain_fit_2d->Draw("colz");
sprintf(savename,"%s [ADU/8 keV]", gain_str.c_str());
pave->AddText((const char *)(savename));
pave->Draw();
gain_fit_2d->GetZaxis()->SetRangeUser(low_ADU_peak,high_ADU_peak);
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
gain_fiterr_2d->GetXaxis()->SetTitle("Column");
gain_fiterr_2d->GetYaxis()->SetTitle("Row");
gain_fiterr_2d->GetYaxis()->SetTitleOffset(0.7);
gain_fiterr_2d->Draw("colz");
gain_fiterr_2d->GetZaxis()->SetRangeUser(0,2);
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fiterr_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
gain_ADUper1keV_2d->GetXaxis()->SetTitle("Column");
gain_ADUper1keV_2d->GetYaxis()->SetTitle("Row");
gain_ADUper1keV_2d->GetYaxis()->SetTitleOffset(0.7);
gain_ADUper1keV_2d->Draw("colz");
if (gain_str == "HG0") {
gain_ADUper1keV_2d->GetZaxis()->SetRangeUser(80,120);
} else if (gain_str == "G0") {
gain_ADUper1keV_2d->GetZaxis()->SetRangeUser(35,50);
}
sprintf(savename,"plots/M%s/CuFluo/%s/gain_ADUper1keV_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
gainerr_ADUper1keV_2d->GetXaxis()->SetTitle("Column");
gainerr_ADUper1keV_2d->GetYaxis()->SetTitle("Row");
gainerr_ADUper1keV_2d->GetYaxis()->SetTitleOffset(0.7);
gainerr_ADUper1keV_2d->Draw("colz");
if (gain_str == "HG0") {
gainerr_ADUper1keV_2d->GetZaxis()->SetRangeUser(0,0.5);
} else if (gain_str == "G0") {
gainerr_ADUper1keV_2d->GetZaxis()->SetRangeUser(0,0.25);
}
sprintf(savename,"plots/M%s/CuFluo/%s/gainerr_ADUper1keV_2d_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
mapcanvas->SaveAs((const char *)(savename));
c1->cd();
fit_par3->GetXaxis()->SetTitle("Fit par 3");
fit_par3->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par3_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
fit_par4->GetXaxis()->SetTitle("Fit par 4");
fit_par4->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par4_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
fit_par5->GetXaxis()->SetTitle("Fit par 5");
fit_par5->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par5_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
fit_par6->GetXaxis()->SetTitle("Fit par 6");
fit_par6->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par6_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
fit_par7->GetXaxis()->SetTitle("Fit par 7");
fit_par7->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/fit_par7_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
peak_fit_pos->GetXaxis()->SetTitle("Peak position [ADU]");
peak_fit_pos->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_pos_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
peak_fit_poserr->GetXaxis()->SetTitle("Peak position uncert [ADU]");
peak_fit_poserr->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/peak_fit_poserr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
noise_fit_pos->GetXaxis()->SetTitle("Noise position [ADU]");
noise_fit_pos->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_pos_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
noise_fit_poserr->GetXaxis()->SetTitle("Noise position uncert [ADU]");
noise_fit_poserr->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/noise_fit_poserr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
sprintf(savename,"Gain %s [ADU / 8 keV]", gain_str.c_str());
gain_fit->GetXaxis()->SetTitle((const char *)(savename));
gain_fit->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
gain_fit->GetXaxis()->SetRangeUser(low_ADU_peak+30, high_ADU_peak);
gain_fit->Fit("gaus");
gain_fit->Draw();
c1->Update();
TPaveText *pave2 = new TPaveText(0.6,0.8,0.94,0.94,"blNDC");
pave2->SetBorderSize(0);
pave2->SetFillStyle(0);
pave2->SetTextSize(0.04);
pave2->SetTextAlign(32);
TF1* gain_fit_gaus = gain_fit->GetFunction("gaus");
sprintf(savename,"Mean %0.2f #pm %0.2f", gain_fit_gaus->GetParameter(1), gain_fit_gaus->GetParError(1));
pave2->AddText((const char *)(savename));
sprintf(savename,"Sigma %0.2f #pm %0.2f", gain_fit_gaus->GetParameter(2), gain_fit_gaus->GetParError(2));
pave2->AddText((const char *)(savename));
pave2->Draw();
gain_fit->SetStats(kFALSE);
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_fit_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
gain_fiterr->GetXaxis()->SetTitle("Gain uncert [ADU / 8 keV]");
gain_fiterr->Draw();
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fiterr_%s_M%s.png",module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
gain_fit_isEdge->SetLineColor(kBlue);
gain_fit_isInnerEdge->SetLineColor(kCyan);
gain_fit_isDouble->SetLineColor(kGreen+2);
gain_fit_isNextToDouble->SetLineColor(kRed);
gain_fit_isQuad->SetLineColor(kOrange);
gain_fit_isEdge->Scale(1./gain_fit_isEdge->GetEntries());
gain_fit_isInnerEdge->Scale(1./gain_fit_isInnerEdge->GetEntries());
gain_fit_isDouble->Scale(1./gain_fit_isDouble->GetEntries());
gain_fit_isNextToDouble->Scale(1./gain_fit_isNextToDouble->GetEntries());
gain_fit_isQuad->Scale(1./gain_fit_isQuad->GetEntries());
gain_fit_isBulk->Scale(1./gain_fit_isBulk->GetEntries());
TLegend *leg = new TLegend(0.62,0.6,0.93,0.93);
leg->AddEntry(gain_fit_isBulk, "Normal", "l");
leg->AddEntry(gain_fit_isDouble, "Double", "l");
leg->AddEntry(gain_fit_isNextToDouble, "Next to D", "l");
leg->AddEntry(gain_fit_isEdge, "Edge", "l");
leg->AddEntry(gain_fit_isInnerEdge, "Inner E", "l");
sprintf(savename,"Gain %s [ADU / 8 keV]", gain_str.c_str());
gain_fit_isDouble->GetXaxis()->SetTitle((const char *)(savename));
gain_fit_isDouble->GetYaxis()->SetTitle("Normalised");
gain_fit_isDouble->GetYaxis()->SetTitleOffset(1.3);
gain_fit_isDouble->SetMinimum(0.0);
gain_fit_isDouble->SetMaximum(0.16);
gain_fit_isDouble->Draw();
gain_fit_isEdge->Draw("same");
gain_fit_isInnerEdge->Draw("same");
gain_fit_isNextToDouble->Draw("same");
gain_fit_isBulk->Draw("same");
leg->Draw("same");
sprintf(savename,"plots/M%s/CuFluo/%s/gain_fit_perType_%s_M%s.png", module_str.c_str(), gain_str.c_str(), gain_str.c_str(), module_str.c_str());
c1->SaveAs((const char *)(savename));
sprintf(savename,"data/M%s/CuFluo_gain_%s_M%s.root", module_str.c_str(), gain_str.c_str(), module_str.c_str());
TFile* saved_file = new TFile((const char *)(savename),"RECREATE");
gain_ADUper1keV_2d->Write();
gainerr_ADUper1keV_2d->Write();
saved_file->Close();
}

133
CuFluo_exposure_sc.sh Normal file
View File

@ -0,0 +1,133 @@
#!/bin/bash
# to run do: bash CuFluo_exposure_sc.sh
# prerequisites:
# - the hostname is set
# - export PATH=/afs/psi.ch/project/sls_det_software/latest_slsDetectorPackage/build/bin:$PATH
# - export LD_LIBRARY_PATH=/afs/psi.ch/project/sls_det_software/latest_slsDetectorPackage/build/bin:$LD_LIBRARY_PATH
# - detector is on
# - xray tube is on and ramped for 40 kV, 60 mA, set to Cu
sls_detector_put stop #just in case
sls_detector_put powerchip 1
sls_detector_put period 0.1 #0.03 #0.002
sls_detector_put exptime 0.000007 #0.000010
sls_detector_put extrastoragecells 15
sls_detector_put storagecell_start 0
sls_detector_put storagecell_delay 0.000025875 #to achieve effective sc period of 35us
sls_detector_put highvoltage 200
# configure for receiver on mpc2012
sls_detector_put udp_dstport 32410
sls_detector_put udp_dstip 10.1.4.105
sls_detector_put udp_dstmac 3C:FD:FE:A2:14:D8
sls_detector_put udp_srcip 10.1.4.9
sls_detector_put udp_srcmac 00:ab:be:cc:dd:e2
sls_detector_put readoutspeed 1
#sls_detector_put reg 0x59 0x1310 #0001 0011 0001 0000
#sls_detector_put readoutspeed 0
#sls_detector_put reg 0x59 0x0100 #0000 0001 0000 0000
KILLRCV="killall ju_udp_receiver_3threads_2_0"
$KILLRCV
CLI=/afs/psi.ch/project/sls_det_software/bin/xrayClient_sl7
$CLI setv 40
$CLI setc 60
$CLI HV on
sls_detector_put clearbit 0x5d 0
$CLI shutter 1 off
echo "warmin up the board"
sls_detector_put frames 2500 #40000
sls_detector_put start
sleep 260 #81 # 2500 * 30ms = 75s
sls_detector_put stop
echo "end of board warm up"
sls_detector_put frames 1000
$KILLRCV
sleep 10 #1
$TKPG0 &
echo "recording G0 pede"
sls_detector_put start
sleep 105 #35
# 1000 frames (per sc) at 34 frames per second (period 30ms) takes 30s
echo "recording G1 pede"
#sls_detector_put gainmode forceswitchg1 #consumes too much power
sls_detector_put start
sleep 105 #35
echo "recording G2 pede"
#sls_detector_put gainmode forceswitchg2 #consumes too much power
sls_detector_put start
sleep 105 #35
sls_detector_put gainmode dynamic
$KILLRCV
echo "closed G0 pede file and open the G0 CuFluo file"
sleep 10 #1
$TKFG0 &
sls_detector_put frames 220000
$CLI shutter 1 on
sleep 10 #1
sls_detector_put start
sleep 220100 #6800
# 200k frames (per sc) at 34 frames per second (period 30ms) takes 6600s (1h 50min)
$CLI shutter 1 off
#We are not interested in HG0
#$KILLRCV
#echo "closed G0 CuFluo file and open HG0 pede file"
#sleep 1
#$TKPHG0 &
#sls_detector_put settings highgain0
#sls_detector_put frames 1000
#echo "recording HG0 pede"
#sls_detector_put start
#sleep 3
# 1000 frames at 500 frames per second takes 2s
#$KILLRCV
#echo "closed HG0 pede file and open the HG0 CuFluo file"
#sleep 1
#$TKFHG0 &
#sls_detector_put frames 220000
#$CLI shutter 1 on
#sleep 1
#sls_detector_put start
#sleep 450
# 200k frames at 500 frames per second takes 400s
#$CLI shutter 1 off
$CLI HV off
$KILLRCV
echo "Script finished"