void ratioPlots( TCanvas* c1, TH1* h_r, TH1* h_i,
string xTitle, string yTitle, string savePath,
double fitMin=-100000, double fitMax=100000, bool doubleColFit=0 ){
double xMaximum = h_r->GetXaxis()->GetBinUpEdge(h_r->GetXaxis()->GetLast());
double xMinimum = h_r->GetXaxis()->GetBinLowEdge(h_r->GetXaxis()->GetFirst());
double yMaximum;
double yMinimum;
h_i->Sumw2();
h_r->Sumw2();
TLine* line1 = new TLine(xMinimum,1,xMaximum,1);
line1->SetLineColor(1);
line1->SetLineWidth(2);
line1->SetLineStyle(7);
TF1* fpol1 = new TF1("fpol1", "pol1", fitMin, fitMax);
fpol1->SetLineColor(2);
fpol1->SetLineWidth(3);
fpol1->SetLineStyle(7);
TH1* hRatio = (TH1*)h_r->Clone("clone_record");
hRatio->Divide(h_i);
yMaximum = hRatio->GetMaximum();
yMinimum = hRatio->GetMinimum(0);
hRatio->GetYaxis()->SetRangeUser(yMinimum/2.5,yMaximum+yMaximum/5);
hRatio->SetXTitle(xTitle.c_str());
hRatio->SetYTitle(yTitle.c_str());
hRatio->SetLineColor(9);
hRatio->SetLineWidth(2);
hRatio->SetMarkerStyle(8);
hRatio->Draw("e");
hRatio->Fit("fpol1", "L");
line1->Draw("SAME");
if(doubleColFit){
double p0=fpol1->GetParameter(0);
double p1=fpol1->GetParameter(1);
double endPoint=double(fitMax*p1)+p0;
double p1new=(endPoint-1)/(fitMax-fitMin);
char fun[100], text[100];
sprintf(fun,"x*(%f)+1",p1new);
sprintf(text,"Tangent: %f",p1new);
TF1* fnew = new TF1("fnew", fun, fitMin, fitMax);
fnew->SetLineColor(2);
fnew->SetLineWidth(3);
fnew->Draw("SAME");
TText* Title = new TText( fitMax/12, yMinimum, text);
Title->SetTextColor(2);
Title->SetTextSize(0.035);
Title->Draw("SAME");
}
c1->SaveAs(savePath.c_str());
c1->cd();
}
void test2bMBcorr(const Char_t *datatag, const Char_t *mctag, Bool_t bayes = kFALSE)
{
TCanvas *c = new TCanvas("c", "c");
c->Divide(4, 3);
for (Int_t i = 0; i < 10; i++) {
TH1 *hnomb = UnfoldMe_TAG(datatag, mctag, "clist", i, kFALSE, kFALSE, kFALSE, 1., 4, AliUnfolding::kPowerLaw, 5000., bayes);
TH1 *hmb = UnfoldMe_TAG(datatag, mctag, "clist", i, kTRUE, kFALSE, kFALSE, 1., 4, AliUnfolding::kPowerLaw, 5000., bayes);
hnomb->Divide(hmb);
c->cd(i+1)->DrawFrame(1., 0.9, 100., 1.1);
c->cd(i+1)->SetLogx();
hnomb->Draw("same");
c->Update();
}
}
//____________________________________________________________________
TH1* One(TDirectory* newDir, TDirectory* oldDir, Double_t c1, Double_t c2)
{
TString name;
name.Form("cent%03dd%02d_%03dd%02d",
Int_t(c1), Int_t(c1*100)%100,
Int_t(c2), Int_t(c2*100)%100);
TDirectory* newSubDir = GetD(newDir, name);
TDirectory* oldSubDir = GetD(oldDir, name);
if (!newSubDir || !oldSubDir) return 0;
Int_t newDim = 0;
if (TString(newDir->GetName()).Contains("etaipz")) newDim = 3;
else if (TString(newDir->GetName()).Contains("eta")) newDim = 2;
else if (TString(newDir->GetName()).Contains("const")) newDim = 1;
Int_t oldDim = 0;
if (TString(oldDir->GetName()).Contains("etaipz")) oldDim = 3;
else if (TString(oldDir->GetName()).Contains("eta")) oldDim = 2;
else if (TString(oldDir->GetName()).Contains("const")) oldDim = 1;
TDirectory* newSubSubDir = GetD(newSubDir, Form("results%dd",newDim));
TDirectory* oldSubSubDir = GetD(oldSubDir, Form("results%dd",oldDim));
if (!newSubSubDir || !oldSubSubDir) return 0;
TH1* newRes = GetH1(newSubSubDir, "result");
TH1* oldRes = GetH1(oldSubSubDir, "result");
if (!newRes || !oldRes) return 0;
TH1* ratio = static_cast<TH1*>(newRes->Clone(name));
ratio->SetDirectory(0);
ratio->SetTitle(Form("%5.1f - %5.1f%%", c1, c2));
ratio->SetYTitle("New / Old");
ratio->Divide(oldRes);
fMin = TMath::Min(fMin, ratio->GetMinimum());
fMax = TMath::Max(fMax, ratio->GetMaximum());
Printf("Calculated %s/%s", newDir->GetName(), oldDir->GetName());
if (!fLegend) return ratio;
TLegendEntry* e =
fLegend->AddEntry("", Form("%3.0f - %3.0f%%", c1, c2), "f");
e->SetFillStyle(1001);
e->SetFillColor(ratio->GetMarkerColor());
return ratio;
}
void plotter::draw_delta_rel(TH1* hist_, TH1* result_, TString file_name){
TH1* hist = (TH1*) hist_->Clone("hist");
TH1* result = (TH1*) result_->Clone("result");
hist->Divide(result);
hist->Scale(100);
TCanvas *c= new TCanvas("Particle Level","",600,600);
gPad->SetLeftMargin(0.15);
hist->SetTitle(file_name);
hist->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
hist->GetYaxis()->SetTitle("relative uncertainty [%]");
hist->GetYaxis()->SetTitleOffset(1.5);
hist->GetYaxis()->SetNdivisions(505);
hist->SetFillColor(810);
hist->SetLineColor(810);
hist->Draw("HIST");
gPad->RedrawAxis();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
TH1* compRatioHistogram(const std::string& ratioHistogramName, const TH1* numerator, const TH1* denominator)
{
TH1* histogramRatio = 0;
if ( numerator->GetDimension() == denominator->GetDimension() &&
numerator->GetNbinsX() == denominator->GetNbinsX() ) {
histogramRatio = (TH1*)numerator->Clone(ratioHistogramName.data());
histogramRatio->Divide(denominator);
int nBins = histogramRatio->GetNbinsX();
for ( int iBin = 1; iBin <= nBins; ++iBin ){
double binContent = histogramRatio->GetBinContent(iBin);
histogramRatio->SetBinContent(iBin, binContent - 1.);
}
histogramRatio->SetLineColor(numerator->GetLineColor());
histogramRatio->SetLineWidth(numerator->GetLineWidth());
histogramRatio->SetMarkerColor(numerator->GetMarkerColor());
histogramRatio->SetMarkerStyle(numerator->GetMarkerStyle());
histogramRatio->SetMarkerSize(numerator->GetMarkerSize());
}
return histogramRatio;
}
void playsmoothiter(const Char_t *datatag, const Char_t *mctag, const Char_t *anatag, Int_t bin, Bool_t ismc = kFALSE)
{
TCanvas *c = new TCanvas("cs", "cs");
c->DrawFrame(0., 0.5, 100., 1.5);
TH1 *href = UnfoldMe_TAG(datatag, mctag, anatag, bin, kTRUE, kFALSE, ismc, 1., 4);
TH1 *hout = NULL;
TH1 *heff_ev = new TH1F("heff_ev", "", 12, 0, 12);
TH1 *heff_ch = new TH1F("heff_ch", "", 12, 0, 12);
for (Int_t j = 2; j < 10; j+=2) {
for (Int_t i = 5; i < 16; i+=2) {
printf("%d %d\n", j, i);
hout = UnfoldMe_TAG(datatag, mctag, anatag, bin, kTRUE, kFALSE, ismc, 0.1 * i, j);
heff_ev->Fill(integr_eff);
heff_ch->Fill(dndeta_eff);
hout->Divide(href);
c->cd();
hout->Draw("same");
c->Update();
}}
}
void DrawTwoInPad(TVirtualPad* p,
Int_t sub,
TH1* h1,
TH1* h2,
Bool_t ratio,
Bool_t logy=false,
Bool_t legend=false)
{
TVirtualPad* pp = p->cd(sub);
pp->SetRightMargin(0.02);
pp->SetLeftMargin(0.10);
TVirtualPad* ppp = pp;
if (ratio) {
pp->Divide(1,2,0,0);
ppp = pp->cd(1);
ppp->SetRightMargin(0.02);
}
if (logy) ppp->SetLogy();
TH1* hs[] = { h1, h2, 0 };
if (h1->GetMaximum() < h2->GetMaximum()) {
hs[0] = h2;
hs[1] = h1;
}
TH1** ph = hs;
Double_t size = (ratio ? 0.1 : 0.05);
Double_t off = (ratio ? 0.6 : 0.5);
h1->SetFillStyle(3004);
h2->SetFillStyle(3005);
while (*ph) {
TString opt("hist");
if (ph != hs) opt.Append(" same");
TH1* copy = (*ph)->DrawCopy(opt);
copy->GetXaxis()->SetLabelSize(2*size);
copy->GetYaxis()->SetLabelSize(size);
copy->GetYaxis()->SetTitleSize(size);
copy->GetYaxis()->SetTitleOffset(off);
copy->SetYTitle(copy->GetTitle());
copy->SetTitle("");
copy->SetDirectory(0);
ph++;
}
TString s1 = h1->GetYaxis()->GetTitle();
TString s2 = h2->GetYaxis()->GetTitle();
if (legend) {
TLegend* l = new TLegend(0.6, 0.1, 0.9, 0.9);
l->SetBorderSize(0);
TLegendEntry* e = l->AddEntry("dummy", s1, "lf");
l->SetFillColor(kWhite);
e->SetFillColor(kBlack);
e->SetFillStyle(h1->GetFillStyle());
e = l->AddEntry("dummy", s2, "lf");
e->SetFillColor(kBlack);
e->SetFillStyle(h2->GetFillStyle());
l->Draw();
}
if (!ratio) return;
ppp = pp->cd(2);
ppp->SetRightMargin(0.02);
TH1* r = static_cast<TH1*>(h1->Clone(Form("ratio%s", h1->GetName())));
r->SetDirectory(0);
r->SetTitle("");
r->GetXaxis()->SetLabelSize(size);
r->GetYaxis()->SetLabelSize(size);
r->GetYaxis()->SetTitleSize(0.9*size);
r->GetYaxis()->SetTitleOffset(0.9*off);
r->SetMarkerStyle(20);
r->SetMarkerColor(h1->GetFillColor()+1);
r->SetFillStyle(3007);
r->SetYTitle(Form("#frac{%s}{%s}", s1.Data(), s2.Data()));
// r->Add(h2, -1);
// r->Divide(h1);
if (!r->IsA()->InheritsFrom(TProfile::Class())) {
r->GetSumw2()->Set(0); // r->Sumw2(false);
h2->GetSumw2()->Set(0); // h2->Sumw2(false);
}
r->Divide(h2);
Printf("%s", r->GetName());
for (UShort_t bin = 1; bin <= r->GetNbinsX(); bin++) {
Printf(" bin # %2d: Diff=%g+/-%g", bin, r->GetBinContent(bin),
r->GetBinError(bin));
r->SetBinError(bin, 0);
}
r->GetSumw2()->Set(0); //r->Sumw2(false);
r->SetMarkerSize(4);
r->SetMaximum(r->GetMaximum()*1.2);
r->SetMinimum(r->GetMinimum()*0.8);
r->Draw("hist text30");
p->Modified();
p->Update();
p->cd();
}
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;
}
TH1 *
UnfoldMe(Char_t *data, Char_t *mc, Char_t *anatag, Int_t bin, Bool_t useMBcorr = kTRUE, Bool_t usecorrfit = kFALSE, Bool_t ismc = kFALSE, Float_t smooth = 0.001, Int_t iter = 50, Int_t regul = AliUnfolding::kPowerLaw, Float_t weight = 100., Bool_t bayesian = kTRUE, Int_t nloop = 1)
{
if (ismc)
TFile *fdt = TFile::Open(data);
else
TFile *fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("clist_%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("clist_%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form("b%d_corrMatrix", bin));
if (useMBcorr)
TH2 *hmatmc = (TH2 *)lmc->FindObject("effMatrix");
else
TH2 *hmatmc = (TH2 *)lmc->FindObject(Form("b%d_corrMatrix", bin));
TH1 *hdata = hmatdt->ProjectionY("hdata");
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));
}
new TCanvas("cEfficiency");
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);
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(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", "", 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.75, 300., 1.25);
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);
}
// dndeta_resu /= integr_resu;
// dndeta_trig /= integr_trig;
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 QAtracklets(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("etaphiTracklets");
TH1 *pdtin = (TH1 *)hdtin->ProjectionY("pdtin_tracklets");
pdtin->SetMarkerStyle(20);
pdtin->SetMarkerSize(1.);
pdtin->SetMarkerColor(kAzure-3);
hdtin->Scale(1. / hdtin->GetEntries());
pdtin->Scale(1. / hdtin->GetEntries());
TFile *fmcin = TFile::Open(fmc);
TList *lmcin = (TList *)fmcin->Get("clist");
if(!lmcin) {
std::cout << "NOLIST" << std::endl;
}
lmcin->ls();
TH2 *hmcin = (TH2 *)lmcin->FindObject("etaphiTracklets");
if(!hmcin) {
std::cout << "NO H!! etaphiTracklets" << std::endl;
}
TH1 *pmcin = (TH1 *)hmcin->ProjectionY("pmcin_tracklets");
pmcin->SetLineColor(kRed+1);
pmcin->SetFillStyle(1001);
pmcin->SetFillColorAlpha(kRed+1, 0.1);
hmcin->Scale(1. / hmcin->GetEntries());
pmcin->Scale(1. / hmcin->GetEntries());
/*
pdtin->Scale(pmcin->Integral(pmcin->FindBin(0. + 0.001),
pmcin->FindBin(1. - 0.001))
/ pdtin->Integral(pdtin->FindBin(0. + 0.001),
pdtin->FindBin(1. - 0.001)));
*/
TCanvas *cData = new TCanvas("cTrackletData", "cTrackletData", 800, 800);
// cData->SetLogz();
TH1 * hfr = cData->DrawFrame(-2.5, 0., 2.5, 2. * TMath::Pi());
hfr->SetTitle(";#eta;#varphi");
hdtin->Draw("same,col");
cData->SaveAs(canvasPrefix+"trackletData.pdf");
TCanvas *cMC = new TCanvas("cTrackletMC", "cTrackletMC", 800, 800);
// cMC->SetLogz();
hfr = cMC->DrawFrame(-2.5, 0., 2.5, 2. * TMath::Pi());
hfr->SetTitle(";#eta;#varphi");
hmcin->Draw("same,col");
cMC->SaveAs(canvasPrefix+"trackletMC.pdf");
TCanvas *cPhi = new TCanvas("cTrackletPhi", "cTrackletPhi", 800, 800);
// cPhi->SetLogy();
hfr = cPhi->DrawFrame(0., 0., 2. * TMath::Pi(), 0.01);
hfr->SetTitle(";#varphi;");
pdtin->DrawCopy("same");
pmcin->DrawCopy("same,histo");
TLegend *legend = new TLegend(0.20, 0.18+0.63, 0.50, 0.30+0.63);
legend->SetFillColor(0);
legend->SetBorderSize(0);
legend->SetTextFont(42);
legend->SetTextSize(0.04);
legend->AddEntry(pdtin, "data", "pl");
legend->AddEntry(pmcin, "Monte Carlo", "l");
legend->Draw("same");
cPhi->SaveAs(canvasPrefix+"trackletPhi.pdf");
TCanvas *cPhir = new TCanvas("cTrackletPhir", "cTrackletPhir", 800, 800);
// cPhi->SetLogy();
hfr = cPhir->DrawFrame(0., 0.5, 2. * TMath::Pi(), 1.5);
hfr->SetTitle(";#varphi;data / Monte Carlo");
pdtin->Divide(pmcin);
pdtin->Draw("same");
cPhir->SaveAs(canvasPrefix+"trackletPhir.pdf");
}
void makePlot(TCanvas* canvas, const std::string& outputFileName, TTree* testTree, const std::string& varName,
unsigned numBinsX, double xMin, double xMax)
{
std::cout << "creating histogramTauIdPassed..." << std::endl;
TString histogramTauIdPassedName = TString("histogramTauIdPassed").Append("_").Append(varName.data());
TH1* histogramTauIdPassed = fillHistogram(testTree, varName, "type==1", "",
histogramTauIdPassedName.Data(), numBinsX, xMin, xMax);
std::cout << "--> histogramTauIdPassed = " << histogramTauIdPassed << ":"
<< " integral = " << histogramTauIdPassed->Integral() << std::endl;
std::cout << "creating histogramTauIdFailed..." << std::endl;
TString histogramTauIdFailedName = TString("histogramTauIdFailed").Append("_").Append(varName.data());
TH1* histogramTauIdFailed = fillHistogram(testTree, varName, "type==0", "",
histogramTauIdFailedName.Data(), numBinsX, xMin, xMax);
std::cout << "--> histogramTauIdFailed = " << histogramTauIdFailed
<< " integral = " << histogramTauIdFailed->Integral() << std::endl;
std::cout << "creating histogramTauIdDenominator..." << std::endl;
TString histogramTauIdDenominatorName = TString("histogramTauIdDenominator").Append("_").Append(varName.data());
TH1* histogramTauIdDenominator = new TH1F(histogramTauIdDenominatorName.Data(),
histogramTauIdDenominatorName.Data(), numBinsX, xMin, xMax);
histogramTauIdDenominator->Add(histogramTauIdPassed);
histogramTauIdDenominator->Add(histogramTauIdFailed);
std::cout << "--> histogramTauIdDenominator = " << histogramTauIdDenominator
<< " integral = " << histogramTauIdDenominator->Integral() << std::endl;
std::cout << "creating histogramFakeRate..." << std::endl;
TString histogramFakeRateName = TString("histogramFakeRate").Append("_").Append(varName.data());
TH1* histogramFakeRate = new TH1F(histogramFakeRateName.Data(),
histogramFakeRateName.Data(), numBinsX, xMin, xMax);
histogramFakeRate->Add(histogramTauIdPassed);
histogramFakeRate->Divide(histogramTauIdDenominator);
std::cout << "--> histogramFakeRate = " << histogramFakeRate
<< " integral = " << histogramFakeRate->Integral() << std::endl;
std::cout << "creating histogramFakeRateWeighted..." << std::endl;
TString histogramFakeRateWeightedName = TString("histogramFakeRateWeighted").Append("_").Append(varName.data());
TH1* histogramFakeRateWeighted = fillHistogram(testTree, varName, "", "MVA_KNN",
histogramFakeRateWeightedName.Data(), numBinsX, xMin, xMax);
histogramFakeRateWeighted->Divide(histogramTauIdDenominator);
std::cout << "--> histogramFakeRateWeighted = " << histogramFakeRateWeighted
<< " entries = " << histogramFakeRateWeighted->GetEntries() << ","
<< " integral = " << histogramFakeRateWeighted->Integral() << std::endl;
// Scale the weighted fake rate histogram
histogramFakeRate->SetTitle(varName.data());
histogramFakeRate->SetStats(false);
histogramFakeRate->SetMinimum(1.e-4);
histogramFakeRate->SetMaximum(1.e+1);
histogramFakeRate->SetLineColor(2);
histogramFakeRate->SetLineWidth(2);
histogramFakeRate->SetMarkerStyle(20);
histogramFakeRate->SetMarkerColor(2);
histogramFakeRate->SetMarkerSize(1);
histogramFakeRate->Draw("e1p");
histogramFakeRateWeighted->SetLineColor(4);
histogramFakeRateWeighted->SetLineWidth(2);
histogramFakeRateWeighted->SetMarkerStyle(24);
histogramFakeRateWeighted->SetMarkerColor(4);
histogramFakeRateWeighted->SetMarkerSize(1);
histogramFakeRateWeighted->Draw("e1psame");
TLegend legend(0.11, 0.73, 0.31, 0.89);
legend.SetBorderSize(0);
legend.SetFillColor(0);
legend.AddEntry(histogramFakeRate, "Tau id. discr.", "p");
legend.AddEntry(histogramFakeRateWeighted, "Fake-Rate weight", "p");
legend.Draw();
canvas->Update();
canvas->Print(outputFileName.data());
}
int main(int argc, char *argv[]){
/////////////////////////////////////
if (argc != 6)
{
std::cout << "Please enter something like: ./run \"filelist_WJets_PU20bx25_100_200.txt\" \"WJets_PU20bx25_100_200\" \"Results\" \"00\" \"0\" " << std::endl;
return EXIT_FAILURE;
}
//get the inputs from user
const string InRootList = argv[1];
const string subSampleKey = argv[2];
const string Outdir = argv[3];
const string inputnumber = argv[4];
const string verbosity = argv[5];
//////////////////////////////////////
int verbose = atoi(verbosity.c_str());
//some varaibles
char filenames[500];
vector<string> filesVec;
ifstream fin(InRootList.c_str());
TChain *sample_AUX = new TChain("TreeMaker2/PreSelection");
char tempname[200];
char histname[200];
const double deltaRMax = 0.1;
const double deltaPtMax = 0.2;
map<string,int> binMap = utils2::BinMap_NoB();
int totNbins=binMap.size();
map<string,int> binMap_mht_nj = utils2::BinMap_mht_nj();
int totNbins_mht_nj=binMap_mht_nj.size();
TH1* hAccAll = new TH1D("hAccAll","Acceptance -- All",totNbins_mht_nj,1,totNbins_mht_nj+1);
TH1* hIsoRecoAll = new TH1D("hIsoRecoAll","Efficiency -- All",totNbins,1,totNbins+1);
TH1* hAccPass = new TH1D("hAccPass","Acceptance -- Pass",totNbins_mht_nj,1,totNbins_mht_nj+1);
TH1* hIsoRecoPass = new TH1D("hIsoRecoPass","Efficiency -- Pass",totNbins,1,totNbins+1);
hAccAll->Sumw2();
hIsoRecoAll->Sumw2();
hAccPass->Sumw2();
hIsoRecoPass->Sumw2();
int TauResponse_nBins=4;
vector<TH1*> vec_resp;
TFile * resp_file = new TFile("TauHad/HadTau_TauResponseTemplates_TTbar_Elog195WithDirectionalTemplates.root","R");
for(int i=0; i<TauResponse_nBins; i++){
sprintf(histname,"hTauResp_%d",i);
vec_resp.push_back( (TH1D*) resp_file->Get( histname )->Clone() );
}
///read the file names from the .txt files and load them to a vector.
while(fin.getline(filenames, 500) ){filesVec.push_back(filenames);}
cout<< "\nProcessing " << subSampleKey << " ... " << endl;
for(unsigned int in=0; in<filesVec.size(); in++){ sample_AUX->Add(filesVec.at(in).c_str()); }
// --- Analyse the events --------------------------------------------
Selection * sel = new Selection();
Utils * utils = new Utils();
// Interface to the event content
Events * evt = new Events(sample_AUX, subSampleKey,verbose);
// Loop over the events (tree entries)
int eventN=0;
while( evt->loadNext() ){
// if(eventN>10000)break;
eventN++;
// Through out an event that contains HTjets with bad id
if(evt->JetId()==0)continue;
//printf("\n@@@@@@@@@@@@@@@@@@@@@@@@@@ \n event: %d \n Njet: %d HT: %g MHT: %g dphi1: %g dphi2: %g dphi3: %g \n ",eventN-1,evt->nJets(),evt->ht(),evt->mht(),evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3()); //Ahmad3
// Apply the NJets baseline-cut
if( !sel->Njet_4(evt->nJets()) ) continue;
// Apply the HT and MHT baseline-cuts
if( !sel->ht_500(evt->ht()) ) continue;
if( !sel->mht_200(evt->mht()) ) continue;
// Apply the delta-phi cuts
// if( !sel->dphi(evt->nJets(),evt->minDeltaPhiN()) ) continue;
if( !sel->dphi(evt->nJets(),evt->deltaPhi1(),evt->deltaPhi2(),evt->deltaPhi3(),evt->deltaPhi4()) ) continue;
if(verbose!=0)printf("\n############ \n event: %d \n ",eventN-1);
double genMuPt=0.;
double genMuEta=-99.;
double genMuPhi=-99.;
int firstMuId=0;
vector<TVector3> genMuonVec;
TVector3 temp3vec;
genMuonVec.clear();
bool isMuon = false;
for(int i=0; i< evt->GenMuPtVec_().size(); i++){
if(evt->GenMuFromTauVec_()[i]==0){
genMuPt = evt->GenMuPtVec_().at(i);
genMuEta = evt->GenMuEtaVec_().at(i);
genMuPhi = evt->GenMuPhiVec_().at(i);
isMuon=true;
temp3vec.SetPtEtaPhi(genMuPt,genMuEta,genMuPhi);
genMuonVec.push_back(temp3vec);
}
if(verbose!=0){
printf("Muon # %d, pt: %g, eta: %g, phi: %g \n ",i,genMuPt,genMuEta,genMuPhi);
}
break; // if more than one muon exist, pick the energetic one.
}
// ask for exactly one muon
if( evt->GenMuPtVec_().size() > 1 ) continue;
if( !( isMuon ) ) continue;
// recompute ht mht njet
double scale;
if(genMuPt >=20.)scale = utils->getRandom(genMuPt,vec_resp );
else scale = utils->getRandom(20.,vec_resp );
double simTauJetPt = scale * genMuPt;
double simTauJetEta = genMuEta;
double simTauJetPhi = genMuPhi;
// 3Vec of muon and scaledMu
TVector3 SimTauJet3Vec,NewTauJet3Vec,Muon3Vec;
SimTauJet3Vec.SetPtEtaPhi(simTauJetPt,simTauJetEta,simTauJetPhi);
Muon3Vec.SetPtEtaPhi(genMuPt,genMuEta,genMuPhi);
// New ht and mht
vector<TVector3> HT3JetVec,MHT3JetVec;
HT3JetVec.clear();
MHT3JetVec.clear();
TVector3 temp3Vec;
int slimJetIdx=-1;
utils->findMatchedObject(slimJetIdx,genMuEta,genMuPhi,evt->slimJetPtVec_(),evt->slimJetEtaVec_(), evt->slimJetPhiVec_(),deltaRMax,verbose);
// If there is no match, add the tau jet as a new one
if(slimJetIdx==-1){
NewTauJet3Vec=SimTauJet3Vec;
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<2.4)HT3JetVec.push_back(NewTauJet3Vec);
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<5.)MHT3JetVec.push_back(NewTauJet3Vec);
}
for(int i=0;i<evt->slimJetPtVec_().size();i++){
if(i!=slimJetIdx){
temp3Vec.SetPtEtaPhi(evt->slimJetPtVec_()[i],evt->slimJetEtaVec_()[i],evt->slimJetPhiVec_()[i]);
if(evt->slimJetPtVec_()[i]>30. && fabs(evt->slimJetEtaVec_()[i])<2.4)HT3JetVec.push_back(temp3Vec);
if(evt->slimJetPtVec_()[i]>30. && fabs(evt->slimJetEtaVec_()[i])<5.)MHT3JetVec.push_back(temp3Vec);
}
else if(i==slimJetIdx){
temp3Vec.SetPtEtaPhi(evt->slimJetPtVec_()[i],evt->slimJetEtaVec_()[i],evt->slimJetPhiVec_()[i]);
NewTauJet3Vec=temp3Vec-Muon3Vec+SimTauJet3Vec;
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<2.4)HT3JetVec.push_back(NewTauJet3Vec);
if(NewTauJet3Vec.Pt()>30. && fabs(NewTauJet3Vec.Eta())<5.)MHT3JetVec.push_back(NewTauJet3Vec);
}
}
// Order the HT3JetVec and MHT3JetVec based on their pT
HT3JetVec = utils->Order_the_Vec(HT3JetVec);
MHT3JetVec = utils->Order_the_Vec(MHT3JetVec);
double newHT=0,newMHT=0,newMHTPhi=-1;
TVector3 newMHT3Vec;
for(int i=0;i<HT3JetVec.size();i++){
newHT+=HT3JetVec[i].Pt();
}
for(int i=0;i<MHT3JetVec.size();i++){
newMHT3Vec-=MHT3JetVec[i];
}
newMHT=newMHT3Vec.Pt();
newMHTPhi=newMHT3Vec.Phi();
//New #Jet
int newNJet = HT3JetVec.size();
if(verbose==1)printf("newNJet: %d \n ",newNJet);
// Acceptance determination 1: Counter for all events
// with muons at generator level
hAccAll->Fill( binMap_mht_nj[utils2::findBin_mht_nj(evt->nJets(),evt->mht()).c_str()] );
// hAccAll->Fill( binMap_mht_nj[utils2::findBin_mht_nj(newNJet,newMHT).c_str()] ); // this doesn't work good
// Check if generator-level muon is in acceptance
if( genMuPt > LeptonAcceptance::muonPtMin() && std::abs(genMuEta) < LeptonAcceptance::muonEtaMax() ) {
if(verbose!=0)printf("Muon is in acceptance \n ");
// Acceptance determination 2: Counter for only those events
// with generator-level muons inside acceptance
// hAccPass->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()] );
hAccPass->Fill( binMap_mht_nj[utils2::findBin_mht_nj(evt->nJets(),evt->mht()).c_str()] );
// hAccPass->Fill( binMap_mht_nj[utils2::findBin_mht_nj(newNJet,newMHT).c_str()] );
// Reconstruction-efficiency determination 1: Counter for all events
// with generator-level muons inside acceptance, regardless of whether
// the muon has also been reconstructed or not.
// hIsoRecoAll->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()]);
hIsoRecoAll->Fill( binMap[utils2::findBin_NoB(evt->nJets(),evt->ht(),evt->mht()).c_str()]);
// Check if the muon has been reconstructed: check if a reconstructed
// muon is present in the event that matches the generator-level muon
// Isolation-efficiency determination 1: Counter for all events with a
// reconstructed muon that has a generator-level muon match inside the
// the acceptance, regardless of whether the reconstructed muon is also
// isolated or not.
//if( evt->MuPtVec_().size()>0 )printf(" RecoMu--> Pt: %g eta: %g phi: %g deltaRMax: %g ",evt->MuPtVec_()[0],evt->MuEtaVec_()[0],evt->MuPhiVec_()[0],deltaRMax); // Ahmad3
//else cout << " Muon size is 0 \n " ;
// in R and in pt
int matchedMuonIdx = -1;
if(evt->MuPtVec_().size()>0 && utils->findMatchedObject(matchedMuonIdx,genMuEta,genMuPhi,evt->MuPtVec_(),evt->MuEtaVec_(),evt->MuPhiVec_(),deltaRMax,verbose) ) {
// Muon is reconstructed
const double relDeltaPtMu = std::abs(genMuPt - evt->MuPtVec_().at(matchedMuonIdx) ) / evt->MuPtVec_().at(matchedMuonIdx) ;
if(verbose!=0)printf(" relDeltaPtMu: %g \n ",relDeltaPtMu);
if( relDeltaPtMu < deltaPtMax ) {
// and matches generated pt
if(verbose!=0)printf("Muon is reconstructed \n ");
// Check if the muon is also isolated: check if an isolated muon is present
// in the event that matches the reconstructed muon in R
if( /*muonsRelIso->at(matchedMuonIdx) <= Selection::muIso()*/ true ){
//.................//.................//
// Currently muons are picked if they are isolated.
// So we don't need to put a cut here.
//.................//.................//
// Muon is isolated
if(verbose!=0)printf("Muon is isolated \n ");
// Reconstruction-efficiency determination 2: Counter for those events
// with generator-level muons inside acceptance where the muon has also
// been reconstructed.
// Isolation-efficiency determination 2: Counter for those events where
// the muon is also isolated.
// hIsoRecoPass->Fill( binMap[utils2::findBin(cntNJetsPt30Eta24,nbtag,HT,template_mht).c_str()] );
hIsoRecoPass->Fill( binMap[utils2::findBin_NoB(evt->nJets(),evt->ht(),evt->mht()).c_str()] );
} // End of muon is isolated
} // End of pt matching
} // End of reconstructed muon
} // End of muon in acceptance
} // end of loop over events
// Compute acceptance
TH1* hAcc = static_cast<TH1*>(hAccPass->Clone("hAcc"));
hAcc->Divide(hAccPass,hAccAll,1,1,"B");// we use B option here because the two histograms are correlated. see TH1 page in the root manual.
// Compute efficiencies
TH1* hEff = static_cast<TH1*>(hIsoRecoPass->Clone("hEff"));
hEff->Divide(hIsoRecoPass,hIsoRecoAll,1,1,"B");
if(verbose!=0){
for(int j=1; j<= totNbins; j++){
printf("hAccAll: %g hAccPass: %g hAcc: %g hIsoRecoAll: %g hIsoRecoPass: %g hEff: %g \n ",hAccAll->GetBinContent(j),hAccPass->GetBinContent(j),hAcc->GetBinContent(j),hIsoRecoAll->GetBinContent(j),hIsoRecoPass->GetBinContent(j),hEff->GetBinContent(j));
}
}
// --- Save the Histograms to File -----------------------------------
sprintf(tempname,"LostLepton/LostLepton2_MuonEfficienciesFrom%s_%s.root",subSampleKey.c_str(),inputnumber.c_str());
TFile outFile(tempname,"RECREATE");
hAcc->Write();
hEff->Write();
hAccAll->Write();
hAccPass->Write();
hIsoRecoAll->Write();
hIsoRecoPass->Write();
outFile.Close();
} // end of main
void makePlot(double canvasSizeX, double canvasSizeY,
TH1* histogramTTH,
TH1* histogramData,
TH1* histogramTT,
TH1* histogramTTV,
TH1* histogramEWK,
TH1* histogramRares,
TH1* histogramBgrSum,
TH1* histogramBgrUncertainty,
const std::string& xAxisTitle, double xAxisOffset,
bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
const std::string& outputFileName)
{
TH1* histogramTTH_density = 0;
if ( histogramTTH ) {
if ( histogramData ) checkCompatibleBinning(histogramTTH, histogramData);
histogramTTH_density = divideHistogramByBinWidth(histogramTTH);
}
TH1* histogramData_density = 0;
if ( histogramData ) {
histogramData_density = divideHistogramByBinWidth(histogramData);
}
TH1* histogramTT_density = 0;
if ( histogramTT ) {
if ( histogramData ) checkCompatibleBinning(histogramTT, histogramData);
histogramTT_density = divideHistogramByBinWidth(histogramTT);
}
TH1* histogramTTV_density = 0;
if ( histogramTTV ) {
if ( histogramData ) checkCompatibleBinning(histogramTTV, histogramData);
histogramTTV_density = divideHistogramByBinWidth(histogramTTV);
}
TH1* histogramEWK_density = 0;
if ( histogramEWK ) {
if ( histogramData ) checkCompatibleBinning(histogramEWK, histogramData);
histogramEWK_density = divideHistogramByBinWidth(histogramEWK);
}
TH1* histogramRares_density = 0;
if ( histogramRares ) {
if ( histogramData ) checkCompatibleBinning(histogramRares, histogramData);
histogramRares_density = divideHistogramByBinWidth(histogramRares);
}
TH1* histogramBgrSum_density = 0;
if ( histogramBgrSum ) {
if ( histogramData ) checkCompatibleBinning(histogramBgrSum, histogramData);
histogramBgrSum_density = divideHistogramByBinWidth(histogramBgrSum);
}
TH1* histogramBgrUncertainty_density = 0;
if ( histogramBgrUncertainty ) {
if ( histogramData ) checkCompatibleBinning(histogramBgrUncertainty, histogramData);
histogramBgrUncertainty_density = divideHistogramByBinWidth(histogramBgrUncertainty);
}
TCanvas* canvas = new TCanvas("canvas", "", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetFillStyle(4000);
canvas->SetFillColor(10);
canvas->SetTicky();
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
TPad* topPad = new TPad("topPad", "topPad", 0.00, 0.35, 1.00, 1.00);
topPad->SetFillColor(10);
topPad->SetTopMargin(0.065);
topPad->SetLeftMargin(0.15);
topPad->SetBottomMargin(0.03);
topPad->SetRightMargin(0.05);
topPad->SetLogy(useLogScale);
TPad* bottomPad = new TPad("bottomPad", "bottomPad", 0.00, 0.00, 1.00, 0.35);
bottomPad->SetFillColor(10);
bottomPad->SetTopMargin(0.02);
bottomPad->SetLeftMargin(0.15);
bottomPad->SetBottomMargin(0.31);
bottomPad->SetRightMargin(0.05);
bottomPad->SetLogy(false);
canvas->cd();
topPad->Draw();
topPad->cd();
TAxis* xAxis_top = histogramData_density->GetXaxis();
xAxis_top->SetTitle(xAxisTitle.data());
xAxis_top->SetTitleOffset(xAxisOffset);
xAxis_top->SetLabelColor(10);
xAxis_top->SetTitleColor(10);
TAxis* yAxis_top = histogramData_density->GetYaxis();
yAxis_top->SetTitle(yAxisTitle.data());
yAxis_top->SetTitleOffset(yAxisOffset);
yAxis_top->SetTitleSize(0.085);
yAxis_top->SetLabelSize(0.05);
yAxis_top->SetTickLength(0.04);
TLegend* legend = new TLegend(0.66, 0.45, 0.94, 0.92, NULL, "brNDC");
legend->SetFillStyle(0);
legend->SetBorderSize(0);
legend->SetFillColor(10);
legend->SetTextSize(0.055);
histogramData_density->SetTitle("");
histogramData_density->SetStats(false);
histogramData_density->SetMaximum(yMax);
histogramData_density->SetMinimum(yMin);
histogramData_density->SetMarkerStyle(20);
histogramData_density->SetMarkerSize(2);
histogramData_density->SetMarkerColor(kBlack);
histogramData_density->SetLineColor(kBlack);
legend->AddEntry(histogramData_density, "Observed", "p");
histogramData_density->Draw("ep");
legend->AddEntry(histogramTTH_density, "t#bar{t}H", "l");
histogramTT_density->SetTitle("");
histogramTT_density->SetStats(false);
histogramTT_density->SetMaximum(yMax);
histogramTT_density->SetMinimum(yMin);
histogramTT_density->SetFillColor(kMagenta - 10);
legend->AddEntry(histogramTT_density, "t#bar{t}+jets", "f");
histogramTTV_density->SetFillColor(kOrange - 4);
legend->AddEntry(histogramTTV_density, "t#bar{t}+V", "f");
histogramEWK_density->SetFillColor(kRed + 2);
legend->AddEntry(histogramEWK_density, "EWK", "f");
histogramRares_density->SetFillColor(kBlue - 8);
legend->AddEntry(histogramRares_density, "Rares", "f");
THStack* histogramStack_density = new THStack("stack", "");
histogramStack_density->Add(histogramRares_density);
histogramStack_density->Add(histogramEWK_density);
histogramStack_density->Add(histogramTTV_density);
histogramStack_density->Add(histogramTT_density);
histogramStack_density->Draw("histsame");
histogramBgrUncertainty_density->SetFillColor(kBlack);
histogramBgrUncertainty_density->SetFillStyle(3344);
histogramBgrUncertainty_density->Draw("e2same");
legend->AddEntry(histogramBgrUncertainty_density, "Uncertainty", "f");
histogramTTH_density->SetLineWidth(2);
histogramTTH_density->SetLineStyle(1);
histogramTTH_density->SetLineColor(kBlue);
histogramTTH_density->Draw("histsame");
histogramData_density->Draw("epsame");
histogramData_density->Draw("axissame");
legend->Draw();
addLabel_CMS_luminosity(0.2050, 0.9225, 0.6850);
canvas->cd();
bottomPad->Draw();
bottomPad->cd();
TH1* histogramRatio = (TH1*)histogramData->Clone("histogramRatio");
histogramRatio->Reset();
if ( !histogramRatio->GetSumw2N() ) histogramRatio->Sumw2();
checkCompatibleBinning(histogramRatio, histogramBgrSum);
histogramRatio->Divide(histogramData, histogramBgrSum);
int numBins_bottom = histogramRatio->GetNbinsX();
for ( int iBin = 1; iBin <= numBins_bottom; ++iBin ) {
double binContent = histogramRatio->GetBinContent(iBin);
if ( histogramData && histogramData->GetBinContent(iBin) >= 0. ) histogramRatio->SetBinContent(iBin, binContent - 1.0);
else histogramRatio->SetBinContent(iBin, -10.);
}
histogramRatio->SetTitle("");
histogramRatio->SetStats(false);
histogramRatio->SetMinimum(-0.50);
histogramRatio->SetMaximum(+0.50);
histogramRatio->SetMarkerStyle(histogramData_density->GetMarkerStyle());
histogramRatio->SetMarkerSize(histogramData_density->GetMarkerSize());
histogramRatio->SetMarkerColor(histogramData_density->GetMarkerColor());
histogramRatio->SetLineColor(histogramData_density->GetLineColor());
histogramRatio->Draw("ep");
TAxis* xAxis_bottom = histogramRatio->GetXaxis();
xAxis_bottom->SetTitle(xAxis_top->GetTitle());
xAxis_bottom->SetLabelColor(1);
xAxis_bottom->SetTitleColor(1);
xAxis_bottom->SetTitleOffset(1.20);
xAxis_bottom->SetTitleSize(0.13);
xAxis_bottom->SetLabelOffset(0.02);
xAxis_bottom->SetLabelSize(0.10);
xAxis_bottom->SetTickLength(0.055);
TAxis* yAxis_bottom = histogramRatio->GetYaxis();
yAxis_bottom->SetTitle("#frac{Data - Simulation}{Simulation}");
yAxis_bottom->SetTitleOffset(0.80);
yAxis_bottom->SetNdivisions(505);
yAxis_bottom->CenterTitle();
yAxis_bottom->SetTitleSize(0.09);
yAxis_bottom->SetLabelSize(0.10);
yAxis_bottom->SetTickLength(0.04);
TH1* histogramRatioUncertainty = (TH1*)histogramBgrUncertainty->Clone("histogramRatioUncertainty");
if ( !histogramRatioUncertainty->GetSumw2N() ) histogramRatioUncertainty->Sumw2();
checkCompatibleBinning(histogramRatioUncertainty, histogramBgrUncertainty);
histogramRatioUncertainty->Divide(histogramBgrSum);
int numBins = histogramRatioUncertainty->GetNbinsX();
for ( int iBin = 1; iBin <= numBins; ++iBin ) {
double binContent = histogramRatioUncertainty->GetBinContent(iBin);
histogramRatioUncertainty->SetBinContent(iBin, binContent - 1.0);
}
histogramRatioUncertainty->SetFillColor(histogramBgrUncertainty_density->GetFillColor());
//histogramRatioUncertainty->SetFillStyle(histogramBgrUncertainty_density->GetFillStyle());
histogramRatioUncertainty->SetFillStyle(3644);
TF1* line = new TF1("line","0", xAxis_bottom->GetXmin(), xAxis_bottom->GetXmax());
line->SetLineStyle(3);
line->SetLineWidth(1);
line->SetLineColor(kBlack);
line->Draw("same");
histogramRatioUncertainty->Draw("e2same");
histogramRatio->Draw("epsame");
canvas->Update();
size_t idx = outputFileName.find(".");
std::string outputFileName_plot(outputFileName, 0, idx);
if ( useLogScale ) outputFileName_plot.append("_log");
else outputFileName_plot.append("_linear");
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete histogramTTH_density;
delete histogramData_density;
delete histogramTT_density;
delete histogramTTV_density;
delete histogramEWK_density;
delete histogramRares_density;
delete histogramBgrSum_density;
//delete histogramBgrUncertainty_density;
delete histogramStack_density;
delete legend;
delete topPad;
delete histogramRatio;
delete histogramRatioUncertainty;
delete line;
delete bottomPad;
delete canvas;
}
// === Main Function ===================================================
void hadTau1(unsigned int id = 11, int nEvts = -1) {
// --- Declare the Output Histograms ---------------------------------
// The tau response templates
// They are filled for different bins in generated tau-lepton pt.
// The binning is encapsulated in ../Utils/TauResponse.h
std::vector<TH1*> hTauResp(TauResponse::nBins());
for(unsigned int i = 0; i < TauResponse::nBins(); ++i) {
hTauResp.at(i) = new TH1D(TauResponse::name(i),";p_{T}(visible) / p_{T}(generated);Probability",50,0.,2.5);
hTauResp.at(i)->Sumw2();
}
// Control histograms for the jet-tau matching efficiency
TH1* hNJetAll = new TH1D("hNJetAll",";N(jets)",10,0,10);
hNJetAll->Sumw2();
TH1* hNJetPass = static_cast<TH1*>(hNJetAll->Clone("hNJetPass"));
TH1* hHtAll = new TH1D("hHtAll",";H_{T} [GeV]",30,0,3000);
hHtAll->Sumw2();
TH1* hHtPass = static_cast<TH1*>(hHtAll->Clone("hHtPass"));
TH1* hMhtAll = new TH1D("hMhtAll",";#slash{H}_{T} [GeV]",20,0,2000);
hMhtAll->Sumw2();
TH1* hMhtPass = static_cast<TH1*>(hMhtAll->Clone("hMhtPass"));
// --- Analyse the events --------------------------------------------
// Interface to the event content
Event* evt = new Event(Sample::fileNameFullSample(id),nEvts);
// Loop over the events (tree entries)
while( evt->loadNext() ) {
// Select only events where the W decayed into a hadronically
// decaying tau
if( !(evt->flgW() == 15 && evt->flgTau() == 1) ) continue;
// Kinematic variables of generator-level tau
const float genTauPt = evt->genLeptonPt();
const float genTauEta = evt->genLeptonEta();
const float genTauPhi = evt->genLeptonPhi();
// Use only events where the tau is inside the muon acceptance
// because lateron we will apply the response to muon+jet events
if( genTauPt < TauResponse::ptMin() ) continue;
if( std::abs(genTauEta) > TauResponse::etaMax() ) continue;
// "Cross cleaning": find the jet that originates in the
// hadronic tau-decay. Associate the jet that is closest in
// deltaR to the tau. The distance has to be smaller than deltaRMax.
// First, fill counters before jet-tau matching
hNJetAll->Fill(evt->nJets());
hHtAll->Fill(evt->ht());
hMhtAll->Fill(evt->mht());
// Do the matching
int tauJetIdx = -1; // Will store the index of the jet matched to the tau
const float deltaRMax = genTauPt < 50. ? 0.2 : 0.1; // Increase deltaRMax at low pt to maintain high-enought matching efficiency
if( !utils::findMatchedObject(tauJetIdx,genTauEta,genTauPhi,evt->jetsEta(),evt->jetsPhi(),evt->jetsN(),deltaRMax) ) continue;
// Then, fill counters after matching
hNJetPass->Fill(evt->nJets());
hHtPass->Fill(evt->ht());
hMhtPass->Fill(evt->mht());
// Calculate RA2 selection-variables from "cleaned" jets,
// i.e. jets withouth the tau-jet
int selNJet = 0; // Number of HT jets (jets pt > 50 GeV and |eta| < 2.5)
for(int jetIdx = 0; jetIdx < evt->jetsN(); ++jetIdx) { // Loop over reco jets
// Skip this jet if it is the tau
if( jetIdx == tauJetIdx ) continue;
// Calculate NJet
if( evt->jetsPt()[jetIdx] > Selection::htJetPtMin() && std::abs(evt->jetsEta()[jetIdx]) < Selection::htJetEtaMax() ) selNJet++;
} // End of loop over reco jets
// Select only events with at least 2 HT jets
if( selNJet < 2 ) continue;
// Fill histogram with relative visible energy of the tau
// ("tau response template") for hadronically decaying taus
for(int jetIdx = 0; jetIdx < evt->jetsN(); ++jetIdx) { // Loop over reco jets
// Select tau jet
if( jetIdx == tauJetIdx ) {
// Get the response pt bin for the tau
const unsigned int ptBin = TauResponse::ptBin(genTauPt);
// Fill the corresponding response template
const double tauJetPt = evt->jetsPt()[jetIdx];
hTauResp.at(ptBin)->Fill( tauJetPt / genTauPt );
break; // End the jet loop once the tau jet has been found
}
} // End of loop over reco jets
} // End of loop over tree entries
// Normalize the response distributions to get the probability density
for(unsigned int i = 0; i < hTauResp.size(); ++i) {
if( hTauResp.at(i)->Integral("width") > 0. ) {
hTauResp.at(i)->Scale(1./hTauResp.at(i)->Integral("width"));
}
}
// Get the jet-tau matching efficiency
TH1* hMatchEffNJet = static_cast<TH1*>(hNJetPass->Clone("hMatchEffNJet"));
hMatchEffNJet->Divide(hNJetAll);
TH1* hMatchEffHt = static_cast<TH1*>(hHtPass->Clone("hMatchEffHt"));
hMatchEffHt->Divide(hHtAll);
TH1* hMatchEffMht = static_cast<TH1*>(hMhtPass->Clone("hMatchEffMht"));
hMatchEffMht->Divide(hMhtAll);
// --- Save the Histograms to File -----------------------------------
TFile outFile("../data/HadTau_TauResponseTemplates.root","RECREATE");
for(unsigned int i = 0; i < hTauResp.size(); ++i) {
hTauResp.at(i)->Write();
}
hMatchEffNJet->Write();
hMatchEffHt->Write();
hMatchEffMht->Write();
outFile.Close();
}
void makeMuEff(const string filename="")
{
if (filename.length()<1)
{
cout << "Need input root file!" << endl;
return;
}
vector< pair<double,double> > vJetBins, vHtBins;
vJetBins.push_back(make_pair(2,2));
vJetBins.push_back(make_pair(3,5));
vJetBins.push_back(make_pair(6,7));
vJetBins.push_back(make_pair(8,1000));
vHtBins.push_back(make_pair(500,8000));
TFile f(filename.c_str());
if (f.IsZombie())
{
cout << "File with name " << filename << " cannot be opened or does not exist!" << endl;
return;
}
const string numname("muEff_num");
const string denname("muEff_den");
TCanvas *c = new TCanvas();
size_t dotpos = filename.find(".");
string substr = filename.substr(0,dotpos);
stringstream epsname_o, epsname, epsname_c;
epsname_o << substr << ".eps[";
epsname << substr << ".eps";
epsname_c << substr << ".eps]";
c->Print(epsname_o.str().c_str());
gStyle->SetOptStat(0);
gStyle->SetPaintTextFormat("1.1f");
for (unsigned jetbin=0; jetbin < vJetBins.size(); ++jetbin)
{
double minjet= vJetBins.at(jetbin).first;
double maxjet= vJetBins.at(jetbin).second;
for (unsigned htbin=0; htbin < vHtBins.size(); ++htbin)
{
double minht= vHtBins.at(htbin).first;
double maxht= vHtBins.at(htbin).second;
stringstream folder, numhistname, denhistname;
folder << "muoneff/Hist/Njet" << minjet << "to" << maxjet << "Ht" << minht << "to" << maxht << "/";
numhistname << folder.str() << numname;
denhistname << folder.str() << denname;
TH1* numhist = dynamic_cast<TH1*>( f.Get(numhistname.str().c_str()));
TH1* denhist = dynamic_cast<TH1*> (f.Get(denhistname.str().c_str()));
if (numhist == NULL)
{
cout << "Numerator hist " << numhistname.str() << " is not found in file " << f.GetName() << endl;
return;
}
if (denhist == NULL)
{
cout << "Denominator hist " << denhistname.str() << " is not found in file " << f.GetName() << endl;
return;
}
numhist->Draw("colz");
c->Print(epsname.str().c_str());
denhist->Draw("colz");
c->Print(epsname.str().c_str());
numhist->Sumw2();
numhist->Divide(denhist);
stringstream title;
title << "Jets " << minjet << "-" << maxjet << ", HT>" << minht << ": Muon Reco+ID efficiency from " << substr << endl;
numhist->SetTitle(title.str().c_str());
//numhist->GetXaxis()->SetRangeUser(0,500);
numhist->SetAxisRange(0,500,"X");
numhist->SetAxisRange(0,3.5,"Y");
//numhist->GetYaxis()->SetRangeUser(0,3.5);
numhist->Draw("colzTEXT90E");
c->Print(epsname.str().c_str());
}
}
c->Print(epsname_c.str().c_str());
}
int ratio5() {
// Constants and arrays
Int_t multi = 2;
const Int_t n_at = 3;
Int_t at[n_at] = { 500, 510, 550 };
//for ( int ii = 0; ii < n_at; ++ii ) { at[ii] = 500 + ii * 10; }
TString eq = "Gt";
const Int_t n = 4;
float pt[n] = { 50., 40., 30., 20. };
Int_t colour[n] = { 1, 2, 3, 4 };
const Int_t m = 2;
Int_t style[m] = { kOpenSquare, kFullSquare };
const Int_t ngr = 1000;
double x3[ngr];
double r[ngr];
int count = 0;
// General style
gStyle->SetOptStat(0);
// // Canvas for RECO curves
// TCanvas* reco_canvas = new TCanvas("Reco");
// reco_canvas->SetFillColor(0);
// reco_canvas->SetLineColor(0);
// reco_canvas->SetLogy();
// TLegend* reco_legend = new TLegend( 0.5, 0.7, 0.88, 0.88, NULL, "brNDC" );
// reco_legend->SetFillColor(0);
// reco_legend->SetLineColor(0);
// bool empty = true;
// double reco_max = 1.e-15.;
// double reco_min = 1.e15;
// Loop through pt bins
for ( Int_t i = 0; i < 1; ++i ) {
std::stringstream pt_can;
pt_can << "PtBin" << pt[i];
// Canvas for Pt bin
TCanvas* pt_canvas = new TCanvas(TString(pt_can.str()),"");
pt_canvas->SetFillColor(0);
pt_canvas->SetLineColor(0);
pt_canvas->SetLogy();
TLegend* pt_legend = new TLegend( 0.82, 0.5, 0.98, 0.9, NULL, "brNDC" );
pt_legend->SetFillColor(0);
pt_legend->SetLineColor(0);
bool empty = true;
double pt_max = 1.e-15.;
double pt_min = 1.e15;
std::vector<TH1*> pt_ratio;
pt_canvas->SetRightMargin(0.2);
// Open files
std::stringstream ss;
ss << "results/4/Reco" << pt[i] << "_QCDPythia6.root";
TString name(ss.str());
TFile* file = new TFile(name);
if ( file->IsZombie() || !(file->IsOpen()) ) { continue; }
file->cd();
// Loop through AlphaT thresolds
for ( Int_t iat = 0; iat < n_at; ++iat ) {
// Loop through RECO and GEN
for ( Int_t j = 0; j < m; ++j ) {
// Define names of histos to open
std::stringstream pre;
std::stringstream post;
if ( j == 0 ) {
pre << "Ratio" << at[iat] << "/GenHt" << eq << "PreAlphaT" << at[iat] << "_" << multi;
post << "Ratio" << at[iat] << "/GenHt" << eq << "PostAlphaT" << at[iat] << "_" << multi;
std::cout << pre.str() << std::endl;
std::cout << post.str() << std::endl;
} else if ( j == 1 ) {
pre << "Ratio" << at[iat] << "/Ht" << eq << "PreAlphaT" << at[iat] << "_" << multi;
post << "Ratio" << at[iat] << "/Ht" << eq << "PostAlphaT" << at[iat] << "_" << multi;
std::cout << pre.str() << std::endl;
std::cout << post.str() << std::endl;
}
// Create ratio histo
TH1* denominator = his( (TH1*)file->Get(TString(pre.str())), 45, 200., 650. );
TH1* numerator = his( (TH1*)file->Get(TString(post.str())), 45, 200., 650. );
int rebin = 5;
numerator->Rebin(rebin);
denominator->Rebin(rebin);
TH1* ratio = (TH1*)numerator->Clone();
ratio->Divide(denominator);
//ratio->Divide(numerator,denominator,1.,1.,"b"); //@@ poisson errors
ratio->SetMarkerStyle(style[j]);
ratio->SetMarkerSize(1.2);
ratio->SetMarkerColor(iat+1);//colour[iat]);
ratio->SetBarOffset(0.1*i);
//ratio->GetXaxis()->SetRangeUser(100.,550.);
ratio->GetYaxis()->SetRangeUser(1.e-7,1.e-1);
ratio->GetXaxis()->SetTitle("HT_{reco} [GeV]");
ratio->GetYaxis()->SetTitle("R(#alpha_{T})");
if ( ratio->GetMaximum() > 0. &&
ratio->GetMaximum() > pt_max ) {
pt_max = ratio->GetMaximum();
}
if ( ratio->GetMinimum() > 0. &&
ratio->GetMinimum() < pt_min ) {
pt_min = ratio->GetMinimum();
}
pt_ratio.push_back(ratio);
if ( empty ) { ratio->Draw(""); empty = false; }
else { ratio->Draw("same"); }
//ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1);
// Text for legend
std::stringstream pt_leg;
if ( j == 0 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", GEN"; }
else if ( j == 1 ) { pt_leg << "#alpha_{T} = " << at[iat]/1000. << ", RECO"; }
pt_legend->AddEntry( ratio, TString(pt_leg.str()), "lep" );
// // Draw histos on canvas for RECO only
// if ( j == 1 ) {
// reco_canvas->cd();
// if ( i == 0 ) ratio->Draw("");
// else ratio->Draw("same");
// std::stringstream reco_leg;
// reco_leg << "p_{T}^{min} = " << pt[i];
// reco_legend->AddEntry( ratio, TString(reco_leg.str()), "lep" );
// }
}
}
// if (0) {
// int nbins = ratio->GetNbinsX();
// int bin_width = ratio->GetBinWidth(1);
// double lower = 0.;
// double upper = 1400.;
// int bin_lower = int( ( lower - ratio->GetBinLowEdge(1) ) / bin_width );
// for ( Int_t ii = bin_lower; ii < ratio->GetNbinsX()-1; ++ii ) {
// if ( ratio->GetBinContent(ii) > 0. ) {
// lower = ratio->GetBinCenter(ii);
// break;
// }
// }
// int bin_upper = int( ( upper - ratio->GetBinLowEdge(1) ) / bin_width );
// for ( Int_t ii = bin_upper; ii > 0; --ii ) {
// if ( ratio->GetBinContent(ii) > 0. ) {
// upper = ratio->GetBinCenter(ii);
// break;
// }
// }
// if (0) {
// std::cout << " bin_width: " << bin_width
// << " bin_lower: " << bin_lower
// << " bin_upper: " << bin_upper
// << " lower: " << lower
// << " upper: " << upper
// << std::endl;
// }
// TF1* fit = new TF1(sample[i],"expo",lower,upper);
// fit->SetLineColor(colour[i]);
// fit->SetLineWidth(1);
// ratio->Fit(sample[i],"QR","same");
// }
pt_canvas->cd();
// for ( Int_t iii = 0; iii < pt_ratio.size(); ++iii ) {
// TH1* ratio = pt_ratio[iii];
// if ( !ratio ) { continue; }
// if ( ii == 0 ) { ratio->Draw(""); }
// else { ratio->Draw("same"); }
// ratio->GetYaxis()->SetRangeUser(pt_min/1.1,pt_max*1.1);
// }
pt_legend->Draw("same");
pt_canvas->Update();
pt_canvas->SaveAs(TString(pt_can.str()+".png"));
// pt_canvas->SaveAs(TString(pt_can.str()+".C"));
}
// reco_canvas->cd();
// reco_legend->Draw("same");
// reco_canvas->Update();
// reco_canvas->SaveAs(TString("Reco.png"));
// reco_canvas->SaveAs(TString("Reco.C"));
// TCanvas* c2 = new TCanvas("C2");
// c2->SetLogy();
// c2->SetFillColor(0);
// gStyle->SetOptStat(0);
// if ( count > 0 ) {
// TGraph* graph = new TGraph(count,x3,r);
// graph->Draw("a*");
// }
}
void FakeLeptonPlotter::writeFakeRate(string extension)
{
for( unsigned int iVar = 0; iVar < nHistograms; ++iVar )
{
if( configContainer.addOverflow )
{
histogramContainers[iVar].addOverflow();
}
if( configContainer.addUnderflow )
{
histogramContainers[iVar].addUnderflow();
}
HistogramContainer fakeHistCont("fake_rate_" + histogramContainers[iVar].containerName, 1);
vector<TH1*> hMC;
bool hasEwkCorrection = false;
for( unsigned int iSample = 0; iSample < nSamples; ++iSample )
{
if( histogramContainers[iVar].sampleType[iSample] == SampleType::DATA )
{
fakeHistCont.add(histogramContainers[iVar], iSample);
}
else if( configContainer.sampleContainer.sampleType[iSample] == SampleType::MC )
{
hMC.push_back(histogramContainers[iVar].histograms[iSample]);
hasEwkCorrection = true;
}
}
// Add QCD signal
for( unsigned int iSample = 0; iSample < nSamples; ++iSample )
{
if( histogramContainers[iVar].sampleType[iSample] == SampleType::SIGNAL )
{
fakeHistCont.add(histogramContainers[iVar], iSample);
}
}
// EKW MC correction
if( hasEwkCorrection )
{
// Add data without ewk correction
fakeHistCont.add(fakeHistCont, 0);
fakeHistCont.color.back() += 3;
fakeHistCont.reducedNames.back() += "_before_ewk_correction";
fakeHistCont.histograms.back() = (TH1*) fakeHistCont.histograms[0]->Clone();
}
for( TH1* h : hMC )
{
fakeHistCont.histograms[0]->Add(h, -1.);
}
// Seperate Numerator and Denominator
if( histogramContainers[iVar].containerName.find("lepton") != string::npos )
{
if( histogramContainers[iVar].containerName.find("loose") != string::npos )
{
hDenomVector.push_back(fakeHistCont.histograms);
}
else
{
fakeHistogramContainers.push_back(fakeHistCont);
}
}
}
for( unsigned int iFake = 0; iFake < fakeHistogramContainers.size(); ++iFake )
{
for( unsigned int iHist = 0; iHist < fakeHistogramContainers[iFake].histograms.size(); ++iHist )
{
// remove underflow in numerator, important for TGraphAsymmErrors to work!
fakeHistogramContainers[iFake].histograms[iHist]->ClearUnderflowAndOverflow();
// fill empty/negative bins
unsigned int nBins = fakeHistogramContainers[iFake].histograms[iHist]->GetNcells();
for( unsigned int i = 0; i < (nBins+2); ++i )
{
if( hDenomVector[iFake][iHist]->GetBinContent(i) <= 0)
{
hDenomVector[iFake][iHist]->SetBinContent(i,1.);
fakeHistogramContainers[iFake].histograms[iHist]->SetBinContent(i,0.);
}
if( fakeHistogramContainers[iFake].histograms[iHist]->GetBinContent(i) < 0.)
{
fakeHistogramContainers[iFake].histograms[iHist]->SetBinContent(i,0);
}
if( fakeHistogramContainers[iFake].histograms[iHist]->GetBinContent(i) > hDenomVector[iFake][iHist]->GetBinContent(i) )
{
fakeHistogramContainers[iFake].histograms[iHist]->SetBinContent(i,hDenomVector[iFake][iHist]->GetBinContent(i));
}
}
}
// Make plots
BasePlotter::writeEfficiency(fakeHistogramContainers[iFake], hDenomVector[iFake], extension);
}
// Write histrograms
system(("mkdir -p " + configContainer.outputDir).c_str());
TFile* f = new TFile((configContainer.outputDir + "Fakerate.root").c_str(), "RECREATE");
for( unsigned int iFake = 0; iFake < fakeHistogramContainers.size(); ++iFake )
{
if( fakeHistogramContainers[iFake].histograms[0]->GetDimension() == 1 )
{
// Write Data FR
TGraphAsymmErrors* tgraph = new TGraphAsymmErrors(fakeHistogramContainers[iFake].histograms[0], hDenomVector[iFake][0], "cl=0.683 b(1,1) mode");
tgraph->Write();
// Write MC signal FR
for( unsigned int iHist = 0; iHist < fakeHistogramContainers[iFake].histograms.size(); ++iHist )
{
if( fakeHistogramContainers[iFake].sampleType[iHist] == SampleType::SIGNAL )
{
TGraphAsymmErrors* tgraph = new TGraphAsymmErrors(fakeHistogramContainers[iFake].histograms[iHist], hDenomVector[iFake][iHist], "cl=0.683 b(1,1) mode");
tgraph->Write();;
}
}
}
else
{
// Write Data FR
TH1* hTemp = (TH1*) fakeHistogramContainers[iFake].histograms[0]->Clone();
hTemp->Divide(hDenomVector[iFake][0]);
hTemp->Write();
// Write MC signal FR
for( unsigned int iHist = 0; iHist < fakeHistogramContainers[iFake].histograms.size(); ++iHist )
{
if( fakeHistogramContainers[iFake].sampleType[iHist] == SampleType::SIGNAL )
{
TH1* hTemp = (TH1*) fakeHistogramContainers[iFake].histograms[iHist]->Clone();
hTemp->Divide(hDenomVector[iFake][iHist]);
hTemp->Write();
}
}
}
}
f->Close();
// verbose output
for( unsigned int iVar = 0; iVar < fakeHistogramContainers.size(); ++iVar )
{
if( iVar == 0 )
BasePlotter::writeHist("fake_lepton_intermediate.root", fakeHistogramContainers[iVar].histograms, "RECREATE");
else
BasePlotter::writeHist("fake_lepton_intermediate.root", fakeHistogramContainers[iVar].histograms, "UPDATE");
BasePlotter::writeHist("fake_lepton_intermediate.root", hDenomVector[iVar], "UPDATE");
}
}
int main(int argc, char* argv[]) {
TFile* dataFile=TFile::Open("pu_truth_data2015_50bins.root");
TFile* mcFile = TFile::Open("computed_mc_GJET_plus_QCD_pu_truth_50bins.root");
TH1* dataHisto = static_cast<TH1*>(dataFile->Get("pileup"));
TH1* mcHisto = static_cast<TH1*>(mcFile->Get("pileup"));
TFile f1("/cmshome/fpreiato/GammaJet/CMSSW_7_4_14/src/JetMETCorrections/GammaJetFilter/analysis/tuples/GJET_MC/PhotonJet_2ndLevel_GJet_Pt-15To6000_TuneCUETP8M1-Flat_13TeV_pythia8_25ns_ReReco.root");
TTree* AnalysisTree_mc = (TTree*) f1.Get("gammaJet/analysis");
uint64_t totalEvents_mc = AnalysisTree_mc->GetEntries();
///////////////////////////////////////////////////////////////////
// Normalize
dataHisto->Scale(1.0 / dataHisto->Integral());
mcHisto->Scale(1.0 / mcHisto->Integral());
TCanvas *c1 = new TCanvas("c1","c1",800,800);
dataHisto-> SetLineColor(kBlue);
mcHisto -> SetLineColor(kRed);
dataHisto -> Draw();
mcHisto -> Draw("same");
c1-> SaveAs("Plot/pileup_truth.png");
// c1-> SaveAs("pileup_truth.root");
// MC * data / MC = data, so the weights are data/MC:
TH1* ratioHisto = static_cast<TH1*>(dataHisto->Clone());
ratioHisto->Divide(mcHisto);
int NBins = ratioHisto->GetNbinsX();
for (int ibin = 1; ibin < NBins + 1; ++ibin) {
std::cout << " " << ibin - 1 << " " << ratioHisto->GetBinContent(ibin) << std::endl;
}
TCanvas *c2 = new TCanvas("c2","c2",800,800);
ratioHisto -> Draw();
c2-> SaveAs("Plot/ratioHisto.png");
// c2-> SaveAs("ratioHisto.root");
TH1D* mcHisto_reweighted = new TH1D("mcHisto_reweighted", "mc Reweighted", 50, 0, 50);
for (uint64_t i = 0; i < totalEvents_mc; i++) {
if(i == 0 || i % 5000 == 0) cout<< "Events processed "<< i <<endl;
AnalysisTree_mc->GetEntry(i);
Float_t interaction;
AnalysisTree_mc->SetBranchAddress("ntrue_interactions", &interaction);
//cout<< ptPhot << endl;
int bin = ratioHisto ->GetXaxis()-> FindBin(interaction);
float PUweight = ratioHisto -> GetBinContent(bin);
double generator_weight;
AnalysisTree_mc->SetBranchAddress("generator_weight", &generator_weight);
if(generator_weight == 0) generator_weight = 1;
float event_weight;
AnalysisTree_mc->SetBranchAddress("evtWeightTot", &event_weight);
double Weight = PUweight* generator_weight * event_weight;
// cout<< "nvertex "<< nvertex_mc<<endl;
// cout<< "PUWeight "<< PUweight<<endl;
mcHisto_reweighted -> Fill(interaction, Weight);
}
mcHisto_reweighted ->Scale(1.0 / mcHisto_reweighted->Integral());
TCanvas *c3 = new TCanvas("c3","c3",800,800);
dataHisto -> SetLineColor(kBlue);
mcHisto_reweighted -> SetLineColor(kRed);
dataHisto -> Draw();
mcHisto_reweighted -> Draw("same");
c3-> SaveAs("Plot/Histo_reweighted.png");
// c3-> SaveAs("Histo_reweighted.root");
}//main
void
GetEccenNpart_new(char* xname = "ile")
{
gStyle->SetOptStat(0);
gStyle->SetTitle(0);
char name[100];
TChain* ch = new TChain("t");
int n;
//you need a file list of root ntuple: fxxxx.lis
//
sprintf(name,"f%s.lis",xname);
cout << "open the filelist : " << name << endl;
ifstream fin(name);
string filename;
while(!fin.eof()){
fin >> filename;
if(filename.empty()) continue;
cout << filename << endl;
ch->AddFile(filename.c_str());
}
fin.close();
double b;
int ncoll;
int npart;
int nHitBbc_n, nHitBbc_s;
double qBBC_n, qBBC_s;
double vertex, ecc_std, ecc_rp, ecc_part,e4;
double r_oll,r_geo,r_arith;
ch->SetBranchAddress("b", &b );
ch->SetBranchAddress("vertex", &vertex );
ch->SetBranchAddress("ncoll", &ncoll );
ch->SetBranchAddress("npart", &npart );
ch->SetBranchAddress("ecc_std", &ecc_std );
ch->SetBranchAddress("ecc_rp", &ecc_rp );
ch->SetBranchAddress("ecc_part", &ecc_part );
ch->SetBranchAddress("r_ollitra", &r_oll );
ch->SetBranchAddress("r_geo", &r_geo );
ch->SetBranchAddress("r_arith", &r_arith );
ch->SetBranchAddress("e4", &e4 );
ch->SetBranchAddress("qBBC_n", &qBBC_n );
ch->SetBranchAddress("qBBC_s", &qBBC_s );
ch->SetBranchAddress("nHitBbc_n", &nHitBbc_n);
ch->SetBranchAddress("nHitBbc_s", &nHitBbc_s);
char fname[100];
sprintf(fname,"rootfile/g%s_cent.root",xname);
TFile* fout = new TFile(fname,"recreate");//rootfile to save distributions
TH1* hbbcq = new TH1D("hbbcq","hbbcq",12000,-0.5,2999.5); hbbcq->Sumw2();
TH1* hbbcqall = new TH1D("hbbcqall","hbbcqall",12000,-0.5,2999.5);hbbcqall->Sumw2();
TH1* hbbcqeff = new TH1D("hbbcqeff","hbbcqeff",12000,-0.5,2999.5);hbbcqeff->Sumw2();
n = ch->GetEntries();
cout << "events: "<< n << endl;
//First loop determines the BBC trigger efficiency
//as function of bbcq;
for(int i=0; i<n; i++){
ch->GetEntry(i);
if(nHitBbc_n>=2&&nHitBbc_s>=2){
hbbcq->Fill( (qBBC_n+qBBC_s)/100. );//divide by 100 to fit in 0-3000 range
}
hbbcqall->Fill( (qBBC_n+qBBC_s)/100. );
}
hbbcqeff->Divide(hbbcq,hbbcqall);
efficiency = hbbcq->Integral()/hbbcqall->Integral();
cout << "efficiency : " << efficiency << endl;
//hbin contains the integrated fraction starting from 0 bbc charge, including the BBC trigger efficiency
TH1* hbin = new TH1D("hbin","hbin",hbbcq->GetNbinsX(),-0.5,2999.5);
TH1* hbbcqscale = (TH1*)hbbcq->Clone("hbbcqscale");
hbbcqscale->Scale(1.0/hbbcq->Integral());
for(int i=1; i<=hbbcqscale->GetNbinsX(); i++){
hbin->SetBinContent(i,hbbcqscale->Integral(1,i));
}
//Following two lines defines the array of cuts and average bbc charge
//for centrality percentitle in 5%, 10% and 20% steps
double bbcq5[21],bbcq10[11],bbcq20[6];
double abbcq5[20],abbcq10[10],abbcq20[5];
//calculate the various variables for 5% step
GetCentrality(hbin,20,bbcq5,hbbcq,abbcq5);
cout << endl << endl;
//calculate the various variables for 10% step
GetCentrality(hbin,10,bbcq10,hbbcq,abbcq10);
cout << endl << endl;
//calculate the various variables for 20% step
GetCentrality(hbin,5,bbcq20,hbbcq,abbcq20);
cout << endl << endl;
cout << " Find cuts for all the centralities " << endl << endl;
const int nval=9;//number of variables to fill
char* centname[3] = {"5pStep","10pStep","20pStep"};
char* varname[nval] = {"npart","ncoll","b","standard_ecc","reactionplane_ecc","participant_ecc","R_Ollitraut","R_Geo", "R_arith"};
double vup[nval] = {499.5,2999.5,19.995,1,1,1,4,4,4};
double vlo[nval] = {-0.5,-0.5,-0.005,-1,-1,-1,0,0,0};
int vNb[nval] = {500,3000,2000,200,200,200,400,400,400};
//initialize the histograms which are used to fill the distribution of variables for each centrality
TH1* hvar[3][nval][20];
for(int i=0; i<3; i++){
int NC = 0;
if(i==0) NC = 20;
else if(i==1) NC = 10;
else if(i==2) NC = 5;
for(int ivar=0; ivar<nval; ivar++){
for(int icen=0; icen<NC; icen++){
sprintf(name,"hvar_%s_%s_cent%d",centname[i],varname[ivar],icen);
hvar[i][ivar][icen] = new TH1D(name,name,vNb[ivar],vlo[ivar],vup[ivar]);
}
}
}
double qbbcsum;
for(int i=0; i<n; i++){
if(i%1000000==0) cout << i << endl;
ch->GetEntry(i);
if(!(nHitBbc_n>=2&&nHitBbc_s>=2)) continue;//BBC trigger condition
qbbcsum = (qBBC_n+qBBC_s)/100.;
int centbin5 = FindBin(20,bbcq5,qbbcsum);
int centbin10 = FindBin(10,bbcq10,qbbcsum);
int centbin20 = FindBin(5,bbcq20,qbbcsum);
if(centbin5==-1) continue;
if(centbin10==-1) continue;
if(centbin20==-1) continue;
//find the weight according to the corresponding average efficiency.
double weight = hbbcqeff->GetBinContent(hbbcqeff->FindBin(qbbcsum));
//5 percent step
//
hvar[0][0][centbin5]->Fill(npart,weight);
hvar[0][1][centbin5]->Fill(ncoll,weight);
hvar[0][2][centbin5]->Fill(b,weight);
hvar[0][3][centbin5]->Fill(ecc_std,weight);
hvar[0][4][centbin5]->Fill(ecc_rp,weight);
hvar[0][5][centbin5]->Fill(ecc_part,weight);
hvar[0][6][centbin5]->Fill(r_oll,weight);
hvar[0][7][centbin5]->Fill(r_geo,weight);
hvar[0][8][centbin5]->Fill(r_arith,weight);
//10 percent step
//
hvar[1][0][centbin10]->Fill(npart,weight);
hvar[1][1][centbin10]->Fill(ncoll,weight);
hvar[1][2][centbin10]->Fill(b,weight);
hvar[1][3][centbin10]->Fill(ecc_std,weight);
hvar[1][4][centbin10]->Fill(ecc_rp,weight);
hvar[1][5][centbin10]->Fill(ecc_part,weight);
hvar[1][6][centbin10]->Fill(r_oll,weight);
hvar[1][7][centbin10]->Fill(r_geo,weight);
hvar[1][8][centbin10]->Fill(r_arith,weight);
//20 percent step
//
hvar[2][0][centbin20]->Fill(npart,weight);
hvar[2][1][centbin20]->Fill(ncoll,weight);
hvar[2][2][centbin20]->Fill(b,weight);
hvar[2][3][centbin20]->Fill(ecc_std,weight);
hvar[2][4][centbin20]->Fill(ecc_rp,weight);
hvar[2][5][centbin20]->Fill(ecc_part,weight);
hvar[2][6][centbin20]->Fill(r_oll,weight);
hvar[2][7][centbin20]->Fill(r_geo,weight);
hvar[2][8][centbin20]->Fill(r_arith,weight);
}
//get mean and RMS values for the variables
float var[3][nval+1][20];
float rms[3][nval+1][20];
for(int i=0; i<3; i++){
int NC = 0;
if(i==0) NC = 20;
else if(i==1) NC = 10;
else if(i==2) NC = 5;
for(int icen=0; icen<NC; icen++){
for(int ivar=0; ivar<nval; ivar++){
var[i][ivar][icen] = hvar[i][ivar][icen]->GetMean();
rms[i][ivar][icen] = hvar[i][ivar][icen]->GetRMS();
}
var[i][nval][icen] = var[i][1][icen]/sigmann;
rms[i][nval][icen] = rms[i][1][icen]/sigmann;
}
}
//save to file
for(int ivar=0; ivar<4; ivar++){
for(int icen=0; icen<16; icen++){
cout<<var[0][ivar][icen]<<",";
}
cout<<var[2][ivar][4]<<",";
cout<<endl;
}
cout.precision(4);
sprintf(name,"5pstepresults/t%s.txt",xname);
ofstream f5(name);
cout << " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<19; icen++){
for(int ivar=0; ivar<7; ivar++){
f5 << var[0][ivar][icen] << " ";
}
f5 << var[0][nval][icen] << " ";
f5 <<endl<< " (";
/* for(int ivar=0; ivar<7; ivar++){
f5 << rms[0][ivar][icen] << " ";
}
f5 << rms[0][nval][icen] << " ";
f5 << ")"<< endl;
*/
cout << icen*5 << "-" << icen*5+5;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[0][ivar][icen] ;
}
cout <<" & " <<var[0][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[0][ivar][icen];
else cout <<" & "<<rms[0][ivar][icen];
}
cout <<" & "<<rms[0][nval][icen];
cout << ")\\\\\\hline" << endl;
// printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[0][0][icen],var[0][1][icen],var[0][2][icen],var[0][3][icen],var[0][4][icen],var[0][5][icen],var[0][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[0][0][icen],rms[0][1][icen],rms[0][2][icen],rms[0][3][icen],rms[0][4][icen],rms[0][5][icen],rms[0][6][icen]);
}
f5.close();
cout << endl << endl;
sprintf(name,"10pstepresults/t%s.txt",xname);
ofstream f10(name);
cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<10; icen++){
for(int ivar=0; ivar<7; ivar++){
f10 << var[1][ivar][icen] << " ";
}
f10 << var[1][nval][icen] << " ";
f10 <<endl<<" (";
/*for(int ivar=0; ivar<7; ivar++){
f10 << rms[1][ivar][icen] << " ";
}
f10 << rms[1][nval][icen] << " ";
f10 << ")" << endl;
*/
cout << icen*10 << "-" << icen*10+10;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[1][ivar][icen] ;
}
cout <<" & " <<var[1][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[1][ivar][icen];
else cout <<" & "<<rms[1][ivar][icen];
}
cout <<" & "<<rms[1][nval][icen];
cout << ")\\\\\\hline" << endl;
//printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[1][0][icen],var[1][1][icen],var[1][2][icen],var[1][3][icen],var[1][4][icen],var[1][5][icen],var[1][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[1][0][icen],rms[1][1][icen],rms[1][2][icen],rms[1][3][icen],rms[1][4][icen],rms[1][5][icen],rms[1][6][icen]);
}
f10.close();
cout << endl << endl;
sprintf(name,"20pstepresults/t%s.txt",xname);
ofstream f20(name);
cout <<endl<< " Bin % & npart & ncoll & b & ecc_std & ecc_rp & ecc_part & r_ollitrau & T_{AB}\\\\\\hline" << endl;
for(int icen=0; icen<5; icen++){
for(int ivar=0; ivar<7; ivar++){
f20 << var[2][ivar][icen] << " ";
}
f20 << var[2][nval][icen] << " ";
f20 << endl<< " (";
/*for(int ivar=0; ivar<7; ivar++){
f20 << rms[2][ivar][icen] << " ";
}
f20 << rms[2][nval][icen] << " ";
f20 << ")"<< endl;
*/
cout << icen*20 << "-" << icen*20+20;
for(int ivar=0; ivar<7; ivar++){
cout <<" & " <<var[2][ivar][icen] ;
}
cout <<" & " <<var[2][nval][icen] ;
cout <<"\\\\"<<endl;
for(int ivar=0; ivar<7; ivar++){
if(ivar==0)cout <<" & ("<<rms[2][ivar][icen];
else cout <<" & "<<rms[2][ivar][icen];
}
cout <<" & "<<rms[2][nval][icen];
cout << ")\\\\\\hline" << endl;
//printf(" & %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f \\\\\n",
// var[2][0][icen],var[2][1][icen],var[2][2][icen],var[2][3][icen],var[2][4][icen],var[2][5][icen],var[2][6][icen]);
//printf(" (& %3.1f & %4.1f & %2.2f & %1.3f & %1.3f & %1.3f & %1.3f) \\\\\\hline\n",
// rms[2][0][icen],rms[2][1][icen],rms[2][2][icen],rms[2][3][icen],rms[2][4][icen],rms[2][5][icen],rms[2][6][icen]);
}
f20.close();
fout->Write();
fout->Close();
return;
}
TCanvas* overlay_Merged_RecoSmeared(const vector<string>& folders,
const hist_t& h
)
{
TLegend *leg = new TLegend(0.6,0.65,0.9,0.9);
leg->SetTextFont(42);
vector<TH1*> hists;
vector<string> jetcoll;
jetcoll.push_back("reco");
jetcoll.push_back("gen");
jetcoll.push_back("smeared");
stringstream title;
const string njets("3-5");
//const string eta("2.5");
const string eta("5.0");
title << njets
<< " Jets, MHT from Jets with P_{T}>30 GeV, |#eta |<"
<< eta << ", L = 10 fb^{-1}" << ";" << h.title ;
for (unsigned j=0; j< jetcoll.size(); ++j)
{
TH1* Hist = 0;
for (unsigned i = 0; i < folders.size(); ++i)
{
stringstream histname;
histname << folders.at(i) << "/" << jetcoll.at(j) << h.name;
cout << __LINE__ << ": Looking for hist: " << histname.str().c_str() << endl;
TH1* htemp = GetHist(histname.str());
if (Hist == 0) Hist = htemp;
else Hist->Add(htemp);
}
Hist->Rebin(h.rebin);
Hist->SetTitle(title.str().c_str());
Hist->SetMarkerStyle(20+j);
Hist->SetLineWidth(2);
Hist->SetStats(0);
stringstream legname;
if (j==0)
{
legname << "Reco";
} else if (j==1)
{
legname << "Gen";
Hist->SetLineColor(kBlue);
Hist->SetMarkerColor(kBlue);
} else if (j==2)
{
legname << "Smeared";
Hist->SetLineColor(kRed);
Hist->SetMarkerColor(kRed);
}
const double sum = Hist->Integral();
legname << " (" << sum << ")";
if (j!=1) leg->AddEntry(Hist, legname.str().c_str());
hists.push_back(Hist);
} //end jetcoll
TH1* ratio = dynamic_cast<TH1*> (hists.at(2)->Clone("ratio"));
ratio->GetYaxis()->SetTitle("Smeared/Reco");
ratio->SetTitle("");
ratio->Divide(hists.at(0));
ratio->GetYaxis()->SetRangeUser(-0.01,2.01);
//ratio->SetTickLength (+0.01,"Y");
//TCanvas *c1 = new TCanvas("c1", "c1",15,60,550,600);
TCanvas *c1 = new TCanvas("c1");
c1->Range(0,0,1,1);
c1->SetBorderSize(2);
c1->SetFrameFillColor(0);
// ------------>Primitives in pad: c1_1
TPad *c1_1 = new TPad("c1_1", "c1_1",0.01,0.30,0.99,0.99);
c1_1->Draw();
c1_1->cd();
c1_1->SetBorderSize(2);
c1_1->SetTickx(1);
c1_1->SetTicky(1);
c1_1->SetTopMargin(0.1);
c1_1->SetBottomMargin(0.0);
//c1_1->SetFrameFillColor(3);
c1_1->SetLogy();
hists.at(0)->GetYaxis()->CenterTitle(1);
hists.at(0)->SetLabelFont(42,"XYZ");
hists.at(0)->SetTitleFont(42,"XYZ");
hists.at(0)->GetYaxis()->SetTitleOffset(0.8);
hists.at(0)->SetLabelSize(0.05,"XYZ");
hists.at(0)->SetTitleSize(0.06,"XYZ");
hists.at(0)->Draw("P");
hists.at(2)->Draw("same P");
leg->Draw();
c1_1->Modified();
c1->cd();
// ------------>Primitives in pad: c1_2
TPad *c1_2 = new TPad("c1_2", "c1_2",0.01,0.01,0.99,0.30);
c1_2->Draw();
c1_2->cd();
c1_2->SetBorderSize(2);
c1_2->SetTickx(1);
c1_2->SetTicky(1);
c1_2->SetTopMargin(0.0);
c1_2->SetBottomMargin(0.24);
c1_2->SetFrameFillColor(0);
c1_2->SetGridx();
c1_2->SetGridy();
ratio->GetYaxis()->SetTitleOffset(0.4);
ratio->GetXaxis()->SetTitleOffset(0.9);
ratio->GetYaxis()->CenterTitle(1);
ratio->GetXaxis()->CenterTitle(1);
ratio->SetLabelSize(0.125,"XYZ");
ratio->SetTitleSize(0.125,"XYZ");
// ratio->SetLabelFont(labelfont,"XYZ");
// ratio->SetTitleFont(titlefont,"XYZ");
ratio->GetXaxis()->SetTickLength(0.07);
ratio->Draw("");
c1_2->Modified();
c1->cd();
//c1->Modified();
//c1->cd();
//c1->SetSelected(c1);
return c1;
}
/**
* Process a single eta bin
*
* @param measured Input collection of measured data
* @param corrections Input collection of correction data
* @param method Unfolding method to use
* @param regParam Regularisation parameter
* @param out Output directory.
*
* @return Stack of histograms or null
*/
THStack* ProcessBin(TCollection* measured,
TCollection* corrections,
UInt_t method,
Double_t regParam,
TDirectory* out)
{
Printf(" Processing %s ...", measured->GetName());
// Try to get the data
TH1* inRaw = GetH1(measured, "rawDist");
TH1* inTruth = GetH1(corrections, "truth");
TH1* inTruthA = GetH1(corrections, "truthAccepted");
TH1* inTrgVtx = GetH1(corrections, "triggerVertex");
TH2* inResp = GetH2(corrections, "response");
if (!inRaw || !inTruth || !inTruthA || !inTrgVtx || !inResp)
return 0;
// Make output directory
TDirectory* dir = out->mkdir(measured->GetName());
dir->cd();
// Copy the input to the output
TH1* outRaw = static_cast<TH1*>(inRaw ->Clone("measured"));
TH1* outTruth = static_cast<TH1*>(inTruth ->Clone("truth"));
TH1* outTruthA = static_cast<TH1*>(inTruthA ->Clone("truthAccepted"));
TH1* outTrgVtx = static_cast<TH1*>(inTrgVtx ->Clone("triggerVertex"));
TH2* outResp = static_cast<TH2*>(inResp ->Clone("response"));
// Make our response matrix
RooUnfoldResponse matrix(0, 0, inResp);
// Store regularization parameter
Double_t r = regParam;
RooUnfold::Algorithm algo = (RooUnfold::Algorithm)method;
RooUnfold* unfolder = RooUnfold::New(algo, &matrix, inRaw, r);
unfolder->SetVerbose(0);
// Do the unfolding and get the result
TH1* res = unfolder->Hreco();
res->SetDirectory(0);
// Make a copy to store on the output
TH1* outUnfold = static_cast<TH1*>(res->Clone("unfolded"));
TString tit(outUnfold->GetTitle());
tit.ReplaceAll("Unfold Reponse matrix", "Unfolded P(#it{N}_{ch})");
outUnfold->SetTitle(tit);
// Clone the unfolded results and divide by the trigger/vertex
// bias correction
TH1* outCorr = static_cast<TH1*>(outUnfold->Clone("corrected"));
outCorr->Divide(inTrgVtx);
tit.ReplaceAll("Unfolded", "Corrected");
outCorr->SetTitle(tit);
// Now normalize the output to integral=1
TH1* hists[] = { outRaw, outUnfold, outCorr, 0 };
TH1** phist = hists;
while (*phist) {
TH1* h = *phist;
if (h) {
Double_t intg = h->Integral(1, h->GetXaxis()->GetXmax());
h->Scale(1. / intg, "width");
}
phist++;
}
// And make ratios
TH1* ratioTrue = static_cast<TH1*>(outCorr->Clone("ratioCorrTruth"));
tit = ratioTrue->GetTitle();
tit.ReplaceAll("Corrected", "Corrected/MC 'truth'");
ratioTrue->SetTitle(tit);
ratioTrue->Divide(outTruth);
ratioTrue->SetYTitle("P_{corrected}(#it{N}_{ch})/P_{truth}(#it{N}_{ch})");
TH1* ratioAcc = static_cast<TH1*>(outUnfold->Clone("ratioUnfAcc"));
tit = ratioAcc->GetTitle();
tit.ReplaceAll("Unfolded", "Unfolded/MC selected");
ratioAcc->SetTitle(tit);
ratioAcc->Divide(outTruthA);
ratioAcc->SetYTitle("P_{unfolded}(#it{N}_{ch})/P_{MC}(#it{N}_{ch})");
// Make a stack
tit = measured->GetName();
tit.ReplaceAll("m", "-");
tit.ReplaceAll("p", "+");
tit.ReplaceAll("d", ".");
tit.ReplaceAll("_", "<#it{#eta}<");
THStack* stack = new THStack("all", tit);
stack->Add(outTruth, "E2");
stack->Add(outTruthA, "E2");
stack->Add(outRaw, "E1");
stack->Add(outUnfold, "E1");
stack->Add(outCorr, "E1");
dir->Add(stack);
// Rest of the function is devoted to making the output look nice
outRaw ->SetDirectory(dir);
outTruth ->SetDirectory(dir);
outTruthA->SetDirectory(dir);
outTrgVtx->SetDirectory(dir);
outResp ->SetDirectory(dir);
outUnfold->SetDirectory(dir);
outCorr ->SetDirectory(dir);
outRaw ->SetMarkerStyle(20); // Measured is closed
outTruth ->SetMarkerStyle(24); // MC is open
outTruthA->SetMarkerStyle(24); // MC is open
outTrgVtx->SetMarkerStyle(20); // Derived is closed
outUnfold->SetMarkerStyle(20); // Derived is closed
outCorr ->SetMarkerStyle(20); // Derived is closed
outRaw ->SetMarkerSize(0.9);
outTruth ->SetMarkerSize(1.6);
outTruthA->SetMarkerSize(1.4);
outTrgVtx->SetMarkerSize(1.0);
outUnfold->SetMarkerSize(0.9);
outCorr ->SetMarkerSize(1.0);
outRaw ->SetMarkerColor(kColorMeasured);
outTruth ->SetMarkerColor(kColorTruth);
outTruthA->SetMarkerColor(kColorAccepted);
outTrgVtx->SetMarkerColor(kColorTrgVtx);
outUnfold->SetMarkerColor(kColorUnfolded);
outCorr ->SetMarkerColor(kColorCorrected);
outRaw ->SetFillColor(kColorError);
outTruth ->SetFillColor(kColorError);
outTruthA->SetFillColor(kColorError);
outTrgVtx->SetFillColor(kColorError);
outUnfold->SetFillColor(kColorError);
outCorr ->SetFillColor(kColorError);
outRaw ->SetFillStyle(0);
outTruth ->SetFillStyle(1001);
outTruthA->SetFillStyle(1001);
outTrgVtx->SetFillStyle(0);
outUnfold->SetFillStyle(0);
outCorr ->SetFillStyle(0);
outRaw ->SetLineColor(kBlack);
outTruth ->SetLineColor(kBlack);
outTruthA->SetLineColor(kBlack);
outTrgVtx->SetLineColor(kBlack);
outUnfold->SetLineColor(kBlack);
outCorr ->SetLineColor(kBlack);
// Legend
TLegend* l = StackLegend(stack);
l->AddEntry(outRaw, "Raw", "lp");
l->AddEntry(outTruth, "MC 'truth'", "fp");
l->AddEntry(outTruthA, "MC 'truth' accepted", "fp");
l->AddEntry(outUnfold, "Unfolded", "lp");
l->AddEntry(outCorr, "Corrected", "lp");
return stack;
}
void plot(int mass) {
double myQCDRelUncert = 0.038;
double myEWKRelUncert = 0.131;
double myFakesRelUncert = 0.238;
double delta = 1.4;
double br = 0.05;
bool debug = false;
bool log = false;
double ymin = 0.001;
double ymax = 48;
static bool bMessage = false;
if (!bMessage) {
cout << "Values used as relative uncertainty (please check):" << endl;
cout << " QCD: " << myQCDRelUncert << endl;
cout << " EWK genuine tau: " << myEWKRelUncert << endl;
cout << " EWK fake tau: " << myFakesRelUncert << endl << endl;
bMessage = true;
}
cout << "Processing mass point: " << mass << " GeV/c2" << endl;
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleFont(43, "xyz");
gStyle->SetTitleSize(33, "xyz");
gStyle->SetLabelFont(43, "xyz");
gStyle->SetLabelSize(27, "xyz");
//std::string infile = "EPS_data_nodeltaphi/hplus_100.root";
//std::string infile = "EPS_data_deltaphi160/hplus_100.root";
std::stringstream s;
s << "lands_histograms_hplushadronic_m" << mass << ".root";
std::string infile = s.str();
// Canvas
TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600);
myCanvas->SetHighLightColor(2);
myCanvas->Range(0,0,1,1);
myCanvas->SetFillColor(0);
myCanvas->SetBorderMode(0);
myCanvas->SetBorderSize(2);
if (log)
myCanvas->SetLogy();
myCanvas->SetTickx(1);
myCanvas->SetTicky(1);
myCanvas->SetLeftMargin(0.16);
myCanvas->SetRightMargin(0.05);
myCanvas->SetTopMargin(0.05);
myCanvas->SetBottomMargin(0.08);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->cd();
Int_t ci;
TFile* f = TFile::Open(infile.c_str());
s.str("");
s << "HW" << mass << "_1";
TH1* hw = (TH1*)f->Get(s.str().c_str());
s.str("");
s << "HH" << mass << "_1";
TH1* hh = (TH1*)f->Get(s.str().c_str());
TH1* data = (TH1*)f->Get("data_obs");
data->SetLineWidth(2);
data->SetMarkerStyle(20);
data->SetMarkerSize(1.2);
TH1* ewktau = (TH1*)f->Get("EWK_Tau");
ci = TColor::GetColor("#993399");
ewktau->SetFillColor(ci);
ewktau->SetLineWidth(0);
TH1* ewkDY = (TH1*)f->Get("EWK_DYx");
TH1* ewkVV = (TH1*)f->Get("EWK_VVx");
ewktau->Add(ewkDY);
ewktau->Add(ewkVV);
//TH1* qcd = (TH1*)f->Get("QCDInv");
TH1* qcd = (TH1*)f->Get("QCD");
ci = TColor::GetColor("#ffcc33");
qcd->SetFillColor(ci);
qcd->SetLineWidth(0);
TH1* fakett = (TH1*)f->Get("fake_tt");
ci = TColor::GetColor("#669900");
fakett->SetFillColor(ci);
fakett->SetLineWidth(0);
TH1* fakeW = (TH1*)f->Get("fake_W");
ci = TColor::GetColor("#cc3300");
fakeW->SetFillColor(ci);
fakeW->SetLineWidth(0);
TH1* faket = (TH1*)f->Get("fake_t");
TH1F *hFrame = new TH1F("hFrame","",20,0,400);
hFrame->SetMinimum(ymin);
if (log)
hFrame->SetMaximum(ymax*1.5);
else
hFrame->SetMaximum(ymax);
hFrame->SetDirectory(0);
hFrame->SetStats(0);
hFrame->SetLineStyle(0);
hFrame->SetMarkerStyle(20);
hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})");
if (paperStatus)
hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})");
hFrame->SetYTitle("Events / 20 GeV/c^{2}");
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(27);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// signal
hh->Scale(br*br);
hw->Scale(2*br*(1.0-br));
TH1* signal = (TH1*)hh->Clone();
signal->Add(hw);
ci = TColor::GetColor("#ff3399");
signal->SetLineColor(ci);
signal->SetLineStyle(2);
signal->SetLineWidth(2);
// Fakes
TH1* fakes = (TH1*)(fakett->Clone());
fakes->Add(fakeW);
fakes->Add(faket);
// stacked backgrounds
THStack *exp = new THStack();
exp->SetName("exp");
exp->SetTitle("exp");
exp->Add(fakes);
exp->Add(ewktau);
exp->Add(qcd);
exp->Add(signal);
TH1* hExpBkg = (TH1*)fakes->Clone();
hExpBkg->Add(ewktau);
hExpBkg->Add(qcd);
// uncertainty
TH1* uncert = (TH1*)fakeW->Clone();
uncert->Add(fakett);
uncert->Add(ewktau);
uncert->Add(qcd);
uncert->SetFillColor(1);
uncert->SetFillStyle(3344);
uncert->SetLineColor(0);
uncert->SetLineStyle(0);
uncert->SetLineWidth(0);
TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone();
hExpBkgTotalUncert->SetFillStyle(3354);
TH1* hAgreement = (TH1*)data->Clone();
hAgreement->Divide(hExpBkg);
TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX());
hAgreementRelUncert->SetLineWidth(2);
hAgreementRelUncert->SetLineColor(kBlack);
for (int i = 1; i <= hFrame->GetNbinsX(); ++i) {
double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2)
+ TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2);
double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2)
+ TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2);
double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2)
+ TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2);
hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert));
if (hExpBkg->GetBinContent(i) > 0) {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i));
double myUncertData = 0;
if (data->GetBinContent(i) > 0)
myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2);
double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2);
hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg));
} else {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0);
hAgreementRelUncert->SetPointError(i-1, 0, 0);
}
if (debug) {
cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10
<< " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl;
cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)"
<< ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)
<< " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl;
}
}
// Agreement pad
TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3);
pad->Draw();
pad->cd();
pad->Range(0,0,1,1);
pad->SetFillColor(0);
pad->SetFillStyle(4000);
pad->SetBorderMode(0);
pad->SetBorderSize(2);
pad->SetTickx(1);
pad->SetTicky(1);
pad->SetLeftMargin(0.16);
pad->SetRightMargin(0.05);
pad->SetTopMargin(0);
pad->SetBottomMargin(0.34);
pad->SetFrameFillStyle(0);
pad->SetFrameBorderMode(0);
// Plot here ratio
if (1.0-delta > 0)
hAgreement->SetMinimum(1.0-delta);
else
hAgreement->SetMinimum(0.);
hAgreement->SetMaximum(1.0+delta);
hAgreement->GetXaxis()->SetLabelOffset(0.007);
hAgreement->GetXaxis()->SetLabelFont(43);
hAgreement->GetXaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelFont(43);
hAgreement->GetYaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelOffset(0.007);
hAgreement->GetYaxis()->SetNdivisions(505);
hAgreement->GetXaxis()->SetTitleFont(43);
hAgreement->GetYaxis()->SetTitleFont(43);
hAgreement->GetXaxis()->SetTitleSize(33);
hAgreement->GetYaxis()->SetTitleSize(33);
hAgreement->SetTitleSize(27, "xyz");
hAgreement->GetXaxis()->SetTitleOffset(3.2);
hAgreement->GetYaxis()->SetTitleOffset(1.3);
hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle());
hAgreement->SetYTitle("Data/#Sigmabkg");
hAgreement->Draw("e2");
// Plot line at zero
TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone());
for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) {
hAgreementLine->SetBinContent(i,1.0);
hAgreementLine->SetBinError(i,0.0);
}
hAgreementLine->SetLineColor(kRed);
hAgreementLine->SetLineWidth(2);
hAgreementLine->SetLineStyle(3);
hAgreementLine->Draw("hist same");
hAgreement->Draw("same");
hAgreementRelUncert->Draw("[]");
pad->RedrawAxis();
myCanvas->cd();
TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.);
plotpad->Draw();
plotpad->cd();
plotpad->Range(0,0,1,1);
plotpad->SetFillColor(0);
plotpad->SetFillStyle(4000);
plotpad->SetBorderMode(0);
plotpad->SetBorderSize(2);
//if (logy)
// plotpad->SetLogy();
plotpad->SetTickx(1);
plotpad->SetTicky(1);
plotpad->SetLeftMargin(0.16);
plotpad->SetRightMargin(0.05);
plotpad->SetTopMargin(0.065);
plotpad->SetBottomMargin(0.0);
plotpad->SetFrameFillStyle(0);
plotpad->SetFrameBorderMode(0);
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(33);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// Draw objects
hFrame->Draw();
exp->Draw("hist same");
uncert->Draw("E2 same");
hExpBkgTotalUncert->Draw("E2 same");
// Data
data->Draw("same");
//signal->Draw("same");
TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(18);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(kWhite);
//leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad
TLegendEntry* entry = leg->AddEntry(data, "Data", "P");
s.str("");
s << "with H^{#pm}#rightarrow#tau^{#pm}#nu";
entry = leg->AddEntry(signal, s.str().c_str(), "L");
entry = leg->AddEntry(qcd, "QCD (meas.)", "F");
entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F");
entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F");
entry = leg->AddEntry(uncert, "stat. uncert.", "F");
entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F");
leg->Draw();
string myTitle = "CMS Preliminary";
if (paperStatus)
myTitle = "CMS";
TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str());
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.43,0.945,"2.2 fb^{-1}");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}";
tex = new TLatex(0.28,0.865,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br;
tex = new TLatex(0.28,0.805,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
plotpad->RedrawAxis();
plotpad->Modified();
s.str("");
s << "mT_datadriven_m" << mass << ".png";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".C";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".eps";
myCanvas->Print(s.str().c_str());
}
