double BTagEffService::GetEfficiency(BTagger const &bTagger, double pt, double eta,
unsigned flavour) const
{
// Find the appropriate efficiency histogram. Load it if needed
auto histGroupIt = effHists.find(bTagger);
TH2 *hist = nullptr;
if (histGroupIt == effHists.end())
{
// Try to load histograms for the given b-tagger
const_cast<BTagEffService *>(this)->LoadEfficiencies(bTagger);
hist = effHists.at(bTagger).at(flavour).get();
}
else
hist = histGroupIt->second.at(flavour).get();
// Make sure the histogram exists
if (not hist)
{
std::ostringstream message;
message << "BTagEffService[\"" << GetName() << "\"]::GetEfficiency: " <<
"Failed to find an efficiency histogram for b tagger " << bTagger.GetTextCode() <<
", efficiency label \"" << curEffLabel << "\", jet flavour " << flavour << ".";
throw std::runtime_error(message.str());
}
// Return the efficiency
return hist->GetBinContent(hist->FindFixBin(pt, eta));
}
void HcalElectronicsSelector::fill(const MyElectronicsId& id, double value) {
TH2* h = m_hist;
int htrChan=(id.fiber-1)*3+1+id.fiberChan;
double fpga= (id.tb==1)?(id.Slot+0.5):(id.Slot);
h->SetBinContent(h->FindBin(fpga*1.0,htrChan*1.0,0.0),value);
}
void QAvertex(const Char_t *fdata, const Char_t *fmc)
{
style();
TFile *fdtin = TFile::Open(fdata);
TList *ldtin = (TList *)fdtin->Get("clist");
TH2 *hdtin = (TH2 *)ldtin->FindObject("zv");
TH1 *hdt = (TH1 *)ldtin->FindObject("zvNoSel");
SetHistoStyle(hdt, 20, kRed+1);
hdt->Scale(1. / hdt->Integral());
TH1 *hdt0010 = hdtin->ProjectionX("hdt0010", 1, 4);
SetHistoStyle(hdt0010, 20, kRed+1);
hdt0010->Scale(1. / hdt0010->Integral());
TH1 *hdt7080 = hdtin->ProjectionX("hdt7080", 11, 11);
SetHistoStyle(hdt7080, 25, kAzure-3);
hdt7080->Scale(1. / hdt7080->Integral());
TFile *fmcin = TFile::Open(fmc);
TList *lmcin = (TList *)fmcin->Get("clist");
TH1 *hmc = (TH1 *)lmcin->FindObject("zvNoSel");
SetHistoStyle(hmc, 25, kAzure-3);
hmc->Scale(1. / hmc->Integral());
TCanvas *c = new TCanvas("cVertex", "cVertex", 800, 800);
TH1 * hfr = c->DrawFrame(-20., 0., 20., 0.1);
hfr->SetTitle(";#it{z}_{vtx};");
hdt0010->Draw("same");
hdt7080->Draw("same");
TLegend *legend = new TLegend(0.20, 0.18+0.60, 0.50, 0.30+0.60);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(hdt0010, "0-10%", "p");
legend->AddEntry(hdt7080, "70-80%", "p");
legend->Draw("same");
c->SaveAs(canvasPrefix+"vertex.pdf");
TCanvas *c1 = new TCanvas("cVertexDataMC", "cVertexDataMC", 800, 800);
hfr = c1->DrawFrame(-20., 0., 20., 0.1);
hfr->SetTitle(";#it{z}_{vtx};");
hdt->Draw("same");
hmc->Draw("same");
legend = new TLegend(0.20, 0.18+0.60, 0.50, 0.30+0.60);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(hdt, "data", "p");
legend->AddEntry(hmc, "Monte Carlo", "p");
legend->Draw("same");
c1->SaveAs(canvasPrefix+"vertexDataMC.pdf");
//return 0;
}
void plot_corr(TH2* phin, float cmin, float cmax) {
ostringstream ssnam;
ssnam << phin->GetName() << "_" << cmin << "_" << cmax;
new TCanvas;
TH2* ph = phin->Clone(ssnam.str().c_str());
ph->GetXaxis()->SetRangeUser(cmin, cmax);
ph->GetYaxis()->SetRangeUser(cmin, cmax);
ph->Draw("colz");
addaxis();
}
void QAoccupancy(const Char_t *fdata, const Char_t *fmc)
{
style();
TFile *fdtin = TFile::Open(fdata);
TList *ldtin = (TList *)fdtin->Get("clist");
TH2 *hdtin = (TH2 *)ldtin->FindObject("NClustersSPD2");
TProfile *pdtin = hdtin->ProfileY("pdtin_clusters");
pdtin->SetMarkerStyle(20);
pdtin->SetMarkerSize(2);
pdtin->SetMarkerColor(kAzure-3);
TFile *fmcin = TFile::Open(fmc);
TList *lmcin = (TList *)fmcin->Get("clist");
TH2 *hmcin = (TH2 *)lmcin->FindObject("NClustersSPD2");
TProfile *pmcin = hmcin->ProfileY("pmcin_clusters");
pmcin->SetMarkerStyle(25);
pmcin->SetMarkerSize(2);
pmcin->SetMarkerColor(kRed+1);
TCanvas *c = new TCanvas("cOccupancy", "cOccupancy", 800, 800);
c->SetLogy();
TH1 * hfr = c->DrawFrame(-0.5, 2., 10.5, 500.);
DrawBinLabelsX(hfr, kTRUE);
hfr->SetTitle(";;#LT#it{N}_{clusters,SPD-1}#GT");
pdtin->DrawCopy("same");
pmcin->DrawCopy("same");
TLegend *legend = new TLegend(0.20, 0.18, 0.50, 0.30);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(pdtin, "data", "pl");
legend->AddEntry(pmcin, "Monte Carlo", "pl");
legend->Draw("same");
c->SaveAs(canvasPrefix+"occupancy.pdf");
return;
TCanvas *cr = new TCanvas("cOccupancyr", "cOccupancyr", 800, 800);
// hfr = cr->DrawFrame(-0.5, 0.75, 10.5, 1.25);
// DrawBinLabelsX(hfr, kTRUE);
// hfr->SetTitle(";;#LT#it{N}_{clusters,SPD-1}#GT ratio");
pdtin->SetLineColor(kAzure-3);
pdtin->SetLineWidth(3);
pdtin->Divide(pmcin);
pdtin->Draw("same,histo");
legend = new TLegend(0.505025, 0.760673, 0.805276, 0.930142);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(pdtin, "data / Monte Carlo", "l");
legend->Draw("same");
cr->SaveAs(canvasPrefix+"occupancyr.pdf");
}
void DynamicExec()
{
// Example of function called when a mouse event occurs in a pad.
// When moving the mouse in the canvas, a second canvas shows the
// projection along X of the bin corresponding to the Y position
// of the mouse. The resulting histogram is fitted with a gaussian.
// A "dynamic" line shows the current bin position in Y.
// This more elaborated example can be used as a starting point
// to develop more powerful interactive applications exploiting CINT
// as a development engine.
//
// Author: Rene Brun
TObject *select = gPad->GetSelected();
if(!select) return;
if (!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return;}
TH2 *h = (TH2*)select;
gPad->GetCanvas()->FeedbackMode(kTRUE);
//erase old position and draw a line at current position
int pyold = gPad->GetUniqueID();
int px = gPad->GetEventX();
int py = gPad->GetEventY();
float uxmin = gPad->GetUxmin();
float uxmax = gPad->GetUxmax();
int pxmin = gPad->XtoAbsPixel(uxmin);
int pxmax = gPad->XtoAbsPixel(uxmax);
if(pyold) gVirtualX->DrawLine(pxmin,pyold,pxmax,pyold);
gVirtualX->DrawLine(pxmin,py,pxmax,py);
gPad->SetUniqueID(py);
Float_t upy = gPad->AbsPixeltoY(py);
Float_t y = gPad->PadtoY(upy);
//create or set the new canvas c2
TVirtualPad *padsav = gPad;
TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
if(c2) delete c2->GetPrimitive("Projection");
else c2 = new TCanvas("c2","Projection Canvas",710,10,700,500);
c2->SetGrid();
c2->cd();
//draw slice corresponding to mouse position
Int_t biny = h->GetYaxis()->FindBin(y);
TH1D *hp = h->ProjectionX("",biny,biny);
hp->SetFillColor(38);
char title[80];
sprintf(title,"Projection of biny=%d",biny);
hp->SetName("Projection");
hp->SetTitle(title);
hp->Fit("gaus","ql");
hp->GetFunction("gaus")->SetLineColor(kRed);
hp->GetFunction("gaus")->SetLineWidth(6);
c2->Update();
padsav->cd();
}
TH2* RootWriter::CreateTH2(Histogram2D* h)
{
const Axis& xax = h->GetAxisX(), yax = h->GetAxisY();
const int xchannels = xax.GetBinCount();
const int ychannels = yax.GetBinCount();
TH2* mat = new TH2F( h->GetName().c_str(), h->GetTitle().c_str(),
xchannels, xax.GetLeft(), xax.GetRight(),
ychannels, yax.GetLeft(), yax.GetRight() );
mat->SetOption( "colz" );
mat->SetContour( 64 );
TAxis* rxax = mat->GetXaxis();
rxax->SetTitle(xax.GetTitle().c_str());
rxax->SetTitleSize(0.03);
rxax->SetLabelSize(0.03);
TAxis* ryax = mat->GetYaxis();
ryax->SetTitle(yax.GetTitle().c_str());
ryax->SetTitleSize(0.03);
ryax->SetLabelSize(0.03);
ryax->SetTitleOffset(1.3);
TAxis* zax = mat->GetZaxis();
zax->SetLabelSize(0.025);
for(int iy=0; iy<ychannels+2; ++iy)
for(int ix=0; ix<xchannels+2; ++ix)
mat->SetBinContent(ix, iy, h->GetBinContent(ix, iy));
mat->SetEntries( h->GetEntries() );
return mat;
}
//________________________________________________________________
void KVCanvas::DynamicZoom(Int_t Sign, Int_t px, Int_t py)
{
// Zoom in or out of histogram with mouse wheel
// Info("DynamicZoom","px=%d py=%d",px,py);
if (!fSelected) return;
TH2* TheHisto = (TH2*) FindHisto();//fSelected;
Double_t percent = 0.15 - Sign * 0.05;
Int_t dX = 0;
Int_t dY = 0;
Double_t ppx = AbsPixeltoX(px);
Double_t ppy = AbsPixeltoY(py);
TAxis* ax = TheHisto->GetXaxis();
Int_t NbinsXtmp = ax->GetNbins();
Int_t X0tmp = ax->GetFirst();
Int_t X1tmp = ax->GetLast();
Int_t step = TMath::Min(TMath::Max(1, (Int_t)(percent * (X1tmp - X0tmp))), NbinsXtmp / 2);
step *= Sign;
X0tmp = TMath::Min(TMath::Max(X0tmp + step, 1), X1tmp - step);
X1tmp = TMath::Max(TMath::Min(X1tmp - step, NbinsXtmp), X0tmp);
if (X0tmp >= X1tmp) X0tmp = X1tmp - 1;
if (Sign > 0) dX = (Int_t)(X0tmp + (X1tmp - X0tmp) * 0.5 - ax->FindBin(ppx));
if ((X0tmp - dX) < 0) ax->SetRange(0, X1tmp - X0tmp);
else if ((X1tmp - dX) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (X1tmp - X0tmp), ax->GetNbins());
else ax->SetRange(X0tmp - dX, X1tmp - dX);
ax = TheHisto->GetYaxis();
Int_t NbinsYtmp = ax->GetNbins();
Int_t Y0tmp = ax->GetFirst();
Int_t Y1tmp = ax->GetLast();
step = TMath::Min(TMath::Max(1, (Int_t)(percent * (Y1tmp - Y0tmp))), NbinsYtmp / 2);
step *= Sign;
Y0tmp = TMath::Min(TMath::Max(Y0tmp + step, 1), Y1tmp - step);
Y1tmp = TMath::Max(TMath::Min(Y1tmp - step, NbinsYtmp), Y0tmp);
if (Y0tmp >= Y1tmp) Y0tmp = Y1tmp - 1;
if (Sign > 0) dY = (Int_t)(Y0tmp + (Y1tmp - Y0tmp) * 0.5 - ax->FindBin(ppy));
if ((Y0tmp - dY) < 0) ax->SetRange(0, Y1tmp - Y0tmp);
else if ((Y1tmp - dY) > ax->GetNbins()) ax->SetRange(ax->GetNbins() - (Y1tmp - Y0tmp), ax->GetNbins());
else ax->SetRange(Y0tmp - dY, Y1tmp - dY);
Modified();
Update();
return;
}
void
HistoCompare::PVCompute(TH2 * oldHisto , TH2 * newHisto , TText * te )
{
myoldHisto2 = oldHisto;
mynewHisto2 = newHisto;
myte = te;
Double_t *res ;
Double_t mypv = myoldHisto2->Chi2Test(mynewHisto2,"WW",res);
TString title = myoldHisto2->GetName();
printRes(title, mypv, myte);
return;
}
void exec2()
{
if (!gPad) {
Error("exec2", "gPad is null, you are not supposed to run this macro");
return;
}
TObject *select = gPad->GetSelected();
if(!select) return;
if (!select->InheritsFrom(TH2::Class())) {gPad->SetUniqueID(0); return;}
gPad->GetCanvas()->FeedbackMode(kTRUE);
//erase old position and draw a line at current position
int pyold = gPad->GetUniqueID();
int px = gPad->GetEventX();
int py = gPad->GetEventY();
float uxmin = gPad->GetUxmin();
float uxmax = gPad->GetUxmax();
int pxmin = gPad->XtoAbsPixel(uxmin);
int pxmax = gPad->XtoAbsPixel(uxmax);
if(pyold) gVirtualX->DrawLine(pxmin,pyold,pxmax,pyold);
gVirtualX->DrawLine(pxmin,py,pxmax,py);
gPad->SetUniqueID(py);
Float_t upy = gPad->AbsPixeltoY(py);
Float_t y = gPad->PadtoY(upy);
//create or set the new canvas c2
TVirtualPad *padsav = gPad;
TCanvas *c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("c2");
if(c2) delete c2->GetPrimitive("Projection");
else c2 = new TCanvas("c2");
c2->cd();
//draw slice corresponding to mouse position
TH2 *h = (TH2*)select;
Int_t biny = h->GetYaxis()->FindBin(y);
TH1D *hp = h->ProjectionX("",biny,biny);
char title[80];
sprintf(title,"Projection of biny=%d",biny);
hp->SetName("Projection");
hp->SetTitle(title);
hp->Fit("gaus","ql");
c2->Update();
padsav->cd();
}
void
polar()
{
TCanvas *c1 = new TCanvas("c1","c1",500,500);
TGraphPolar * grP1 = new TGraphPolar();
grP1->SetTitle("TGraphPolar example");
for (Int_t i = 0; i < 2; i++) {
grP1->SetPoint(i, (i+1) * TMath::Pi() / 4, (i+1) * 0.05);
grP1->SetPointError(i, 9*TMath::Pi()/180, 0.0);
Double_t rr = grP1->GetY()[i];
Double_t tt = grP1->GetX()[i];
Double_t x = rr * TMath::Cos(tt);
Double_t y = rr * TMath::Sin(tt);
Printf("(x,y)=(%f,%f)", x, y);
}
Double_t r = 1;
TH2* frame = new TH2F("frame", "Frame", 100, -r,r, 100, -r, r);
frame->Draw();
grP1->SetMarkerStyle(1);
grP1->SetMarkerSize(1.);
grP1->SetMarkerColor(4);
grP1->SetLineColor(4);
grP1->SetLineWidth(3);
grP1->SetFillColor(kRed+1);
grP1->SetFillStyle(3001);
grP1->Draw("PNEF same");
// grP1->Draw("APNEF");
// Update, otherwise GetPolargram returns 0
c1->Update();
TGraphPolargram* gram = grP1->GetPolargram();
gram->SetLineWidth(0);
// gram->SetLineColor(kWhite);
gram->SetNdivPolar(20);
gram->SetNdivRadial(10);
gram->SetTextSize(0);
gram->SetRadialLabelSize(0);
gram->SetPolarLabelSize(0);
gram->SetAxisAngle(9*TMath::Pi()/180);
gram->SetTwoPi();
gram->SetToRadian();
c1->SetGridx();
c1->SetGridy();
c1->Update();
}
void format1Dhisto(TH2& h2, double Ymax, double Ymin, double& col, double& Mstyle, double& fill, double& style, const char* titx, const char* tity ){
//void format1Dhisto(TH1& h1, string& xTitle, double Ymax, double Ymin){
//h2.SetTitle(";XXXX;XXXX");
if(Ymax!=-1 && Ymin!=-1) h2.GetYaxis()->SetRangeUser(Ymax, Ymin);
//if(Ymax==-1 && Ymin!=-1) h2.GetYaxis()->SetMinimum(Ymin);
//h2.SetMarkerColor(col);
//h2.SetMarkerStyle(Mstyle);
//h2.SetLineColor(col);
//h2.SetFillColor(fill);
//h2.SetFillStyle(style);
h2.GetXaxis()->SetTitle(titx);
h2.GetYaxis()->SetTitle(tity);
h2.GetXaxis()->CenterTitle();
h2.GetYaxis()->CenterTitle();
//cout<<"The title is : "<<tit<<endl;
return;
}
//______________________________________________________________________________
TH2* CreateHisto(const Char_t* name, Int_t nPar, const Double_t* par)
{
TH2* h;
if (gIsTAPS)
h = new TH2F(name, name, 4000, -100, 100, nPar, 0, nPar);
else
h = new TH2F(name, name, 2000, -100, 100, nPar, 0, nPar);
// fill histo
for (Long64_t i = 0; i < gEntries; i++)
{
const Double_t time_1 = gGain[gElem_1[i]] * (gRaw_Time_1[i] - par[gElem_1[i]]);
const Double_t time_2 = gGain[gElem_2[i]] * (gRaw_Time_2[i] - par[gElem_2[i]]);
h->Fill(time_1 - time_2, gElem_1[i]);
h->Fill(time_2 - time_1, gElem_2[i]);
}
return h;
}
void root_hist_test()
{
// Project3D uses overflows?
TH3* h3D = new TH3D("h3D", "h3D", 2,0,2, 2,0,2, 2,0,2);
for(int i=0; i<=h3D->GetNbinsX()+1; i++) {
for(int j=0; j<=h3D->GetNbinsY()+1; j++) {
for(int k=0; k<=h3D->GetNbinsZ()+1; k++) {
h3D->SetBinContent(i,j,k, 1);
}
}
}
printf("h3D integral = %d\tentries = %d\n", h3D->Integral(), h3D->GetEntries());
h3D->GetZaxis()->SetRange(3,3);
TH2* hYX = (TH2*) h3D->Project3D("yx");
printf("hYX integral = %d\tentries = %d\n", hYX->Integral(), hYX->GetEntries());
hYX->Draw("colz");
}
void Draw()
{
float min = 100000;
float max = 0;
std::vector<TGraph*> gs;
float_array bg(fTKine.size());
for (size_t i = 0; i < fTKine.size(); i++) bg[i] = fTKine[i]/fPDG->Mass();
for (mech_array::iterator j = fMechs.begin(); j != fMechs.end(); ++j) {
if (!(*j)->fStatus) continue;
for (size_t i = 0; i < fTKine.size(); i++) {
if ((*j)->fValues[i] == 0) continue;
min = std::min(min, (*j)->fValues[i]);
max = std::max(max, (*j)->fValues[i]);
}
}
TCanvas* c = new TCanvas("c", "C", 700, 700);
c->SetFillColor(0);
c->SetLogy();
c->SetLogx();
c->SetGridy();
c->SetGridx();
float_array y(101);
float ymin = log10(min);
float dy = (log10(max)+.5 - log10(min)) / y.size();
for (size_t i = 1; i < y.size(); i++) y[i] = pow(10, ymin + i * dy);
TH2* f = new TH2F("x", "X-sec",bg.size()-1,&(bg[0]),y.size()-1,&(y[0]));
f->SetXTitle("#beta#gamma");
f->SetDirectory(0);
f->SetStats(kFALSE);
f->Draw();
TLegend* l = new TLegend(0.45, 0.125, 0.90, 0.45);
l->SetFillColor(0);
// l->SetFillStyle(0);
for (mech_array::iterator j = fMechs.begin(); j != fMechs.end(); ++j) {
if (!(*j)->fStatus) continue;
TGraph& g = (*j)->Draw();
l->AddEntry(&g, g.GetTitle(), "l");
}
l->Draw("same");
}
void smoothHisto(TH2* hist, int Niter) {
for(int iter=0; iter<Niter; iter++) {
if(iter>2) {
TH2* clone = (TH2*) hist->Clone("clone");
for(int ix=2; ix<hist->GetNbinsX()-1; ix++) {
for(int iy=2; iy<hist->GetNbinsY()-1; iy++) {
double nn1 = clone->GetBinContent(ix-1,iy);
double nn2 = clone->GetBinContent(ix,iy-1);
double nn3 = clone->GetBinContent(ix+1,iy);
double nn4 = clone->GetBinContent(ix,iy+1);
hist->SetBinContent(ix,iy,0.25*(nn1+nn2+nn3+nn4));
}
}
delete clone;
} else {
TH2* clone = (TH2*) hist->Clone("clone");
for(int ix=2; ix<hist->GetNbinsX()-1; ix++) {
for(int iy=2; iy<hist->GetNbinsY()-1; iy++) {
double nn1 = clone->GetBinContent(ix-1,iy-1);
double nn2 = clone->GetBinContent(ix-1,iy+1);
double nn3 = clone->GetBinContent(ix+1,iy-1);
double nn4 = clone->GetBinContent(ix+1,iy+1);
if(nn1+nn2+nn3+nn4>2 && hist->GetBinContent(ix,iy))
hist->SetBinContent(ix,iy,1.);
else
hist->SetBinContent(ix,iy,0.25*(nn1+nn2+nn3+nn4));
}
}
delete clone;
}
}
}
void DrawHistos(TString infile = "histos.root"){
set_plot_style();
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
TFile *_file0 = TFile::Open(infile);
TH1* hHardPartonspT = (TH1*)gROOT->FindObject("hHardPartonspT");
TH1* hHardPartonsName = (TH1*)gROOT->FindObject("hHardPartonsName");
TH1* hParticlepT = (TH1*)gROOT->FindObject("hParticlepT");
TH2* hParticleEtaPhi = (TH2*)gROOT->FindObject("hParticleEtaPhi");
TCanvas* can1 = new TCanvas("can1","",600,600);
gPad->SetLeftMargin(0.15);
gPad->SetLogy();
SetHist(hParticlepT,"p_{T} (GeV/c)","Counts",2);
SetHist(hHardPartonspT,"p_{T} (GeV/c)","Counts",1);
hParticlepT->Draw();
hHardPartonspT->Draw("same");
TLegend* leg1 = new TLegend(0.6,0.7,0.85,0.85);
SetLeg(leg1);
leg1->AddEntry(hHardPartonspT,"Hard Parton","L");
leg1->AddEntry(hParticlepT,"Final Particles","L");
leg1->Draw();
can1->SaveAs("pTgraph.png");
TCanvas* can2 = new TCanvas("can2","",600,600);
gPad->SetLeftMargin(0.15);
SetHist(hHardPartonsName,"parton ID","Counts",1);
hHardPartonsName->Draw();
TCanvas* can3 = new TCanvas("can3","",600,600);
gPad->SetLeftMargin(0.15);
SetHist(hParticleEtaPhi,"p_{T} (GeV/c)","Counts",1);
hParticleEtaPhi->Draw("COLZ");
}
TH2* smoothHoles(const TH2* originalHist)
{
TH2* hist = (TH2*)originalHist->Clone("_smoothed");
int xMax = hist->GetNbinsX();
int yMax = hist->GetNbinsY();
int xMin = 0;
for(int xBin = 1; xBin <= xMax; xBin++)
{
for(int yBin = 1; yBin <= yMax; yBin++)
{
if(hist->GetBinContent(xBin,yBin)>0)
{
xMin = xBin;
yBin = yMax+1;
xBin = xMax+1;
}
}
}
// for(unsigned int i = 0; i< 1000; i++) smoothHistAcross(hist,xMin);
for(unsigned int i = 0; i< 1000; i++) interpolateHistAcross(hist,xMin);
return hist;
}
TList* getContours(const TH2* hist,double contourLevel,const TString filename)
{
TH2* h = (TH2*)hist->Clone("_clone");
double limitValue[1] = {contourLevel};
h->SetContour(1,limitValue);
TCanvas* c = new TCanvas("contour_canvas","Contour List",0,0,600,600);
h->Draw("CONT LIST");
c->Update();
TList* contours = (TList*)((TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours"))->At(0);
TGraph* contour = (TGraph*)contours->First();
if(filename!="")
{
for(unsigned int j = 0; j < contours->GetSize(); j++)
{
TString newFilename = filename+"_";
newFilename+=j;
contour->SaveAs(newFilename+".C");
contour = (TGraph*)contours->After(contour); // Get Next graph
}
}
delete h;
delete c;
return contours;
}
void
HistoCompare::PVCompute(TH2 * oldHisto , TH2 * newHisto , TText * te )
{
myoldHisto2 = oldHisto;
mynewHisto2 = newHisto;
myte = te;
Double_t *res ;
Double_t mypvchi = myoldHisto2->Chi2Test(mynewHisto2,"WW",res);
char str [128];
sprintf(str,"chi^2 P Value: %f",mypvchi);
TString title = str;
printRes(title, mypvchi, myte);
return;
}
void SetBorders( TH2 &hist, Double_t val=0 )
{
int numx = hist.GetNbinsX();
int numy = hist.GetNbinsY();
for(int i=0; i <= numx+1 ; i++){
hist.SetBinContent(i,0,val);
hist.SetBinContent(i,numy+1,val);
}
for(int i=0; i <= numy+1 ; i++) {
hist.SetBinContent(0,i,val);
hist.SetBinContent(numx+1,i,val);
}
}
// normalize migmatrix column-wise
TH2* normalizeMigMat(TH2* h)
{
TH2* hclone = (TH2*) h->Clone();
const int xbins = hclone->GetNbinsX();
const int ybins = hclone->GetNbinsY();
for(int x=0; x<xbins; x++)
{
double integ = hclone->Integral(x+1, x+1, 1, ybins);
for(int y=0; y<ybins; y++)
{
hclone->SetBinContent(x+1,y+1, hclone->GetBinContent(x+1, y+1)/integ);
}
}
return hclone;
}
// Make 2D efficiency plots
void makeplots2D( TH2& eff, TString name) {
gROOT->ProcessLine(".L ~/tdrstyle.C");
setTDRStyle();
const Int_t NRGBs = 5;
const Int_t NCont = 200;
Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 };
Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 };
TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
tdrStyle->SetNumberContours(NCont);
if(name.Contains("_Pt")) {
eff.GetXaxis()->SetTitle("p_{T} (GeV/c)");
eff.GetYaxis()->SetTitle("#eta ");
}
if(name.Contains("_Phi")) {
eff.GetXaxis()->SetTitle("#phi ");
eff.GetYaxis()->SetTitle("#eta ");
}
eff.GetYaxis()->SetTitleOffset(1);
tdrStyle->SetPadLeftMargin(0.08);
tdrStyle->SetPadRightMargin(0.1);
TCanvas canvas("canvas",name,600,600);
eff.Draw("colz");
gPad->Update();
TPaletteAxis* palette =
(TPaletteAxis*)eff.GetListOfFunctions()->FindObject("palette");
palette->SetLabelSize(0.02);
canvas.SaveAs(name + TString(".eps"));
canvas.SaveAs(name + TString(".gif"));
canvas.Close();
}
void IslandLoss()
{
/*****************************************************************/
// Prepare the canvas
gStyle->SetOptStat("");
TCanvas *canvas = (TCanvas *) gROOT->GetListOfCanvases()->At(0);
canvas->Clear();
/*****************************************************************/
TH2 *hExpected = (TH2 *)gDirectory->Get("hExpectedNumberOfIslands");
TH2 *hActual = (TH2 *)gDirectory->Get("hNumberOfIslands");
if (hExpected && hActual)
{
TVirtualPad *pad = canvas->cd(1);
hExpected->Add(hActual, -1);
hExpected->SetTitle("Difference between Expected Number of TPulseIslands and Actual Number of TPulseIslands");
hExpected->GetXaxis()->SetRange(9,9);
hExpected->GetYaxis()->SetRangeUser(0, 1200);
hExpected->Draw("COLZ");
}
}
void DrawGrid()
{
Int_t ncol = 100;
Int_t nrow = 200;
TPad *grid = new TPad("grid","",0,0,1,1);
grid->Draw();
grid->cd();
grid->SetGrid();
grid->SetFillStyle(4000);
grid->SetFrameFillStyle(0);
TH2 *hgrid = new TH2C("hgrid","", ncol+1, -5, ncol+5, nrow, -5, nrow-1+5);
hgrid->Draw();
hgrid->GetXaxis()->SetNdivisions(6,100);
hgrid->GetYaxis()->SetNdivisions(200);
hgrid->GetYaxis()->SetLabelOffset(999.);
hgrid->GetXaxis()->SetLabelOffset(999.);
}
void pidHistogramMaker::distributionReport( string pType ){
uint nBinsPt = ptBins.size() - 1;
string rName = speciesName( pType, 0 );
taskProgress tp( pType + " distribution report", nBinsPt );
book->cd( "tof" );
for ( uint i = 0; i < nBinsPt; i ++ ){
tp.showProgress( i );
// momentum value used for finding nice range
double p = ptBins[ i ];
double p2 = ptBins[ i + 1 ];
double avgP = 0.2;
avgP = (ptBins[ i ] + ptBins[ i + 1])/2.0;
string name = speciesName( pType, 0, i, 0 );
book->cd( "dedx_tof" );
TH2 * pTof = book->get2D( name );
book->cd( "scratch" );
TH2 * pDedx = (TH2*)pTof->Clone( "pDedx__" );
// start a new page on the report file
pReport[ rName ]->newPage( 2, 2 );
// get information on plot ranges
double tofLow, tofHigh, dedxLow, dedxHigh;
autoViewport( pType, p, &tofLow, &tofHigh, &dedxLow, &dedxHigh, tofPadding, dedxPadding, tofScalePadding, dedxScalePadding );
if ( true ) { // show the tof proj
string title = "#beta^{-1} : " + ts(ptBins[ i ], 4) + " < pT < " + ts(ptBins[i+1], 4);
vector<string> others = otherSpecies( pType );
vector< double > tofMean = enhanceTof( pType, others, avgP );
vector< double > dedxMean = enhanceDedx( pType, others, avgP );
pReport[ rName ]->cd( 1, 1 );
//hdt->GetXaxis()->SetRangeUser( -.06, .06 );
// Make the all tof tracks histogram
string hName = sTofName( pType, 0, i );
book->cd( "scratch" );
TH1* hTof = (TH1D*)pTof->ProjectionY( "_py" );
book->cd( "tof" );
book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) );
book->style( hName )->set( "style.tof" )
->set( "title", title )->draw();
TLine * l1 = new TLine( tofMean[ 0 ], hTof->GetMinimum(), tofMean[ 0 ], hTof->GetMaximum() );
l1->Draw();
TLine * l2 = new TLine( tofMean[ 1 ], hTof->GetMinimum(), tofMean[ 1 ], hTof->GetMaximum() );
l2->Draw();
pReport[ rName ]->cd( 2, 1 );
pTof->GetXaxis()->SetRangeUser( -.06, .06 );
// Make the all tof tracks histogram
hName = sTofName( pType, 0, i, 0, pType );
book->cd( "scratch" );
hTof = (TH1D*)pTof->ProjectionY( "_py" );
book->cd( "tof" );
book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) );
book->style( hName )->set( "style.tof" )
->set( "title", title + " " + pType + " enhanced" )->draw();
for ( int j = 0; j < dedxMean.size(); j++ ){
pReport[ rName ]->cd( j+1, 2 );
pTof->GetXaxis()->SetRangeUser( dedxMean[j]-0.06, dedxMean[j]+0.06 );
// Make the all tof tracks histogram
hName = sTofName( pType, 0, i, 0, others[ j ] );
book->cd( "scratch" );
hTof = (TH1D*)pTof->ProjectionY( "_py" );
book->cd( "tof" );
book->add( hName, (TH1*)hTof->Clone( hName.c_str() ) );
book->style( hName )->set( "style.tof" )
->set( "title", title + " " + others[ j ] + " enhanced" )->draw();
}
}
pReport[ rName ]->savePage();
pReport[ rName ]->newPage( 2, 2 );
if ( true ) { // show the dedx proj
string title = "dEdx : " + ts(ptBins[ i ], 4) + " < pT < " + ts(ptBins[i+1], 4);
pTof->GetXaxis()->SetRange( 1, pTof->GetXaxis()->GetNbins() );
pTof->GetYaxis()->SetRange( 1, pTof->GetYaxis()->GetNbins() );
vector<string> others = otherSpecies( pType );
vector< double > tofMean = enhanceTof( pType, others, avgP );
vector< double > dedxMean = enhanceDedx( pType, others, avgP );
pReport[ rName ]->cd( 1, 1 );
// Make the all dedx tracks histogram
string hName = sDedxName( pType, 0, i );
book->cd( "scratch" );
TH1* hDedx = (TH1D*)pTof->ProjectionX( "_px" );
book->cd( "dedx" );
book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) );
book->style( hName )->set( "style.dedx" )
->set( "title", title )->draw();
TLine * l1 = new TLine( dedxMean[ 0 ], hDedx->GetMinimum(), dedxMean[ 0 ], hDedx->GetMaximum() );
l1->Draw();
TLine * l2 = new TLine( dedxMean[ 1 ], hDedx->GetMinimum(), dedxMean[ 1 ], hDedx->GetMaximum() );
l2->Draw();
pReport[ rName ]->cd( 2, 1 );
pTof->GetYaxis()->SetRangeUser( -.012, .012 );
// Make the all tof tracks histogram
hName = sDedxName( pType, 0, i, 0, pType );
book->cd( "scratch" );
hDedx = (TH1D*)pTof->ProjectionX( "_px" );
book->cd( "dedx" );
book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) );
book->style( hName )->set( "style.dedx" )
->set( "title", title + " " + pType + " enhanced" )->draw();
for ( int j = 0; j < dedxMean.size(); j++ ){
pReport[ rName ]->cd( j+1, 2 );
pTof->GetYaxis()->SetRangeUser( tofMean[j]-0.012, tofMean[j]+0.012 );
// Make the all tof tracks histogram
hName = sDedxName( pType, 0, i, 0, others[ j ] );
book->cd( "scratch" );
hDedx = (TH1D*)pTof->ProjectionX( "_px" );
book->cd( "dedx" );
book->add( hName, (TH1*)hDedx->Clone( hName.c_str() ) );
book->style( hName )->set( "style.dedx" )
->set( "title", title + " " + others[ j ] + " enhanced" )->draw();
}
}
pReport[ rName ]->savePage();
}
}
void pidHistogramMaker::speciesReport( string pType, int charge, int etaBin ){
string name = speciesName( pType, charge );
cout << "\tSpecies Report : " << name << endl;
uint nBinsP = ptBins.size();
TH3 * h3 = book->get3D( "nSig_" + name );
taskProgress tp( pType + " report", nBinsP );
for ( uint i = 0; i < nBinsP; i ++ ){
tp.showProgress( i );
// momentum value used for finding nice range
double p = ptBins[ i ];
pReport[ name ]->newPage( 2, 2 );
pReport[ name ]->cd( 1, 2 );
h3->GetZaxis()->SetRange( i, i );
TH2* proj;
TH1* proj1D;
double pLow = h3->GetZaxis()->GetBinLowEdge( i );
double pHi = h3->GetZaxis()->GetBinLowEdge( i + 1 );
if ( 0 == i ){
pLow = h3->GetZaxis()->GetBinLowEdge( 1 );
pHi = h3->GetZaxis()->GetBinLowEdge( ptBins.size()-1 );
}
string order = "xy";
string tofAxis = config->getString( "binning.tofAxis", "x" );
if ( tofAxis == "y" )
order = "yx";
proj = (TH2*)h3->Project3D( order.c_str() );
if ( i > 0 && tofMetric == inverseBeta ){
double tofLow, tofHigh, dedxLow, dedxHigh;
autoViewport( pType, p, &tofLow, &tofHigh, &dedxLow, &dedxHigh, tofPadding, dedxPadding, tofScalePadding, dedxScalePadding );
proj->GetYaxis()->SetRangeUser( tofLow, tofHigh );
proj->GetXaxis()->SetRangeUser( dedxLow, dedxHigh );
}
string hTitle = (pType + " : " + ts( pLow, 4 ) + " #leq " + " P #leq" + ts( pHi, 4 ) );
string hName = (pType + "_" + ts(i) + "_" + ts(etaBin) );
proj->SetTitle( hTitle.c_str() );
gPad->SetLogz( 1 );
proj->Draw( "colz" );
if ( tofAxis == "x" ){
pReport[ name ]->cd( 2, 2 );
proj1D = proj->ProjectionX();
proj1D->SetTitle( ( "dedx : " + pType + " : " + ts( pLow, 4 ) + " #leq " + " P #leq" + ts( pHi, 4 ) ).c_str() );
proj1D->SetFillColor( kBlue );
gPad->SetLogx( 1 );
proj1D->Draw( "hbar" );
pReport[ name ]->cd( 1, 1 );
proj1D = proj->ProjectionY();
proj1D->SetTitle( ( "1/#beta : " + pType + " : " + ts( pLow, 4 ) + " #leq " + " P #leq" + ts( pHi, 4 ) ).c_str() );
gPad->SetLogy( 1 );
proj1D->SetFillColor( kBlue );
proj1D->Draw( "" );
} else {
pReport[ name ]->cd( 2, 2 );
proj1D = proj->ProjectionY();
proj1D->SetTitle( ( "#beta^{-1} : " + pType + " : " + ts( pLow, 4 ) + " #leq " + " P #leq" + ts( pHi, 4 ) ).c_str() );
proj1D->SetFillColor( kBlue );
gPad->SetLogx( 1 );
proj1D->Draw( "hbar" );
pReport[ name ]->cd( 1, 1 );
proj1D = proj->ProjectionX();
proj1D->SetTitle( ( "dedx : " + pType + " : " + ts( pLow, 4 ) + " #leq " + " P #leq" + ts( pHi, 4 ) ).c_str() );
gPad->SetLogy( 1 );
proj1D->SetFillColor( kBlue );
proj1D->Draw( "" );
}
pReport[ name ]->savePage();
}
}
TH2 *
ReturnCorrFromFit(TH2 *hcorr)
{
gStyle->SetOptStat(kFALSE);
gStyle->SetOptFit(kTRUE);
TObjArray *oa = new TObjArray();
hcorr->FitSlicesX(0, 0, -1, 0, "QNR", oa);
TCanvas *cFit = new TCanvas("cFit", "cFit");
cFit->Divide(2, 2);
TF1 *fMean = new TF1("fMean", "[0] + [1] * TMath::Power(x, [2])", 1., 100.);
fMean->SetParameter(0, 0.);
fMean->SetParameter(1, 1.);
fMean->SetParameter(2, 1.);
TH1 *hMean = (TH1 *)oa->At(1);
hMean->Fit(fMean, "0q", "I", 1., 100.);
cFit->cd(1)->SetLogx();
cFit->cd(1)->SetLogy();
hMean->Draw();
fMean->Draw("same");
TF1 *fSigma = new TF1("fSigma", "[0] + [1] * TMath::Power(x, [2])", 1., 100.);
fSigma->SetParameter(0, 0.);
fSigma->SetParameter(1, 1.);
fSigma->SetParameter(2, 0.5);
TH1 *hSigma = (TH1 *)oa->At(2);
hSigma->Fit(fSigma, "0q", "", 1., 100.);
cFit->cd(3)->SetLogx();
cFit->cd(3)->SetLogy();
hSigma->Draw();
fSigma->Draw("same");
cFit->cd(2)->SetLogx();
cFit->cd(2)->SetLogy();
cFit->cd(2)->SetLogz();
hcorr->Draw("colz");
TH2 *hcorrfit = (TH2 *)hcorr->Clone("hcorrfit");
// hcorrfit->Reset();
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
Float_t cent = hcorr->GetXaxis()->GetBinCenter(i + 1);
Float_t mean = fMean->Eval(cent);
Float_t sigma = fSigma->Eval(cent);
if (cent < 25 || cent > 100) continue;
for (Int_t j = 0; j < 10000; j++) {
Float_t val = gRandom->Gaus(mean, sigma);
if (val <= 0.) continue;
hcorrfit->Fill(val, cent);
}
}
cFit->cd(4)->SetLogx();
cFit->cd(4)->SetLogy();
cFit->cd(4)->SetLogz();
hcorrfit->Draw("colz");
return hcorrfit;
}
TH1 *
UnfoldMe_MB2(const Char_t *data, const Char_t *mc, const Char_t *anatag, Int_t bin, Bool_t useMBcorr , Bool_t usecorrfit , Bool_t ismc , Float_t smooth , Int_t iter , Int_t regul , Float_t weight , Bool_t bayesian , Int_t nloop )
{
// MF comments:
// usedMBcorr: changes the matrix used for unfonding, from effMatrix to bin matrix (I think this is just to use mult dependent v s mb correction_)
// usecorrfit: if I understand correctly, fits the response matrix and uses fit to extrapolate it
TFile *fdt =0;
if (ismc)
fdt = TFile::Open(data);
else
fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form(responseMatrix, bin));
TH2 *hmatmc = 0;
if (useMBcorr){
hmatmc = (TH2 *)lmc->FindObject("effMatrix");
std::cout << "USING MB" << std::endl;
}
else {
hmatmc = (TH2 *)lmc->FindObject(Form(responseMatrix, bin));
}
TH1 *hdata = hmatdt->ProjectionY("hdata");
// TH1 *hdata = hmatdt->ProjectionY("htrue"); // For truth Only Calculations
hdata->Sumw2();
hdata->SetBinContent(1, 0.);
hdata->SetBinError(1, 0.);
// hdata->Scale(1. / hdata->Integral());
hdata->SetMarkerStyle(25);
TH1 *htrue = hmatdt->ProjectionX("htrue");
htrue->Sumw2();
// htrue->Scale(1. / htrue->Integral());
htrue->SetMarkerStyle(7);
htrue->SetMarkerColor(2);
htrue->SetBinContent(1, 0.);
htrue->SetBinError(1, 0.);
TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr");
TH1 *hinit = (TH1 *)hdata->Clone("hinit");
TH1 *hresu = (TH1 *)hdata->Clone("hresu");
TH1 *hbias = (TH1 *)hdata->Clone("hbias");
hresu->SetMarkerStyle(20);
hresu->SetMarkerColor(4);
hresu->Reset();
TH1 *hnum = hcorr->ProjectionY("hnum");
TH1 *hden = hcorr->ProjectionY("hden");
TH1 *heff = hcorr->ProjectionY("heff");
hnum->Reset();
hnum->Sumw2();
hden->Reset();
hden->Sumw2();
heff->Reset();
for (Int_t i = 0; i < heff->GetNbinsX(); i++) {
Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1);
if (int1 <= 0.) continue;
Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1);
hnum->SetBinContent(i + 1, int2);
hnum->SetBinError(i + 1, TMath::Sqrt(int2));
hden->SetBinContent(i + 1, int1);
hden->SetBinError(i + 1, TMath::Sqrt(int1));
}
TCanvas *cEfficiency = new TCanvas("cEfficiency", "cEfficiency");
cEfficiency->SetLogx();
cEfficiency->SetLogy();
heff->Divide(hnum, hden, 1., 1., "B");
heff->Draw();
#if 0
for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) {
heff->SetBinContent(ii + 1, 1.);
heff->SetBinError(ii + 1, 0.);
}
#endif
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
hcorr->SetBinContent(i + 1, 1, 0.);
hcorr->SetBinError(i + 1, 1, 0.);
}
for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) {
hcorr->SetBinContent(1, i + 1, 0.);
hcorr->SetBinError(1, i + 1, 0.);
}
TH2 *hcorrfit = ReturnCorrFromFit(hcorr);
// Docs from AliUnfolding
//Int_t AliUnfolding::Unfold(TH2* correlation, TH1* efficiency, TH1* measured, TH1* initialConditions, TH1* result, Bool_t check)
// unfolds with unfolding method fgMethodType
//
// parameters:
// correlation: response matrix as measured vs. generated
// efficiency: (optional) efficiency that is applied on the unfolded spectrum, i.e. it has to be in unfolded variables. If 0 no efficiency is applied.
// measured: the measured spectrum
// initialConditions: (optional) initial conditions for the unfolding. if 0 the measured spectrum is used as initial conditions.
// result: target for the unfolded result
// check: depends on the unfolding method, see comments in specific functions
for (Int_t iloop = 0; iloop < nloop; iloop++) {
if (bayesian) {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
AliUnfolding::SetBayesianParameters(smooth, iter);
} else {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
AliUnfolding::SetChi2Regularization(AliUnfolding::RegularizationType(regul), weight);
}
AliUnfolding::SetSkip0BinInChi2(kTRUE);
AliUnfolding::SetSkipBinsBegin(1);
AliUnfolding::SetNbins(150, 150);
AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu);
hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop));
}
printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1));
printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1));
TCanvas *cUnfolded = new TCanvas ("cUnfolded", "cUnfolded", 400, 800);
cUnfolded->Divide(1, 2);
cUnfolded->cd(1)->SetLogx();
cUnfolded->cd(1)->SetLogy();
hdata->Draw();
hresu->Draw("same");
htrue->Draw("same");
cUnfolded->cd(2)->SetLogx();
cUnfolded->cd(2)->DrawFrame(1., 0, 300., 10);
TH1 *hrat = (TH1 *)hresu->Clone("hrat");
hrat->Divide(htrue);
hrat->Draw("same");
TH1 *htrig = (TH1 *)hresu->Clone("htrig");
htrig->Multiply(heff);
Float_t dndeta_resu = 0.;
Float_t integr_resu = 0.;
Float_t dndeta_trig = 0.;
Float_t integr_trig = 0.;
for (Int_t i = 1; i < hresu->GetNbinsX(); i++) {
dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1);
integr_resu += hresu->GetBinContent(i + 1);
dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1);
integr_trig += htrig->GetBinContent(i + 1);
}
cUnfolded->SaveAs("unfold_efficiency.pdf");
integr_eff = integr_trig / integr_resu;
integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu);
dndeta_eff = dndeta_trig / dndeta_resu;
dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu);
printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err);
printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err);
return hresu;
}
void profileDistributions(TString dist)
{
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetPalette(1);
TFile *inF=TFile::Open("~/work/top_539/plotter.root");
TFile *inSystF=TFile::Open("~/work/top_539/plotter_syst.root");
bool isPhi(dist.Contains("phi"));
TString profs[]={dist,
dist+"toward",
dist+"transverse",
dist+"away"};
const size_t nprofs= isPhi ? 1 : sizeof(profs)/sizeof(TString);
Int_t colors[]={1,kBlue,kRed,kGreen-3};
TString cats[]={"inclusive","away","transverse","toward"};
/*
TFile *inNomF=inF;
TString nomTTbar="t#bar{t}";
TString nomTTbarTitle="MG+PY";
//TString systList[]={"t#bar{t}systmcatnlo"};
//TString systLabels[]={"MC@NLO+HW"};
//TString systList[]={"t#bar{t}systq2down","t#bar{t}systq2up"};
//TString systLabels[]={"-Q^{2}","+Q^{2}"};
//TString systList[]={"t#bar{t}systmepsdown","t#bar{t}systmepsup"};
// TString systLabels[]={"-ME-PS","+ME-PS"};
*/
TFile *inNomF=inSystF;
TString nomTTbar="t#bar{t}systtunep11";
TString nomTTbarTitle="P11";
TString systList[]={"t#bar{t}systtunep11nocr","t#bar{t}systtunep11tev"};
TString systLabels[]={"P11-noCR","P11TeV"};
Int_t systColors[]={1,kAzure,kRed-6,kGreen+3};
const size_t nSysts=sizeof(systList)/sizeof(TString);
TString ch[]={"emu"};
const size_t nch=sizeof(ch)/sizeof(TString);
for(size_t ich=0; ich<nch; ich++)
{
TCanvas *c=new TCanvas("c"+ch[ich]+dist,"c"+ch[ich]+dist,800,800); c->SetTopMargin(0); c->SetBottomMargin(0);
c->Divide(1,nprofs);
TCanvas *cratios=new TCanvas("cratios"+ch[ich]+dist,"cratios"+ch[ich]+dist,800,800); cratios->SetTopMargin(0); cratios->SetBottomMargin(0);
cratios->Divide(1,nprofs);
TCanvas *cproj=new TCanvas("cproj"+ch[ich]+dist,"cproj"+ch[ich]+dist,600,600);
TLegend *dataprojLeg=new TLegend(0.5,0.9,0.6,0.7,"Data","brNDC");
TLegend *mcprojLeg=new TLegend(0.7,0.9,0.92,0.7,"MC","brNDC");
for(size_t i=0; i<nprofs; i++)
{
TH2 *bckgMC = (TH2 *) inF->Get("Z#rightarrow ll/"+ch[ich]+"_"+profs[i]);
bckgMC->Add( (TH2 *) inF->Get("VV/"+ch[ich]+"_"+profs[i]) );
bckgMC->Add( (TH2 *) inF->Get("Single top/"+ch[ich]+"_"+profs[i]) );
bckgMC->Add( (TH2 *) inF->Get("W+jets-multijets/"+ch[ich]+"_"+profs[i]) );
//build the total MC with signal alternatives
TH2 *MC = (TH2 *) inNomF->Get(nomTTbar+"/"+ch[ich]+"_"+profs[i]) ;
Double_t totalTTbar(MC->Integral());
MC->Add(bckgMC);
MC->SetDirectory(0);
MC->Sumw2();
std::vector<TH2 *> systMC;
for(size_t isyst=0; isyst<nSysts; isyst++)
{
TH2F *h=(TH2F *)inSystF->Get(systList[isyst]+"/"+ch[ich]+"_"+profs[i]) ;
h->Scale(totalTTbar/h->Integral());
h->Add(bckgMC);
h->Sumw2();
h->SetDirectory(0);
systMC.push_back(h);
}
//get the data
TH2 *Data = (TH2 *) inF->Get("data/"+ch[ich]+"_"+profs[i]);
Data->SetDirectory(0);
Data->Sumw2();
TGraphErrors *MCProf = new TGraphErrors(MC->ProfileX()); MCProf->SetMarkerStyle(24); MCProf->SetFillStyle(0); MCProf->SetName(ch[ich]+profs[i]+"mc");
TGraphErrors *DataProf = new TGraphErrors(Data->ProfileX()); DataProf->SetMarkerStyle(20); DataProf->SetFillStyle(0); DataProf->SetName(ch[ich]+profs[i]+"data");
//build data/MC scale factors
std::vector<TGraphErrors *> data2mcProfs;
for(size_t isyst=0; isyst<=systMC.size(); isyst++)
{
TGraphErrors *prof= (isyst==0 ? MCProf : new TGraphErrors(systMC[isyst-1]->ProfileX()));
TString baseName(ch[ich]+profs[i]);
if(isyst) baseName += systList[isyst];
prof = (TGraphErrors *) prof->Clone(baseName+"data2mc");
for(int ip=0; ip<DataProf->GetN(); ip++)
{
Double_t x,y,ydata,y_err,ydata_err;
prof->GetPoint(ip,x,y); y_err=prof->GetErrorY(ip);
DataProf->GetPoint(ip,x,ydata); ydata_err=DataProf->GetErrorY(ip);
if(y<=0) continue;
prof->SetPoint(ip,x,ydata/y);
prof->SetPointError(ip,0,sqrt(pow(ydata*y_err,2)+pow(ydata_err*y,2))/pow(y,2));
}
prof->SetFillColor(systColors[isyst]);
prof->SetFillStyle(3001+isyst%2);
prof->SetTitle( isyst==0 ? nomTTbarTitle : systLabels[isyst-1] );
//prof->SetMarkerStyle(24); prof->SetFillStyle(3001); prof->SetMarkerColor(1+isyst); prof->SetMarkerColor(1+isyst); prof->SetLineColor(1+isyst);
data2mcProfs.push_back(prof);
}
TH1D *MCProjY=MC->ProjectionY();
MCProjY->Scale(1./MCProjY->Integral());
TGraphErrors *MCProj = new TGraphErrors(MCProjY); MCProj->SetMarkerStyle(24); MCProj->SetFillStyle(0); MCProj->SetName(ch[ich]+profs[i]+"projmc");
TH1D *DataProjY=Data->ProjectionY();
DataProjY->Scale(1./DataProjY->Integral());
TGraphErrors *DataProj = new TGraphErrors(DataProjY); DataProj->SetMarkerStyle(20); DataProj->SetFillStyle(0); DataProj->SetName(ch[ich]+profs[i]+"projdata");
MCProj->SetLineColor(colors[i]); MCProj->SetMarkerColor(colors[i]); MCProj->SetFillColor(colors[i]); MCProj->SetFillStyle(1001);
DataProj->SetLineColor(colors[i]); DataProj->SetMarkerColor(colors[i]); DataProj->SetFillColor(colors[i]);
TPad *p=(TPad *)cproj->cd();
p->SetLeftMargin(0.15);
p->SetRightMargin(0.02);
p->SetTopMargin(0.05);
p->SetLogy();
MCProj->SetFillStyle(0);
MCProj->Draw(i==0 ? "al3" : "l3");
MCProj->GetYaxis()->SetRangeUser(1e-5,1.0);
MCProj->GetXaxis()->SetTitle( MC->GetYaxis()->GetTitle() );
MCProj->GetYaxis()->SetTitle( "1/N dN/dx" );
MCProj->GetYaxis()->SetTitleOffset(1.8);
DataProj->Draw("p");
std::pair<float,int> chi2=computeChiSquareFor(DataProj,MCProj);
char buf[200];
sprintf(buf,"#scale[0.7]{#chi^{2}/ndof=%3.1f}", chi2.first/chi2.second );
dataprojLeg->AddEntry(DataProj,buf,"p");
mcprojLeg->AddEntry(MCProj,cats[i],"l");
if(i==0) drawCMSHeader(ch[ich]);
p=(TPad *)c->cd(i+1);
if(i<nprofs-1) p->SetBottomMargin(0.01);
if(i>0) p->SetTopMargin(0);
if(i==0)p->SetTopMargin(0.1);
if(i==nprofs-1) p->SetBottomMargin(0.15);
TGraphErrors *frame=DataProf;
frame->Draw("ap");
//frame->GetYaxis()->SetRangeUser(0.54,1.46);
frame->GetXaxis()->SetTitle(MC->GetXaxis()->GetTitle());
//frame->GetXaxis()->SetRangeUser(0,4.75);
TString yTit("<"); yTit+=MC->GetYaxis()->GetTitle(); yTit +=">";
frame->GetYaxis()->SetTitle(yTit);
frame->GetYaxis()->SetLabelSize(0.07);
frame->GetYaxis()->SetTitleSize(0.09);
frame->GetYaxis()->SetTitleOffset(0.5);
frame->GetXaxis()->SetLabelSize(0.07);
frame->GetXaxis()->SetTitleSize(0.09);
frame->GetXaxis()->SetTitleOffset(0.7);
//p->SetGridy();
//DataProf->Draw("p");
MCProf->Draw("p");
if(i==0)
{
drawCMSHeader(ch[ich],0.08);
TLegend *leg=new TLegend(0.6,0.95,1.0,0.99);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.09);
leg->AddEntry(DataProf,"data","p");
leg->AddEntry(MCProf,"simulation","p");
leg->SetNColumns(2);
leg->Draw();
}
TPaveText *pt=new TPaveText(0.15,0.5,0.8,0.85,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextColor(kBlue);
pt->SetTextSize(0.08);
pt->AddText("[ "+cats[i]+" ]");
if(i==0)
{
pt->AddText("p_{T}>0.5 GeV");
pt->AddText("|#eta|<2.1");
}
pt->Draw();
p=(TPad *) cratios->cd(i+1);
if(i<nprofs-1) p->SetBottomMargin(0.01);
if(i>0) p->SetTopMargin(0);
if(i==0)p->SetTopMargin(0.1);
if(i==nprofs-1) p->SetBottomMargin(0.15);
frame=data2mcProfs[0];
frame->Draw("a3");
TLine *l=new TLine(frame->GetXaxis()->GetXmin(),1,frame->GetXaxis()->GetXmax(),1);
l->Draw();
frame->GetYaxis()->SetRangeUser(0.54,1.46);
frame->GetXaxis()->SetTitle(MC->GetXaxis()->GetTitle());
frame->GetYaxis()->SetTitle("Data/Simulation");
frame->GetYaxis()->SetLabelSize(0.07);
frame->GetYaxis()->SetTitleSize(0.09);
frame->GetYaxis()->SetTitleOffset(0.5);
frame->GetXaxis()->SetLabelSize(0.07);
frame->GetXaxis()->SetTitleSize(0.09);
frame->GetXaxis()->SetTitleOffset(0.7);
//p->SetGridy();
for(size_t ip=1; ip<data2mcProfs.size(); ip++) data2mcProfs[ip]->Draw("3");
if(i==0)
{
drawCMSHeader(ch[ich],0.08);
TLegend *leg=new TLegend(0.6,0.94,1.0,0.98);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
leg->SetTextFont(42);
leg->SetTextSize(0.09);
leg->SetNColumns(data2mcProfs.size());
for(size_t ip=0; ip<data2mcProfs.size(); ip++)
leg->AddEntry(data2mcProfs[ip],data2mcProfs[ip]->GetTitle(),"f");
leg->Draw();
}
pt=new TPaveText(0.12,0.65,0.8,0.9,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(13);
pt->SetTextFont(42);
pt->SetTextColor(kBlue);
pt->SetTextSize(0.08);
pt->AddText("[ "+cats[i]+" ]");
if(i==0)
{
pt->AddText("p_{T}>0.5 GeV");
pt->AddText("|#eta|<2.1");
}
pt->Draw();
}
cproj->cd();
dataprojLeg->SetFillStyle(0);
dataprojLeg->SetBorderSize(0);
dataprojLeg->SetTextFont(42);
dataprojLeg->SetTextSize(0.03);
dataprojLeg->Draw();
mcprojLeg->SetFillStyle(0);
mcprojLeg->SetBorderSize(0);
mcprojLeg->SetTextFont(42);
mcprojLeg->SetTextSize(0.03);
mcprojLeg->Draw();
TString pf(".png");
c->SaveAs(outDir+c->GetName()+pf);
cproj->SaveAs(outDir+cproj->GetName()+pf);
cratios->SaveAs(outDir+cratios->GetName()+pf);
}
inF->Close();
inSystF->Close();
}
