//------------------------------------------------------------------------
void fitSlices(TH2* hCorr, TF1* func){
int nBins = hCorr->GetNbinsX();
TH1D* hMean = new TH1D(Form("%s_1",hCorr->GetName()),"",nBins,hCorr->GetXaxis()->GetXmin(),hCorr->GetXaxis()->GetXmax());
TH1D* hSigma = new TH1D(Form("%s_2",hCorr->GetName()),"",nBins,hCorr->GetXaxis()->GetXmin(),hCorr->GetXaxis()->GetXmax());
for(int i = 1; i < nBins+1; i++){
int bin = nBins - i;
TH1D* h = hCorr->ProjectionY(Form("%s_bin%d",hCorr->GetName(),bin),i,i);
func->SetParameter(0,h->GetMaximum());
func->SetParameter(1,h->GetMean());
func->SetParameter(2,h->GetRMS());
h->Fit(func,"Q");
/*hMean->SetBinContent(i,func->GetParameter(1));
hMean->SetBinError(i,func->GetParError(1));
hSigma->SetBinContent(i,func->GetParameter(2));
hSigma->SetBinError(i,func->GetParError(2));*/
hMean->SetBinContent(i,h->GetMean());
hMean->SetBinError(i,func->GetParError(1)); //errors are not use later for the actual table
hSigma->SetBinContent(i,h->GetRMS());
hSigma->SetBinError(i,func->GetParError(2));
}
}
int main(int argc, char* argv[]){
double initP = atof(argv[1]);
//let should add script to run all models, then individual rms can be extracted from the rms file
// Path to Histograms
TFile *f = new TFile("../../EventOutputs/ResultHistos_Minimalist.root");
TFile *f_2 = new TFile("../../EventOutputs/ResultHistos_Minimalist2.root");
//grab the pi0 energy sum from the result histos file
//histogram of the minimalist energy sum
//TH1D * minRMS = (TH1D*)f->Get("hESumConstrained");
//histogram of the elimination method and minimization fit Energy vaules
//TH1D * elimRMS = (TH1D*)f->Get("hEfitSum");
//measured value of pi0 energy
//TH1D * measRMS = (TH1D*)f->Get("hESum");
//pull the RMS from the histograms
//double min = minRMS->GetRMS();
//double elim = elimRMS->GetRMS();
//double meas = measRMS->GetRMS();
// double myrms = (TH1D*)f->Get("hEfitSum")->GetRMS();
//get the minimimalist stuff
TH1D * minRMS = (TH1D*)f->Get("hmass_min");
TH1D * measRMS = (TH1D*)f_2->Get("hmass_m");
TH1D * min2RMS = (TH1D*)f_2->Get("hmass_min2");
double min = minRMS->GetRMS();
double meas = measRMS->GetRMS();
double min2 = min2RMS->GetRMS();
//append the RMS to a text file
std::ofstream f1;
std::ofstream f2;
std::ofstream f3;
f1.open("RMSmin.txt", std::ofstream::out | std::ofstream::app);
f2.open("RMSmin2.txt", std::ofstream::out | std::ofstream::app);
f3.open("RMSmeas.txt", std::ofstream::out | std::ofstream::app);
f1<<std::setprecision(9);
f2<<std::setprecision(9);
f3<<std::setprecision(9);
//f1<<meas<<" "<<min<<" "<<elim<<" "<<initP<<std::endl;
f1<<meas<<" "<<min<<" "<<initP<<std::endl;
f2<<meas<<" "<<min2<<" "<<initP<<std::endl;
f3<<meas<<" "<<initP<<std::endl;
f1.close();
f2.close();
f3.close();
return 0;
}
void fitSlices(TH2* hCorr, TF1* func){
int nBins = hCorr->GetNbinsX();
TH1D* hMean = new TH1D(Form("%s_1",hCorr->GetName()),"",nBins,hCorr->GetXaxis()->GetXmin(),hCorr->GetXaxis()->GetXmax());
TH1D* hSigma = new TH1D(Form("%s_2",hCorr->GetName()),"",nBins,hCorr->GetXaxis()->GetXmin(),hCorr->GetXaxis()->GetXmax());
for(int i = 1; i < nBins+1; ++i){
int bin = nBins - i;
TH1D* h = hCorr->ProjectionY(Form("%s_bin%d",hCorr->GetName(),bin),i,i);
func->SetParameter(0,h->GetMaximum());
func->SetParameter(1,h->GetMean());
func->SetParameter(2,h->GetRMS());
if(useFits) h->Fit(func);
hMean->SetBinContent(i,func->GetParameter(1));
hMean->SetBinError(i,func->GetParError(1));
hSigma->SetBinContent(i,func->GetParameter(2));
hSigma->SetBinError(i,func->GetParError(2));
if(onlySaveTable){
h->Delete();
}
}
}
TH1D * smartGausProfileXSQRTN (TH2F * strip, double width){
TProfile * stripProfile = strip->ProfileX () ;
// (from FitSlices of TH2.h)
double xmin = stripProfile->GetXaxis ()->GetXmin () ;
double xmax = stripProfile->GetXaxis ()->GetXmax () ;
int profileBins = stripProfile->GetNbinsX () ;
std::string name = strip->GetName () ;
name += "_smartGaus_X" ;
TH1D * prof = new TH1D(name.c_str (),strip->GetTitle (),profileBins,xmin,xmax) ;
int cut = 0 ; // minimum number of entries per fitted bin
int nbins = strip->GetXaxis ()->GetNbins () ;
int binmin = 1 ;
int ngroup = 1 ; // bins per step
int binmax = nbins ;
// loop over the strip bins
for (int bin=binmin ; bin<=binmax ; bin += ngroup)
{
TH1D *hpy = strip->ProjectionY ("_temp",bin,bin+ngroup-1,"e") ;
if (hpy == 0) continue ;
int nentries = Int_t (hpy->GetEntries ()) ;
if (nentries == 0 || nentries < cut) {delete hpy ; continue ;}
Int_t biny = bin + ngroup/2 ;
TF1 * gaussian = new TF1 ("gaussian","gaus", hpy->GetMean () - width * hpy->GetRMS (), hpy->GetMean () + width * hpy->GetRMS ()) ;
gaussian->SetParameter (1,hpy->GetMean ()) ;
gaussian->SetParameter (2,hpy->GetRMS ()) ;
hpy->Fit ("gaussian","RQL") ;
// hpy->GetXaxis ()->SetRangeUser ( hpy->GetMean () - width * hpy->GetRMS (), hpy->GetMean () + width * hpy->GetRMS ()) ;
prof->Fill (strip->GetXaxis ()->GetBinCenter (biny), gaussian->GetParameter (1)) ;
prof->SetBinError (biny,gaussian->GetParameter (2) / sqrt(hpy->GetEntries())) ;
// prof->SetBinError (biny,gaussian->GetParError (1)) ;
delete gaussian ;
delete hpy ;
} // loop over the bins
delete stripProfile ;
return prof ;
}
void testResult(){
std::ifstream ifs0("simGain.txt");
std::ifstream ifs1("CalibrationN.txt");
if( !ifs0.is_open() ){return;}
if( !ifs1.is_open() ){return;}
TH1D* hisGain = new TH1D("test","",200,0,2);
TH1D* hisInit = new TH1D("test1","",200,0,2);
double cal0;
double cal1;
double calfactor0[2716]={0};
double calfactor1[2716]={0};
Int_t N;
Int_t ID;
while( !ifs0.eof() ){
ifs0 >> ID >> cal0;
calfactor0[ID] = cal0;
std::cout<< ID << std::endl;
}
while( !ifs1.eof() ){
ifs1 >> ID >> cal1 >> N;
std::cout<< ID << std::endl;
calfactor1[ID] = cal1;
}
for( int i = 0; i< 2716; i++){
if(calfactor0[i] ==0 || calfactor1[i] ==0){
continue;
}
hisGain->Fill(calfactor0[i]/calfactor1[i]);
hisInit->Fill(calfactor0[i]);
}
hisGain->Draw();
hisInit->SetLineColor(2);
hisInit->Draw("same");
std::cout<< hisGain->GetRMS()/hisGain->GetMean() << "\t"
<< hisInit->GetRMS()/hisInit->GetMean() << std::endl;
}
void GaussianProfile::getTruncatedMeanRMS(TH1* hist, float& mean, float& mean_error, float& rms, float& rms_error) {
int nBins = hist->GetNbinsX();
double xMin = hist->GetXaxis()->GetXmin();
double xMax = hist->GetXaxis()->GetXmax();
//double binWidth = (xMax - xMin) / (double) nBins; //WARNING: this works only if bins are of the same size
double integral = hist->Integral();
int maxBin = 0;
TF1* gaussian = new TF1("gaussian", "gaus");
fitProjection(hist, gaussian, 1.5, "RQN");
//maxBin = (int) ceil((gaussian->GetParameter(1) - xMin) / binWidth);
maxBin = hist->FindBin(gaussian->GetParameter(1));
delete gaussian;
TH1D* newHisto = new TH1D("newHisto", "", nBins, xMin, xMax);
newHisto->SetBinContent(maxBin, hist->GetBinContent(maxBin));
newHisto->SetBinError(maxBin, hist->GetBinError(maxBin));
int iBin = maxBin;
int delta_iBin = 1;
int sign = 1;
while (newHisto->Integral() < 0.99 * integral) {
iBin += sign * delta_iBin;
newHisto->SetBinContent(iBin, hist->GetBinContent(iBin));
newHisto->SetBinError(iBin, hist->GetBinError(iBin));
delta_iBin += 1;
sign *= -1;
}
rms = newHisto->GetRMS();
rms_error = newHisto->GetRMSError();
while (newHisto->Integral() < 0.99 * integral) {
iBin += sign * delta_iBin;
newHisto->SetBinContent(iBin, hist->GetBinContent(iBin));
newHisto->SetBinError(iBin, hist->GetBinError(iBin));
delta_iBin += 1;
sign *= -1;
}
mean = newHisto->GetMean();
mean_error = newHisto->GetMeanError();
delete newHisto;
}
//_____________________________________________________________________________
TH1D *SetRMS(TH2D *h2, const TString s)
{
TH1D *h = h2->ProjectionX(s.Data()); h->Reset();
for (Int_t kx=1; kx<=h2->GetNbinsX(); kx++) {
TH1D *hTmp = h2->ProjectionY(Form("hTmp_%d",kx), kx, kx);
if (hTmp->Integral()<=0.)
h->SetBinContent(kx, 0.);
else
h->SetBinContent(kx, hTmp->GetRMS());
cout << h->GetBinContent(kx) << endl;
delete hTmp; hTmp = 0;
}
return h;
}
double FitConfidence::choleskyUncertainty( double xx, double * fCov, TF1 * f, int nSamples ){
int nP = f->GetNpar();
INFO( FitConfidence::classname(), "Num Params : " << nP );
double *fCovSqrt = new double[ nP * nP ];
calcCholesky( nP, fCov, fCovSqrt );
double yerr = 0;
TH1D *hDistributionAtX = new TH1D("hDistributionAtX","",200,f->Eval(xx) - .2,f->Eval(xx) + .2);
for (int n = 0; n < nSamples; n++ ) {
double val = randomSqrtCov(xx,f,nP,fCovSqrt);
hDistributionAtX->Fill( val );
}
yerr = hDistributionAtX->GetRMS();
hDistributionAtX->Delete();
return yerr;
}
void chipHistos(const char *filenames = "/export/data1/dambach/hardware/ntpls/gradeA/*.root")
{
Init(); // do not forget to load the Utilities.C
TH1D *gainH = new TH1D("gainH", "RMS(gain)/Mean(gain)", 100, 0., 0.2);
TH1D *pedH = new TH1D("pedH", "RMS(pedestal)", 100, 0., 100.);
TH1D *noiseH = new TH1D("noiseH", "RMS(trimmed threshold)", 100, 0., 8.);
TH1D *tthrH = new TH1D("tthrH", "Mean (trimmed threshold)", 100, 50., 70.);
TH1D *gainDist = new TH1D("gainDist", "gainR/gainM", 100, 0., 10.);
TH1D *pedDist = new TH1D("pedDist", "pedR", 100, -1000., 1000.);
TChain *c = new TChain("mod");
c->Add(filenames);
float ped[16][4160], gain[16][4160];
int defects[16][4160];
c->SetBranchAddress("ped", ped);
c->SetBranchAddress("gain", gain);
c->SetBranchAddress("defects", defects);
int nb(0), nbytes(0);
for (int i = 0; i < c->GetEntries(); ++i)
{
nb = c->GetEntry(i); nbytes += nb;
for(int chipId = 0; chipId < 16; chipId++)
{
gainDist->Reset();
pedDist->Reset();
int allPix = 4160;
for (int p = 0; p < allPix; p++)
{
if(defects[chipId][p] == 0)
{
gainDist->Fill(gain[chipId][p]);
pedDist->Fill(ped[chipId][p]);
}
}
double gainRMS = gainDist->GetRMS();
double pedRMS = pedDist->GetRMS();
double gainMean = gainDist->GetMean();
double pedMean = pedDist->GetMean();
if (gainMean != 0) gainH->Fill(gainRMS/gainMean);
pedH->Fill(pedRMS);
}
}
canvas->Clear();
canvas->Divide(2,2);
canvas->cd(1);
InitPad("log");
gainH->GetXaxis()->SetTitle("DAC units");
gainH->GetYaxis()->SetTitle("# pixels");
gainH->GetXaxis()->SetTitleSize(0.055);
gainH->GetYaxis()->SetTitleSize(0.055);
gainH->Draw();
canvas->cd(2);
InitPad("log");
pedH->GetXaxis()->SetTitle("DAC units");
pedH->GetYaxis()->SetTitle("# pixels");
pedH->GetXaxis()->SetTitleSize(0.055);
pedH->GetYaxis()->SetTitleSize(0.055);
pedH->Draw();
canvas->cd(3);
InitPad("log");
noiseH->GetXaxis()->SetTitle("DAC units");
noiseH->GetYaxis()->SetTitle("# pixels");
noiseH->GetXaxis()->SetTitleSize(0.055);
noiseH->GetYaxis()->SetTitleSize(0.055);
c->Draw("tthrR>>noiseH");
canvas->cd(4);
InitPad("log");
tthrH->SetMinimum(0.5);
tthrH->GetXaxis()->SetTitle("DAC units");
tthrH->GetYaxis()->SetTitle("# pixels");
tthrH->GetXaxis()->SetTitleSize(0.055);
tthrH->GetYaxis()->SetTitleSize(0.055);
c->Draw("tthrM>>tthrH");
}
void writeSignalHistosForModel(std::vector<TH1D *>& vsd,
const TString& sigmodel,
TFile *allHistFile)
{
for (int ichan=0; ichan<NUMCHAN; ichan++) {
TH1D * sdh = vsd[ichan];
// Find limit window from gaussian fit to signal peak.
//
double wid = sdh->GetRMS();
double mean = sdh->GetMean();
//TCanvas *c1 = new TCanvas(s,s,300,300);
TFitResultPtr r = sdh->Fit("gaus","QNS","",mean-2.5*wid,mean+2.5*wid);
cout<<" mean= "<<mean<<", RMS= "<<wid<<", Fit sigma= "<<r->Parameter(2)<<endl;
//cout<<r->Parameter(0)<<" "<<r->Parameter(1)<<" "<<r->Parameter(2)<<endl;
TAxis *xax = sdh->GetXaxis();
#if 0
int lobin = xax->FindFixBin(r->Parameter(1)-2*r->Parameter(2));
int hibin = xax->FindFixBin(r->Parameter(1)+2*r->Parameter(2));
sd.sumwinmin = xax->GetBinLowEdge(lobin);
sd.sumwinmax = xax->GetBinUpEdge(hibin);
#elif 0
int lobin = xax->FindFixBin(140); sd.sumwinmin=140; // 1 bin left,
int hibin = xax->FindFixBin(170)-1; sd.sumwinmax=170; // 2 bins right
#else
int lobin = xax->FindFixBin(sumwinmin);
int hibin = xax->FindFixBin(sumwinmax)-1;
#endif
int nbins = hibin-lobin+1;
// for variable binning - all histos must have the same binning per channel
TVectorD xbins = TVectorD(sdh->GetNbinsX(),sdh->GetXaxis()->GetXbins()->GetArray());
TVectorD xwindow = xbins.GetSub(lobin-1,hibin);
xax->SetRange(lobin,hibin);
// Copy contents to window-restricted signal histogram
// and write to output file.
//
TString name = Form("Signal%s_%s",sigmodel.Data(),channames[ichan]);
printf("Booking TH1D(%s,%s,%d,xwindowarray)\n",
name.Data(),sdh->GetTitle(),nbins);
TH1D *signm = new TH1D(name.Data(),
sdh->GetTitle(),
nbins,
xwindow.GetMatrixArray());
// make copies of the histograms that are restricted to the
// bin range lobin-hibin
//
for (int ibin=lobin; ibin<=hibin; ibin++)
signm->SetBinContent((ibin-lobin+1),
sdh->GetBinContent(ibin)
*sdh->GetBinWidth(ibin)
);
if (!sigmodel.CompareTo("wh"))
signm->Scale(whsigscaleto);
else
signm->Scale(sigscaleto);
allHistFile->WriteTObject(signm);
} // channel loop
} // writeSignalHistosForModel
void chipSummary(const char *dirName, int chipId, int TrimVcal)
{
if (f && f->IsOpen()) f->Close();
// if (f1 && f1->IsOpen()) f1->Close();
if (g && g->IsOpen()) g->Close();
gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
gStyle->SetOptStat(0);
gStyle->SetTitle(0);
gStyle->SetStatFont(132);
gStyle->SetTextFont(132);
gStyle->SetLabelFont(132, "X");
gStyle->SetLabelFont(132, "Y");
gStyle->SetLabelSize(0.08, "X");
gStyle->SetLabelSize(0.08, "Y");
gStyle->SetNdivisions(6, "X");
gStyle->SetNdivisions(8, "Y");
gStyle->SetTitleFont(132);
gROOT->ForceStyle();
tl = new TLatex;
tl->SetNDC(kTRUE);
tl->SetTextSize(0.09);
ts = new TLatex;
ts->SetNDC(kTRUE);
ts->SetTextSize(0.08);
line = new TLine;
line->SetLineColor(kRed);
line->SetLineStyle(kSolid);
box = new TBox;
box->SetFillColor(kRed);
box->SetFillStyle(3002);
f = new TFile(Form("%s/%s", dirName, fileName), "READ");
// if (strcmp(fileName, adFileName) == 0) f1 = f;
// else f1 = new TFile(Form("%s/%s", dirName, adFileName), "READ");
sprintf(trimFileName,"Trim%i.root",TrimVcal);
if (strcmp(fileName, trimFileName) == 0) g = f;
else g = new TFile(Form("%s/%s", dirName, trimFileName), "READ");
//sprintf(fname, "%s/../../criteria.dat", dirName);
sprintf(fname, "criteria.dat", dirName);
if ( !readCriteria(fname) ) {
printf("\nchipSummary> ----> COULD NOT READ GRADING CRITERIA !!!");
printf("chipSummary> ----> Aborting execution of chipgSummaryPage.C ... \n\n", fileName, dirName);
break;
}
TH1D *h1;
TH2D *h2;
c1 = new TCanvas("c1", "", 800, 800);
c1->Clear();
c1->Divide(4,4, 0.01, 0.04);
// shrinkPad(0.1, 0.1, 0.1, 0.3);
TString noslash(dirName);
noslash.ReplaceAll("/", " ");
noslash.ReplaceAll(".. ", "");
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Dead pixels
TH2D *hpm = new TH2D("hpm", "", 80, 0., 80., 52, 0., 52.);
int nDeadPixel(0);
int nMaskDefect(0);
int nNoisyPixel(0);
int nRootFileProblems(0);
c1->cd(1);
h2 = (TH2D*)f->Get(Form("PixelMap_C%i", chipId));
if (h2) {
for (int icol = 0; icol < 52; ++icol)
{
for (int irow = 0; irow < 80; ++irow)
{
hpm->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1));
if (h2->GetBinContent(icol+1, irow+1) == 0)
{
++nDeadPixel;
}
if (h2->GetBinContent(icol+1, irow+1) > 10)
{
++nNoisyPixel;
}
if (h2->GetBinContent(icol+1, irow+1) < 0)
{
++nMaskDefect;
}
}
}
h2->SetTitle("");
h2->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Pixel Map");
}
else { ++nRootFileProblems; }
// -- sCurve width and noise level
TH1D *hw = new TH1D("hw", "", 100, 0., 600.);
TH1D *hd = new TH1D("hd", "", 100, 0., 600.); // Noise in unbonded pixel (not displayed)
TH2D *ht = new TH2D("ht", "", 52, 0., 52., 80, 0., 80.);
TH1D *htmp;
float mN(0.), sN(0.), nN(0.), nN_entries(0.);
int over(0), under(0);
double htmax(255.), htmin(0.);
float thr, sig;
int a,b;
FILE *inputFile;
char string[200];
sprintf(string, "%s/SCurve_C0%i.dat", dirName, TrimVcal);
inputFile = fopen(string, "r");
double minThrDiff(-5.);
double maxThrDiff(5.);
h2 = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId));
if (!inputFile)
{
printf("chipSummary> !!!!!!!!! ----> SCurve: Could not open file %s to read fit results\n", string);
}
else
{
for (int i = 0; i < 2; i++) fgets(string, 200, inputFile);
for (int icol = 0; icol < 52; ++icol)
{
for (int irow = 0; irow < 80; ++irow)
{
fscanf(inputFile, "%e %e %s %2i %2i", &thr, &sig, string, &a, &b); //comment
// printf("chipSummary> sig %e thr %e\n", sig, thr);
hw->Fill(sig);
thr = thr / 65;
ht->SetBinContent(icol+1, irow+1, thr);
if ( h2 ) {
if( h2->GetBinContent(icol+1, irow+1) > minThrDiff)
{
hd->Fill(sig);
}
}
}
}
c1->cd(2);
hw->Draw();
tl->DrawLatex(0.1, 0.92, "S-Curve widths: Noise (e^{-})");
/* c1->cd(15);
hd->SetLineColor(kRed);
hd->Draw();
tl->DrawLatex(0.1, 0.92, "S-Curve widths of dead bumps");
if ( hd->GetEntries() > 0 ) {
ts->DrawLatex(0.55, 0.82, Form("entries: %4.0f", hd->GetEntries()));
ts->DrawLatex(0.55, 0.74, Form("#mu:%4.2f", hd->GetMean()));
ts->DrawLatex(0.55, 0.66, Form("#sigma: %4.2f", hd->GetRMS()));
}
*/
mN = hw->GetMean();
sN = hw->GetRMS();
nN = hw->Integral(hw->GetXaxis()->GetFirst(), hw->GetXaxis()->GetLast());
nN_entries = hw->GetEntries();
under = hw->GetBinContent(0);
over = hw->GetBinContent(hw->GetNbinsX()+1);
ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nN));
ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mN));
ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sN));
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
c1->cd(3);
if ( ht->GetMaximum() < htmax ) {
htmax = ht->GetMaximum();
}
if ( ht->GetMinimum() > htmin ) {
htmin = ht->GetMinimum();
}
ht->GetZaxis()->SetRangeUser(htmin,htmax);
ht->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Vcal Threshold from SCurve");
}
// -- Noise level map
c1->cd(4);
gPad->SetLogy(1);
gStyle->SetOptStat(1);
float mV(0.), sV(0.), nV(0.), nV_entries(0.);
over = 0.; under = 0.;
if (!g->IsZombie())
{
h1 = (TH1D*)g->Get(Form("VcalThresholdMap_C%iDistribution;7", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(0., 100.);
h1->Draw();
mV = h1->GetMean();
sV = h1->GetRMS();
nV = h1->Integral(h1->GetXaxis()->GetFirst(), h1->GetXaxis()->GetLast());
nV_entries = h1->GetEntries();
under = h1->GetBinContent(0);
over = h1->GetBinContent(h1->GetNbinsX()+1);
}
else {
++nRootFileProblems;
mV = 0.;
sV = 0.;
}
ts->DrawLatex(0.15, 0.82, Form("N: %4.0f", nV));
ts->DrawLatex(0.15, 0.74, Form("#mu: %4.1f", mV));
ts->DrawLatex(0.15, 0.66, Form("#sigma: %4.1f", sV));
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
}
tl->DrawLatex(0.1, 0.92, "Vcal Threshold Trimmed");
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 2
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Bump Map
TH2D *hbm = new TH2D("hbm", "", 80, 0., 80., 52, 0., 52.);
int nDeadBumps(0);
c1->cd(5);
gStyle->SetOptStat(0);
h2 = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId));
if (h2) {
for (int icol = 0; icol < 52; ++icol)
{
for (int irow = 0; irow < 80; ++irow)
{
hbm->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1));
if ( h2->GetBinContent(icol+1, irow+1) >= minThrDiff )
{
cout << Form("chipSummary> dead %3d %3d: %7.5f", icol, irow, h2->GetBinContent(icol, irow)) << endl;
++nDeadBumps;
}
}
}
h2->SetTitle("");
h2->GetZaxis()->SetRangeUser(minThrDiff, maxThrDiff);
h2->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Bump Bonding Problems");
}
else { ++nRootFileProblems; }
// -- Bump Map
c1->cd(6);
gPad->SetLogy(1);
//gStyle->SetOptStat(1);
h1 = (TH1D*)f->Get(Form("vcals_xtalk_C%iDistribution", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(-50., 50.); //DOES NOT WORK!!!???
h1->Draw();
tl->DrawLatex(0.1, 0.92, "Bump Bonding");
}
else { ++nRootFileProblems; }
// -- Trim bits
int trimbitbins(3);
int nDeadTrimbits(0);
c1->cd(7);
gPad->SetLogy(1);
h1 = (TH1D*)f->Get(Form("TrimBit14_C%i", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(0., 60.);
h1->SetMinimum(0.5);
h1->Draw("");
tl->DrawLatex(0.1, 0.92, "Trim Bit Test");
for (int i = 1; i <= trimbitbins; ++i) nDeadTrimbits += h1->GetBinContent(i);
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit13_C%i", chipId));
if (h1) {
h1->SetLineColor(kRed);
h1->Draw("same");
for (int i = 1; i <= trimbitbins; ++i) nDeadTrimbits += h1->GetBinContent(i);
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit11_C%i", chipId));
if (h1) {
h1->SetLineColor(kBlue);
h1->Draw("same");
for (int i = 1; i <= trimbitbins; ++i) nDeadTrimbits += h1->GetBinContent(i);
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit7_C%i", chipId));
if (h1) {
h1->SetLineColor(kGreen);
h1->Draw("same");
for (int i = 1; i <= trimbitbins; ++i) nDeadTrimbits += h1->GetBinContent(i);
}
else { ++nRootFileProblems; }
// -- For numerics and titels see at end
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 3
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Address decoding
TH2D *ham = new TH2D("ham", "", 80, 0., 80., 52, 0., 52.);
int nAddressProblems(0);
c1->cd(9);
gStyle->SetOptStat(0);
h2 = (TH2D*)f->Get(Form("AddressDecoding_C%i", chipId));
if (h2) {
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
ham->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1));
if (h2 && h2->GetBinContent(icol+1, irow+1) < 1) {
cout << Form("chipSummary> address problem %3d %3d: %7.5f", icol, irow, h2->GetBinContent(icol, irow))
<< endl;
++nAddressProblems;
}
}
}
h2->SetTitle("");
h2->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Address decoding");
}
else { ++nRootFileProblems; }
// -- Address levels
c1->cd(10);
gPad->SetLogy(1);
h1 = (TH1D*)f->Get(Form("AddressLevels_C%i", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(-1200., 1000.);
h1->Draw();
tl->DrawLatex(0.1, 0.92, "Address Levels");
}
else { ++nRootFileProblems; }
// -- PHCalibration (Gain & Pedesdtal)
TH1D *hg = new TH1D("hg", "", 250, -1., 5.5);
TH2D *hgm = new TH2D("hgm", "", 52, 0., 52., 80, 0., 80.);
TH1D *hp1 = new TH1D("hp", "", 100,0,5);
TH1D *hp = new TH1D("hp", "", 900, -600., 600.);
hp->StatOverflows(kTRUE);
TH1D *rp = new TH1D("rp", "", 900, -600., 600.);
rp->StatOverflows(kFALSE);
TH1D *htmp;
float mG(0.), sG(0.), nG(0.), nG_entries(0.);
float mP(0.), sP(0.), nP(0.), nP_entries(0.);
over = 0.; under = 0.;
float par0, par1, par2, par3, par4, par5; // Parameters of Vcal vs. Pulse Height Fit
float ped, gain;
int a,b;
int mPbin(0), xlow(-100), xup(255), extra(0); // for restricted RMS
double integral(0.);
FILE *inputFile;
char string[200];
sprintf(string, "%s/phCalibrationFitTan_C0%i.dat", dirName, TrimVcal);
inputFile = fopen(string, "r");
if (!inputFile)
{
printf("chipSummary> !!!!!!!!! ----> phCal: Could not open file %s to read fit results\n", string);
}
else
{
for (int i = 0; i < 2; i++) fgets(string, 200, inputFile);
for (int icol = 0; icol < 52; ++icol)
{
for (int irow = 0; irow < 80; ++irow)
{
// fscanf(inputFile, "%e %e %e %e %e %e %s %2i %2i", &par0, &par1, &par2, &par3, &par4, &par5, string, &a, &b);
fscanf(inputFile, "%e %e %e %e %s %2i %2i", &par0, &par1, &par2, &par3, string, &a, &b);
if (par2 != 0.) // dead pixels have par2 == 0.
{
// ped = -par3/par2;
gain = 1./par2;
// ped = par3;
ped=par3+par2*(tanh(-par1));
hp->Fill(ped);
hg->Fill(gain);
hp1->Fill(par1);
// cout <<gain<<" " << ped<<endl;
hgm->SetBinContent(icol + 1, irow + 1, gain);
}
}
}
mG = hg->GetMean();
sG = hg->GetRMS();
nG = hg->Integral(hg->GetXaxis()->GetFirst(), hg->GetXaxis()->GetLast());
nG_entries = hg->GetEntries();
under = hg->GetBinContent(0);
over = hg->GetBinContent(hp->GetNbinsX()+1);
c1->cd(11);
// hg->Draw();
tl->DrawLatex(0.1, 0.92, "PH Calibration: Gain (ADC/DAC)");
if ( hg->GetMean() > 1.75 ) {
ts->DrawLatex(0.15, 0.82, Form("N: %4.0f", nG));
ts->DrawLatex(0.15, 0.74, Form("#mu: %4.2f", mG));
ts->DrawLatex(0.15, 0.66, Form("#sigma: %4.2f", sG));
if ( under ) ts->DrawLatex(0.15, 0.82, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.82, Form("%i =>", over ));
}
else {
ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nG));
ts->DrawLatex(0.65, 0.74, Form("#mu: %4.2f", mG));
ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.2f", sG));
if ( under ) ts->DrawLatex(0.15, 0.82, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.82, Form("%i =>", over ));
}
mP = hp->GetMean();
sP = hp->GetRMS();
nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast());
nP_entries = hp->GetEntries();
if ( nP > 0 ) {
// -- restricted RMS
integral = 0.;
mPbin = -1000; xlow = -1000; xup = 1000;
over = 0.; under = 0.;
mPbin = hp->GetXaxis()->FindBin(mP);
for (int i = 0; integral < pedDistr; i++) {
xlow = mPbin-i;
xup = mPbin+i;
integral = hp->Integral(xlow, xup)/nP;
}
extra = xup - xlow;
}
else {
xlow = -300; xup = 600; extra = 0;
over = 0.; under = 0.;
}
hp->GetXaxis()->SetRange(xlow - extra, xup + extra);
nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast());
under = hp->GetBinContent(0);
over = hp->GetBinContent(hp->GetNbinsX()+1);
c1->cd(15);
// hgm->Draw("colz");
hp1->Draw();
tl->DrawLatex(0.1, 0.92, "PH Calibration: P1");
c1->cd(12);
hp->DrawCopy();
rp->Add(hp);
rp->GetXaxis()->SetRange(xlow, xup);
mP = rp->GetMean();
sP = rp->GetRMS();
// box->DrawBox( rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xup), 1.05*rp->GetMaximum());
rp->SetFillColor(kRed);
rp->SetFillStyle(3002);
rp->Draw("same");
line->DrawLine(rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xlow), 0.6*rp->GetMaximum());
line->DrawLine(rp->GetBinCenter(xup), 0, rp->GetBinCenter(xup), 0.6*rp->GetMaximum());
tl->DrawLatex(0.1, 0.92, "PH Calibration: Pedestal (DAC)");
if ( hp->GetMean() < 126. ) {
ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nP));
ts->SetTextColor(kRed);
ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mP));
ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sP));
ts->SetTextColor(kBlack);
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
}
else {
ts->DrawLatex(0.16, 0.82, Form("N: %4.0f", nP));
ts->SetTextColor(kRed);
ts->DrawLatex(0.16, 0.74, Form("#mu: %4.1f", mP));
ts->DrawLatex(0.16, 0.66, Form("#sigma: %4.1f", sP));
ts->SetTextColor(kBlack);
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
}
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Numerics and Titles
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Compute the final verdict on this chip //?? FIXME (below is pure randomness)
char finalVerdict(0);
if (nDeadTrimbits > 40) finalVerdict += 1;
if (nDeadPixel > 40) finalVerdict += 10;
if (nNoisyPixel > 40) finalVerdict += 10;
if (nAddressProblems > 40) finalVerdict += 10;
if (nDeadBumps > 40) finalVerdict += 100;
// -- Defects
c1->cd(8);
tl->SetTextSize(0.10);
tl->SetTextFont(22);
double y = 0.92;
y -= 0.11;
tl->DrawLatex(0.1, y, "Summary");
tl->DrawLatex(0.7, y, Form("%d", finalVerdict));
tl->SetTextFont(132);
tl->SetTextSize(0.09);
y -= 0.11;
tl->DrawLatex(0.1, y, Form("Dead Pixels: "));
tl->DrawLatex(0.7, y, Form("%4d", nDeadPixel));
y -= 0.10;
tl->DrawLatex(0.1, y, Form("Noisy Pixels: "));
tl->DrawLatex(0.7, y, Form("%4d", nNoisyPixel));
y -= 0.10;
tl->DrawLatex(0.1, y, "Mask defects: ");
tl->DrawLatex(0.7, y, Form("%4d", nMaskDefect));
y -= 0.10;
tl->DrawLatex(0.1, y, "Dead Bumps: ");
tl->DrawLatex(0.7, y, Form("%4d", nDeadBumps));
y -= 0.10;
tl->DrawLatex(0.1, y, "Dead Trimbits: ");
tl->DrawLatex(0.7, y, Form("%4d", nDeadTrimbits));
y -= 0.10;
tl->DrawLatex(0.1, y, "Address Probl: ");
tl->DrawLatex(0.7, y, Form("%4d", nAddressProblems));
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 4
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
TH2D *htm = new TH2D("htm", "", 80, 0., 80., 52, 0., 52.);
c1->cd(13);
gStyle->SetOptStat(0);
h2 = (TH2D*)g->Get(Form("TrimMap_C%i;8", chipId));
if (h2) {
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
htm->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1));
}
}
h2->SetTitle("");
h2->GetZaxis()->SetRangeUser(0., 16.);
h2->Draw("colz");
}
else { ++nRootFileProblems; }
tl->DrawLatex(0.1, 0.92, "Trim Bits");
FILE *tCalFile;
sprintf(string, "%s/../T-calibration/TemperatureCalibration_C%i.dat", dirName, chipId);
tCalFile = fopen(string, "r");
char tCalDir[200];
sprintf(tCalDir, "%s/../T-calibration", dirName);
if ( tCalFile ) {
analyse(tCalDir, chipId);
}
else {
c1->cd(14);
TGraph *graph = (TGraph*)f->Get(Form("TempCalibration_C%i", chipId));
if ( graph ) { graph->Draw("A*"); }
else { ++nRootFileProblems; }
tl->DrawLatex(0.1, 0.92, "Temperature calibration");
}
// -- Operation Parameters
c1->cd(16);
y = 0.92;
tl->SetTextSize(0.10);
tl->SetTextFont(22);
y -= 0.11;
tl->DrawLatex(0.1, y, Form("Op. Parameters"));
tl->SetTextFont(132);
tl->SetTextSize(0.09);
y -= 0.11;
int vana(-1.);
vana = dac_findParameter(dirName, "Vana", chipId);
tl->DrawLatex(0.1, y, "VANA: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3i DAC", vana));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int caldel(-1.);
caldel = dac_findParameter(dirName, "CalDel", chipId);
tl->DrawLatex(0.1, y, "CALDEL: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", caldel));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int vthrcomp(-1.);
vthrcomp = dac_findParameter(dirName, "VthrComp", chipId);
tl->DrawLatex(0.1, y, "VTHR: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vthrcomp));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int vtrim(-1.);
vtrim = dac_findParameter(dirName, "Vtrim", chipId);
tl->DrawLatex(0.1, y, "VTRIM: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vtrim));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int ibias(-1.);
ibias = dac_findParameter(dirName, "Ibias_DAC", chipId);
tl->DrawLatex(0.1, y, "IBIAS_DAC: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", ibias));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int voffset(-1.);
voffset = dac_findParameter(dirName, "VoffsetOp", chipId);
tl->DrawLatex(0.1, y, "VOFFSETOP: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", voffset));
else tl->DrawLatex(0.7, y, "N/A");
// -- Page title
c1->cd(0);
tl->SetTextSize(0.025);
tl->SetTextFont(22);
tl->DrawLatex(0.02, 0.97, Form("%s (Trim%i)", noslash.Data(),TrimVcal));
TDatime date;
tl->SetTextSize(0.02);
tl->DrawLatex(0.75, 0.97, Form("%s", date.AsString()));
c1->SaveAs(Form("%s/chipSummary_C%i_%i.ps", dirName, chipId,TrimVcal));
c1->SaveAs(Form("%s/C%i_%i.gif", dirName, chipId,TrimVcal));
// -- Dump into logfile
ofstream OUT(Form("%s/summary_C%i_%i.txt", dirName, chipId,TrimVcal));
OUT << "nDeadPixel: " << nDeadPixel << endl;
OUT << "nNoisyPixel: " << nNoisyPixel << endl;
OUT << "nDeadTrimbits: " << nDeadTrimbits << endl;
OUT << "nDeadBumps: " << nDeadBumps << endl;
OUT << "nMaskDefect: " << nMaskDefect << endl;
OUT << "nAddressProblems: " << nAddressProblems << endl;
OUT << "nRootFileProblems: " << nRootFileProblems << endl;
OUT << "SCurve " << nN_entries << " " << mN << " " << sN << endl;
OUT << "Threshold " << nV_entries << " " << mV << " " << sV << endl;
OUT << "Gain " << nG_entries << " " << mG << " " << sG << endl;
OUT << "Pedestal " << nP_entries << " " << mP << " " << sP << endl;
OUT.close();
}
void plotXY(char* fname){
// input: root file from GBL
gStyle->SetOptStat(0);
Double_t w = 1.2; // number of RMS for gaussian fit
TString filename = fname;
TCanvas *cTop = new TCanvas("cTop","Residuals in lab frame, TOP", 800, 1000);
TCanvas *cBot = new TCanvas("cBot","Residuals in lab frame, BOTTOM",800, 1000);
cTop->SetFillColor(kBlue-10); cTop->SetFillStyle(3001);
cBot->SetFillColor(kMagenta-10); cBot->SetFillStyle(3001);
Double_t halfWid = 38.34/2.;
Double_t halfLen = 98.33/2.;
TBox *module = new TBox(-halfLen, -halfWid, halfLen, halfWid);
module->SetLineColor(kMagenta);
module->SetFillStyle(0);
Int_t ic=0;
TFile *f = new TFile(filename.Data());
// extract string
Int_t idx2 = filename.Index("/");
Int_t idx1 = filename.Index("_");
TString outn = filename(idx1+1,idx2-(idx1+1));
TString outname ="predXY_"; outname += outn.Data(); outname += ".txt";
TString topName ="predXY_"; topName += outn.Data(); topName += "_topO.gif";
TString botName ="predXY_"; botName += outn.Data(); botName += "_botO.gif";
// ofstream outf(outname.Data());
// top
Int_t nrow = 13;
Double_t space = 0.007;
Double_t space1 = 0.03;
Double_t y2 = 1./13*nrow-space1;
Double_t y1 = 1./13*(--nrow)-space1;
TPad *tp1 = new TPad("tp1","tp1",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp2 = new TPad("tp2","tp2",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *tp3 = new TPad("tp3","tp3",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp4 = new TPad("tp4","tp4",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *tp5 = new TPad("tp5","tp5",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp6 = new TPad("tp6","tp6",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
Double_t off = 0.12;
off = 0.165;
y1 -= space1; y2 -= space1;
space1 *= 2;
TPad *tp7 = new TPad("tp7","tp7",0.+off,y1,0.33+off,y2);
TPad *tp8 = new TPad("tp8","tp8",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp9 = new TPad("tp9","tp9",0.+off,y1,0.33+off,y2);
TPad *tp10 = new TPad("tp10","tp10",0.66-off,y1,1.-off,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *tp11 = new TPad("tp11","tp11",0.+off,y1,0.33+off,y2);
TPad *tp12 = new TPad("tp12","tp12",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp13 = new TPad("tp13","tp13",0.+off,y1,0.33+off,y2);
TPad *tp14 = new TPad("tp14","tp14",0.66-off,y1,1.-off,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *tp15 = new TPad("tp15","tp15",0.+off,y1,0.33+off,y2);
TPad *tp16 = new TPad("tp16","tp16",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *tp17 = new TPad("tp17","tp17",0.+off,y1,0.33+off,y2);
TPad *tp18 = new TPad("tp18","tp18",0.66-off,y1,1.-off,y2);
cout << " TOP " << endl;
cTop->cd();
tp1->Draw();
tp2->Draw();
tp3->Draw();
tp4->Draw();
tp5->Draw();
tp6->Draw();
tp7->Draw();
tp8->Draw();
tp9->Draw();
tp10->Draw();
tp11->Draw();
tp12->Draw();
tp13->Draw();
tp14->Draw();
tp15->Draw();
tp16->Draw();
tp17->Draw();
tp18->Draw();
ic = 2;
Int_t ipad=0;
for(Int_t i=1; i<4; i++){
TString hisname = "h_xy_module_L"; hisname += i;
hisname += "t_halfmodule_axial_sensor0";
TString layer = "L"; layer+=i; layer+= "TA";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
TH1D *his = (TH1D*)his2->ProjectionY();
ipad++;
TString pd = "tp"; pd+=ipad;
TPad *pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
Double_t low = his->GetMean()-w*his->GetRMS();
Double_t up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up);
his2->Draw("colz");
module->Draw("same");
TF1 *fit = his->GetFunction("gaus");
// cout << "sensor " << i << " axial mean : " << his->GetMean()*1000. << " - RMS : " << his->GetRMS()*1000. << " (um) " << " " << his->GetEntries() << endl;
// cout << "sensor " << i << " axial mu : " << fit->GetParameter(1)*1000. << " - sigma : " << fit->GetParameter(2)*1000. << " (um) " << endl;
// outf << layer.Data() << " " << fit->GetParameter(1)*1000. << " " << fit->GetParameter(2)*1000. << " " << his->GetEntries() << endl;
hisname = "h_xy_module_L"; hisname += i;
hisname += "t_halfmodule_stereo_sensor0";
layer = "L"; layer+=i; layer+= "TS";
his2 = (TH2D*) f->Get(hisname.Data());
his = (TH1D*)his2->ProjectionY();
ipad++;
pd = "tp"; pd+=ipad;
pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
}
// ic = 19;
for(Int_t i=4; i<7; i++){
TString hisname = "h_xy_module_L"; hisname += i;
TString hisname2 = hisname;
hisname += "t_halfmodule_axial_hole_sensor0";
hisname2 += "t_halfmodule_axial_slot_sensor0";
TH2D *hisOther = (TH2D*) f->Get(hisname2.Data());
Double_t norma2 = hisOther->GetMaximum();
TString layer = "L"; layer+=i; layer+= "TAHo";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
TH1D *his = (TH1D*)his2->ProjectionY();
Double_t norma1 = his2->GetMaximum();
Double_t normamax = TMath::Max(norma1,norma2);
his2->SetMaximum(normamax);
ipad++;
TString pd = "tp"; pd+=ipad;
TPad *pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
Double_t low = his->GetMean()-w*his->GetRMS();
Double_t up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
TF1 *fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname2 = hisname;
hisname += "t_halfmodule_stereo_hole_sensor0";
hisname2 += "t_halfmodule_stereo_slot_sensor0";
TH2D *hisOther = (TH2D*) f->Get(hisname2.Data());
norma2 = hisOther->GetMaximum();
TString layer = "L"; layer+=i; layer+= "TAHo";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
TH1D *his = (TH1D*)his2->ProjectionY();
norma1 = his2->GetMaximum();
normamax2 = TMath::Max(norma1,norma2);
his2->SetMaximum(normamax2);
layer = "L"; layer+=i; layer+= "TSHo";
his2 = (TH2D*) f->Get(hisname.Data());
his = (TH1D*)his2->ProjectionY();
ipad++; ipad++;
pd = "tp"; pd+=ipad;
pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname += "t_halfmodule_axial_slot_sensor0";
layer = "L"; layer+=i; layer+= "TASl";
his2 = (TH2D*) f->Get(hisname.Data());
his2->SetMaximum(normamax);
his = (TH1D*)his2->ProjectionY();
ipad--;
pd = "tp"; pd+=ipad;
pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname += "t_halfmodule_stereo_slot_sensor0";
layer = "L"; layer+=i; layer+= "TSSl";
his2 = (TH2D*) f->Get(hisname.Data());
his2->SetMaximum(normamax2);
his = (TH1D*)his2->ProjectionY();
ipad++; ipad++;
pd = "tp"; pd+=ipad;
pad = (TPad*) cTop->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
}
cout << endl;
cout << "------------------------" << endl;
cout << endl;
cout << " BOTTOM " << endl;
nrow = 13;
space = 0.007;
space1 = 0.03;
y2 = 1./13*nrow-space1;
y1 = 1./13*(--nrow)-space1;
TPad *bp1 = new TPad("bp1","bp1",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp2 = new TPad("bp2","bp2",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *bp3 = new TPad("bp3","bp3",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp4 = new TPad("bp4","bp4",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *bp5 = new TPad("bp5","bp5",0.33,y1,0.66,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp6 = new TPad("bp6","bp6",0.33,y1,0.66,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
off = 0.165;
y1 -= space1; y2 -= space1;
space1 *= 2;
TPad *bp7 = new TPad("bp7","bp7",0.+off,y1,0.33+off,y2);
TPad *bp8 = new TPad("bp8","bp8",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp9 = new TPad("bp9","bp9",0.+off,y1,0.33+off,y2);
TPad *bp10 = new TPad("bp10","bp10",0.66-off,y1,1.-off,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *bp11 = new TPad("bp11","bp11",0.+off,y1,0.33+off,y2);
TPad *bp12 = new TPad("bp12","bp12",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp13 = new TPad("bp13","bp13",0.+off,y1,0.33+off,y2);
TPad *bp14 = new TPad("bp14","bp14",0.66-off,y1,1.-off,y2);
y2 = y1-space; y1 = 1./13.*(--nrow)-space1;
TPad *bp15 = new TPad("bp15","bp15",0.+off,y1,0.33+off,y2);
TPad *bp16 = new TPad("bp16","bp16",0.66-off,y1,1.-off,y2);
y2 = y1; y1 = 1./13.*(--nrow)-space1;
TPad *bp17 = new TPad("bp17","bp17",0.+off,y1,0.33+off,y2);
TPad *bp18 = new TPad("bp18","bp18",0.66-off,y1,1.-off,y2);
cBot->cd();
bp1->Draw();
bp2->Draw();
bp3->Draw();
bp4->Draw();
bp5->Draw();
bp6->Draw();
bp7->Draw();
bp8->Draw();
bp9->Draw();
bp10->Draw();
bp11->Draw();
bp12->Draw();
bp13->Draw();
bp14->Draw();
bp15->Draw();
bp16->Draw();
bp17->Draw();
bp18->Draw();
cBot->cd();
bp1->Draw();
bp2->Draw();
bp3->Draw();
bp4->Draw();
bp5->Draw();
bp6->Draw();
bp7->Draw();
bp8->Draw();
bp9->Draw();
bp10->Draw();
bp11->Draw();
bp12->Draw();
bp13->Draw();
bp14->Draw();
bp15->Draw();
bp16->Draw();
bp17->Draw();
bp18->Draw();
ic=0;
ipad = 0;
for(Int_t i=1; i<4; i++){
TString hisname = "h_xy_module_L"; hisname += i;
TString hisname2 = hisname;
hisname += "b_halfmodule_stereo_sensor0";
hisname2 += "b_halfmodule_axial_sensor0";
TH2D *hisOther = (TH2D*) f->Get(hisname2.Data());
Double_t norma2 = hisOther->GetMaximum();
TString layer = "L"; layer+=i; layer+= "BS";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
Double_t norma1 = his2->GetMaximum();
Double_t normamax = TMath::Max(norma1,norma2);
// his2->SetMaximum(normamax);
TH1D *his = (TH1D*)his2->ProjectionY();
if(layer.Contains("1")){his->SetFillColor(kRed);}
else if(layer.Contains("2")){his->SetFillColor(kOrange);}
else if(layer.Contains("3")){his->SetFillColor(kYellow);}
else if(layer.Contains("4")){his->SetFillColor(kGreen);}
else if(layer.Contains("5")){his->SetFillColor(kCyan);}
else if(layer.Contains("6")){his->SetFillColor(kBlue);}
if(layer.Contains("A")){his->SetFillStyle(3007);}
else if(layer.Contains("S")){his->SetFillStyle(3004);}
// cBot->cd(++ic);
ipad++;
TString pd = "bp"; pd+=ipad;
TPad *pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
Double_t low = his->GetMean()-w*his->GetRMS();
Double_t up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
TF1 *fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname += "b_halfmodule_axial_sensor0";
layer = "L"; layer+=i; layer+= "BA";
his2 = (TH2D*) f->Get(hisname.Data());
// his2->SetMaximum(normamax);
his = (TH1D*)his2->ProjectionY();
ipad++;
pd = "bp"; pd+=ipad;
pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
}
for(Int_t i=4; i<7; i++){
TString hisname = "h_xy_module_L"; hisname += i;
TString hisname2 = hisname;
hisname += "b_halfmodule_stereo_hole_sensor0";
hisname2 += "b_halfmodule_stereo_slot_sensor0";
TH2D *hisOther = (TH2D*) f->Get(hisname2.Data());
Double_t norma2 = hisOther->GetMaximum();
TString layer = "L"; layer+=i; layer+= "BSHo";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
TH1D *his = (TH1D*)his2->ProjectionY();
Double_t norma1 = his2->GetMaximum();
Double_t normamax1 = TMath::Max(norma1,norma2);
his2->SetMaximum(normamax1);
ipad++;
TString pd = "bp"; pd+=ipad;
TPad *pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
Double_t low = his->GetMean()-w*his->GetRMS();
Double_t up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
TF1 *fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
TString hisname2 = hisname;
hisname += "b_halfmodule_axial_hole_sensor0";
hisname2 += "b_halfmodule_axial_slot_sensor0";
TH2D *hisOther = (TH2D*) f->Get(hisname2.Data());
Double_t norma2 = hisOther->GetMaximum();
TString layer = "L"; layer+=i; layer+= "BAHo";
TH2D *his2 = (TH2D*) f->Get(hisname.Data());
TH1D *his = (TH1D*)his2->ProjectionY();
Double_t norma1 = his2->GetMaximum();
Double_t normamax2 = TMath::Max(norma1,norma2);
his2->SetMaximum(normamax2);
ipad++; ipad++;
pd = "bp"; pd+=ipad;
pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname += "b_halfmodule_stereo_slot_sensor0";
layer = "L"; layer+=i; layer+= "BSSl";
his2 = (TH2D*) f->Get(hisname.Data());
his2->SetMaximum(normamax1);
his = (TH1D*)his2->ProjectionY();
ipad--;
pd = "bp"; pd+=ipad;
pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
hisname = "h_xy_module_L"; hisname += i;
hisname += "b_halfmodule_axial_slot_sensor0";
layer = "L"; layer+=i; layer+= "BASl";
his2 = (TH2D*) f->Get(hisname.Data());
his2->SetMaximum(normamax2);
his = (TH1D*)his2->ProjectionY();
ipad++; ipad++;
pd = "bp"; pd+=ipad;
pad = (TPad*) cBot->GetListOfPrimitives()->FindObject(pd.Data());
pad->cd();
low = his->GetMean()-w*his->GetRMS();
up = his->GetMean()+w*his->GetRMS();
his->Fit("gaus","Q0","",low,up); his2->Draw("colz");
module->Draw("same");
fit = his->GetFunction("gaus");
}
// outf.close();
cTop->SaveAs(topName.Data());
cBot->SaveAs(botName.Data());
}
// ============================================================================
/// finalize the algorithm
// ============================================================================
StatusCode Aida2Root::finalize()
{
always() << "Get the native ROOT representation of histograms!" << endmsg ;
{ // loop over all 1D-histograms
for ( List::const_iterator ipath = m_1Ds.begin() ;
m_1Ds.end() != ipath ; ++ipath )
{
/// retrieve the historam by full path:
AIDA::IHistogram1D* aida = 0 ;
StatusCode sc = histoSvc()->retrieveObject( *ipath , aida ) ;
if ( sc.isFailure() || 0 == aida )
{ return Error ( "Unable to retrieve 1D-histogram '" + (*ipath) + "'" ) ; }
/// convert it to ROOT
TH1D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
if ( 0 == root )
{ return Error ( "Unable to convert to ROOT the 1D-histogram '"+(*ipath)+"'") ; }
/// use the native printout from ROOT
info() << "The native ROOT printout for 1D-histogram '" << (*ipath) << "':" << endmsg ;
root->Print() ;
info () << " | Compare | AIDA/HistoStats | ROOT/TH1 | Delta | " << endmsg ;
const std::string format = " | %1$-14.14s | %2$ 15.8g | %3$- 15.8g | %4$= 15.8g | " ;
info () << print
( Gaudi::Utils::HistoStats::mean ( aida ) ,
root->GetMean () , "'mean'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::meanErr ( aida ) ,
root->GetMeanError () , "'meanErr'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::rms ( aida ) ,
root->GetRMS () , "'rms'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::rmsErr ( aida ) ,
root->GetRMSError () , "'rmsErr'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::skewness ( aida ) ,
root->GetSkewness () , "'skewness'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::skewnessErr ( aida ) ,
root->GetSkewness ( 11 ) , "'skewnessErr'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::kurtosis ( aida ) ,
root->GetKurtosis () , "'kurtosis'" , format ) << endmsg ;
info () << print
( Gaudi::Utils::HistoStats::kurtosisErr ( aida ) ,
root->GetKurtosis ( 11 ) , "'kurtosisErr'" , format ) << endmsg ;
}
}
{ // loop over all 2D-histograms
for ( List::const_iterator ipath = m_2Ds.begin() ;
m_2Ds.end() != ipath ; ++ipath )
{
/// retrieve the historam by full path:
AIDA::IHistogram2D* aida = 0 ;
StatusCode sc = histoSvc()->retrieveObject( *ipath , aida ) ;
if ( sc.isFailure() || 0 == aida )
{ return Error ( "Unable to retrieve 2D-histogram '" + (*ipath) + "'" ) ; }
/// convert it to ROOT
TH2D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
if ( 0 == root )
{ return Error ( "Unable to convert to ROOT the 2D-histogram '"+(*ipath)+"'") ; }
/// use the native printout from ROOT
info() << "The native ROOT printout for 2D-histogram '" << (*ipath) << "':" << endmsg ;
root->Print() ;
}
}
{ // loop over all 3D-histograms
for ( List::const_iterator ipath = m_3Ds.begin() ;
m_3Ds.end() != ipath ; ++ipath )
{
/// retrieve the historam by full path:
AIDA::IHistogram3D* aida = 0 ;
StatusCode sc = histoSvc()->retrieveObject( *ipath , aida ) ;
if ( sc.isFailure() || 0 == aida )
{ return Error ( "Unable to retrieve 3D-histogram '" + (*ipath) + "'" ) ; }
/// convert it to ROOT
TH3D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
if ( 0 == root )
{ return Error ( "Unable to convert to ROOT the 3D-histogram '"+(*ipath)+"'") ; }
/// use the native printout from ROOT
info() << "The native ROOT printout for 3D-histogram '" << (*ipath) << "':" << endmsg ;
root->Print() ;
}
}
{ // loop over all 1D-profiles
for ( List::const_iterator ipath = m_1Ps.begin() ;
m_1Ps.end() != ipath ; ++ipath )
{
/// retrieve the historam by full path:
AIDA::IProfile1D* aida = 0 ;
StatusCode sc = histoSvc()->retrieveObject( *ipath , aida ) ;
if ( sc.isFailure() || 0 == aida )
{ return Error ( "Unable to retrieve 1D-profile '" + (*ipath) + "'" ) ; }
/// convert it to ROOT
TProfile* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
if ( 0 == root )
{ return Error ( "Unable to convert to ROOT the 1D-profile '"+(*ipath)+"'") ; }
/// use the native printout from ROOT
info() << "The native ROOT printout for 1D-profile '" << (*ipath) << "':" << endmsg ;
root->Print() ;
}
}
{ // loop over all 2D-profiles
for ( List::const_iterator ipath = m_2Ps.begin() ;
m_2Ps.end() != ipath ; ++ipath )
{
/// retrieve the historam by full path:
AIDA::IProfile2D* aida = 0 ;
StatusCode sc = histoSvc()->retrieveObject( *ipath , aida ) ;
if ( sc.isFailure() || 0 == aida )
{ Error ( "Unable to retrieve 2D-profile '" + (*ipath) + "'" ) ; }
/// convert it to ROOT
TProfile2D* root = Gaudi::Utils::Aida2ROOT::aida2root ( aida ) ;
if ( 0 == root )
{ Error ( "Unable to convert to ROOT the 2D-profile '"+(*ipath)+"'") ; }
/// use the native printout from ROOT
info() << "The native ROOT printout for 2D-profile '" << (*ipath) << "':" << endmsg ;
root->Print() ;
}
}
return GaudiHistoAlg::finalize() ;
}
int logWeightingScanAll(){//main
SetTdrStyle();
//TString plotDir = "../PLOTS/gitV00-02-12/version12/gamma/200um/";
TString plotDir = "/afs/cern.ch/work/a/amagnan/PFCalEEAna/PLOTS/gitV00-02-12/version12/gamma/200um/";
bool useFit = true;
//const unsigned nPu = 2;
//unsigned pu[nPu] = {0,140};
const unsigned nPu = 1;//2;
unsigned pu[nPu] = {0};//,140};
const unsigned nScans = 50;
const double wStart = 1.;
const double wStep = (6.-wStart)/nScans;
const unsigned neta = 4;//7;
const unsigned npt = 3;//13;
const unsigned nLayers = 30;
unsigned eta[neta] = {17,21,25,29};
//unsigned pt[npt] = {20,30,40,50,60,70,80,90,100,125,150,175,200};
unsigned pt[npt] = {20,50,100};
//TF1 *cauchy = new TF1("cauchy","1/(TMath::Pi()*[2]*(1+pow((x-[0])/[2],2)))",-15,15);
//cauchy->SetParameters(0,0,2.5);
double wxminall[nPu][nLayers][neta];
double wyminall[nPu][nLayers][neta];
double etaval[neta];
const unsigned nCanvas = 5;
TCanvas *mycx[nCanvas];
TCanvas *mycy[nCanvas];
for (unsigned iC(0);iC<nCanvas;++iC){
std::ostringstream lName;
lName << "mycx" << iC;
mycx[iC] = new TCanvas(lName.str().c_str(),lName.str().c_str(),1500,1000);
mycx[iC]->Divide(3,2);
lName.str("");
lName << "mycy" << iC;
mycy[iC] = new TCanvas(lName.str().c_str(),lName.str().c_str(),1500,1000);
mycy[iC]->Divide(3,2);
}
TCanvas *mycW = new TCanvas("mycW","mycW",1500,1000);
TCanvas *mycFit = new TCanvas("mycFit","mycFit",1);
for (unsigned ieta(0); ieta<neta;++ieta){
etaval[ieta] = eta[ieta]/10.;
bool savePoint = (eta[ieta] == 17);// && pt[ipt]==50);
std::ostringstream pteta;
pteta << "eta" << eta[ieta];// << "_et" << pt[ipt];
TFile *fin[nPu];
TFile *fout = 0;
if (savePoint) {
fout = TFile::Open(("PLOTS/LogWeightingStudy_"+pteta.str()+".root").c_str(),"RECREATE");
fout->mkdir("scan");
fout->mkdir("scan/xpos");
fout->mkdir("scan/ypos");
for (unsigned iS(0); iS<nScans;++iS){
std::ostringstream lName;
lName << "scan/xpos/scan_" << wStart+iS*wStep;
fout->mkdir(lName.str().c_str());
lName.str("");
lName << "scan/ypos/scan_" << wStart+iS*wStep;
fout->mkdir(lName.str().c_str());
}
fout->cd();
}
TH1F *p_xt;
TH1F *p_yt;
TH1F *p_intercalibSigmaSquare[nPu];
TH1F *p_chi2ndf;
if (savePoint) {
p_xt = new TH1F("p_xt",";x truth (mm)",100,-5,5);
p_yt = new TH1F("p_yt",";y truth (mm)",100,-5,5);//200,1170,1370);
p_intercalibSigmaSquare[0] = new TH1F("p_intercalibSigmaSquare_0",";#sigma_{E}^{2} (2% intercalib) (GeV^2)",3000,0,30000);
p_intercalibSigmaSquare[1] = new TH1F("p_intercalibSigmaSquare_140",";#sigma_{E}^{2} (2% intercalib) (GeV^2)",3000,0,30000);
p_chi2ndf = new TH1F("p_chi2ndf",";#chi^{2}/N",100,0,20);
}
TH1F *p_posx[nPu][nLayers][nScans];
TH1F *p_posy[nPu][nLayers][nScans];
TH1F *p_wx[nPu][nLayers][3];
TH1F *p_wy[nPu][nLayers][3];
TH2F *p_Exy[nPu][nLayers];
TH2F *p_deltavsreco_x[nPu][nLayers];
TH2F *p_deltavsreco_y[nPu][nLayers];
TH2F *p_recovstruth_x[nPu][nLayers];
TH2F *p_recovstruth_y[nPu][nLayers];
if (savePoint){
mycFit->Print("PLOTS/fits_x.pdf[");
mycFit->Print("PLOTS/fits_y.pdf[");
}
gStyle->SetOptStat("eMRuo");
TGraphErrors *grX[nPu][nLayers];
TGraphErrors *grY[nPu][nLayers];
TGraphErrors *grXrms[nPu][nLayers];
TGraphErrors *grYrms[nPu][nLayers];
double resxmin[nPu][nLayers];
double resymin[nPu][nLayers];
double lay[nLayers];
double wxmin[nPu][nLayers];
double wymin[nPu][nLayers];
for (unsigned ipu(0); ipu<nPu; ++ipu){//loop on pu
std::vector<std::vector<double> > Exy;
std::vector<double> init;
init.resize(25,0);
Exy.resize(nLayers,init);
std::vector<double> truthPosX;
truthPosX.resize(nLayers,0);
std::vector<double> truthPosY;
truthPosY.resize(nLayers,0);
std::ostringstream label;
label << "pu" << pu[ipu];
if (savePoint){
fout->mkdir(label.str().c_str());
fout->cd(label.str().c_str());
}
for (unsigned iL(0);iL<nLayers;++iL){
lay[iL] = iL;
resxmin[ipu][iL] = 100;
wxmin[ipu][iL] = 10;
resymin[ipu][iL] = 100;
wymin[ipu][iL] = 10;
label.str("");
label << "pu" << pu[ipu];
if (savePoint) fout->cd(label.str().c_str());
label.str("");
label << "grX_pu" << pu[ipu] << "_" << iL;
grX[ipu][iL] = new TGraphErrors();
grX[ipu][iL]->SetName(label.str().c_str());
label.str("");
label << "grY_pu" << pu[ipu] << "_" << iL;
grY[ipu][iL] = new TGraphErrors();
grY[ipu][iL]->SetName(label.str().c_str());
label.str("");
label << "grXrms_pu" << pu[ipu] << "_" << iL;
grXrms[ipu][iL] = new TGraphErrors();
grXrms[ipu][iL]->SetName(label.str().c_str());
label.str("");
label << "grYrms_pu" << pu[ipu] << "_" << iL;
grYrms[ipu][iL] = new TGraphErrors();
grYrms[ipu][iL]->SetName(label.str().c_str());
if (savePoint) {
label.str("");
label << "Exy_pu"<< pu[ipu] << "_" << iL;
p_Exy[ipu][iL] = new TH2F(label.str().c_str(),";x idx;y idx; E (mips)",
5,0,5,5,0,5);
}
label.str("");
label << "deltavsreco_x_pu"<< pu[ipu] << "_" << iL;
p_deltavsreco_x[ipu][iL] = new TH2F(label.str().c_str(),";x reco (mm);x_{reco}-x_{truth} (mm);",
30,-15,15,100,-10,10);
label.str("");
label << "deltavsreco_y_pu"<< pu[ipu] << "_" << iL;
p_deltavsreco_y[ipu][iL] = new TH2F(label.str().c_str(),";y reco (mm);y_{reco}-y_{truth} (mm);",
30,-15,15,100,-10,10);
if (savePoint) {
label.str("");
label << "recovstruth_x_pu"<< pu[ipu] << "_" << iL;
p_recovstruth_x[ipu][iL] = new TH2F(label.str().c_str(),";x_{truth} (mm);x reco (mm)",
30,-15,15,30,-15,15);
label.str("");
label << "recovstruth_y_pu"<< pu[ipu] << "_" << iL;
p_recovstruth_y[ipu][iL] = new TH2F(label.str().c_str(),";y_{truth} (mm);y reco (mm)",
30,-15,15,//200,1170,1370,
30,-15,15
);
}
if (savePoint) {
if (savePoint) {
label.str("");
label << "pu" << pu[ipu];
fout->cd(label.str().c_str());
}
for (unsigned i(0);i<5;++i){
label.str("");
label << "wx_pu" << pu[ipu] << "_" << iL << "_" << i;
p_wx[ipu][iL][i] = new TH1F(label.str().c_str(),
";wx;events",
100,-10,0);
label.str("");
label << "wy_pu" << pu[ipu] << "_" << iL << "_" << i;
p_wy[ipu][iL][i] = new TH1F(label.str().c_str(),
";wy;events",
100,-10,0);
}
}
for (unsigned iS(0); iS<nScans;++iS){
label.str("");
label << "scan/xpos/scan_" << wStart+iS*wStep;
if (savePoint) fout->cd(label.str().c_str());
label.str("");
label << "posx_pu" << pu[ipu] << "_" << iL << "_" << iS;
p_posx[ipu][iL][iS] = new TH1F(label.str().c_str(),
";x-x_{truth} (mm);events",
100,-10,10);
label.str("");
label << "scan/ypos/scan_" << wStart+iS*wStep;
if (savePoint) fout->cd(label.str().c_str());
label.str("");
label << "posy_pu" << pu[ipu] << "_" << iL << "_" << iS;
p_posy[ipu][iL][iS] = new TH1F(label.str().c_str(),
";y-y_{truth} (mm);events",
100,-10,10);
}
}//loop on layers
for (unsigned ipt(0); ipt<npt;++ipt){
std::ostringstream linputStr;
linputStr << plotDir << "/" << "eta" << eta[ieta] << "_et" << pt[ipt] << "_pu" << pu[ipu] ;
//linputStr << "_logweight";
linputStr << ".root";
fin[ipu] = TFile::Open(linputStr.str().c_str());
if (!fin[ipu]) {
std::cout << " -- Error, input file " << linputStr.str() << " cannot be opened. Skipping..." << std::endl;
continue;
}
else std::cout << " -- File " << linputStr.str() << " successfully opened." << std::endl;
TTree *tree = (TTree*)gDirectory->Get("EcellsSR2");
if (!tree) {
std::cout << " Tree not found! " << std::endl;
continue;
//return 1;
}
for (unsigned iL(0);iL<nLayers;++iL){
label.str("");
label << "TruthPosX_" << iL;
tree->SetBranchAddress(label.str().c_str(),&truthPosX[iL]);
label.str("");
label << "TruthPosY_" << iL;
tree->SetBranchAddress(label.str().c_str(),&truthPosY[iL]);
for (unsigned iy(0);iy<5;++iy){
for (unsigned ix(0);ix<5;++ix){
unsigned idx = 5*iy+ix;
label.str("");
label << "E_" << iL << "_" << idx;
tree->SetBranchAddress(label.str().c_str(),&Exy[iL][idx]);
}
}
}//loop on layers
unsigned nEvts = tree->GetEntries();
for (unsigned ievt(0); ievt<nEvts; ++ievt){//loop on entries
if (ievt%50 == 0) std::cout << "... Processing entry: " << ievt << std::endl;
tree->GetEntry(ievt);
double Etotsq = 0;
for (unsigned iL(0);iL<nLayers;++iL){
double Etot = 0;
double Ex[5] = {0,0,0,0,0};
double Ey[5] = {0,0,0,0,0};
for (unsigned idx(0);idx<25;++idx){
if (iL>22) Etot += Exy[iL][idx];
else if ((idx>5 && idx<9)||
(idx>10 && idx<14)||
(idx>15 && idx<19)) Etot += Exy[iL][idx];
}
Etotsq += pow(calibratedE(Etot*absWeight(iL,eta[ieta]/10.),eta[ieta]/10.),2);
if (iL>22){
Ex[0] = Exy[iL][0]+Exy[iL][5]+Exy[iL][10]+Exy[iL][15]+Exy[iL][20];
Ex[1] = Exy[iL][1]+Exy[iL][6]+Exy[iL][11]+Exy[iL][16]+Exy[iL][21];
Ex[2] = Exy[iL][2]+Exy[iL][7]+Exy[iL][12]+Exy[iL][17]+Exy[iL][22];
Ex[3] = Exy[iL][3]+Exy[iL][8]+Exy[iL][13]+Exy[iL][18]+Exy[iL][23];
Ex[4] = Exy[iL][4]+Exy[iL][9]+Exy[iL][14]+Exy[iL][19]+Exy[iL][24];
Ey[0] = Exy[iL][0]+Exy[iL][1]+Exy[iL][2]+Exy[iL][3]+Exy[iL][4];
Ey[1] = Exy[iL][5]+Exy[iL][6]+Exy[iL][7]+Exy[iL][8]+Exy[iL][9];
Ey[2] = Exy[iL][10]+Exy[iL][11]+Exy[iL][12]+Exy[iL][13]+Exy[iL][14];
Ey[3] = Exy[iL][15]+Exy[iL][16]+Exy[iL][17]+Exy[iL][18]+Exy[iL][19];
Ey[4] = Exy[iL][20]+Exy[iL][21]+Exy[iL][22]+Exy[iL][23]+Exy[iL][24];
}
else {
Ex[0] = Exy[iL][6]+Exy[iL][11]+Exy[iL][16];
Ex[1] = Exy[iL][7]+Exy[iL][12]+Exy[iL][17];
Ex[2] = Exy[iL][8]+Exy[iL][13]+Exy[iL][18];
Ey[0] = Exy[iL][6]+Exy[iL][7]+Exy[iL][8];
Ey[1] = Exy[iL][11]+Exy[iL][12]+Exy[iL][13];
Ey[2] = Exy[iL][16]+Exy[iL][17]+Exy[iL][18];
}
double simplex = 0;
double simpley = 0;
if (Etot!=0) {
if (iL>22) {
simplex = 10*(2*Ex[4]+Ex[3]-Ex[1]-2*Ex[0])/Etot;
simpley = 10*(2*Ey[4]+Ey[3]-Ey[1]-2*Ey[0])/Etot;
}
else {
simplex = 10*(Ex[2]-Ex[0])/Etot;
simpley = 10*(Ey[2]-Ey[0])/Etot;
}
}
double xt = truthPosX[iL];
unsigned cellCenter = static_cast<unsigned>((truthPosY[iL]+5)/10.)*10;
double yt = 0;
//if (cellCenter>truthPosY[iL]) yt = cellCenter-truthPosY[iL];
yt=truthPosY[iL]-cellCenter;
p_deltavsreco_x[ipu][iL]->Fill(simplex,simplex-xt);
p_deltavsreco_y[ipu][iL]->Fill(simpley,simpley-yt);
if (savePoint) {
p_xt->Fill(xt);
p_yt->Fill(yt);
p_recovstruth_x[ipu][iL]->Fill(xt,simplex);
p_recovstruth_y[ipu][iL]->Fill(yt,simpley);
for (unsigned idx(0);idx<9;++idx){
p_Exy[ipu][iL]->Fill(idx%5,idx/5,Exy[iL][idx]/Etot);
}
}
double wx[6][nScans];
double wy[6][nScans];
for (unsigned i(0);i<6;++i){
for (unsigned iS(0); iS<nScans;++iS){
wx[i][iS] = 0;
wy[i][iS] = 0;
}
}
for (unsigned i(0);i<5;++i){
if (savePoint) p_wx[ipu][iL][i]->Fill(log(Ex[i]/Etot));
if (savePoint) p_wy[ipu][iL][i]->Fill(log(Ey[i]/Etot));
for (unsigned iS(0); iS<nScans;++iS){
double w0 = wStart+iS*wStep;
wx[i][iS] = std::max(0.,log(Ex[i]/Etot)+w0);
wy[i][iS] = std::max(0.,log(Ey[i]/Etot)+w0);
// if (log(Ex[i]/Etot)+w0<0)
// std::cout << " - iL= " << iL << " i=" << i << " w0=" << w0
// << " logEx=" << log(Ex[i]/Etot)
// << " wx " << wx[i][iS]
// << std::endl;
// if (log(Ey[i]/Etot)+w0<0)
// std::cout << " - iL= " << iL << " i=" << i << " w0=" << w0
// << " logEy=" << log(Ey[i]/Etot)
// << " wy " << wy[i][iS]
// << std::endl;
wx[5][iS] += wx[i][iS];
wy[5][iS] += wy[i][iS];
}
}
for (unsigned iS(0); iS<nScans;++iS){
double x = 0;//10*(wx[2][iS]-wx[0][iS])/wx[3][iS];
if (wx[5][iS]!=0) {
if (iL>22) x = 10*(2*wx[4][iS]+wx[3][iS]-wx[1][iS]-2*wx[0][iS])/wx[5][iS];
else x = 10*(wx[2][iS]-wx[0][iS])/wx[5][iS];
}
double y = 0;//10*(wy[2][iS]-wy[0][iS])/wy[3][iS];
if (wy[5][iS]!=0) {
if (iL>22) y = 10*(2*wy[4][iS]+wy[3][iS]-wy[1][iS]-2*wy[0][iS])/wy[5][iS];
else y = 10*(wy[2][iS]-wy[0][iS])/wy[5][iS];
}
//if (fabs(y-yt)>5) std::cout << " --- iL=" << iL << " iS=" << iS
//<< " x=" << x << " xt=" << xt
//<< " y=" << y << " yt=" << yt
//<< std::endl;
p_posx[ipu][iL][iS]->Fill(x-xt);
p_posy[ipu][iL][iS]->Fill(y-yt);
}
}//loop on layers
if (savePoint) p_intercalibSigmaSquare[ipu]->Fill(Etotsq);
}//loop on entries
}//loop on pt
//fill first point with linear weighting
TLatex lat;
char buf[500];
for (unsigned iL(0);iL<nLayers;++iL){
mycFit->cd();
TH1D *projy = p_deltavsreco_x[ipu][iL]->ProjectionY();
projy->Draw();
projy->Fit("gaus","0+Q");
TF1 *fitx = projy->GetFunction("gaus");
fitx->SetLineColor(6);
fitx->Draw("same");
sprintf(buf,"Layer %d, linear weighting, pu=%d",iL,pu[ipu]);
lat.DrawLatexNDC(0.1,0.96,buf);
grX[ipu][iL]->SetPoint(0,0.5,fitx->GetParameter(2));
grX[ipu][iL]->SetPointError(0,0,fitx->GetParError(2));
grXrms[ipu][iL]->SetPoint(0,0.5,projy->GetRMS());
grXrms[ipu][iL]->SetPointError(0,0,projy->GetRMSError());
mycFit->Update();
if (savePoint) mycFit->Print("PLOTS/fits_x.pdf");
mycFit->cd();
projy = p_deltavsreco_y[ipu][iL]->ProjectionY();
projy->Draw();
projy->Fit("gaus","0+Q");
TF1 *fity = projy->GetFunction("gaus");
fitx->SetLineColor(6);
fitx->Draw("same");
sprintf(buf,"Layer %d, linear weighting, pu=%d",iL,pu[ipu]);
lat.DrawLatexNDC(0.1,0.96,buf);
grY[ipu][iL]->SetPoint(0,0.5,fity->GetParameter(2));
grY[ipu][iL]->SetPointError(0,0,fity->GetParError(2));
grYrms[ipu][iL]->SetPoint(0,0.5,projy->GetRMS());
grYrms[ipu][iL]->SetPointError(0,0,projy->GetRMSError());
mycFit->Update();
if (savePoint) mycFit->Print("PLOTS/fits_y.pdf");
}
//fit vs w0, get w0min
for (unsigned iL(0);iL<nLayers;++iL){
for (unsigned iS(0); iS<nScans;++iS){
mycFit->cd();
p_posx[ipu][iL][iS]->Draw();
double w0 = wStart+iS*wStep;
//myGaus->SetParameters();
p_posx[ipu][iL][iS]->Fit("gaus","0+Q","",-2.,2.);
TF1 *fitx = p_posx[ipu][iL][iS]->GetFunction("gaus");
fitx->SetLineColor(6);
fitx->Draw("same");
sprintf(buf,"Layer %d, w0=%3.1f, pu=%d",iL,w0,pu[ipu]);
lat.DrawLatexNDC(0.1,0.96,buf);
mycFit->Update();
if (savePoint) mycFit->Print("PLOTS/fits_x.pdf");
mycFit->cd();
p_posy[ipu][iL][iS]->Draw();
p_posy[ipu][iL][iS]->Fit("gaus","0+Q","",-2.,2.);
TF1 *fity = p_posy[ipu][iL][iS]->GetFunction("gaus");
fity->SetLineColor(6);
fity->Draw("same");
sprintf(buf,"Layer %d, w0=%3.1f, pu=%d",iL,w0,pu[ipu]);
lat.DrawLatexNDC(0.1,0.96,buf);
mycFit->Update();
if (savePoint) mycFit->Print("PLOTS/fits_y.pdf");
//grX[ipu][iL]->SetPoint(iS,w0,p_posx[ipu][iL][iS]->GetRMS());
//grX[ipu][iL]->SetPointError(iS,0,p_posx[ipu][iL][iS]->GetRMSError());
//grY[ipu][iL]->SetPoint(iS,w0,p_posy[ipu][iL][iS]->GetRMS());
//grY[ipu][iL]->SetPointError(iS,0,p_posy[ipu][iL][iS]->GetRMSError());
double xval = useFit? fitx->GetParameter(2) : p_posx[ipu][iL][iS]->GetRMS();
if (savePoint) p_chi2ndf->Fill(fitx->GetChisquare()/fitx->GetNDF());
grX[ipu][iL]->SetPoint(iS+1,w0,fitx->GetParameter(2));
grX[ipu][iL]->SetPointError(iS+1,0,fitx->GetParError(2));
grXrms[ipu][iL]->SetPoint(iS+1,w0,p_posx[ipu][iL][iS]->GetRMS());
grXrms[ipu][iL]->SetPointError(iS+1,0,p_posx[ipu][iL][iS]->GetRMSError());
if (xval < resxmin[ipu][iL]){
resxmin[ipu][iL] = xval;
wxminall[ipu][iL][ieta] = w0;
wxmin[ipu][iL] = w0;
}
double yval = useFit? fity->GetParameter(2) : p_posy[ipu][iL][iS]->GetRMS();
if (savePoint) p_chi2ndf->Fill(fity->GetChisquare()/fity->GetNDF());
grY[ipu][iL]->SetPoint(iS+1,w0,fity->GetParameter(2));
grY[ipu][iL]->SetPointError(iS+1,0,fity->GetParError(2));
grYrms[ipu][iL]->SetPoint(iS+1,w0,p_posy[ipu][iL][iS]->GetRMS());
grYrms[ipu][iL]->SetPointError(iS+1,0,p_posy[ipu][iL][iS]->GetRMSError());
if (yval < resymin[ipu][iL]){
resymin[ipu][iL] = yval;
wyminall[ipu][iL][ieta] = w0;
wymin[ipu][iL] = w0;
}
}
grX[ipu][iL]->SetTitle(";W0; #sigma(x-xt) (mm)");
grY[ipu][iL]->SetTitle(";W0; #sigma(y-yt) (mm)");
grX[ipu][iL]->SetLineColor(ipu+1);
grX[ipu][iL]->SetMarkerColor(ipu+1);
grX[ipu][iL]->SetMarkerStyle(ipu+21);
grY[ipu][iL]->SetLineColor(ipu+1);
grY[ipu][iL]->SetMarkerColor(ipu+1);
grY[ipu][iL]->SetMarkerStyle(ipu+21);
grXrms[ipu][iL]->SetLineColor(ipu+3);
grXrms[ipu][iL]->SetMarkerColor(ipu+3);
grXrms[ipu][iL]->SetMarkerStyle(ipu+23);
grYrms[ipu][iL]->SetLineColor(ipu+3);
grYrms[ipu][iL]->SetMarkerColor(ipu+3);
grYrms[ipu][iL]->SetMarkerStyle(ipu+23);
mycx[iL/6]->cd(iL%6+1);
grX[ipu][iL]->Draw(ipu==0?"APL":"PLsame");
grXrms[ipu][iL]->Draw("PLsame");
//gStyle->SetStatX(0.4);
//gStyle->SetStatY(1.0);
//p_Exy[ipu][iL]->Draw("colztext");
sprintf(buf,"Layer %d",iL);
lat.DrawLatexNDC(0.4,0.85,buf);
mycy[iL/6]->cd(iL%6+1);
grY[ipu][iL]->Draw(ipu==0?"APL":"PLsame");
grYrms[ipu][iL]->Draw("PLsame");
lat.DrawLatexNDC(0.4,0.85,buf);
}//loop on layers
//return 1;
}//loop on pu
if (savePoint) {
mycFit->Print("PLOTS/fits_x.pdf]");
mycFit->Print("PLOTS/fits_y.pdf]");
}
return 1;
TLegend *leg = new TLegend(0.6,0.6,0.94,0.94);
leg->SetFillColor(0);
if (grX[0][10]) leg->AddEntry(grX[0][10],"fit pu=0","P");
if (grXrms[0][10]) leg->AddEntry(grXrms[0][10],"RMS pu=0","P");
if (grX[1][10]) leg->AddEntry(grX[1][10],"fit pu=140","P");
if (grXrms[1][10]) leg->AddEntry(grXrms[1][10],"RMS pu=140","P");
for (unsigned iC(0);iC<nCanvas;++iC){
mycx[iC]->cd(1);
leg->Draw("same");
mycx[iC]->Update();
std::ostringstream lsave;
lsave << "PLOTS/logWeighted_x_" << 6*iC << "_" << 6*iC+5 << "_" << pteta.str() ;
lsave << ".pdf";
mycx[iC]->Print(lsave.str().c_str());
mycx[iC]->Update();
mycy[iC]->cd(1);
leg->Draw("same");
lsave.str("");
lsave << "PLOTS/logWeighted_y_" << 6*iC << "_" << 6*iC+5 << "_" << pteta.str();
lsave << ".pdf";
mycy[iC]->Print(lsave.str().c_str());
}
//plot w0min vs layer
TGraph *grW[4] = {0,0,0,0};
for (unsigned ipu(0); ipu<nPu; ++ipu){//loop on pu
std::cout << " --Processing pu " << pu[ipu] << std::endl;
grW[2*ipu] = new TGraph(nLayers,lay,wxmin[ipu]);
grW[2*ipu+1] = new TGraph(nLayers,lay,wymin[ipu]);
for (unsigned iL(0);iL<nLayers;++iL){
std::cout << " if (layer==" << iL
<< ") return " << (wxmin[ipu][iL]+wymin[ipu][iL])/2. <<";"
// << " minimum x= " << grX[ipu][iL]->GetYaxis()->GetXmin()
// << " minimum y= " << grY[ipu][iL]->GetYaxis()->GetXmin()
<< std::endl;
}
mycW->cd();
grW[2*ipu]->SetTitle(";layer;W0");
grW[2*ipu]->SetMaximum(6);
grW[2*ipu]->SetMinimum(0);
grW[2*ipu]->SetLineColor(2*ipu+1);
grW[2*ipu]->SetMarkerColor(2*ipu+1);
grW[2*ipu]->SetMarkerStyle(20+2*ipu+1);
grW[2*ipu+1]->SetLineColor(2*ipu+2);
grW[2*ipu+1]->SetMarkerColor(2*ipu+2);
grW[2*ipu+1]->SetMarkerStyle(20+2*ipu+2);
if (ipu==0) {
grW[2*ipu]->Draw("APL");
grW[2*ipu+1]->Draw("PLsame");
}
else {
grW[2*ipu]->Draw("PLsame");
grW[2*ipu+1]->Draw("PLsame");
}
}
std::ostringstream lsave;
lsave << "PLOTS/w0minvsLayers_" << pteta.str();
if (useFit) lsave << "_fit";
else lsave << "_rms";
lsave << ".pdf";
mycW->Update();
mycW->Print(lsave.str().c_str());
if (savePoint) fout->Write();
else {
for (unsigned i(0);i<4;++i){
if (grW[i]) grW[i]->Delete();
}
for (unsigned ipu(0); ipu<nPu; ++ipu){//loop on pu
for (unsigned iL(0); iL<nLayers;++iL){//loop on layers
grX[ipu][iL]->Delete();
grXrms[ipu][iL]->Delete();
grY[ipu][iL]->Delete();
grYrms[ipu][iL]->Delete();
p_deltavsreco_x[ipu][iL]->Delete();
p_deltavsreco_y[ipu][iL]->Delete();
for (unsigned iS(0); iS<nScans;++iS){
p_posx[ipu][iL][iS]->Delete();
p_posy[ipu][iL][iS]->Delete();
}
}
}
}
std::cout << " -- eta point finished successfully" << std::endl;
}//loop on eta
//plot w0min vs pt for all eta
TGraph *grW[4] = {0,0,0,0};
mycW->Clear();
for (unsigned iL(0); iL<nLayers;++iL){//loop on layers
for (unsigned ipu(0); ipu<nPu; ++ipu){//loop on pu
std::cout << " --Processing pu " << pu[ipu] << std::endl;
grW[2*ipu] = new TGraph(neta,etaval,wxminall[ipu][iL]);
grW[2*ipu+1] = new TGraph(neta,etaval,wyminall[ipu][iL]);
mycW->cd();//ieta+1);
grW[2*ipu]->SetTitle(";#eta;W0");
grW[2*ipu]->SetMaximum(6);
grW[2*ipu]->SetMinimum(0);
grW[2*ipu]->SetLineColor(2*ipu+1);
grW[2*ipu]->SetMarkerColor(2*ipu+1);
grW[2*ipu]->SetMarkerStyle(20+2*ipu+1);
grW[2*ipu+1]->SetLineColor(2*ipu+2);
grW[2*ipu+1]->SetMarkerColor(2*ipu+2);
grW[2*ipu+1]->SetMarkerStyle(20+2*ipu+2);
if (ipu==0) {
grW[2*ipu]->Draw("APL");
grW[2*ipu+1]->Draw("PLsame");
}
else {
grW[2*ipu]->Draw("PLsame");
grW[2*ipu+1]->Draw("PLsame");
}
}//loop on pu
std::ostringstream lsave;
lsave << "PLOTS/w0minvseta_layer" << iL;
if (useFit) lsave << "_fit";
else lsave << "_rms";
lsave << ".pdf";
char buf[500];
TLatex lat;
sprintf(buf,"Layer %d",iL);
lat.DrawLatexNDC(0.1,0.96,buf);
mycW->Update();
mycW->Print(lsave.str().c_str());
}//loop on layers
return 0;
}//main
void fitTools::getTruncatedMeanAndRMS(TH1D* h1_projection, Float_t& mean, Float_t& mean_err, Float_t& rms, Float_t& rms_err, Double_t percentIntegral_MEAN, Double_t percentIntegral_RMS) {
//TCanvas* getTruncatedMeanAndRMS(TH1D* h1_projection, Float_t& mean, Float_t& mean_err, Float_t& rms, Float_t& rms_err, Double_t percentIntegral_MEAN=0.9, Double_t percentIntegral_RMS=0.68) {
bool useMode = false;
if( percentIntegral_MEAN<0. || percentIntegral_MEAN>1. ) {
std::cout << "WARNING! percentIntegral_MEAN is " << percentIntegral_MEAN << "!! Setting it to 90%." << std::endl;
percentIntegral_MEAN = 0.9;
}
if( percentIntegral_RMS<0. || percentIntegral_RMS>1. ) {
std::cout << "WARNING! percentIntegral_RMS is " << percentIntegral_RMS << "!! Setting it to 68%." << std::endl;
percentIntegral_RMS = 0.68;
}
Int_t nBins = h1_projection->GetNbinsX();
Double_t xMin = h1_projection->GetXaxis()->GetXmin();
Double_t xMax = h1_projection->GetXaxis()->GetXmax();
Double_t binWidth = (xMax-xMin)/(Double_t)nBins; //WARNING: this works only if bins are of the same size
Double_t integral = h1_projection->Integral();
// std::cout << "xmax: " << xMax << "\txMin: " << xMin << std::endl;
//first: find maximum
// std::cout << "N: " << gaussian->GetParameter(0) << "\tmu: " << gaussian->GetParameter(1) << "\tsigma: " << gaussian->GetParameter(2) << std::endl;
Int_t maxBin;
if( useMode ) {
maxBin = h1_projection->GetMaximumBin();
} else {
TF1* gaussian = new TF1("gaussian", "gaus");
gaussian->SetLineColor(kGreen);
fitProjection(h1_projection, gaussian, 1.5, "RQN");
maxBin = (Int_t)ceil((gaussian->GetParameter(1)-xMin)/binWidth);
delete gaussian;
}
// std::cout << "maxBin: " << maxBin << "\tbin center: " << h1_projection->GetXaxis()->GetBinCenter(maxBin) << "\t gauss mu: " << gaussian->GetParameter(1) << std::endl;
TH1D* newHisto = new TH1D("newHisto", "", nBins, xMin, xMax);
newHisto->SetBinContent( maxBin, h1_projection->GetBinContent(maxBin) );
newHisto->SetBinError( maxBin, h1_projection->GetBinError(maxBin) );
Int_t iBin = maxBin;
Int_t delta_iBin = 1;
Int_t sign = 1;
// std::cout << "iBin: " << iBin << "\tint: " << newHisto->Integral()/integral << std::endl;
while( newHisto->Integral() < percentIntegral_RMS*integral ) {
iBin += sign*delta_iBin;
// std::cout << "iBin: " << iBin << "\tint: " << newHisto->Integral()/integral << std::endl;
newHisto->SetBinContent( iBin, h1_projection->GetBinContent(iBin) );
newHisto->SetBinError( iBin, h1_projection->GetBinError(iBin) );
delta_iBin += 1;
sign *= -1;
}
// std::cout << "done with rms." << std::endl;
// TCanvas* c1 = new TCanvas("c1", "c1", 800, 600);
// c1->cd();
// h1_projection->Draw();
// newHisto->SetFillColor(kRed);
// newHisto->DrawClone("HISTO same");
rms = newHisto->GetRMS();
rms_err = newHisto->GetRMSError();
//std::cout << "rms: " << rms << std::endl;
while( newHisto->Integral() < percentIntegral_MEAN*integral ) {
// std::cout << "iBin: " << iBin << "\tint: " << newHisto->Integral()/integral << std::endl;
iBin += sign*delta_iBin;
newHisto->SetBinContent( iBin, h1_projection->GetBinContent(iBin) );
newHisto->SetBinError( iBin, h1_projection->GetBinError(iBin) );
delta_iBin += 1;
sign *= -1;
}
// newHisto->SetFillStyle(3004);
// newHisto->SetFillColor(kBlue);
// newHisto->DrawClone("HISTO same");
mean = newHisto->GetMean();
mean_err = newHisto->GetMeanError();
delete newHisto;
// return c1;
}
TGraphErrors *FitConfidence::choleskyBands( TFitResultPtr fitResult, TF1 * f, int nSamples, int nPoints, Reporter* rp, double x1, double x2 ){
int nP = f->GetNpar();
// INFO( FitConfidence::classname(), "Num Params : " << nP );
TMatrixDSym cov = fitResult->GetCovarianceMatrix();
double *covArray = new double[ nP * nP ]; // number of parameters x number of parameters
covArray = cov.GetMatrixArray();
// for ( int i = 0; i < 9; i++ ){
// INFO( FitConfidence::classname(), "[" << i << "] = " << covArray[ i ] );
// }
double *fCov = new double[ nP * nP ];
fCov = cov.GetMatrixArray();
double *fCovSqrt = new double[ nP * nP ];
calcCholesky( nP, fCov, fCovSqrt );
// for ( int i = 0; i < 9; i++ ){
// INFO( FitConfidence::classname(), "[" << i << "] = " << fCovSqrt[ i ] );
// }
// calculate instead
if ( -1.0 == x1 && -1.0 == x2 )
f->GetRange( x1, x2 );
double step = ( x2 - x1 ) / (double) nPoints;
double x[ nPoints + 1 ];
double y[ nPoints + 1 ];
// double yup[ nPoints + 1 ];
// double ydown[ nPoints + 1 ];
double yerr[ nPoints + 1 ];
vector<double> samples;
int i = 0;
for (double xx = x1; xx < x2; xx+= step) {
x[i] = xx;
TH1D *hDistributionAtX = new TH1D("hDistributionAtX","",200,f->Eval(x[i]) - .2,f->Eval(x[i]) + .2);
for (int n = 0; n < nSamples; n++ ) {
double val = randomSqrtCov(x[i],f,nP,fCovSqrt);
hDistributionAtX->Fill( val );
samples.push_back( val );
}
//hDistributionAtX->DrawCopy();
y[i] = f->Eval(x[i]);
yerr[i] = hDistributionAtX->GetRMS();
// cross check - should always give the same result
// but very innefficient
//yerr[i] = choleskyUncertainty( xx, fitResult, f, nSamples );
// rp.savePage();
hDistributionAtX->Delete();
i++;
}
TGraphErrors * g = new TGraphErrors( i - 1, x, y, 0, yerr );
return g;
}
void runlsbpvrw(TString name = "ge1bLoose") {
TFile* fin = TFile::Open("../pvrw.root","READ");
if(fin->IsZombie()) cout << "Problem opening input file!" << endl;
TH1D* hPVphysics = (TH1D*)fin->Get("hPVphysics_"+name);
TH1D* hPVprescalePass = (TH1D*)fin->Get("hPVprescalePass_"+name);
TH1D* hPVprescaleFail = (TH1D*)fin->Get("hPVprescaleFail_"+name);
TH1D* tPVphysics = (TH1D*)hPVphysics->Clone("tPVphysics");
TH1D* tPVprescalePass = (TH1D*)hPVprescalePass->Clone("tPVprescalePass");
TH1D* tPVprescaleFail = (TH1D*)hPVprescaleFail->Clone("tPVprescaleFail");
tPVphysics->Reset();
tPVprescalePass->Reset();
tPVprescaleFail->Reset();
TH1D* hPFresults = new TH1D("hPFresults", "hPFresults", 500, 0.0, 0.3);
//toy loop
for(int i=0; i<1000; i++) {
//make toy inputs
for(int n=1; n<=hPVphysics->GetNbinsX(); n++) {
//tPVphysics->SetBinContent(n,r->Gaus(hPVphysics->GetBinContent(n), hPVphysics->GetBinError(n)));
//tPVprescalePass->SetBinContent(n,r->Gaus(hPVprescalePass->GetBinContent(n),hPVprescalePass->GetBinError(n)));
//tPVprescaleFail->SetBinContent(n,r->Gaus(hPVprescaleFail->GetBinContent(n),hPVprescaleFail->GetBinError(n)));
tPVphysics->SetBinContent(n,r->Poisson(hPVphysics->GetBinContent(n)));
tPVprescalePass->SetBinContent(n,r->Poisson(hPVprescalePass->GetBinContent(n)));
tPVprescaleFail->SetBinContent(n,r->Poisson(hPVprescaleFail->GetBinContent(n)));
}
//do cross check (no toy)
if(i==0) {
TH1D* hPVprescale = (TH1D*)hPVprescalePass->Clone("hPVprescale");
hPVprescale->Reset();
hPVprescale->Add(hPVprescalePass,hPVprescaleFail);
TH1D* hPVprescale_RW = (TH1D*)hPVphysics->Clone("hPVprescale_RW");
hPVprescale_RW->Scale(hPVprescale->Integral()/hPVphysics->Integral());
TH1D* hPV_W = (TH1D*)hPVphysics->Clone("hPV_W");
hPV_W->Reset();
hPV_W->Divide(hPVprescale_RW,hPVprescale);
//weighted LSB pass and fail mdp
TH1D* hPVprescalePass_RW = (TH1D*)hPVprescalePass->Clone("hPVprescalePass_RW");
TH1D* hPVprescaleFail_RW = (TH1D*)hPVprescaleFail->Clone("hPVprescaleFail_RW");
hPVprescalePass_RW->Multiply(hPV_W);
hPVprescaleFail_RW->Multiply(hPV_W);
cout << name << " PFratio: " << hPVprescalePass_RW->Integral()/hPVprescaleFail_RW->Integral() << endl;
}
//now find PFratio for this toy
TH1D* tPVprescale = (TH1D*)tPVprescalePass->Clone("tPVprescale");
tPVprescale->Reset();
tPVprescale->Add(tPVprescalePass,tPVprescaleFail);
TH1D* tPVprescale_RW = (TH1D*)tPVphysics->Clone("tPVprescale_RW");
tPVprescale_RW->Scale(tPVprescale->Integral()/tPVphysics->Integral());
TH1D* tPV_W = (TH1D*)tPVphysics->Clone("tPV_W");
tPV_W->Reset();
tPV_W->Divide(tPVprescale_RW,tPVprescale);
//weighted LSB pass and fail mdp
TH1D* tPVprescalePass_RW = (TH1D*)tPVprescalePass->Clone("tPVprescalePass_RW");
TH1D* tPVprescaleFail_RW = (TH1D*)tPVprescaleFail->Clone("tPVprescaleFail_RW");
tPVprescalePass_RW->Multiply(tPV_W);
tPVprescaleFail_RW->Multiply(tPV_W);
double tPFratio = tPVprescalePass_RW->Integral()/tPVprescaleFail_RW->Integral();
hPFresults->Fill(tPFratio);
}//end of toy loop
cout << name << " result: " << hPFresults->GetMean() << " +- " << hPFresults->GetRMS() << endl;
TCanvas* c1 = new TCanvas("c1", "c1", 640, 480);
c1->cd();
hPFresults->Draw();
c1->SaveAs("lsbpvrw_"+name+".png");
fin->Close();
}
void balanceMetVsAj(TString infname,
TString insrc, TString metType = "",bool drawLegend = false,
bool drawSys = true
)
{
// ===========================================================
// Get Input
// ===========================================================
TFile *inf = new TFile(infname);
// ===========================================================
// Analysis Setup
// ===========================================================
Int_t plotLayer=10; // 0 only >0.5, 1 >0.5 and highpt, 10 ~ all
cout << infname << " " << insrc << endl;
TH1D *ppos[nptrange+1];
TH1D *pneg[nptrange+1];
TH1D *pe[nptrange+1];
// =================================
// Get Weighted Mean for each Aj bin
// =================================
// Book histograms
for (int i=0;i<nptrange+1;i++) {
pe[i]=new TH1D(Form("p%d",i),"",nAjBin,AjBins);
}
TTree * tm = (TTree*)inf->Get("t"+insrc);
// Find cone boundary
int coneidr=0;
for (int idr=0; idr<ndrbin; ++idr) {
if (drbins[idr]>=0.8) {
coneidr=idr;
break;
}
}
// Get Values
for (int a=0; a<nAjBin; ++a) {
float sum=0, sumerr=0;
for (int i=0;i<nptrange+1;i++) {
// hname = Form("%s_merge%d_%s",insrc.Data(),i,metType.Data());
TString hname = "hMpt"+insrc;
if (i<nptrange) hname+=Form("_pt%d",i);
else hname+=Form("_ptall");
// TH2D * hMptAj = (TH2D*)inf->Get(hname);
// cout << hname << " " << hMptAj << endl;
// TH1D * hMpt = hMptAj->ProjectionY(hname+Form("_a%d",a),a+1,a+1);
hname+=Form("_a%d",a);
TString cut = Form("Aj>=%.3f&&Aj<%.3f",AjBins[a],AjBins[a+1]);
TH1D * hMpt = new TH1D(hname,cut,1600,-800,800);
// Define Observable: limited dR
TString var;
int idrbeg,idrend;
if (metType=="InCone") {
idrbeg=0; idrend=coneidr;
} else {
idrbeg=coneidr; idrend=ndrbin;
}
if (i<nptrange) {
var = Form("xptdr[%d][%d]",i,idrbeg);
for (int idr=idrbeg+1; idr<idrend; ++idr) {
var+= Form("+xptdr[%d][%d]",i,idr);
}
} else {
var = Form("Sum$(xptdr[][%d])",idrbeg);
for (int idr=idrbeg+1; idr<idrend; ++idr) {
var+= Form("+Sum$(xptdr[][%d])",idr);
}
}
// Now make histograms
if (a==0) cout << metType << ": " << var << endl;
tm->Project(hname,var,cut);
float mpt = hMpt->GetMean();
float mpterr = hMpt->GetRMS()/sqrt(hMpt->GetEntries());
if (doResCorr) {
if (i==nptrange) {
mpt-=(pe[nptrange-4]->GetBinContent(a+1)*0.2);
mpt-=(pe[nptrange-3]->GetBinContent(a+1)*0.2);
mpt-=(pe[nptrange-2]->GetBinContent(a+1)*0.2);
mpt-=(pe[nptrange-1]->GetBinContent(a+1)*0.2);
} else if (i>=nptrange-4) {
mpt*=0.8;
}
}
pe[i]->SetBinContent(a+1,mpt);
pe[i]->SetBinError(a+1,mpterr);
// cout << hMpt->GetName() << ": " << hMpt->GetEntries() << " mean: " << pe[i]->GetBinContent(a+1) << " err: " << pe[i]->GetBinError(a+1) << endl;
if (i<nptrange) {
sum+=mpt;
sumerr+=pow(mpterr,2);
}
}
cout << "Aj " << a << " pt sum: " << sum << endl;
}
StackHistograms(nptrange,pe,ppos,pneg,nAjBin);
TH1D *pall=pe[nptrange];
pall->SetXTitle("A_{J}");
pall->SetYTitle("<#slash{p}_{T}^{#parallel}> (GeV/c)");
pall->GetXaxis()->CenterTitle();
pall->GetYaxis()->CenterTitle();
pall->GetXaxis()->SetLabelSize(22);
pall->GetXaxis()->SetLabelFont(43);
pall->GetXaxis()->SetTitleSize(24);
pall->GetXaxis()->SetTitleFont(43);
pall->GetYaxis()->SetLabelSize(22);
pall->GetYaxis()->SetLabelFont(43);
pall->GetYaxis()->SetTitleSize(24);
pall->GetYaxis()->SetTitleFont(43);
pall->GetXaxis()->SetTitleOffset(1.8);
pall->GetYaxis()->SetTitleOffset(2.4);
pall->SetNdivisions(505);
pall->SetAxisRange(-59.9,59.9,"Y");
pall->SetMarkerSize(1);
pall->SetMarkerColor(kBlack);
pall->SetMarkerStyle(kFullCircle);
pall->Draw("E");
float addSys = 0;
if ( drawSys==1) addSys=0; // No sys error at this moment
// ====================
// Finally Draw
// ====================
for (int i=0;i<nptrange;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nptrange-1) continue;
ppos[i]->SetLineWidth(1);
ppos[i]->SetFillStyle(1001);
ppos[i]->Draw("hist same");
pneg[i]->SetLineWidth(1);
pneg[i]->SetFillStyle(1001);
pneg[i]->Draw("hist same");
// PrintHistogram(ppos[i]);
// PrintHistogram(pneg[i]);
}
// ====================
// Draw Statistical Error bars
// ====================
for (int i=0;i<nptrange;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nptrange-1) continue;
if ( i==0 ) drawErrorShift(ppos[i],-0.016, addSys);
if ( i==1 || i==4) drawErrorShift(ppos[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(ppos[i],0.008,addSys);
if ( i==3 ) drawErrorShift(ppos[i],0.016,addSys);
if ( i==0 ) drawErrorShift(pneg[i],-0.016, addSys);
if ( i==1 || i==4) drawErrorShift(pneg[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(pneg[i],0.008,addSys);
if ( i==3 ) drawErrorShift(pneg[i],0.016,addSys);
}
pall->Draw("E same");
// PrintHistogram(pall);
// ====================
// Draw Systematic Errors
// ====================
if (drawSys == 1) {
for(int i = 0; i < nAjBin; ++i){
double x = pall->GetBinCenter(i+1);
double y = pall->GetBinContent(i+1);
// Quote the difference between GEN and RECO in >8 Bin (20%) before adjusting eff as systematics
double errReco = -pe[nptrange-1]->GetBinContent(i+1)*0.2;
double errBck = 3.0; // compare HYDJET+SIG to SIG
double err = sqrt(errReco*errReco+errBck*errBck);
DrawTick(y,err,err,x,1,0.02,1);
}
}
// ====================
// Draw Legend
// ====================
TLegend *leg = new TLegend(0.10,0.68,0.70,0.96);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(16);
leg->AddEntry(pall,Form("> %.1f GeV/c",ptranges[0]),"p");
for (int i=0;i<nptrange;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nptrange-1) continue;
if (i!=nptrange-1){
leg->AddEntry(ppos[i],Form("%.1f - %.1f GeV/c",ptranges[i],ptranges[i+1]),"f");
} else {
leg->AddEntry(ppos[i],Form("> %.1f GeV/c",ptranges[i]),"f");
}
}
if (drawLegend) leg->Draw();
TLine * l0 = new TLine(0,0,0.5,0);
l0->SetLineStyle(2);
l0->Draw();
TLine * l1 = new TLine(0.0001,-10,0.0001,10);
l1->Draw();
}
int main(int argc, char* argv[]) {
std::string outputDir = "AK4Jets_Plot";
mkdir(outputDir.c_str(), 0777);
TString dataFileName_DoubleMu;
// dataFileName_DoubleMu = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_DoubleMu.root");
// dataFileName_DoubleMu = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_WideEtaBin_DoubleMu.root");
dataFileName_DoubleMu = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_WideEtaBin_DoubleMu.root");
TFile* dataFile_DoubleMu = TFile::Open(dataFileName_DoubleMu);
if (dataFile_DoubleMu) {
std::cout << "Opened data file '" << dataFileName_DoubleMu << "'." << std::endl;
}
TString dataFileName_HT450;
// dataFileName_HT450 = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_HT450.root");
// dataFileName_HT450 = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_WideEtaBin_HT450.root");
dataFileName_HT450 = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_WideEtaBin_HT450.root");
TFile* dataFile_HT450 = TFile::Open(dataFileName_HT450);
if (dataFile_HT450) {
std::cout << "Opened data file '" << dataFileName_HT450 << "'." << std::endl;
}
TH1D *pT_AK4JetHLT = (TH1D*)dataFile_HT450->Get("AK4_pT_JetHLT");
gErrorIgnoreLevel = kWarning;
TF1* lineup1 = new TF1("lineup1", " 0.01", 0, 3000);
TF1* linedown1 = new TF1("linedown1", "-0.01", 0, 3000);
lineup1->SetLineColor(kBlack);
lineup1->SetLineStyle(2);
linedown1->SetLineColor(kBlack);
linedown1->SetLineStyle(2);
TF1* lineup2 = new TF1("lineup2", " 0.02", 0, 3000);
TF1* linedown2 = new TF1("linedown2", "-0.02", 0, 3000);
lineup2->SetLineColor(kBlack);
lineup2->SetLineStyle(2);
linedown2->SetLineColor(kBlack);
linedown2->SetLineStyle(2);
// procedura
// prendo gli istogramma 1D del bias
// per ogni bin di pT e eta
// li fitto con una cristal ball
// poi grafico il picco in funzione del pT in ogni bin di eta
// fitto con una funzione logaritmica
// mi creo l'istogramma 2D (eta,pT) con correzione sull'asse z
//////////////////////// pTBias 1D
EtaBinning mEtaBinning;
size_t etaBinningSize = mEtaBinning.size();
PtBinning mPtBinning;
size_t pTBinningSize = mPtBinning.size();
cout<< etaBinningSize << endl;
for (size_t ii = 0; ii < etaBinningSize; ii++) {
// for (size_t ii = 0; ii < 1; ii++) {
for (size_t jj = 0; jj < pTBinningSize; jj++) {
// for (size_t jj = 8; jj < 9; jj++) {
std::string etaName = mEtaBinning.getBinName(ii);
std::pair<float, float> ptBins = mPtBinning.getBinValue(jj);
std::string HistoName = TString::Format("AK4_pTBias_%s_pT_%i_%i", etaName.c_str(), (int) ptBins.first, (int) ptBins.second ).Data();
cout<< "("<<ii << ";"<< jj<<")" << endl;
cout<< HistoName.c_str() << endl;
TH1D *h;
double sigma;
double sigma2;
if( jj < 2){ // pT<300
sigma = 3;
sigma2 = 4;
h = (TH1D*)dataFile_DoubleMu->Get( HistoName.c_str() );
cout << " Lo prendo dal DoubleMu" << endl;
}else if( jj<8 ){
sigma = 4; // 4
sigma2 = 5; //5
h = (TH1D*)dataFile_HT450->Get( HistoName.c_str() );
cout << " Lo prendo dal HT450" << endl;
}else{
sigma = 4;
sigma2 = 4; //3
h = (TH1D*)dataFile_HT450->Get( HistoName.c_str() );
cout << " Lo prendo dal HT450" << endl;
}
if( jj > 8) continue; // >8 prima
if( ii==3 && jj > 6) continue; // ultimo fit in endcap non funziona
if(!h) continue;
int Nentries = h->GetEntries();
if(Nentries<100) continue; //200
h->Rebin(2);
double hN = h->GetMaximum();
double hMean = h->GetMean();
double hRMS = h->GetRMS();
/*
TF1 *expon = new TF1("expon", "[0] + [1]*exp(-[2]*x)", 0.1, 0.4);
h -> Fit(expon, "R");
*/
/*
TF1 *crystal = new TF1("crystal", CrystalBall, hMean-2*hRMS , hMean+1*hRMS, 5);
crystal->SetParameters(hN, hMean, hRMS, 1.0, 2.0);
crystal->SetParNames("N", "Mean", "sigma","#alpha","n");
crystal->SetParLimits(0, hN-0.05*hN, hN+0.05*hN);
h -> Fit(crystal, "R");
*/
/*
TF1 *doublecrystal = new TF1("doublecrystal", doubleCrystalBall, hMean-3*hRMS , hMean+4*hRMS, 7);
doublecrystal->SetParNames("N", "Mean", "sigma","#alphaR","nR","#alphaL", "nL");
doublecrystal->SetParameters(hN, 0.01, 0.03, 1.2, 30., 15, 40.);
doublecrystal->SetParLimits(1, 0.005, 0.015);
doublecrystal->SetParLimits(2, 0.015, 0.035);
doublecrystal->SetParLimits(3, 0 , 1.4);
doublecrystal->SetParLimits(4, 1, 10);
doublecrystal->SetParLimits(5, 0, 10);
doublecrystal->SetParLimits(6, 0, 15);
h -> Fit(doublecrystal, "R");
*/
/*
// secondo giro
TF1 *doublecrystal2 = new TF1("doublecrystal2", doubleCrystalBall, doublecrystal->GetParameter(1)-2* doublecrystal->GetParameter(2),doublecrystal->GetParameter(1)+1*doublecrystal->GetParameter(2), 7);
doublecrystal2->SetLineColor(kBlue);
doublecrystal2->SetParNames("N", "Mean", "sigma","#alphaR","nR","#alphaL", "nL");
doublecrystal2->SetParameters(doublecrystal->GetParameter(0), doublecrystal->GetParameter(1), doublecrystal->GetParameter(2), doublecrystal->GetParameter(3), doublecrystal->GetParameter(4), doublecrystal->GetParameter(5), doublecrystal->GetParameter(6));
h -> Fit(doublecrystal2, "+R");
// terzo giro
TF1 *doublecrystal3 = new TF1("doublecrystal3", doubleCrystalBall, doublecrystal2->GetParameter(1)-2* doublecrystal2->GetParameter(2),doublecrystal2->GetParameter(1)+1*doublecrystal2->GetParameter(2), 7);
doublecrystal3->SetLineColor(kGreen);
doublecrystal3->SetParNames("N", "Mean", "sigma","#alphaR","nR","#alphaL", "nL");
doublecrystal3->SetParameters(doublecrystal2->GetParameter(0), doublecrystal2->GetParameter(1), doublecrystal2->GetParameter(2), doublecrystal2->GetParameter(3), doublecrystal2->GetParameter(4), doublecrystal2->GetParameter(5), doublecrystal2->GetParameter(6));
h -> Fit(doublecrystal3, "+R");
*/
/*
// provo a fittare solo la coda --> non viene manco cosi
TF1 *Function = new TF1("Function", "[0]*( (pow([4]/fabs([3]),[4])*exp(-0.5*[3]*[3])) / pow( ([4]/fabs([3])- fabs([3]) - (x - [1])/[2]),[4]))", 0.03 , 0.4);
Function->SetParNames("N", "Mean", "sigma","aR","nR");
Function->SetParameters(hN, hMean, hRMS, 1 , 3.);
Function->SetParLimits(0, hN-0.05*hN, hN+0.05*hN);
h -> Fit(Function, "R");
*/
TF1 *ExponentialGauss = new TF1("ExponentialGauss", ExpGaussExp, hMean-sigma*hRMS , hMean+sigma*hRMS, 5);
ExponentialGauss->SetParNames("N", "Mean", "sigma","kL","kR");
ExponentialGauss->SetParameters(hN, hMean, hRMS, 1., 1.);
ExponentialGauss->SetParLimits(0, hN-0.2*hN, hN+0.2*hN); // se non funziona rimettilo
if( jj>= 8 ) ExponentialGauss->SetParLimits(2, 0.005, 0.025);
// if( jj>= 9 ) ExponentialGauss->SetParLimits(1, -0.01, 0.01);
// ExponentialGauss->FixParameter(0, hN);
h -> Fit(ExponentialGauss, "R");
// secondo giro
TF1 *ExponentialGauss2 = new TF1("ExponentialGauss2", ExpGaussExp, ExponentialGauss->GetParameter(1)-sigma2*ExponentialGauss->GetParameter(2) , ExponentialGauss->GetParameter(1)+sigma2*ExponentialGauss->GetParameter(2), 5);
ExponentialGauss2 -> SetParNames("N", "Mean", "sigma","kL","kR");
ExponentialGauss2 -> SetParameters( ExponentialGauss->GetParameter(0), ExponentialGauss->GetParameter(1), ExponentialGauss->GetParameter(2), ExponentialGauss->GetParameter(3), ExponentialGauss->GetParameter(4));
h -> Fit(ExponentialGauss2, "R");
TCanvas *c1 = new TCanvas("c1", "c1", 800, 800);
// gPad->SetLogy();
// h -> SetStats(0);
gStyle->SetOptFit(1111);
h -> SetMarkerStyle(20);
h -> SetMarkerSize(1.5);
h -> GetXaxis()->SetRangeUser(-0.4, 0.4);
h -> Draw();
c1 -> SaveAs( Form("AK4Jets_Plot/%s.png", HistoName.c_str() ) );
c1 -> Destructor();
/////////////////////////////////////////////////
// int pTMin = ptBins.first;
// int pTMax = ptBins.second;
// double pTMean= (pTMin + pTMax) /2. ;
pT_AK4JetHLT ->GetXaxis()->SetRangeUser(ptBins.first, ptBins.second);
double pTMean = pT_AK4JetHLT->GetMean();
std::cout<< "Bin " << ptBins.first<< "-"<<ptBins.second<<" -> Mean "<< pTMean << std::endl;
double pTBias = ExponentialGauss2 -> GetParameter(1);
double pTBiasErr = ExponentialGauss2 -> GetParError(1);
cout<< "ii = "<< ii <<endl;
cout<< "pT mean = "<< pTMean <<endl;
cout<< "pT Bias = "<< pTBias <<endl;
cout<< "sigma(pT Bias) = "<< pTBiasErr <<endl;
std::string TGraphName = TString::Format("AK4_pTBias_vs_pT_etabin_%s", etaName.c_str()).Data();
cout<< TGraphName.c_str() << endl;
CreateAndFillUserTGraph(TGraphName.c_str(), jj, pTMean, pTBias, 0, pTBiasErr);
}
}
cout << endl;
cout<< "Fitto i TGraph" << endl;
for(int ii = 0; ii < etaBinningSize ; ii++){
// for(int ii = 0; ii < 1 ; ii++){
std::string etaName = mEtaBinning.getBinName(ii);
std::string TGraphName = TString::Format("AK4_pTBias_vs_pT_etabin_%s", etaName.c_str()).Data();
map<std::string , TGraphErrors*>::iterator nh_h = userTGraphs_.find( TGraphName );
if( nh_h == userTGraphs_.end()) continue;
cout<< TGraphName.c_str() << endl;
// TF1* functionFit = new TF1( "functionFit", "[0]*(log(x)*log(x)*log(x)) + [1]*(log(x)*log(x)) + [2]*log(x) + [3]", 65, 700);
// TF1* functionFit = new TF1( "functionFit", "[0]*(log(x)*log(x)) + [1]*(log(x)) + [2]", 60, 700);
// TF1* functionFit = new TF1( "functionFit", "[0]*log(x) + [1]", 65, 700);
TF1* functionFit = new TF1("functionFit"," ([0]/2)*( [3] + TMath::Erf( (x-[1])/[2]) )", 0, 1000);
// TF1* functionFit = new TF1("functionFit"," [0]*(TMath::Erf( (x-[1])/[2])) ", 0, 1000);
functionFit -> SetParameters(0.02, 100, 200, -0.01);
functionFit -> SetParLimits(0, 0.005, 0.05); //0.04
functionFit -> SetParLimits(1, 150, 300);
functionFit -> SetParLimits(2, 100, 350); //125
if(ii==3){
functionFit -> SetParLimits(0, 0.005, 0.03); //0.04
functionFit -> SetParLimits(1, 150, 300);
functionFit -> SetParLimits(2, 20, 350); //125
}
// functionFit -> SetParLimits(3, 0, 10000);
TCanvas *c1 = new TCanvas("c1", "c1", 800, 800);
// gPad -> SetLogx();
gStyle->SetOptFit(0);
nh_h->second->SetMarkerStyle(20);
nh_h->second->SetMarkerSize(1.5);
nh_h->second->SetMaximum(0.05);
nh_h->second->SetMinimum(-0.05);
nh_h->second->Fit(functionFit, "R");
nh_h->second->Draw("ZAP");
lineup1 -> Draw("same");
linedown1 -> Draw("same");
lineup2 -> Draw("same");
linedown2 -> Draw("same");
c1 -> SaveAs( Form("AK4Jets_Plot/%s.png", TGraphName.c_str() ) );
c1 -> Destructor();
double Par0 = functionFit->GetParameter(0);
double Par1 = functionFit->GetParameter(1);
double Par2 = functionFit->GetParameter(2);
double Par3 = functionFit->GetParameter(3);
double NDF = functionFit->GetNDF();
double Chisquare = functionFit->GetChisquare();
cout<< "Par 0 = " << Par0 << endl;
cout<< "Par 1 = " << Par1 << endl;
cout<< "Par 2 = " << Par2 << endl;
cout<< "Par 3 = " << Par3 << endl;
cout<< "Chisquare / NDF = " << Chisquare<<"/"<<NDF << endl;
for(int jj=0; jj < binnum; jj++){
int pTMin = pTMeanArray[jj];
int pTMax = pTMeanArray[jj+1];
double pTMean= (pTMin + pTMax) /2. ;
cout<<"pT Mean = " << pTMean <<endl;
// double pTBiasFit = Par0*(log(pTMean)*log(pTMean)) + Par1*log(pTMean) + Par2;
//double pTBiasFit = Par0*(log(pTMean)*log(pTMean)*log(pTMean)) + Par1*log(pTMean)*log(pTMean) + Par2*log(pTMean) + Par3;
// functionFit = ([0]/2) *( [3] + TMath::Erf( (x-[1])/[2]) )", 0, 1000);
double pTBiasFit = (Par0/2)*( Par3 + TMath::Erf( (pTMean -Par1)/Par2));
cout<<"pT Bias from fit = " << pTBiasFit <<endl;
Histo_Corrections->SetBinContent(ii+1, jj+1, pTBiasFit);
}
}
TCanvas *c2 = new TCanvas("c2", "c2", 900, 800);
Histo_Corrections->SetStats(0);
gStyle->SetPalette(55);
Histo_Corrections->SetContour(100);
Histo_Corrections->Draw("colz");
c2->SetRightMargin(0.13);
c2->SaveAs("AK4Jets_Plot/Corrections.png");
TFile* outputFile= new TFile("AK4JetsCorrections_JEC_HLT_v7.root","RECREATE");
outputFile->cd();
Histo_Corrections -> Write();
outputFile->Close();
return 0;
}
void chipSummary(const char *dirName, int chipId)
{
directory = TString(dirName);
if (f && f->IsOpen()) f->Close();
if (f1 && f1->IsOpen()) f1->Close();
if (g && g->IsOpen()) g->Close();
gROOT->SetStyle("Plain");
gStyle->SetPalette(1);
gStyle->SetOptStat(0);
gStyle->SetTitle(0);
gStyle->SetStatFont(132);
gStyle->SetTextFont(132);
gStyle->SetLabelFont(132, "X");
gStyle->SetLabelFont(132, "Y");
gStyle->SetLabelSize(0.08, "X");
gStyle->SetLabelSize(0.08, "Y");
gStyle->SetNdivisions(6, "X");
gStyle->SetNdivisions(8, "Y");
gStyle->SetTitleFont(132);
gROOT->ForceStyle();
tl = new TLatex;
tl->SetNDC(kTRUE);
tl->SetTextSize(0.09);
ts = new TLatex;
ts->SetNDC(kTRUE);
ts->SetTextSize(0.08);
line = new TLine;
line->SetLineColor(kRed);
line->SetLineStyle(kSolid);
box = new TBox;
box->SetFillColor(kRed);
box->SetFillStyle(3002);
f = new TFile(Form("%s/%s", dirName, fileName), "READ");
if (strcmp(fileName, adFileName) == 0) f1 = f;
else f1 = new TFile(Form("%s/%s", dirName, adFileName), "READ");
if (strcmp(fileName, trimFileName) == 0) g = f;
else g = new TFile(Form("%s/%s", dirName, trimFileName), "READ");
sprintf(fname, "%s/../../macros/criteria-full.dat", dirName);
if ( !readCriteria(fname) ) {
printf("\nchipSummary> ----> COULD NOT READ GRADING CRITERIA !!!");
printf("chipSummary> ----> Aborting execution of chipgSummaryPage.C ... \n\n", fileName, dirName);
break;
}
TH1D *h1;
TH2D *h2;
c1 = new TCanvas("c1", "", 800, 800);
c1->Clear();
c1->Divide(4,4, 0.01, 0.04);
// shrinkPad(0.1, 0.1, 0.1, 0.3);
FILE *sCurveFile, *phLinearFile, *phTanhFile;
TString noslash(dirName);
noslash.ReplaceAll("/", " ");
noslash.ReplaceAll(".. ", "");
char string[200];
int pixel_alive;
int nDeadPixel(0);
int nIneffPixel(0);
int nMaskDefect(0);
int nNoisy1Pixel(0);
int nDeadBumps(0);
int nDeadTrimbits(0);
int nAddressProblems(0);
int nNoisy2Pixel(0);
int nThrDefect(0);
int nGainDefect(0);
int nPedDefect(0);
int nPar1Defect(0);
int nRootFileProblems(0);
int nDoubleFunctCounts(0);
int nDoublePerfCounts(0);
int nDoubleCounts(0);
int nDoubleTrims(0);
int nDoublePHs(0);
int vcal = dac_findParameter(dirName, "Vcal", chipId);
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 1
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Dead pixels
c1->cd(1);
TH2D *hpm;
hpm = (TH2D*)f->Get(Form("PixelMap_C%i", chipId));
if (hpm) {
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
hpm->SetTitle("");
hpm->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Pixel Map");
}
}
} else {
++nRootFileProblems;
}
// -- sCurve width and noise level
TH1D *hw = new TH1D("hw", "", 100, 0., 600.);
TH1D *hd = new TH1D("hd", "", 100, 0., 600.); // Noise in unbonded pixel (not displayed)
TH2D *ht = new TH2D("ht", "", 52, 0., 52., 80, 0., 80.);
TH1D *htmp;
float mN(0.), sN(0.), nN(0.), nN_entries(0.);
int over(0), under(0);
double htmax(255.), htmin(0.);
float thr, sig;
int a,b;
double minThrDiff(-5.);
double maxThrDiff(5.);
h2 = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId));
sprintf(string, "%s/SCurve_C%i.dat", dirName, chipId);
sCurveFile = fopen(string, "r");
if (!sCurveFile) {
printf("chipSummary> !!!!!!!!! ----> SCurve: Could not open file %s to read fit results\n", string);
} else {
for (int i = 0; i < 2; i++) fgets(string, 200, sCurveFile);
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
fscanf(sCurveFile, "%e %e %s %2i %2i", &thr, &sig, string, &a, &b);
// printf("chipSummary> sig %e thr %e\n", sig, thr);
hw->Fill(sig);
thr = thr / 65.;
ht->SetBinContent(icol+1, irow+1, thr);
if ( h2 ) {
if( h2->GetBinContent(icol+1, irow+1) >= minThrDiff) {
hd->Fill(sig);
}
}
}
}
fclose(sCurveFile);
c1->cd(2);
hw->Draw();
tl->DrawLatex(0.1, 0.92, "S-Curve widths: Noise (e^{-})");
/* c1->cd(15);
hd->SetLineColor(kRed);
hd->Draw();
tl->DrawLatex(0.1, 0.92, "S-Curve widths of dead bumps");
if ( hd->GetEntries() > 0 ) {
ts->DrawLatex(0.55, 0.82, Form("entries: %4.0f", hd->GetEntries()));
ts->DrawLatex(0.55, 0.74, Form("#mu:%4.2f", hd->GetMean()));
ts->DrawLatex(0.55, 0.66, Form("#sigma: %4.2f", hd->GetRMS()));
}
*/
mN = hw->GetMean();
sN = hw->GetRMS();
nN = hw->Integral(hw->GetXaxis()->GetFirst(), hw->GetXaxis()->GetLast());
nN_entries = hw->GetEntries();
under = hw->GetBinContent(0);
over = hw->GetBinContent(hw->GetNbinsX()+1);
ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nN));
ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mN));
ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sN));
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
c1->cd(3);
if ( ht->GetMaximum() < htmax ) {
htmax = ht->GetMaximum();
}
if ( ht->GetMinimum() > htmin ) {
htmin = ht->GetMinimum();
}
ht->GetZaxis()->SetRangeUser(htmin,htmax);
ht->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Vcal Threshold Untrimmed");
}
// -- Noise level map
c1->cd(4);
gPad->SetLogy(1);
gStyle->SetOptStat(1);
float mV(0.), sV(0.), nV(0.), nV_entries(0.);
over = 0.; under = 0.;
if (!g->IsZombie())
{
h1 = (TH1D*)g->Get(Form("VcalThresholdMap_C%iDistribution;7", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(0., 100.);
h1->Draw();
mV = h1->GetMean();
sV = h1->GetRMS();
nV = h1->Integral(h1->GetXaxis()->GetFirst(), h1->GetXaxis()->GetLast());
nV_entries = h1->GetEntries();
under = h1->GetBinContent(0);
over = h1->GetBinContent(h1->GetNbinsX()+1);
}
else {
++nRootFileProblems;
mV = 0.;
sV = 0.;
}
ts->DrawLatex(0.15, 0.82, Form("N: %4.0f", nV));
ts->DrawLatex(0.15, 0.74, Form("#mu: %4.1f", mV));
ts->DrawLatex(0.15, 0.66, Form("#sigma: %4.1f", sV));
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
}
tl->DrawLatex(0.1, 0.92, "Vcal Threshold Trimmed");
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 2
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Bump Map
TH2D *hbm;
c1->cd(5);
gStyle->SetOptStat(0);
hbm = (TH2D*)f->Get(Form("vcals_xtalk_C%i", chipId));
if (hbm) {
h2->SetTitle("");
h2->GetZaxis()->SetRangeUser(minThrDiff, maxThrDiff);
h2->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Bump Bonding Problems");
}
else { ++nRootFileProblems; }
// -- Bump Map
c1->cd(6);
gPad->SetLogy(1);
//gStyle->SetOptStat(1);
h1 = (TH1D*)f->Get(Form("vcals_xtalk_C%iDistribution", chipId));
if (h1) {
h1->SetTitle("");
h1->GetXaxis()->SetRangeUser(-50., 50.);
h1->GetYaxis()->SetRangeUser(0.5, 5.0*h1->GetMaximum());
h1->DrawCopy();
tl->DrawLatex(0.1, 0.92, "Bump Bonding");
} else {
++nRootFileProblems;
}
// -- Trim bits
int trimbitbins(3);
c1->cd(7);
gPad->SetLogy(1);
h1 = (TH1D*)f->Get(Form("TrimBit14_C%i", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(0., 60.);
h1->SetMinimum(0.5);
h1->Draw("");
tl->DrawLatex(0.1, 0.92, "Trim Bit Test");
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit13_C%i", chipId));
if (h1) {
h1->SetLineColor(kRed);
h1->Draw("same");
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit11_C%i", chipId));
if (h1) {
h1->SetLineColor(kBlue);
h1->Draw("same");
}
else { ++nRootFileProblems; }
h1 = (TH1D*)f->Get(Form("TrimBit7_C%i", chipId));
if (h1) {
h1->SetLineColor(kGreen);
h1->Draw("same");
}
else { ++nRootFileProblems; }
// -- For numerics and titels see at end
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 3
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Address decoding
// --------------------
TH2D *ham;
ham = (TH2D*)f1->Get(Form("AddressDecoding_C%i", chipId));
c1->cd(9);
gStyle->SetOptStat(0);
if (ham) {
ham->SetTitle("");
ham->Draw("colz");
tl->DrawLatex(0.1, 0.92, "Address decoding");
}
else { ++nRootFileProblems; }
// -- Address levels
c1->cd(10);
gPad->SetLogy(1);
h1 = (TH1D*)f1->Get(Form("AddressLevels_C%i", chipId));
if (h1) {
h1->SetTitle("");
h1->SetAxisRange(-1500., 1500.);
h1->Draw();
tl->DrawLatex(0.1, 0.92, "Address Levels");
} else {
++nRootFileProblems;
}
// -- PHCalibration: Linear Fit (Gain & Pedesdtal)
// -----------------------------------------------
TH1D *hg = new TH1D("hg", "", 300, -2.0, 5.5);
TH2D *hgm = new TH2D("hgm", "", 52, 0., 52., 80, 0., 80.);
TH1D *hp = new TH1D("hp", "", 900, -300., 600.);
hp->StatOverflows(kTRUE);
TH1D *rp = new TH1D("rp", "", 900, -300., 600.);
rp->StatOverflows(kFALSE);
TH1D *htmp;
float par0, par1, par2, par3, par4, par5; // Parameters of Vcal vs. Pulse Height Fit
float mG(0.), sG(0.), nG(0.), nG_entries(0.);
float mP(0.), sP(0.), nP(0.), nP_entries(0.);
over = 0.; under = 0.;
float ped, gain;
int a,b;
int mPbin(0), xlow(-100), xup(255), extra(0); // for restricted RMS
float pedMin(0), pedMax(1000);
double integral(0.);
sprintf(string, "%s/phCalibrationFit_C%i.dat", dirName, chipId);
phLinearFile = fopen(string, "r");
if (!phLinearFile) {
printf("chipSummary> !!!!!!!!! ----> phCal: Could not open file %s to read fit results\n", string);
} else {
for (int i = 0; i < 2; i++) fgets(string, 200, phLinearFile);
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
fscanf(phLinearFile, "%e %e %e %e %e %e %s %2i %2i",
&par0, &par1, &par2, &par3, &par4, &par5, string, &a, &b);
if (par2 != 0.) { // dead pixels have par2 == 0.
gain = 1./par2;
ped = par3;
hp->Fill(ped);
hg->Fill(gain);
hgm->SetBinContent(icol + 1, irow + 1, gain);
}
}
}
fclose(phLinearFile);
// -- Gain
c1->cd(11);
mG = hg->GetMean();
sG = hg->GetRMS();
nG = hg->Integral(hg->GetXaxis()->GetFirst(), hg->GetXaxis()->GetLast());
nG_entries = hg->GetEntries();
under = hg->GetBinContent(0);
over = hg->GetBinContent(hp->GetNbinsX()+1);
gPad->SetLogy(1);
hg->GetYaxis()->SetRangeUser(0.5, 5.0*hg->GetMaximum());
hg->Draw();
tl->DrawLatex(0.1, 0.92, "PH Calibration: Gain (ADC/DAC)");
if ( hg->GetMean() > 1.75 ) {
ts->DrawLatex(0.15, 0.80, Form("N: %4.0f", nG));
ts->DrawLatex(0.15, 0.72, Form("#mu: %4.2f", mG));
ts->DrawLatex(0.15, 0.64, Form("#sigma: %4.2f", sG));
} else {
ts->DrawLatex(0.65, 0.80, Form("N: %4.0f", nG));
ts->DrawLatex(0.65, 0.72, Form("#mu: %4.2f", mG));
ts->DrawLatex(0.65, 0.64, Form("#sigma: %4.2f", sG));
}
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
c1->cd(15);
hgm->Draw("colz");
tl->DrawLatex(0.1, 0.92, "PH Calibration: Gain (ADC/DAC)");
// -- Pedestal
c1->cd(12);
mP = hp->GetMean();
sP = hp->GetRMS();
nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast());
nP_entries = hp->GetEntries();
if ( nP > 0 ) {
// -- restricted RMS
integral = 0.;
mPbin = -1000; xlow = -1000; xup = 1000;
over = 0.; under = 0.;
mPbin = hp->GetXaxis()->FindBin(mP);
for (int i = 0; integral < pedDistr; i++) {
xlow = mPbin-i;
xup = mPbin+i;
integral = hp->Integral(xlow, xup)/nP;
}
extra = xup - xlow;
}
else {
xlow = -300; xup = 600; extra = 0;
over = 0.; under = 0.;
}
under = hp->Integral(0, xlow - extra);
over = hp->Integral(xup + 1.5*extra, hp->GetNbinsX());
hp->GetXaxis()->SetRange(xlow - extra, xup + 1.5*extra);
nP = hp->Integral(hp->GetXaxis()->GetFirst(), hp->GetXaxis()->GetLast());
pedMin = hp->GetBinCenter(xlow-extra);
pedMax = hp->GetBinCenter(xup+1.5*extra);
cout<< " ========> Ped min " << pedMin << " Ped max " << pedMax
<< ", over: " << over << " under: " << under << endl;
hp->DrawCopy();
rp->Add(hp);
rp->GetXaxis()->SetRange(xlow, xup);
mP = rp->GetMean();
sP = rp->GetRMS();
// box->DrawBox( rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xup), 1.05*rp->GetMaximum());
rp->SetFillColor(kRed);
rp->SetFillStyle(3002);
rp->Draw("same");
line->DrawLine(rp->GetBinCenter(xlow), 0, rp->GetBinCenter(xlow), 0.6*rp->GetMaximum());
line->DrawLine(rp->GetBinCenter(xup), 0, rp->GetBinCenter(xup), 0.6*rp->GetMaximum());
tl->DrawLatex(0.1, 0.92, "PH Calibration: Pedestal (DAC)");
if ( hp->GetMean() < 126. ) {
ts->DrawLatex(0.65, 0.82, Form("N: %4.0f", nP));
ts->SetTextColor(kRed);
ts->DrawLatex(0.65, 0.74, Form("#mu: %4.1f", mP));
ts->DrawLatex(0.65, 0.66, Form("#sigma: %4.1f", sP));
} else {
ts->DrawLatex(0.16, 0.82, Form("N: %4.0f", nP));
ts->SetTextColor(kRed);
ts->DrawLatex(0.16, 0.74, Form("#mu: %4.1f", mP));
ts->DrawLatex(0.16, 0.66, Form("#sigma: %4.1f", sP));
}
if ( under ) ts->DrawLatex(0.15, 0.55, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.55, Form("%i =>", over ));
ts->SetTextColor(kBlack);
}
// -- PHCalibration: Tanh Fit (Parameter1)
// ----------------------------------------
c1->cd(11);
over = 0.; under = 0.;
float nPar1(0.), nPar1_entries(0.), mPar1(0.), sPar1(0.);
TH1D *hPar1 = new TH1D("par1", "", 350, -1., 6.);
sprintf(string, "%s/phCalibrationFitTan_C%i.dat", dirName, chipId);
phTanhFile = fopen(string, "r");
if (!phTanhFile) {
printf("chipSummary> !!!!!!!!! ----> phCal: Could not open file %s to read fit results\n", string);
} else {
for (int i = 0; i < 2; i++) fgets(string, 200, phTanhFile);
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
fscanf(phTanhFile, "%e %e %e %e %s %2i %2i", &par0, &par1, &par2, &par3, string, &a, &b);
hPar1->Fill(par1);
}
}
fclose(phTanhFile);
// -- Parameter 1
hPar1->SetLineColor(kBlue);
hPar1->Draw("same");
mPar1 = hPar1->GetMean();
sPar1 = hPar1->GetRMS();
nPar1 = hPar1->Integral(hPar1->GetXaxis()->GetFirst(), hPar1->GetXaxis()->GetLast());
nPar1_entries = hPar1->GetEntries();
under = hPar1->GetBinContent(0);
over = hPar1->GetBinContent(hPar1->GetNbinsX()+1);
ts->SetTextColor(kBlue);
if ( hg->GetMean() > 1.75 ) {
ts->DrawLatex(0.15, 0.40, "Par1:");
ts->DrawLatex(0.15, 0.30, Form("N: %4.0f", nPar1));
ts->DrawLatex(0.15, 0.22, Form("#mu: %4.2f", mPar1));
ts->DrawLatex(0.15, 0.14, Form("#sigma: %4.2f", sPar1));
} else {
ts->DrawLatex(0.65, 0.40, "Par1:");
ts->DrawLatex(0.65, 0.30, Form("N: %4.0f", nPar1));
ts->DrawLatex(0.65, 0.22, Form("#mu: %4.2f", mPar1));
ts->DrawLatex(0.65, 0.14, Form("#sigma: %4.2f", sPar1));
}
if ( under ) ts->DrawLatex(0.15, 0.48, Form("<= %i", under));
if ( over ) ts->DrawLatex(0.75, 0.48, Form("%i =>", over ));
ts->SetTextColor(kBlack);
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Row 4
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Trim Bits
// ----------
TH2D *htm = new TH2D("htm", "", 80, 0., 80., 52, 0., 52.);
c1->cd(13);
gStyle->SetOptStat(0);
h2 = (TH2D*)f->Get(Form("TrimMap_C%i;8", chipId));
if (h2) {
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
htm->SetBinContent(irow+1, icol+1, h2->GetBinContent(icol+1, irow+1));
}
}
h2->SetTitle("");
h2->GetZaxis()->SetRangeUser(0., 16.);
h2->Draw("colz");
}
else { ++nRootFileProblems; }
tl->DrawLatex(0.1, 0.92, "Trim Bits");
FILE *tCalFile;
sprintf(string, "%s/../T-calibration/TemperatureCalibration_C%i.dat", dirName, chipId);
tCalFile = fopen(string, "r");
char tCalDir[200];
sprintf(tCalDir, "%s/../T-calibration", dirName);
if ( tCalFile ) {
analyse(tCalDir, chipId);
}
else {
c1->cd(14);
TGraph *graph = (TGraph*)f->Get(Form("TempCalibration_C%i", chipId));
if ( graph ) { graph->Draw("A*"); }
else { ++nRootFileProblems; }
tl->DrawLatex(0.1, 0.92, "Temperature calibration");
}
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Count defects and double counting
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
float fl0, fl1, fl2, fl3, fl4, fl5, tmp;
int i1, i2;
char hname[200];
// TH2D *get = 0, *hget = 0, *htb0 = 0, *htb1 = 0, *htb2 = 0, *htb3 = 0, *htb4 = 0;
// for (int i = 1; i < 6; ++i) {
// get = (TH2D*)f->Get(Form("CalThresholdMap_C%i;%i", chipId, i));
// if (get) {
// hget = (TH2D*)get->Clone();
// hget->SetName(Form("TB0C%i", i));
// if (i == 1) htb0 = hget;
// if (i == 2) htb1 = hget;
// if (i == 3) htb2 = hget;
// if (i == 4) htb3 = hget;
// if (i == 5) htb4 = hget;
// }
// }
TH2D *htb[5];
for (int i = 0; i < 5; ++i) {
htb[i] = (TH2D*)f->Get(Form("CalThresholdMap_C%i;%i", chipId, i+1));
htb[i]->SetName(Form("tbC%i%i", chipId, i+1));
}
TH2D *htthr = 0;
htthr = (TH2D*)f->Get(Form("VcalThresholdMap_C%d;8", chipId));
sprintf(string, "%s/SCurve_C%i.dat", dirName, chipId);
sCurveFile = fopen(string, "r");
sprintf(string, "%s/phCalibrationFit_C%i.dat", dirName, chipId);
phLinearFile = fopen(string, "r");
sprintf(string, "%s/phCalibrationFitTan_C%i.dat", dirName, chipId);
phTanhFile = fopen(string, "r");
if (sCurveFile) for (int i = 0; i < 2; i++) fgets(string, 200, sCurveFile);
if (phLinearFile) for (int i = 0; i < 2; i++) fgets(string, 200, phLinearFile);
if (phTanhFile) for (int i = 0; i < 2; i++) fgets(string, 200, phTanhFile);
int px_counted = 0;
int px_funct_counted = 0;
int px_perf_counted = 0;
int trim_counted = 0;
int ph_counted = 0;
float tb_diff = 0;
float tb, tb0;
for (int icol = 0; icol < 52; ++icol) {
for (int irow = 0; irow < 80; ++irow) {
pixel_alive = 1;
px_funct_counted = 0;
px_perf_counted = 0;
px_counted = 0;
trim_counted = 0;
ph_counted = 0;
// -- Pixel alive
if (hpm && hpm->GetBinContent(icol+1, irow+1) == 0) {
pixel_alive = 0;
++nDeadPixel;
cout << Form("chipSummary> dead pixel %3d %3d: %7.5f",
icol, irow, hpm->GetBinContent(icol+1, irow+1)) << endl;
}
if (hpm && hpm->GetBinContent(icol+1,irow+1) > 10) { ++nNoisy1Pixel; px_counted = 1; px_funct_counted = 1;}
if (hpm && hpm->GetBinContent(icol+1, irow+1) < 0) { ++nMaskDefect; px_counted = 1; px_funct_counted = 1;}
if (hpm && (hpm->GetBinContent(icol+1, irow+1) < 10)
&& (hpm->GetBinContent(icol+1, irow+1) > 0) ) { ++nIneffPixel; px_counted = 1; px_funct_counted = 1;}
// -- Bump bonding
if ( pixel_alive && hbm ) {
if ( hbm->GetBinContent(icol+1, irow+1) >= minThrDiff ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_funct_counted ) nDoubleFunctCounts++;
px_funct_counted = 1;
++nDeadBumps;
cout << Form("chipSummary> bump defect %3d %3d: %7.5f",
icol, irow, hbm->GetBinContent(icol+1, irow+1)) << endl;
}
}
// -- Trim bits 1 - 4
if ( pixel_alive && htb[0] ) {
tb0 = htb[0]->GetBinContent(icol+1, irow+1);
for ( int i = 1; i <= 4; i++ ) {
if ( htb[i] ) {
tb = htb[i]->GetBinContent(icol+1, irow+1);
tb_diff = TMath::Abs(tb-tb0);
if (tb_diff <= 2) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_funct_counted ) nDoubleFunctCounts++;
px_funct_counted = 1;
if ( trim_counted ) nDoubleTrims++;
trim_counted = 1;
++nDeadTrimbits;
cout << Form("chipSummary> trim bit defect %3d %3d: %4.2f", icol, irow, tb_diff) << endl;
}
}
}
}
// -- Address decoding
if (pixel_alive && ham) {
if( ham->GetBinContent(icol+1, irow+1) < 1 ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_funct_counted ) nDoubleFunctCounts++;
px_funct_counted = 1;
++nAddressProblems;
cout << Form("chipSummary> address problem %3d %3d: %7.5f",
icol, irow, ham->GetBinContent(icol+1, irow+1)) << endl;
}
}
// -- Threshold
if (pixel_alive && htthr) {
if ( TMath::Abs(htthr->GetBinContent(icol+1, irow+1) - vcalTrim) > tthrTol ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_perf_counted ) nDoublePerfCounts++;
px_perf_counted = 1;
++nThrDefect;
cout << Form("chipSummary> threshold problem %3d %3d: %7.5f",
icol, irow, htthr->GetBinContent(icol+1, irow+1)) << endl;
}
}
// -- Noise
fscanf(sCurveFile, "%e %e %s %2i %2i", &fl1, &fl2, string, &i1, &i2);
if (pixel_alive) {
if ( (fl2 < noiseMin)
|| (fl2 > noiseMax) ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_perf_counted ) nDoublePerfCounts++;
px_perf_counted = 1;
++nNoisy2Pixel;
cout << Form("chipSummary> noise defect %3d %3d: %7.5f (%2i %2i)",
icol, irow, fl2, i1, i2) << endl;
}
}
// -- Gain & Pedestal
fscanf(phLinearFile, "%e %e %e %e %e %e %s %2i %2i",
&fl0, &fl1, &fl2, &fl3, &fl4, &fl5, string, &i1, &i2);
if (pixel_alive) {
if (fl2 != 0) gain = 1./fl2;
ped = fl3;
if ( (gain < gainMin) || (gain > gainMax) ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_perf_counted ) nDoublePerfCounts++;
px_perf_counted = 1;
if ( ph_counted ) nDoublePHs++;
ph_counted = 1;
++nGainDefect;
cout << Form("chipSummary> gain defect %3d %3d: %7.5f (%2i %2i)",
icol, irow, gain, i1, i2) << endl;
}
if ( (ped < pedMin)
|| (ped > pedMax) ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_perf_counted ) nDoublePerfCounts++;
px_perf_counted = 1;
if ( ph_counted ) nDoublePHs++;
ph_counted = 1;
++nPedDefect;
cout << Form("chipSummary> pedestal defect %3d %3d: %7.5f (%2i %2i)",
icol, irow, ped, i1, i2) << endl;
}
}
// -- Par1
fscanf(phTanhFile, "%e %e %e %e %s %2i %2i",
&fl0, &fl1, &fl2, &fl3, string, &i1, &i2);
if (pixel_alive && phTanhFile) {
if ( (fl1 < par1Min)
|| (fl1 > par1Max) ) {
if ( px_counted ) nDoubleCounts++;
px_counted = 1;
if ( px_perf_counted ) nDoublePerfCounts++;
px_perf_counted = 1;
if ( ph_counted ) nDoublePHs++;
ph_counted = 1;
++nPar1Defect;
cout << Form("chipSummary> par1 defect %3d %3d: %7.5f (%2i %2i)",
icol, irow, par1, i1, i2) << endl;
}
}
}
}
fclose(sCurveFile);
fclose(phLinearFile);
fclose(phTanhFile);
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// Numerics and Titles
// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// -- Compute the final verdict on this chip //?? FIXME (below is pure randomness)
float finalVerdict(0);
if (nDeadTrimbits > 0) finalVerdict += 1;
if (nDeadPixel > 0) finalVerdict += 10;
if (nNoisy1Pixel > 0) finalVerdict += 10;
if (nAddressProblems > 0) finalVerdict += 10;
if (nDeadBumps > 0) finalVerdict += 100;
if (nNoisy2Pixel > 0) finalVerdict += 1000;
if (nThrDefect > 0) finalVerdict += 10000;
if (nGainDefect > 0) finalVerdict += 100000;
if (nPedDefect > 0) finalVerdict += 100000;
if (nPar1Defect > 0) finalVerdict += 100000;
// -- Defects
c1->cd(8);
tl->SetTextSize(0.10);
tl->SetTextFont(22);
double y = 0.98;
y -= 0.11;
tl->DrawLatex(0.1, y, "Summary");
// tl->DrawLatex(0.6, y, Form("%06d", finalVerdict));
tl->SetTextFont(132);
tl->SetTextSize(0.09);
y -= 0.11;
tl->DrawLatex(0.1, y, Form("Dead Pixels: "));
tl->DrawLatex(0.7, y, Form("%4d", nDeadPixel));
// y -= 0.10;
// tl->DrawLatex(0.1, y, Form("Noisy Pixels 1: "));
// tl->DrawLatex(0.7, y, Form("%4d", nNoisy1Pixel));
y -= 0.10;
tl->DrawLatex(0.1, y, "Mask defects: ");
tl->DrawLatex(0.7, y, Form("%4d", nMaskDefect));
y -= 0.10;
tl->DrawLatex(0.1, y, "Dead Bumps: ");
tl->DrawLatex(0.7, y, Form("%4d", nDeadBumps));
y -= 0.10;
tl->DrawLatex(0.1, y, "Dead Trimbits: ");
tl->DrawLatex(0.7, y, Form("%4d", nDeadTrimbits));
y -= 0.10;
tl->DrawLatex(0.1, y, "Address Probl: ");
tl->DrawLatex(0.7, y, Form("%4d", nAddressProblems));
y -= 0.10;
tl->DrawLatex(0.1, y, Form("Noisy Pixels 2: "));
tl->DrawLatex(0.7, y, Form("%4d", nNoisy2Pixel));
y -= 0.10;
tl->DrawLatex(0.1, y, Form("Trim Probl.: "));
tl->DrawLatex(0.7, y, Form("%4d", nThrDefect));
y -= 0.10;
tl->DrawLatex(0.1, y, Form("PH defects: "));
tl->DrawLatex(0.5, y, Form("%4d/", nGainDefect));
tl->SetTextColor(kRed);
tl->DrawLatex(0.6, y, Form("%4d/",nPedDefect));
tl->SetTextColor(kBlack);
tl->SetTextColor(kBlue);
tl->DrawLatex(0.7, y, Form("%4d",nPar1Defect));
tl->SetTextColor(kBlack);
// y -= 0.10;
// tl->DrawLatex(0.1, y, Form("Par1 defect: "));
// tl->DrawLatex(0.7, y, Form("%4d", nPar1Defect));
// -- Operation Parameters
c1->cd(16);
y = 0.92;
tl->SetTextSize(0.10);
tl->SetTextFont(22);
y -= 0.11;
tl->DrawLatex(0.1, y, Form("Op. Parameters"));
tl->SetTextFont(132);
tl->SetTextSize(0.09);
y -= 0.11;
int vana(-1.);
vana = dac_findParameter(dirName, "Vana", chipId);
tl->DrawLatex(0.1, y, "VANA: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3i DAC", vana));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int caldel(-1.);
caldel = dac_findParameter(dirName, "CalDel", chipId);
tl->DrawLatex(0.1, y, "CALDEL: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", caldel));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int vthrcomp(-1.);
vthrcomp = dac_findParameter(dirName, "VthrComp", chipId);
tl->DrawLatex(0.1, y, "VTHR: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vthrcomp));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int vtrim(-1.);
vtrim = dac_findParameter(dirName, "Vtrim", chipId);
tl->DrawLatex(0.1, y, "VTRIM: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", vtrim));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int ibias(-1.);
ibias = dac_findParameter(dirName, "Ibias_DAC", chipId);
tl->DrawLatex(0.1, y, "IBIAS_DAC: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", ibias));
else tl->DrawLatex(0.7, y, "N/A");
y -= 0.10;
int voffset(-1.);
voffset = dac_findParameter(dirName, "VoffsetOp", chipId);
tl->DrawLatex(0.1, y, "VOFFSETOP: ");
if (vana >= 0.) tl->DrawLatex(0.6, y, Form("%3d DAC", voffset));
else tl->DrawLatex(0.7, y, "N/A");
// -- Page title
c1->cd(0);
tl->SetTextSize(0.04);
tl->SetTextFont(22);
tl->DrawLatex(0.02, 0.97, Form("%s (C%i)", noslash.Data(), chipId));
TDatime date;
tl->SetTextSize(0.02);
tl->DrawLatex(0.75, 0.97, Form("%s", date.AsString()));
c1->SaveAs(Form("%s/chipSummary_C%i.ps", dirName, chipId));
c1->SaveAs(Form("%s/C%i.png", dirName, chipId));
// -- Dump into logfile
ofstream OUT(Form("%s/summary_C%i.txt", dirName, chipId));
OUT << "nDeadPixel: " << nDeadPixel << endl;
OUT << "nNoisy1Pixel: " << nNoisy1Pixel << endl;
OUT << "nDeadTrimbits: " << nDeadTrimbits << endl;
OUT << "nDeadBumps: " << nDeadBumps << endl;
OUT << "nMaskDefect: " << nMaskDefect << endl;
OUT << "nAddressProblems: " << nAddressProblems << endl;
OUT << "nNoisy2Pixel: " << nNoisy2Pixel << endl;
OUT << "nTThrDefect: " << nThrDefect << endl;
OUT << "nGainDefect: " << nGainDefect << endl;
OUT << "nPedDefect: " << nPedDefect << endl;
OUT << "nParDefect: " << nPar1Defect << endl;
OUT << "nDoubleCounts: " << nDoubleCounts << endl;
OUT << "nDoubleFunctCounts: " << nDoubleFunctCounts << endl;
OUT << "nDoublePerfCounts: " << nDoublePerfCounts << endl;
OUT << "nDoubleTrims: " << nDoubleTrims << endl;
OUT << "nDoublePHs: " << nDoublePHs << endl;
OUT << "nRootFileProblems: " << nRootFileProblems << endl;
OUT << "SCurve " << nN_entries << " " << mN << " " << sN << endl;
OUT << "Threshold " << nV_entries << " " << mV << " " << sV << endl;
OUT << "Gain " << nG_entries << " " << mG << " " << sG << endl;
OUT << "Pedestal " << nP_entries << " " << mP << " " << sP << endl;
OUT << "Parameter1 " << nPar1_entries << " " << mPar1 << " " << sPar1 << endl;
OUT.close();
}
int main(int argc, char* argv[]) {
std::string outputDir = "WideJets_Plot";
mkdir(outputDir.c_str(), 0777);
// TString dataFileName_DoubleMu;
// dataFileName_DoubleMu = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_DoubleMu.root");
// TFile* dataFile_DoubleMu = TFile::Open(dataFileName_DoubleMu);
// if (dataFile_DoubleMu) {
// std::cout << "Opened data file '" << dataFileName_DoubleMu << "'." << std::endl;
// }
TString dataFileName_HT450;
dataFileName_HT450 = TString::Format("../../output/HLTReco_Comparison/rootFile_JEC_HLT_v7_RecoLowerCuts10GeV_HT450.root");
TFile* dataFile_HT450 = TFile::Open(dataFileName_HT450);
if (dataFile_HT450) {
std::cout << "Opened data file '" << dataFileName_HT450 << "'." << std::endl;
}
TH1D *pT_WideJetHLT = (TH1D*)dataFile_HT450->Get("pT_WideJetHLT");
if( !pT_WideJetHLT) cout<<"Not found" <<endl;
gErrorIgnoreLevel = kWarning;
// procedura
// prendo gli istogramma 1D del bias
// per ogni bin di pT e eta
// li fitto con una cristal ball
// poi grafico il picco in funzione del pT in ogni bin di eta
// fitto con una funzione logaritmica
// mi creo l'istogramma 2D (eta,pT) con correzione sull'asse z
//////////////////////// pTBias 1D
EtaBinning mEtaBinning;
size_t etaBinningSize = mEtaBinning.size();
PtBinning mPtBinning;
size_t pTBinningSize = mPtBinning.size();
cout<< etaBinningSize << endl;
for (size_t ii = 0; ii < etaBinningSize; ii++) {
// for (size_t ii = 9; ii < 10; ii++) {
for (size_t jj = 0; jj < pTBinningSize; jj++) {
cout<< "ii = "<< ii <<endl;
cout<< "jj = "<< jj <<endl;
if(jj < 2) continue; // pT<300
if(jj > 7) continue; // pT>900
std::string etaName = mEtaBinning.getBinName(ii);
std::pair<float, float> ptBins = mPtBinning.getBinValue(jj);
std::string HistoName = TString::Format("pTBias_%s_pT_%i_%i", etaName.c_str(), (int) ptBins.first, (int) ptBins.second ).Data();
cout<< HistoName.c_str() << endl;
TH1D *h;
h = (TH1D*)dataFile_HT450->Get( HistoName.c_str() );
double hN = h->GetMaximum();
double hMean = h->GetMean();
double hRMS = h->GetRMS();
//histo->GetMean() - sigma * histo->GetRMS(), histo->GetMean() + sigma * histo->GetRMS()
// TF1 *crystal = new TF1("crystal", CrystalBall, hMean-1*hRMS , hMean+1*hRMS, 5);
TF1 *crystal = new TF1("crystal", CrystalBall, -0.1, 0.15, 5);
// TF1 *crystal = new TF1("crystal", CrystalBall, -0.05, 0.1, 5);
crystal->SetParameters(hN, hMean, hRMS, 1.0, 2.0);
crystal->SetParNames("N", "Mean", "sigma","#alpha","n");
// TF1 *doublecrystal = new TF1("doublecrystal", doubleCrystalBall, hMean-1*hRMS , hMean+1*hRMS, 7);
TF1 *doublecrystal = new TF1("doublecrystal", doubleCrystalBall, -0.2 , 0.2, 7);
doublecrystal->SetParameters(hN, hMean, hRMS, 3, 3, 3, 3);
doublecrystal->SetParNames("N", "Mean", "sigma","#alphaR","nR","#alphaL", "nL");
TCanvas *c1 = new TCanvas("c1", "c1", 800, 800);
h -> SetMarkerStyle(20);
h -> SetMarkerSize(1.5);
h -> GetXaxis()->SetRangeUser(-0.4, 0.4);
// h -> Fit(crystal, "R");
h -> Fit(doublecrystal, "R");
h -> Draw();
c1 -> SaveAs( Form("WideJets_Plot/%s.png", HistoName.c_str() ) );
c1-> Destructor();
/////////////////////////////////////////////////
pT_WideJetHLT ->GetXaxis()->SetRangeUser(ptBins.first, ptBins.second);
double pTMean = pT_WideJetHLT->GetMean();
std::cout<< "Bin " << ptBins.first<< "-"<<ptBins.second<<" -> Mean "<< pTMean << std::endl;
double pTBias = doublecrystal->GetParameter(1);
double pTBiasErr = doublecrystal->GetParError(1);
cout<< "pT mean = "<< pTMean <<endl;
cout<< "pT Bias = "<< pTBias <<endl;
cout<< "sigma(pT Bias) = "<< pTBiasErr <<endl;
std::string TGraphName = TString::Format("pTBias_vs_pT_etabin_%i", ii).Data();
cout<< TGraphName.c_str() << endl;
CreateAndFillUserTGraph(TGraphName.c_str(), jj, pTMean, pTBias, 0, pTBiasErr);
}
}
for(int ii = 0; ii < etaBinningSize ; ii++){
std::string TGraphName = TString::Format("pTBias_vs_pT_etabin_%i", ii).Data();
cout<< TGraphName.c_str() << endl;
map<std::string , TGraphErrors*>::iterator nh_h = userTGraphs_.find( TGraphName );
if( nh_h == userTGraphs_.end()) continue;
TF1* functionFit = new TF1( "functionFit", "[0]*(log(x)*log(x)*log(x)) + [1]*(log(x)*log(x)) + [2]*log(x) + [3]", 300, 1000);
//TF1* functionFit = new TF1( "functionFit", "[0]*(log(x)*log(x)) + [1]*log(x) + [2]", 300, 1000);
TCanvas *c1 = new TCanvas("c1", "c1", 800, 800);
nh_h->second->SetMarkerStyle(20);
nh_h->second->SetMarkerSize(1.5);
nh_h->second->GetXaxis()->SetRangeUser(300, 1000);
nh_h->second->SetMaximum(0.1);
nh_h->second->SetMinimum(-0.1);
nh_h->second->Fit(functionFit, "R");
nh_h->second->Draw("ZAP");
c1 -> SaveAs( Form("WideJets_Plot/%s.png", TGraphName.c_str() ) );
c1 -> Destructor();
double Par0 = functionFit->GetParameter(0);
double Par1 = functionFit->GetParameter(1);
double Par2 = functionFit->GetParameter(2);
double Par3 = functionFit->GetParameter(3);
double NDF = functionFit->GetNDF();
double Chisquare = functionFit->GetChisquare();
cout<< "Par 0 = " << Par0 << endl;
cout<< "Par 1 = " << Par1 << endl;
cout<< "Par 2 = " << Par2 << endl;
cout<< "Par 3 = " << Par3 << endl;
cout<< "Chisquare / NDF = " << Chisquare<<"/"<<NDF << endl;
for(int jj=0; jj < binnum; jj++){
int pTMin = pTMeanArray[jj];
int pTMax = pTMeanArray[jj+1];
double pTMean= (pTMin + pTMax) /2. ;
cout<<"pT Mean = " << pTMean <<endl;
// double pTBiasFit = Par0*(log(pTMean)*log(pTMean)) + Par1*log(pTMean) + Par2;
double pTBiasFit = Par0*(log(pTMean)*log(pTMean)*log(pTMean)) + Par1*log(pTMean)*log(pTMean) + Par2*log(pTMean) + Par3;
cout<<"pT Bias from fit = " << pTBiasFit <<endl;
Histo_Corrections->SetBinContent(ii+1, jj+1, pTBiasFit);
}
}
TCanvas *c2 = new TCanvas("c2", "c2", 900, 800);
Histo_Corrections->SetStats(0);
gStyle->SetPalette(55);
Histo_Corrections->SetContour(100);
Histo_Corrections->Draw("colz");
c2->SetRightMargin(0.13);
c2->SaveAs("WideJets_Plot/Corrections.png");
TFile* outputFile= new TFile("WideJetsCorrections_JEC_HLT_v7.root","RECREATE");
outputFile->cd();
Histo_Corrections -> Write();
outputFile->Close();
return 0;
}
void composeTrackAnalysisbyAssociator(string FileListName, int FileNumber) {
if(debug) cout << FileListName << endl;
string theFileName;
ifstream composeFileList;
composeFileList.open(FileListName.c_str());
string OutputPlotNamepreFix = FileListName + "_";
string OutputPlotNameFix = ".png";
unsigned int EventNumber;
unsigned int trackingParticleMatch;
double recTrackPurity;
double recTrackrefMomentum;
double recTrackrefPhi;
double recTrackrefEta;
double recTrackinnerMomentum;
double recTrackinnerPhi;
double recTrackinnerEta;
unsigned int recTrackinnerValid;
double recTrackouterMomentum;
double recTrackouterPhi;
double recTrackouterEta;
unsigned int recTrackouterValid;
double simTrackinnerMomentum;
double simTrackinnerPhi;
double simTrackinnerEta;
unsigned int simTrackinnerMatch;
double simTrackouterMomentum;
double simTrackouterPhi;
double simTrackouterEta;
unsigned int simTrackouterMatch;
double recTrackinnerMomentumofTSOS;
double recTrackinnerPhiofTSOS;
double recTrackinnerEtaofTSOS;
unsigned int recTrackinnerValidofTSOS;
double recTrackouterMomentumofTSOS;
double recTrackouterPhiofTSOS;
double recTrackouterEtaofTSOS;
unsigned int recTrackouterValidofTSOS;
double recTrackimpactMomentumofTSOS;
double recTrackimpactPhiofTSOS;
double recTrackimpactEtaofTSOS;
unsigned int recTrackimpactValidofTSOS;
int recTrackCharge;
double simTrackMomentumPt;
double simTrackPhi;
double simTrackEta;
int simTrackCharge;
TObjArray* myEfficiencyHist = new TObjArray();
TObjArray* myParticleHist = new TObjArray();
TObjArray* mySTAHist = new TObjArray();
TObjArray* myChargeCheckHist = new TObjArray();
TObjArray* myDeltaPtHist = new TObjArray();
TObjArray* myDeltaPhiHist = new TObjArray();
TObjArray* myDeltaEtaHist = new TObjArray();
vector<string> TypeName;
TypeName.clear();
for(int Index = 0; Index < FileNumber; Index++) {
getline(composeFileList, theFileName);
TypeName.push_back(theFileName);
string fullFileName = "data/"+ theFileName + ".root";
if(debug) cout << theFileName << endl;
TFile* RootFile = TFile::Open(fullFileName.c_str());
TTree* T1 = (TTree*)RootFile->Get("ExTree");
T1->SetBranchAddress("EventNumber", &EventNumber);
T1->SetBranchAddress("trackingParticleMatch", &trackingParticleMatch);
T1->SetBranchAddress("recTrackPurity", &recTrackPurity);
T1->SetBranchAddress("recTrackrefMomentum", &recTrackrefMomentum);
T1->SetBranchAddress("recTrackrefPhi", &recTrackrefPhi);
T1->SetBranchAddress("recTrackrefEta", &recTrackrefEta);
T1->SetBranchAddress("recTrackinnerMomentum", &recTrackinnerMomentum);
T1->SetBranchAddress("recTrackinnerPhi", &recTrackinnerPhi);
T1->SetBranchAddress("recTrackinnerEta", &recTrackinnerEta);
T1->SetBranchAddress("recTrackinnerValid", &recTrackinnerValid);
T1->SetBranchAddress("recTrackouterMomentum", &recTrackouterMomentum);
T1->SetBranchAddress("recTrackouterPhi", &recTrackouterPhi);
T1->SetBranchAddress("recTrackouterEta", &recTrackouterEta);
T1->SetBranchAddress("recTrackouterValid", &recTrackouterValid);
T1->SetBranchAddress("simTrackinnerMomentum", &simTrackinnerMomentum);
T1->SetBranchAddress("simTrackinnerPhi", &simTrackinnerPhi);
T1->SetBranchAddress("simTrackinnerEta", &simTrackinnerEta);
T1->SetBranchAddress("simTrackinnerMatch", &simTrackinnerMatch);
T1->SetBranchAddress("simTrackouterMomentum", &simTrackouterMomentum);
T1->SetBranchAddress("simTrackouterPhi", &simTrackouterPhi);
T1->SetBranchAddress("simTrackouterEta", &simTrackouterEta);
T1->SetBranchAddress("simTrackouterMatch", &simTrackouterMatch);
T1->SetBranchAddress("recTrackinnerMomentumofTSOS", &recTrackinnerMomentumofTSOS);
T1->SetBranchAddress("recTrackinnerPhiofTSOS", &recTrackinnerPhiofTSOS);
T1->SetBranchAddress("recTrackinnerEtaofTSOS", &recTrackinnerEtaofTSOS);
T1->SetBranchAddress("recTrackinnerValidofTSOS", &recTrackinnerValidofTSOS);
T1->SetBranchAddress("recTrackouterMomentumofTSOS", &recTrackouterMomentumofTSOS);
T1->SetBranchAddress("recTrackouterPhiofTSOS", &recTrackouterPhiofTSOS);
T1->SetBranchAddress("recTrackouterEtaofTSOS", &recTrackouterEtaofTSOS);
T1->SetBranchAddress("recTrackouterValidofTSOS", &recTrackouterValidofTSOS);
T1->SetBranchAddress("recTrackimpactMomentumofTSOS", &recTrackimpactMomentumofTSOS);
T1->SetBranchAddress("recTrackimpactPhiofTSOS", &recTrackimpactPhiofTSOS);
T1->SetBranchAddress("recTrackimpactEtaofTSOS", &recTrackimpactEtaofTSOS);
T1->SetBranchAddress("recTrackimpactValidofTSOS", &recTrackimpactValidofTSOS);
T1->SetBranchAddress("recTrackCharge", &recTrackCharge);
T1->SetBranchAddress("simTrackMomentumPt", &simTrackMomentumPt);
T1->SetBranchAddress("simTrackPhi", &simTrackPhi);
T1->SetBranchAddress("simTrackEta", &simTrackEta);
T1->SetBranchAddress("simTrackCharge", &simTrackCharge);
string TempHistName;
TempHistName = theFileName + "_Efficiency2simPt";
TH1D* Efficiency2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_Particle2simPt";
TH1D* Particle2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_STA2simPt";
TH1D* STA2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_InverseChargeRato2simPt";
TH1D* InverseChargeRato2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaPt2simPt";
TH1D* DeltaPt2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaPhi2simPt";
TH1D* DeltaPhi2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_DeltaEta2simPt";
TH1D* DeltaEta2simPtHist = new TH1D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale);
TempHistName = theFileName + "_MaxPurity2simPt";
TH2D* MaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 6, 0., 1.2);
TempHistName = theFileName + "_Multiplicity2simPt";
TH2D* Multiplicity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 10, 0., 10.);
TempHistName = theFileName + "_ChargeCheck2simPt";
TH2D* ChargeCheck2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 5, -2.5, 2.5);
TempHistName = theFileName + "_simTrackMomentumPtmaxPurity2simPt";
TH2D* simTrackMomentumPtmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, 0, PtScale);
TempHistName = theFileName + "_simTrackPhimaxPurity2simPt";
TH2D* simTrackPhimaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_simTrackEtamaxPurity2simPt";
TH2D* simTrackEtamaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 400, -2.0, 2.0);
TempHistName = theFileName + "_recTrackimpactMomentumofTSOSmaxPurity2simPt";
TH2D* recTrackimpactMomentumofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, 0, PtScale);
TempHistName = theFileName + "_recTrackimpactPhiofTSOSmaxPurity2simPt";
TH2D* recTrackimpactPhiofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_recTrackimpactEtaofTSOSmaxPurity2simPt";
TH2D* recTrackimpactEtaofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 600, -3.0, 3.0);
TempHistName = theFileName + "_recTrackimpactValidofTSOSmaxPurity2simPt";
TH2D* recTrackimpactValidofTSOSmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 2, 0., 2.);
TempHistName = theFileName + "_DeltaPtmaxPurity2simPt";
TH2D* DeltaPtmaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, (int)5*PtScale, -1.*PtScale, PtScale);
TempHistName = theFileName + "_DeltaPhimaxPurity2simPt";
TH2D* DeltaPhimaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 314, -PI, PI);
TempHistName = theFileName + "_DeltaEtamaxPurity2simPt";
TH2D* DeltaEtamaxPurity2simPtHist = new TH2D(TempHistName.c_str(), TempHistName.c_str(), (int)(PtScale/2), 0, PtScale, 400, -2.0, 2.0);
unsigned int trackingParticleMatch_temp;
unsigned int efficiency_temp;
double recTrackPurity_temp;
double recTrackrefMomentum_temp;
double recTrackrefPhi_temp;
double recTrackrefEta_temp;
double recTrackinnerMomentum_temp;
double recTrackinnerPhi_temp;
double recTrackinnerEta_temp;
unsigned int recTrackinnerValid_temp;
double recTrackouterMomentum_temp;
double recTrackouterPhi_temp;
double recTrackouterEta_temp;
unsigned int recTrackouterValid_temp;
double simTrackinnerMomentum_temp;
double simTrackinnerPhi_temp;
double simTrackinnerEta_temp;
unsigned int simTrackinnerMatch_temp;
double simTrackouterMomentum_temp;
double simTrackouterPhi_temp;
double simTrackouterEta_temp;
unsigned int simTrackouterMatch_temp;
double recTrackinnerMomentumofTSOS_temp;
double recTrackinnerPhiofTSOS_temp;
double recTrackinnerEtaofTSOS_temp;
unsigned int recTrackinnerValidofTSOS_temp;
double recTrackouterMomentumofTSOS_temp;
double recTrackouterPhiofTSOS_temp;
double recTrackouterEtaofTSOS_temp;
unsigned int recTrackouterValidofTSOS_temp;
double recTrackimpactMomentumofTSOS_temp;
double recTrackimpactPhiofTSOS_temp;
double recTrackimpactEtaofTSOS_temp;
unsigned int recTrackimpactValidofTSOS_temp;
int recTrackCharge_temp;
double simTrackMomentumPt_temp;
double simTrackPhi_temp;
double simTrackEta_temp;
int simTrackCharge_temp;
int Nentries = T1->GetEntries();
for(int i = 0; i < Nentries; i++) {
T1->GetEntry(i);
if(trackingParticleMatch == 0) {
MaxPurity2simPtHist->Fill(simTrackMomentumPt, 0);
Multiplicity2simPtHist->Fill(simTrackMomentumPt, 0);
int tempParticleBinNumber = Particle2simPtHist->FindBin(simTrackMomentumPt);
double tempParticleBinValue = Particle2simPtHist->GetBinContent(tempParticleBinNumber);
tempParticleBinValue += 1.;
Particle2simPtHist->SetBinContent(tempParticleBinNumber, tempParticleBinValue);
}
else {
efficiency_temp = 1;
trackingParticleMatch_temp = trackingParticleMatch;
recTrackPurity_temp = recTrackPurity;
recTrackrefMomentum_temp = recTrackrefMomentum;
recTrackrefPhi_temp = recTrackrefPhi;
recTrackrefEta_temp = recTrackrefEta;
recTrackinnerMomentum_temp = recTrackinnerMomentum;
recTrackinnerPhi_temp = recTrackinnerPhi;
recTrackinnerEta_temp = recTrackinnerEta;
recTrackinnerValid_temp = recTrackinnerValid;
recTrackouterMomentum_temp = recTrackouterMomentum;
recTrackouterPhi_temp = recTrackouterPhi;
recTrackouterEta_temp = recTrackouterEta;
recTrackouterValid_temp = recTrackouterValid;
simTrackinnerMomentum_temp = simTrackinnerMomentum;
simTrackinnerPhi_temp = simTrackinnerPhi;
simTrackinnerEta_temp = simTrackinnerEta;
simTrackinnerMatch_temp = simTrackinnerMatch;
simTrackouterMomentum_temp = simTrackouterMomentum;
simTrackouterPhi_temp = simTrackouterPhi;
simTrackouterEta_temp = simTrackouterEta;
simTrackouterMatch_temp = simTrackouterMatch;
recTrackinnerMomentumofTSOS_temp = recTrackinnerMomentumofTSOS;
recTrackinnerPhiofTSOS_temp = recTrackinnerPhiofTSOS;
recTrackinnerEtaofTSOS_temp = recTrackinnerEtaofTSOS;
recTrackinnerValidofTSOS_temp = recTrackinnerValidofTSOS;
recTrackouterMomentumofTSOS_temp = recTrackouterMomentumofTSOS;
recTrackouterPhiofTSOS_temp = recTrackouterPhiofTSOS;
recTrackouterEtaofTSOS_temp = recTrackouterEtaofTSOS;
recTrackouterValidofTSOS_temp = recTrackouterValidofTSOS;
recTrackimpactMomentumofTSOS_temp = recTrackimpactMomentumofTSOS;
recTrackimpactPhiofTSOS_temp = recTrackimpactPhiofTSOS;
recTrackimpactEtaofTSOS_temp = recTrackimpactEtaofTSOS;
recTrackimpactValidofTSOS_temp = recTrackimpactValidofTSOS;
recTrackCharge_temp = recTrackCharge;
simTrackMomentumPt_temp = simTrackMomentumPt;
simTrackPhi_temp = simTrackPhi;
simTrackEta_temp = simTrackEta;
simTrackCharge_temp = simTrackCharge;
bool nextStep = true;
while(nextStep) {
i++;
T1->GetEntry(i);
if(trackingParticleMatch <= trackingParticleMatch_temp)
nextStep = false;
else
trackingParticleMatch_temp = trackingParticleMatch;
if(nextStep == true && recTrackPurity_temp < recTrackPurity) {
if(debug) cout << "step another match, trackingParticleMatch_temp: " << trackingParticleMatch_temp << endl;
//trackingParticleMatch_temp = trackingParticleMatch;
recTrackPurity_temp = recTrackPurity;
recTrackrefMomentum_temp = recTrackrefMomentum;
recTrackrefPhi_temp = recTrackrefPhi;
recTrackrefEta_temp = recTrackrefEta;
recTrackinnerMomentum_temp = recTrackinnerMomentum;
recTrackinnerPhi_temp = recTrackinnerPhi;
recTrackinnerEta_temp = recTrackinnerEta;
recTrackinnerValid_temp = recTrackinnerValid;
recTrackouterMomentum_temp = recTrackouterMomentum;
recTrackouterPhi_temp = recTrackouterPhi;
recTrackouterEta_temp = recTrackouterEta;
recTrackouterValid_temp = recTrackouterValid;
simTrackinnerMomentum_temp = simTrackinnerMomentum;
simTrackinnerPhi_temp = simTrackinnerPhi;
simTrackinnerEta_temp = simTrackinnerEta;
simTrackinnerMatch_temp = simTrackinnerMatch;
simTrackouterMomentum_temp = simTrackouterMomentum;
simTrackouterPhi_temp = simTrackouterPhi;
simTrackouterEta_temp = simTrackouterEta;
simTrackouterMatch_temp = simTrackouterMatch;
recTrackinnerMomentumofTSOS_temp = recTrackinnerMomentumofTSOS;
recTrackinnerPhiofTSOS_temp = recTrackinnerPhiofTSOS;
recTrackinnerEtaofTSOS_temp = recTrackinnerEtaofTSOS;
recTrackinnerValidofTSOS_temp = recTrackinnerValidofTSOS;
recTrackouterMomentumofTSOS_temp = recTrackouterMomentumofTSOS;
recTrackouterPhiofTSOS_temp = recTrackouterPhiofTSOS;
recTrackouterEtaofTSOS_temp = recTrackouterEtaofTSOS;
recTrackouterValidofTSOS_temp = recTrackouterValidofTSOS;
recTrackimpactMomentumofTSOS_temp = recTrackimpactMomentumofTSOS;
recTrackimpactPhiofTSOS_temp = recTrackimpactPhiofTSOS;
recTrackimpactEtaofTSOS_temp = recTrackimpactEtaofTSOS;
recTrackimpactValidofTSOS_temp = recTrackimpactValidofTSOS;
recTrackCharge_temp = recTrackCharge;
simTrackMomentumPt_temp = simTrackMomentumPt;
simTrackPhi_temp = simTrackPhi;
simTrackEta_temp = simTrackEta;
simTrackCharge_temp = simTrackCharge;
}
}
i--;
//if(debug) cout << "Filling Multiplicity " << trackingParticleMatch_temp << endl;
MaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackPurity_temp);
Multiplicity2simPtHist->Fill(simTrackMomentumPt_temp, trackingParticleMatch_temp);
ChargeCheck2simPtHist->Fill(simTrackMomentumPt_temp, simTrackCharge_temp*recTrackCharge_temp);
simTrackMomentumPtmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackMomentumPt_temp);
simTrackPhimaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackPhi_temp);
simTrackEtamaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, simTrackEta_temp);
recTrackimpactMomentumofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactMomentumofTSOS_temp);
recTrackimpactPhiofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactPhiofTSOS_temp);
recTrackimpactEtaofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactEtaofTSOS_temp);
recTrackimpactValidofTSOSmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactValidofTSOS_temp);
DeltaPtmaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, (recTrackimpactMomentumofTSOS_temp-simTrackMomentumPt_temp)/simTrackMomentumPt_temp);
DeltaPhimaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactPhiofTSOS_temp-simTrackPhi_temp);
DeltaEtamaxPurity2simPtHist->Fill(simTrackMomentumPt_temp, recTrackimpactEtaofTSOS_temp-simTrackEta_temp);
int tempParticleBinNumber = STA2simPtHist->FindBin(simTrackMomentumPt_temp);
double tempParticleBinValue = Particle2simPtHist->GetBinContent(tempParticleBinNumber);
tempParticleBinValue += 1.;
Particle2simPtHist->SetBinContent(tempParticleBinNumber, tempParticleBinValue);
double tempSTABinValue = STA2simPtHist->GetBinContent(tempParticleBinNumber);
tempSTABinValue += 1.;
STA2simPtHist->SetBinContent(tempParticleBinNumber, tempSTABinValue);
}
}
for(int PtIndex = 1; PtIndex <= (int)(PtScale/2); PtIndex++) {
double ParticleBinValue = Particle2simPtHist->GetBinContent(PtIndex);
double STABinValue = STA2simPtHist->GetBinContent(PtIndex);
if(ParticleBinValue == 0.)
ParticleBinValue += 1.;
double EfficiencyBinValue = STABinValue / ParticleBinValue * 100.;
double EfficiencyBinError = sqrt(EfficiencyBinValue * (100. - EfficiencyBinValue) / ParticleBinValue);
cout << ParticleBinValue << ", " << STABinValue << ", " << EfficiencyBinValue << endl;
Efficiency2simPtHist->SetBinContent(PtIndex, EfficiencyBinValue);
Efficiency2simPtHist->SetBinError(PtIndex, EfficiencyBinError);
TH1D* ChargeCheckHist = ChargeCheck2simPtHist->ProjectionY("ChargeCheck", PtIndex, PtIndex, "o");
double ReverseChargeBinValue = ChargeCheckHist->GetBinContent(2);
double CoverseChargeBinValue = ChargeCheckHist->GetBinContent(4);
double TotalChargeBinValue = ReverseChargeBinValue + CoverseChargeBinValue;
if(TotalChargeBinValue == 0.);
TotalChargeBinValue += 1.;
double ReverseChargeRato = ReverseChargeBinValue / TotalChargeBinValue;
InverseChargeRato2simPtHist->SetBinContent(PtIndex, ReverseChargeRato);
TH1D* DeltaPtHist = DeltaPtmaxPurity2simPtHist->ProjectionY("DeltaPt", PtIndex, PtIndex, "o");
double DeltaPtMean = DeltaPtHist->GetMean();
double DeltaPtRMS = DeltaPtHist->GetRMS();
DeltaPt2simPtHist->SetBinContent(PtIndex, DeltaPtMean);
DeltaPt2simPtHist->SetBinError(PtIndex, DeltaPtRMS);
TH1D* DeltaPhiHist = DeltaPhimaxPurity2simPtHist->ProjectionY("DeltaPhi", PtIndex, PtIndex, "o");
double DeltaPhiMean = DeltaPhiHist->GetMean();
double DeltaPhiRMS = DeltaPhiHist->GetRMS();
DeltaPhi2simPtHist->SetBinContent(PtIndex, DeltaPhiMean);
DeltaPhi2simPtHist->SetBinError(PtIndex, DeltaPhiRMS);
TH1D* DeltaEtaHist = DeltaEtamaxPurity2simPtHist->ProjectionY("DeltaEta", PtIndex, PtIndex, "o");
double DeltaEtaMean = DeltaEtaHist->GetMean();
double DeltaEtaRMS = DeltaEtaHist->GetRMS();
DeltaEta2simPtHist->SetBinContent(PtIndex, DeltaEtaMean);
DeltaEta2simPtHist->SetBinError(PtIndex, DeltaEtaRMS);
}
myEfficiencyHist->AddLast(Efficiency2simPtHist);
myParticleHist->AddLast(Particle2simPtHist);
mySTAHist->AddLast(STA2simPtHist);
myChargeCheckHist->AddLast(InverseChargeRato2simPtHist);
myDeltaPtHist->AddLast(DeltaPt2simPtHist);
}
double minX = 0;
double minY = 0;
double maxX = 110;
double maxY = 40;
TCanvas* myCanvas = new TCanvas("Canvas", "Canvas", 800, 600);
myCanvas->cd();
TPad* myPad = new TPad("Pad", "Pad", 0, 0, 1, 1);
myPad->Draw();
myPad->cd();
((TH1D*)(myParticleHist->At(0)))->SetStats(0);
((TH1D*)(myParticleHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myParticleHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myParticleHist->At(0)))->Draw();
for(int Index = 0; Index < FileNumber; Index++) {
((TH1D*)(mySTAHist->At(Index)))->SetStats(0);
((TH1D*)(mySTAHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(mySTAHist->At(Index)))->Draw("same");
}
TLegend *STALeg = new TLegend(0.6,0.1,0.9,0.3);
STALeg->SetBorderSize(1);
TString LegKey = "ParticleTrack";
STALeg->AddEntry(myParticleHist->At(0), LegKey, "lpf");
for(int Index = 0; Index < FileNumber; Index++) {
LegKey = TypeName[Index];
STALeg->AddEntry(mySTAHist->At(Index), LegKey, "lpf");
}
STALeg->Draw();
string SaveName = OutputPlotNamepreFix + "_STA2simPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
myPad->Clear();
myPad->Update();
double YScale = myPad->GetUymax() / 110.;
((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myEfficiencyHist->At(0)))->SetStats(0);
((TH1D*)(myEfficiencyHist->At(0)))->Scale(YScale);
((TH1D*)(myEfficiencyHist->At(0)))->SetLineColor(kRed);
((TH1D*)(myEfficiencyHist->At(0)))->Draw("same,ah");
for(int Index = 1; Index < FileNumber; Index++) {
((TH1D*)(myEfficiencyHist->At(Index)))->SetStats(0);
((TH1D*)(myEfficiencyHist->At(Index)))->Scale(YScale);
((TH1D*)(myEfficiencyHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(myEfficiencyHist->At(Index)))->Draw("same,ah");
}
myPad->Update();
if(debug) cout << "Y: " << myPad->GetUymax() << endl;
double YAxisMinValue=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetXmin();
double YAxisMaxValue=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetXmax();
int YAxisNBins=((TH1D*)(myEfficiencyHist->At(0)))->GetYaxis()->GetNbins();
TGaxis* YAxis = new TGaxis(myPad->GetUxmin(), myPad->GetUymin(), myPad->GetUxmin(), myPad->GetUymax(), 0, 110, 510, "-R");
YAxis->SetLineColor(kGreen);
YAxis->SetLabelColor(kGreen);
YAxis->SetTitle("Efficiency of STA for simPts");
YAxis->CenterTitle(1);
YAxis->Draw();
double XAxisMinValue=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetXmin();
double XAxisMaxValue=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetXmax();
int XAxisNBins=((TH1D*)(myEfficiencyHist->At(0)))->GetXaxis()->GetNbins();
TGaxis* XAxis = new TGaxis(myPad->GetUxmin(), myPad->GetUymin(), myPad->GetUxmax(), myPad->GetUymin(), XAxisMinValue, XAxisMaxValue, 510, "+L");
XAxis->SetTitle("simPt/Gev");
XAxis->CenterTitle(1);
XAxis->Draw();
TLegend *EffLeg = new TLegend(0.1,0.9,0.4,1.0);
EffLeg->SetBorderSize(1);
for(int Index = 0; Index < FileNumber; Index++) {
TString LegKey = TypeName[Index];
EffLeg->AddEntry(myEfficiencyHist->At(Index), LegKey, "lpf");
}
EffLeg->Draw();
string SaveName = OutputPlotNamepreFix + "_Eff2simPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
((TH1D*)(myDeltaPtHist->At(0)))->SetStats(0);
((TH1D*)(myDeltaPtHist->At(0)))->GetXaxis()->SetTitle("simPt/Gev");
((TH1D*)(myDeltaPtHist->At(0)))->GetXaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(0)))->GetYaxis()->SetTitle("deltPt/simPt");
((TH1D*)(myDeltaPtHist->At(0)))->GetYaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(0)))->SetLineColor(kRed);
((TH1D*)(myDeltaPtHist->At(0)))->Draw("");
for(int Index = 1; Index < FileNumber; Index++) {
((TH1D*)(myDeltaPtHist->At(Index)))->SetStats(0);
//((TH1D*)(myDeltaPtHist->At(Index)))->GetXaxis()->SetTitle("simPt/Gev");
//((TH1D*)(myDeltaPtHist->At(Index)))->GetXaxis()->CenterTitle(1);
//((TH1D*)(myDeltaPtHist->At(Index)))->GetYaxis()->SetTitle("deltPt/simPt");
//((TH1D*)(myDeltaPtHist->At(Index)))->GetYaxis()->CenterTitle(1);
((TH1D*)(myDeltaPtHist->At(Index)))->SetLineColor(kRed+Index);
((TH1D*)(myDeltaPtHist->At(Index)))->Draw("same");
//SaveName = OutputPlotNamepreFix + TypeName[Index] + "DeltaPt" + OutputPlotNameFix;
//myCanvas->SaveAs(SaveName.c_str());
}
TLegend *PtLeg = new TLegend(0.6,0.8,0.9,0.9);
PtLeg->SetBorderSize(1);
for(int Index = 0; Index < FileNumber; Index++) {
TString LegKey = TypeName[Index];
PtLeg->AddEntry(myDeltaPtHist->At(Index), LegKey, "lpf");
}
PtLeg->Draw();
SaveName = OutputPlotNamepreFix + "_DeltaPt" + OutputPlotNameFix;
myCanvas->SaveAs(SaveName.c_str());
}
void balanceMetVsAj(TString infname,
TString insrc, TString metType = "",bool drawLegend = false,
bool drawSys = true
)
{
// ===========================================================
// Get Input
// ===========================================================
TFile *inf = new TFile(infname);
// ===========================================================
// Analysis Setup
// ===========================================================
Int_t plotLayer=10; // 0 only >0.5, 1 >0.5 and highpt, 10 ~ all
const int nBin = 5;
double bins[nBin+1] = {0.5,1.0,2,4,8,1000};
const int nBinAj = 4;
double ajBins[nBinAj+1] = {0.0001,0.11,0.22,0.33,0.49999};
cout << infname << endl;
TH1D *ppos[nBin+1];
TH1D *pneg[nBin+1];
TH1D *pe[nBin+1];
// =================================
// Get Weighted Mean for each Aj bin
// =================================
for (int i=0;i<nBin+1;i++)
{
pe[i]=new TH1D(Form("p%d",i),"",nBinAj,ajBins);
for (int a=0; a<nBinAj; ++a) {
TString hname = Form("%s_mptx%s_merge%d_%dSigAll",insrc.Data(),metType.Data(),i,a);
TH1D * hMpt = (TH1D*)inf->Get(hname);
// cout << hname << " Aj bin: " << a+1 << " mean: " << hMpt->GetMean() << endl;
pe[i]->SetBinContent(a+1,hMpt->GetMean());
pe[i]->SetBinError(a+1,hMpt->GetRMS()/sqrt(hMpt->GetEntries()));
}
}
StackHistograms(nBin,pe,ppos,pneg,nBinAj);
TH1D *pall=pe[nBin];
pall->SetXTitle("A_{J}");
pall->SetYTitle("<#slash{p}_{T}^{#parallel}> (GeV/c)");
pall->GetXaxis()->CenterTitle();
pall->GetYaxis()->CenterTitle();
pall->GetXaxis()->SetLabelSize(22);
pall->GetXaxis()->SetLabelFont(43);
pall->GetXaxis()->SetTitleSize(24);
pall->GetXaxis()->SetTitleFont(43);
pall->GetYaxis()->SetLabelSize(22);
pall->GetYaxis()->SetLabelFont(43);
pall->GetYaxis()->SetTitleSize(24);
pall->GetYaxis()->SetTitleFont(43);
pall->GetXaxis()->SetTitleOffset(1.8);
pall->GetYaxis()->SetTitleOffset(2.4);
pall->SetNdivisions(505);
pall->SetAxisRange(-59.9,59.9,"Y");
pall->SetMarkerSize(1);
pall->SetMarkerColor(kBlack);
pall->SetMarkerStyle(kFullCircle);
pall->Draw("E");
float addSys = 0;
if ( drawSys==1) addSys=0; // No sys error at this moment
// ====================
// Finally Draw
// ====================
for (int i=0;i<nBin;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nBin-1) continue;
ppos[i]->SetLineWidth(1);
ppos[i]->Draw("hist same");
pneg[i]->SetLineWidth(1);
pneg[i]->Draw("hist same");
// PrintHistogram(ppos[i]);
// PrintHistogram(pneg[i]);
}
// ====================
// Draw Statistical Error bars
// ====================
for (int i=0;i<nBin;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nBin-1) continue;
if ( i==0 ) drawErrorShift(ppos[i],-0.016, addSys);
if ( i==1 || i==4) drawErrorShift(ppos[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(ppos[i],0.008,addSys);
if ( i==3 ) drawErrorShift(ppos[i],0.016,addSys);
if ( i==0 ) drawErrorShift(pneg[i],-0.016, addSys);
if ( i==1 || i==4) drawErrorShift(pneg[i],-0.008,addSys);
if ( i==2 ) drawErrorShift(pneg[i],0.008,addSys);
if ( i==3 ) drawErrorShift(pneg[i],0.016,addSys);
}
pall->Draw("E same");
// PrintHistogram(pall);
// ====================
// Draw Systematic Errors
// ====================
if (drawSys == 1) {
for(int i = 0; i < nBinAj; ++i){
double x = pall->GetBinCenter(i+1);
double y = pall->GetBinContent(i+1);
// Quote the difference between GEN and RECO in >8 Bin (20%) before adjusting eff as systematics
double errReco = -pe[nBin-1]->GetBinContent(i+1)*0.2;
double errBck = 3.0; // compare HYDJET+SIG to SIG
double err = sqrt(errReco*errReco+errBck*errBck);
DrawTick(y,err,err,x,1,0.02,1);
}
}
// ====================
// Draw Legend
// ====================
TLegend *leg = new TLegend(0.10,0.68,0.70,0.96);
leg->SetFillStyle(0);
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(16);
leg->AddEntry(pall,Form("> %.1f GeV/c",bins[0]),"p");
for (int i=0;i<nBin;++i) {
if (plotLayer==0) continue;
if (plotLayer==1&&i!=nBin-1) continue;
if (i!=nBin-1){
leg->AddEntry(ppos[i],Form("%.1f - %.1f GeV/c",bins[i],bins[i+1]),"f");
} else {
leg->AddEntry(ppos[i],Form("> %.1f GeV/c",bins[i]),"f");
}
}
if (drawLegend) leg->Draw();
TLine * l0 = new TLine(0,0,0.5,0);
l0->SetLineStyle(2);
l0->Draw();
TLine * l1 = new TLine(0.0001,-10,0.0001,10);
l1->Draw();
}
void advancedNoiseAnalysis( unsigned int runNumber, unsigned int loop = 1) {
string inputFileName = "./histo/run00" + toString( runNumber ) + "-ped-histo.root";
string outputFileName = "./histo/run00" + toString( runNumber ) + "-adv-noise.root";
// before opening the input and the output files, try to see if they
// are not opened yet and in case close them before continue
TList * listOfOpenedFile = (TList*) gROOT->GetListOfFiles();
for ( int i = 0; i < listOfOpenedFile->GetSize() ; ++i ) {
TFile * file = (TFile*) listOfOpenedFile->At( i ) ;
TString fileName(file->GetName());
TString inputFileName1( inputFileName.c_str() );
TString outputFileName1( outputFileName.c_str() );
if ( ( fileName.Contains( inputFileName1 ) ) ||
( inputFileName1.Contains( fileName ) ) ||
( fileName.Contains( outputFileName1 ) ) ||
( outputFileName1.Contains( fileName ) ) ) {
cout << "Closing " << fileName << " before reopen " << endl;
file->Close();
}
}
// close also all the previously opened canvas
TList * listOfOpenedCanvas = (TList*) gROOT->GetListOfCanvases();
for ( int i = 0 ; i < listOfOpenedCanvas->GetSize() ; ++i ) {
TCanvas * canvas = (TCanvas*) listOfOpenedCanvas->At( i );
TString canvasName2 = canvas->GetName();
if ( canvasName2.Contains( "det" ) ) {
canvas->Close();
}
}
// now safely open the file
TFile * inputFile = TFile::Open( inputFileName.c_str() ) ;
TFile * outputFile = TFile::Open( outputFileName.c_str(), "RECREATE") ;
TList * outputHistoList = new TList;
// look into the inputFile for a folder named
string pedeProcessorFolderName = "PedestalAndNoiseCalculator";
TDirectoryFile * pedeProcessorFolder = (TDirectoryFile*) inputFile->Get( pedeProcessorFolderName.c_str() );
if ( pedeProcessorFolder == 0 ) {
cerr << "No pedestal processor folder found in file " << inputFileName << endl;
return ;
}
// this folder should contain one folder for each loop.
string loopFolderName = "loop-" + toString( loop );
TDirectoryFile * loopFolder = (TDirectoryFile *) pedeProcessorFolder->Get( loopFolderName.c_str() );
if ( loopFolder == 0 ) {
cerr << "No " << loopFolderName << " found in file " << inputFileName << endl;
return ;
}
// guess the number of sensors from the number of subfolder in the loopfolder
size_t nDetector = loopFolder->GetListOfKeys()->GetSize();
cout << "This file contains " << nDetector << " detectors" << endl;
// prepare arrays to store the mean and the rms of the noise distribution
if ( noiseMean == NULL ) {
delete [] noiseMean;
noiseMean = NULL;
}
if ( noiseRMS == NULL ) {
delete [] noiseRMS;
noiseRMS = NULL;
}
if ( channel == NULL ) {
delete [] channel;
channel = NULL;
}
noiseMean = new double[ nDetector * kNChan ];
noiseRMS = new double[ nDetector * kNChan ];
channel = new double[ kNChan ];
string canvasName = "comparison";
string canvasTitle = "Noise comparison";
TCanvas * comparisonCanvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
comparisonCanvas->Divide(1,2);
TPad * topPad = (TPad*) comparisonCanvas->cd(1);
topPad->Divide( nDetector );
TPad * middlePad = (TPad *) comparisonCanvas->cd(2);
middlePad->Divide( kNChan );
// for each detector we have to get the noise map and to prepare 4
// separe histos and maps
for ( unsigned int iDetector = 0; iDetector < nDetector; iDetector++ ) {
// get the noise map.
string noiseMapName = "detector-" + toString( iDetector ) ;
noiseMapName += "/NoiseMap-d" + toString( iDetector ) ;
noiseMapName += "-l" + toString( loop ) ;
TH2D * noiseMap = ( TH2D* ) loopFolder->Get( noiseMapName.c_str() );
// create a folder in the output file
TDirectory * subfolder = outputFile->mkdir( string( "detector_" + toString( iDetector ) ).c_str(),
string( "detector_" + toString( iDetector ) ).c_str()
);
subfolder->cd();
string canvasName = "det" + toString( iDetector );
string canvasTitle = "Detector " + toString( iDetector );
TCanvas * canvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
canvas->Divide( kNChan, 2 );
// ok now start the loop on channels
for ( size_t iChan = 0 ; iChan < kNChan ; ++iChan ) {
if ( iDetector == 0 ) channel[iChan] = iChan - 0.5;
string tempName = "NoiseMap_d" + toString( iDetector ) + "_l" + toString( loop ) + "_ch" + toString( iChan ) ;
string tempTitle = "NoiseMap Det. " + toString( iDetector ) + " - Ch. " + toString( iChan ) ;
TH2D * noiseMapCh = new TH2D ( tempName.c_str() , tempTitle.c_str(),
kXPixel / kNChan , -0.5 + xLimit[ iChan ] , -0.5 + xLimit[ iChan + 1 ],
kYPixel, -0.5, -0.5 + kYPixel );
noiseMapCh->SetXTitle("X [pixel]");
noiseMapCh->SetYTitle("Y [pixel]");
noiseMapCh->SetZTitle("Noise [ADC]");
noiseMapCh->SetStats( false );
outputHistoList->Add( noiseMapCh ) ;
tempName = "NoiseDist_d" + toString( iDetector ) + "_l" + toString( loop ) + "_ch" + toString( iChan ) ;
tempTitle = "NoiseDist Det. " + toString( iDetector ) + " - Ch. " + toString( iChan ) ;
TH1D * noiseDistCh = new TH1D( tempName.c_str(), tempTitle.c_str(), 50, 0., 10. );
noiseDistCh->SetXTitle("Noise [ADC]");
noiseDistCh->SetLineColor( kColor[iDetector] );
noiseDistCh->SetLineStyle( iChan + 2 );
noiseDistCh->SetLineWidth( 2 );
outputHistoList->Add( noiseDistCh );
// let's start looping on pixels now
for ( size_t yPixel = 1 ; yPixel <= kYPixel ; ++yPixel ) {
for ( size_t xPixel = xLimit[ iChan ] + 1; xPixel <= xLimit[ iChan +1 ] ; ++xPixel ) {
double noise = noiseMap->GetBinContent( xPixel , yPixel );
noiseMapCh->Fill( xPixel - 1 , yPixel - 1, noise );
noiseDistCh->Fill( noise );
}
}
canvas->cd( iChan + 1 ) ;
noiseMapCh->Draw("colz");
canvas->cd( iChan + kNChan + 1 );
noiseDistCh->Draw();
topPad->cd( iDetector + 1 );
if ( iChan == 0 ) {
noiseDistCh->Draw();
} else {
noiseDistCh->Draw("same");
}
middlePad->cd( iChan + 1 );
if ( iDetector == 0 ) {
noiseDistCh->Draw();
} else {
noiseDistCh->Draw("same");
}
noiseMean[ kNChan * iDetector + iChan ] = noiseDistCh->GetMean();
noiseRMS[ kNChan * iDetector + iChan ] = noiseDistCh->GetRMS();
}
canvas->Write();
}
canvasName = "summary";
canvasTitle = "Noise summary";
TCanvas * summaryCanvas = new TCanvas( canvasName.c_str(), canvasTitle.c_str(), 1000, 500 );
summaryCanvas->SetGridx(1);
TLegend * legend = new TLegend(0.5, 4.8, 1.5, 4.3,"","br");;
for ( size_t iDetector = 0 ; iDetector < nDetector ; ++iDetector ) {
TGraphErrors * gr = new TGraphErrors( kNChan, channel, &noiseMean[ iDetector * kNChan ], NULL, &noiseRMS[ iDetector * kNChan ] );
gr->SetName( string( "NoisePerChannel_d" + toString( iDetector )).c_str());
gr->SetTitle(string("Detector " + toString( iDetector )).c_str());
gr->GetXaxis()->SetTitle("Channel #");
gr->GetYaxis()->SetTitle("Noise [ADC]");
gr->GetXaxis()->SetNdivisions( 5 );
gr->GetXaxis()->SetLabelSize( 0 );
gr->SetMarkerStyle( iDetector + 1 );
gr->SetMarkerColor( kColor[iDetector] );
gr->SetLineColor( kColor[iDetector] );
gr->SetLineWidth( 2 );
legend->AddEntry( gr, string("Detector " + toString( iDetector )).c_str(), "LP");
if ( iDetector == 0 ) {
gr->Draw("ALP");
} else {
gr->Draw("LP");
}
}
legend->Draw();
for ( size_t iChan = 0 ; iChan < kNChan ; ++iChan ) {
TPaveLabel * label = new TPaveLabel( iChan - 0.75 , 3.2 , iChan -0.25 , 3, string("Ch " + toString( iChan ) ).c_str());
label->Draw();
}
summaryCanvas->Write();
comparisonCanvas->Write();
outputHistoList->Write();
}
// ----------------------------------
//======= Doing real fit and producing Fit/RMS resolution histograms =======
void projectAndFit(TH2F* th2, TH1F*& hFit, TH1F*& hRMS,int tailSign,string name, bool variableBinning,bool wait){
TCanvas* canv = new TCanvas("tmp","tmp",500,500); canv->cd();
//static double sigma;
int xBins = th2->GetNbinsX();
//cout << "xBins: " << xBins << endl;
//for resolution vs pt
if(variableBinning){
hFit = new TH1F("tmp","tmp",xBins,th2->GetXaxis()->GetXbins()->GetArray());
hRMS = new TH1F("tmp2","tmp2",xBins,th2->GetXaxis()->GetXbins()->GetArray());
}else{
//for resolution vs eta
hFit = new TH1F("tmp","tmp",xBins,th2->GetBinLowEdge(1),th2->GetBinLowEdge(xBins+1));
hRMS = new TH1F("tmp2","tmp2",xBins,th2->GetBinLowEdge(1),th2->GetBinLowEdge(xBins+1));
}
for(int i=1;i<=xBins; i++){
cout << "i,xLeft: " << i << " , " << th2->GetBinLowEdge(i) << endl;
TH1D* proj = th2->ProjectionY("prova",i,i+1);
if(proj->GetEntries()<20){
//cout << "N entries < 20. Should I continue? " << endl; Wait();
hRMS->SetBinContent(i,0);
hRMS->SetBinError(i,0);
hFit->SetBinContent(i,0);
hFit->SetBinError(i,0);
delete proj;
continue;
}
double rms = proj->GetRMS();
double tmpMean;
double tmpSigma;
// quick fit with standard gauss
double leftBound,rightBound;
if(tailSign<0){
leftBound = -1.5*rms;
rightBound = +1.0*rms;
cout << "negative tailSign gives: " << leftBound << " , " << rightBound << endl;
} else if(tailSign>0){
leftBound = -1.0*rms;
rightBound = +1.5*rms;
cout << "positive tailSign gives: " << leftBound << " , " << rightBound << endl;
}else{
leftBound = -1.0*rms;
rightBound = +1.0*rms;
cout << "null tailSign gives: " << leftBound << " , " << rightBound << endl;
}
TF1* f1 = new TF1("f1","gaus",leftBound,rightBound);
TFitResultPtr r = proj->Fit(f1,"S M R L");
proj->Draw(); gPad->Update();
stringstream outputName;
if(i<10) outputName << name << "_raw_bin_" << "0" << i ; else outputName << name << "_bin" << i ;
//printCanvas(canv,outputName.str(),1);
if(wait) Wait();
tmpMean = r->Parameter(1);
tmpSigma = r->Parameter(2);
double xMin,xMax;
xMin = tmpMean - tmpSigma*5.;
xMax = tmpMean + tmpSigma*5.;
RooRealVar x("x","x",xMin,xMax) ;
double meanRangeMin;
double meanRangeMax;
if(tmpMean<0){
meanRangeMin = 1.6*tmpMean;
meanRangeMax = 0.1*tmpMean;
}else{
meanRangeMin = 0.1*tmpMean;
meanRangeMax = 1.6*tmpMean;
}
RooRealVar meanRoo("mean","mean of gaussian",tmpMean,meanRangeMin,meanRangeMax) ;
RooRealVar sigmaRoo("sigma","width of gaussian",tmpSigma,tmpSigma*0.5,tmpSigma*1.5);
RooRealVar a("a","a",3.,2.,10.);
RooRealVar aDx("aDx","aDx",3.,2.,10.);
RooRealVar n("n","n",5.,0.,10.);
RooRealVar nDx("nDx","nDx",5.,0.,10.);
if(tailSign!=0){
if(tailSign<0){
a.setVal(1); a.setMin(0.5); a.setMax(3.);
}else{
aDx.setVal(1); aDx.setMin(0.5); aDx.setMax(3.);
}
}
RooDoubleCB func1("cb","cb PDF",x,meanRoo,sigmaRoo,a,n,aDx,nDx) ;
RooPlot* xframe = x.frame(Title("Gaussian p.d.f.")) ;
RooDataHist dh("dh","dh",x,Import(*proj));
func1.fitTo(dh);
dh.plotOn(xframe);
func1.plotOn(xframe) ;
//
xframe->Draw(); gPad->Update();
stringstream outputName2;
if(i<10) outputName2 << name << "_bin" << "0" << i ; else outputName2 << name << "_bin" << i ;
//printCanvas(canv,outputName2.str(),1);
if(wait) Wait();
tmpMean = meanRoo.getVal();
tmpSigma = sigmaRoo.getVal();
double sigma;
double sigmaErr;
sigma= sigmaRoo.getVal();
sigmaErr = sigmaRoo.getError();
/*
proj->SetAxisRange(-5*sigma,5*sigma);
rms = proj->GetRMS();
double rmsErr = proj->GetRMSError();
hFit->SetBinContent(i,sigma);
hFit->SetBinError(i,sigmaErr);
hRMS->SetBinContent(i,rms);
hRMS->SetBinError(i,rmsErr);
delete proj;
*/
// ---- NEW IMPLEMENTATION
double fullIntegral = proj->Integral(0,proj->GetNbinsX()+1);
//double fullIntegral = proj->Integral();
//double fullAverage = proj->GetMean();
double step = proj->GetBinWidth(1);;
int peakBin = proj->FindBin(tmpMean);
//double range2nd(0.954);
double range2nd(0.90);
//
bool found68(false);
double range68(0), uncert68(0.);
double range95(0), uncert95(0.);
for(int j=0; j<proj->GetNbinsX()/2 ; j++){
if((peakBin-j)<1 || (peakBin+j) > proj->GetNbinsX()) break;
double fraction = proj->Integral(peakBin-j,peakBin+j)/fullIntegral;
if(fraction>0.682 && !found68){ //2sigma range
found68=true;
range68 = step*(2*j+1)*0.5;
double averageBinContent = (proj->GetBinContent(peakBin-j) + proj->GetBinContent(peakBin+j))/2.0 ;
uncert68 = sqrt(0.682*(1-0.682)/fullIntegral)/(averageBinContent/step/fullIntegral);
}
if(fraction>range2nd){ //3sigma range
range95 = step*(2*j+1)*0.5;
double averageBinContent = (proj->GetBinContent(peakBin-j) + proj->GetBinContent(peakBin+j))/2.0 ;
uncert95 = sqrt(range2nd*(1-range2nd)/fullIntegral)/(averageBinContent/step/fullIntegral);
break;
}
}
// --- OLD IMPLEMENTATION
/*
double fullIntegral = proj->Integral();
double step = sigma/20.;
//
double range68(0);
for(int j=2; j<20000;j++){
xMin = tmpMean - step*j;
xMax = tmpMean + step*j;
proj->SetAxisRange(xMin,xMax);
double fraction = proj->Integral()/fullIntegral;
if(fraction>0.682){ //2sigma range
range68 = step*j;
break;
}
}
//
double range95(0);
for(int j=2; j<20000;j++){
xMin = tmpMean - step*j;
xMax = tmpMean + step*j;
proj->SetAxisRange(xMin,xMax);
double fraction = proj->Integral()/fullIntegral;
if(fraction>range2nd){ //2sigma range
range95 = step*j;
break;
}
}
uncert68 = step;
uncert95 = step;
*/
//--------
//hFit->SetBinContent(i,sigma);
//hFit->SetBinError(i,sigmaErr);
hFit->SetBinContent(i,range68);
hFit->SetBinError(i,uncert68);
hRMS->SetBinContent(i,range95);
hRMS->SetBinError(i,uncert95);
delete proj;
}
hFit->SetDirectory(gROOT);
hRMS->SetDirectory(gROOT);
delete canv;
//hFit->Draw();gPad->Update(); Wait();
}