void
plotSignificance(const char* filename, const char* channel, double min_=0., double max_=7., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="m_{H} [GeV]", std::string yaxis_="Significance", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraph* observed = (TGraph*)file->Get(std::string(channel).append("/observed").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
TGraphAsymmErrors* outerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand").c_str());
// set up styles
SetStyle();
// create the unit lines
TGraph* unit3 = new TGraph();
TGraph* unit5 = new TGraph();
for(int imass=0, ipoint=0; imass<expected->GetN(); ++imass){
unit3->SetPoint(ipoint, expected->GetX()[imass], 3.);
unit5->SetPoint(ipoint, expected->GetX()[imass], 5.);
++ipoint;
}
// set proper maximum
float max = maximum(expected, max_);
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
// do the plotting
plottingSignificance(canv, innerBand, outerBand, expected, observed, unit3, unit5, xaxis_, yaxis_, min_, max, log_, mssm_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_significance").append(".png").c_str());
canv.Print(std::string(channel).append("_significance").append(".pdf").c_str());
canv.Print(std::string(channel).append("_significance").append(".eps").c_str());
return;
}
void
plotMaxLikelihood(const char* filename, const char* channel, double min_=0., double max_=-1., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="m_{H} [GeV]", std::string yaxis_="best fit for #sigma/#sigma_{SM}", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
// set up styles
SetStyle();
// create the unit line
TGraph* unit = 0;
if(!mssm_){
unit = new TGraph();
for(int imass=0, ipoint=0; imass<expected->GetN(); ++imass){
unit->SetPoint(ipoint, expected->GetX()[imass], 1.); ++ipoint;
}
}
// set proper maximum
float max = maximum(expected, max_);
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
plottingLimit(canv, innerBand, 0, expected, 0, unit, xaxis_, yaxis_, min_, max, log_, "BESTFIT", "", mssm_);
// setup CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_").append("bestfit").append(".png").c_str());
canv.Print(std::string(channel).append("_").append("bestfit").append(".pdf").c_str());
canv.Print(std::string(channel).append("_").append("bestfit").append(".eps").c_str());
return;
}
void
plotMultidimFit(const char* filename, const char* channel, int mass=125, bool temp_=false, bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="#kappa_{V}", std::string yaxis_="#kappa_{F}", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
TString style = temp_ ? "graph" : "filled";
// retrieve TGraphs from file
TH2F* plot2D;
TRegexp regex2D(TString::Format("plot2D_%d_*", mass));
TGraph* bestfit;
TRegexp regexXY(TString::Format("bestfit_%d_*", mass));
std::vector<TGraph*> graph68;
TRegexp regex68(TString::Format("%s68_%d_*", style.Data(), mass));
std::vector<TGraph*> graph95;
TRegexp regex95(TString::Format("%s95_%d_*", style.Data(), mass));
file->cd(channel);
TIter next(gDirectory->GetListOfKeys());
TKey* iobj;
while((iobj = (TKey*)next())){
TString obj(iobj->GetName());
if(obj.Contains(regex2D)){
plot2D = (TH2F*)file->Get(TString::Format("%s/%s", channel, obj.Data()));
}
if(obj.Contains(regexXY)){
bestfit = (TGraph*)file->Get(TString::Format("%s/%s", channel, obj.Data()));
}
if(obj.Contains(regex68)){
std::cout << " ...found object: " << iobj->GetName() << std::endl;
graph68.push_back((TGraph*)file->Get(TString::Format("%s/%s", channel, obj.Data())));
}
if(obj.Contains(regex95)){
std::cout << " ...found object: " << iobj->GetName() << std::endl;
graph95.push_back((TGraph*)file->Get(TString::Format("%s/%s", channel, obj.Data())));
}
}
//return;
// set up styles
SetStyle();
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
std::string masslabel = mssm_ ? std::string("m_{#phi}") : std::string("m_{H}");
plotting2DScan(canv, plot2D, graph95 , graph68 , bestfit, xaxis_, yaxis_, masslabel, mass, -1, -1, -1, -1, temp_, log_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_scan2D").append(".png").c_str());
canv.Print(std::string(channel).append("_scan2D").append(".pdf").c_str());
canv.Print(std::string(channel).append("_scan2D").append(".eps").c_str());
return;
}
void
plotTanb(const char* filename, const char* channel, bool draw_injected_=false, double min_=0., double max_=60., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.8 fb^{-1} at 8 TeV", std::string xaxis_="m_{A} [GeV]", std::string yaxis_="#bf{tan#beta}")
{
TFile* file = TFile::Open(filename);
// retrieve TGraphs from file
TGraph* expected = (TGraph*)file->Get(std::string(channel).append("/expected").c_str());
TGraph* expected_low = (TGraph*)file->Get(std::string(channel).append("/expected_low").c_str());
TGraph* observed = (TGraph*)file->Get(std::string(channel).append("/observed").c_str());
TGraph* observed_low = (TGraph*)file->Get(std::string(channel).append("/observed_low").c_str());
TGraph* upperLEP = (TGraph*)file->Get(std::string(channel).append("/upperLEP").c_str());
TGraph* lowerLEP = (TGraph*)file->Get(std::string(channel).append("/lowerLEP").c_str());
TGraphAsymmErrors* innerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand").c_str());
TGraphAsymmErrors* innerBand_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/innerBand_low").c_str());
TGraphAsymmErrors* outerBand = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand").c_str());
TGraphAsymmErrors* outerBand_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/outerBand_low").c_str());
TGraphAsymmErrors* plain = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/plain").c_str());
TGraphAsymmErrors* plain_low = (TGraphAsymmErrors*)file->Get(std::string(channel).append("/plain_low").c_str());
// this is new for injected plot
TGraph* injected = 0;;
if(draw_injected_) {injected = (TGraph*)file->Get("injected/observed");}
if(draw_injected_){
for( int i=0; i<expected->GetN(); i++){
double shift = injected->GetY()[i]-expected->GetY()[i];
innerBand->SetPoint(i, innerBand->GetX()[i], innerBand->GetY()[i]+shift);
outerBand->SetPoint(i, outerBand->GetX()[i], outerBand->GetY()[i]+shift);
}
}
// this functionality is not yet supported
std::map<double, TGraphAsymmErrors*> higgsBands;
// this functionality is not yet supported
std::map<std::string, TGraph*> comparisons;
// set up styles
SetStyle();
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
// do the plotting
plottingTanb(canv, plain, plain_low, innerBand, innerBand_low, outerBand, outerBand_low, expected, expected_low, observed, observed_low, lowerLEP, upperLEP, higgsBands, comparisons, xaxis_, yaxis_, injected, min_, max_, log_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_tanb").append(".png").c_str());
canv.Print(std::string(channel).append("_tanb").append(".pdf").c_str());
canv.Print(std::string(channel).append("_tanb").append(".eps").c_str());
return;
}
void
plotLikelihoodScan(const char* filename, const char* channel, int mass=125, double max_=70., bool log_=false, std::string dataset_="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV", std::string xaxis_="Signal Strength", std::string yaxis_="#Delta NLL", bool mssm_=false)
{
TFile* file = TFile::Open(filename);
// retrieve histogram from file
TH1F* scan1D = (TH1F*)file->Get(TString::Format("%s/plot1D_%d", channel, (int)mass));
// set up styles
SetStyle();
// do the plotting
TCanvas canv = TCanvas("canv", "Limits", 600, 600);
std::string masslabel = mssm_ ? std::string("m_{#phi}") : std::string("m_{H}");
plotting1DScan(canv, scan1D, xaxis_, yaxis_, masslabel, mass, max_, 0, scan1D->GetNbinsX(), log_);
/// setup the CMS Preliminary
CMSPrelim(dataset_.c_str(), "", 0.145, 0.835);
// write results to files
canv.Print(std::string(channel).append("_likelihood").append(".png").c_str());
canv.Print(std::string(channel).append("_likelihood").append(".pdf").c_str());
canv.Print(std::string(channel).append("_likelihood").append(".eps").c_str());
return;
}
void bbtt_upg_em(std::string var,int nbins, double xmin, double xmax,std::string xtitle, std::string ytitle, double sigscale=1)
{
TFile *outDC = new TFile("hh_em_inputs.root","RECREATE");
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
TH1::SetDefaultSumw2(1);
//std::string dir = "/data/blue/Bacon/029a/Upgrade/merged_talk_jun30/";
std::string dir = "/afs/cern.ch/work/j/jlawhorn/public/ntuples/";
std::stringstream scale; scale << sigscale;
//Cut definitions
double luminosity = 3000;
std::stringstream lumi; lumi << luminosity;
std::string objcut = "(tauCat1==3 && tauCat2==2 && ptTau1>20 && ptTau2>20 && tauIso2<0.4 && tauIso1<0.4 && (bTag1==2||bTag1==3||bTag1==6||bTag1==7) && (bTag2==1||bTag2==3||bTag2==6||bTag2==7) && ptB1>20 && ptB2>20 && sqrt( (etaTau1-etaTau2)**2 + (phiTau1-phiTau2)**2 )>0.4)";
std::string jetcut = objcut+"*(mTT>20 && mTT<90)*(mBB1>70 && mBB1<140)*(mt2pileup>100)*(bdtVal>-0.05)";
//signal region
std::string mccut = jetcut+"*eventWeight*"+lumi.str();
std::string sigcut = jetcut+"*eventWeight*"+lumi.str();
std::string zjetcut = jetcut+"*eventWeight*(eventType==4)*"+lumi.str();
std::string wjetcut = jetcut+"*eventWeight*(eventType==3)*"+lumi.str();
std::string ewkcut = jetcut+"*eventWeight*(eventType!=1)*"+lumi.str();
//--------------------------------------------------------------------------
//Get the trees
TTree *hhtree = load(dir+"HHToTTBB_14TeV.root");
TTree *tttree = load(dir+"tt.root");
//TTree *vbfhtree = load(dir+"VBFToTT_14TeV_phase2.root");
//TTree *gfhtree = load(dir+"H.root");
//TTree *vjettree = load(dir+"Vjets.root");
//TTree *ewktree = load(dir+"diboson.root");
//-------------------------------------------------------------------------
//Get histograms
TCanvas *canv0 = MakeCanvas("canv", "histograms", 600, 600);
canv0->cd();
std::string vardraw;
/* TH1F *Ztt = new TH1F("DY","",nbins,xmin,xmax);
vardraw = var+">>"+"DY";
vjettree->Draw(vardraw.c_str(),zjetcut.c_str());
InitHist(Ztt , xtitle.c_str(), ytitle.c_str(), TColor::GetColor(248,206,104), 1001);*/
TH1F *ttbar = new TH1F("TTbar","",nbins,xmin,xmax);
vardraw = var+">>"+"TTbar";
tttree->Draw(vardraw.c_str(),mccut.c_str());
InitHist(ttbar, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(155,152,204), 1001);
/* TH1F *wjets = new TH1F("Wjets","",nbins,xmin,xmax);
vardraw = var+">>"+"Wjets";
vjettree->Draw(vardraw.c_str(),wjetcut.c_str());
InitHist(wjets, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
TH1F *ewk = new TH1F("Ewk","",nbins,xmin,xmax);
vardraw = var+">>"+"Ewk";
ewktree->Draw(vardraw.c_str(),ewkcut.c_str());
InitHist(ewk, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
TH1F *vbfh = new TH1F("VBFH","",nbins,xmin,xmax);
vardraw = var+">>"+"VBFH";
vbfhtree->Draw(vardraw.c_str(),mccut.c_str());
InitHist(vbfh, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(250,202,255), 1001);
TH1F *ggh = new TH1F("GGH","",nbins,xmin,xmax);
vardraw = var+">>"+"GGH";
gfhtree->Draw(vardraw.c_str(),mccut.c_str());
InitHist(ggh, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(250,202,255), 1001);*/
TH1F *smhh = new TH1F("SMhh","",nbins,xmin,xmax);
vardraw = var+">>"+"SMhh";
hhtree->Draw(vardraw.c_str(),sigcut.c_str());
InitSignal(smhh);
smhh->SetLineColor(kBlack);
delete canv0;
//---------------------------------------------------------------------------
//Print out the yields
Double_t error=999;
//ofstream outfile;
//outfile.open("yields.txt");
//outfile << "Yields for the signal region." << std::endl;
cout << "SM hh " << smhh->IntegralAndError(0,smhh->GetNbinsX(),error) << "+/-";
cout << error << endl; error=999;
/* outfile << "SM h " << smhh->IntegralAndError(0,smhh->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "Ztt " << Ztt->IntegralAndError(0,Ztt->GetNbinsX(),error) << "+/-" << error << endl;*/
cout << "ttbar " << ttbar->IntegralAndError(0,ttbar->GetNbinsX(),error) << "+/-";
cout << error << endl; error=999;
/* outfile << "ewk " << ewk->IntegralAndError(0,ewk->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "wjets " << wjets->IntegralAndError(0,wjets->GetNbinsX(),error) << "+/-" << error << endl;*/
//--------------------------------------------------------------------------
//outfile.close();
outDC->cd();
TDirectory* lTD = outDC->mkdir("emu");
outDC->cd(lTD->GetPath());
ttbar->SetName("data_obs");
ttbar->SetTitle("data_obs");
ttbar->Write();
/*Ztt->SetName("ZTT");
Ztt->SetTitle("ZTT");
Ztt->Write();*/
ttbar->SetName("TT");
ttbar->SetTitle("TT");
ttbar->Write();
/*wjets->SetName("W");
wjets->SetTitle("W");
wjets->Write();
ewk->SetName("VV");
ewk->SetTitle("VV");
ewk->Write();
vbfh->SetName("qqH");
vbfh->SetTitle("qqH");
vbfh->Write();
ggh->SetName("ggH");
ggh->SetTitle("ggH");
ggh->Write();*/
smhh->SetName("ggHH");
smhh->SetTitle("ggHH");
smhh->Write();
outDC->Close();
//stack some histtograms together
//vbfh->Add(ggh);
//wjets->Add(ewk);
//-----------------------------------------------------------------------
smhh->Scale(sigscale);
//Draw the histograms
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
//wjets->Add(ttbar); //Ztt->Add(wjets);
//vbfh->Add(Ztt);
//Error band stat
//TH1F* errorBand = (TH1F*)vbfh ->Clone("errorBand");
TH1F* errorBand = (TH1F*)ttbar ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
// for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
// if(errorBand->GetBinContent(idx)>0){
// std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
// break;
// }
//}
ttbar->SetMaximum(1.1*std::max(maximum(ttbar, 0), maximum(smhh, 0)));
//blind(data,75,150);
//data->Draw("e");
//vbfh->Draw("hist");
//Ztt->Draw("histsame");
//wjets->Draw("histsame");
//ttbar->Draw("histsame");
ttbar->SetTitle("");
ttbar->Draw("hist");
//data->Draw("esame");
errorBand->Draw("e2same");
smhh->Draw("histsame");
canv->RedrawAxis();
//canv->SetLogy(1);
//---------------------------------------------------------------------------
//Adding a legend
TLegend* leg = new TLegend(0.53, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(smhh , TString::Format("%.0f#timeshh#rightarrow#tau#tau bb", sigscale) , "L" );
//leg->AddEntry(smhh , TString::Format("%.0f#timeshh#rightarrow#tau#tau bb", sigscale1) , "L" );
//leg->AddEntry(data , "Observed" , "LP");
//leg->AddEntry(vbfh , "SM H#rightarrow#tau#tau" , "F" );
//leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
//leg->AddEntry(wjets , "Electroweak" , "F" );
leg->AddEntry(errorBand,"bkg. uncertainty","F");
leg->Draw();
//---------------------------------------------------------------------------
//CMS preliminary
const char* dataset = "CMS Simulation, 3000 fb^{-1} at 14 TeV";
const char* category = "";
CMSPrelim(dataset, "#tau_{e}#tau_{#mu}", 0.17, 0.835);
//CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->Draw();
//-------------------------------------------------------------------------
//Save histograms
canv->Print((var+"_em.png").c_str());
/*
Ratio Data over MC
*/
/*
TCanvas *canv1 = MakeCanvas("canv0", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
TH1F* model = (TH1F*)Ztt ->Clone("model");
TH1F* test1 = (TH1F*)vbfh->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
//model->SetBinError (ibin+1, CONVERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
model->SetBinError (ibin+1, 0);
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
std::vector<double> edges;
TH1F* zero = (TH1F*)ttbar->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)vbfh->Clone("rat1");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, Ztt->GetBinContent(ibin+1)>0 ? vbfh->GetBinContent(ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? vbfh->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? Ztt ->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv1->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
//stat1->Draw();
canv1->Print((var+"_ratio.png").c_str());
*/
}
// examples macro
void
etauAfterFit_novbf(bool scaled = true, bool log = true)
{
// defining the common canvas, axes pad styles
SetStyle();
// open example histogram file
TFile* exampleFile = new TFile("eleTau_sm.root");
//load example histograms
TH1F* data = (TH1F*)exampleFile->Get("eleTau_SM0/data_obs");
if(data) {InitHist(data, "#bf{m_{vis} [GeV]}", "#bf{Events}"); InitData(data);} else{std::cout << "can't find hitogram " << "eleTau_SM0/data_obs" << std::endl;}
TH1F* Fakes = refill((TH1F*)exampleFile->Get("eleTau_SM0/QCD")) ; InitHist(Fakes, "", "", kMagenta-10, 1001);
TH1F* EWK1 = refill((TH1F*)exampleFile->Get("eleTau_SM0/W" )) ; InitHist(EWK1 , "", "", kRed + 2, 1001);
TH1F* EWK2 = refill((TH1F*)exampleFile->Get("eleTau_SM0/ZJ" )) ; InitHist(EWK2 , "", "", kRed + 2, 1001);
TH1F* EWK3 = refill((TH1F*)exampleFile->Get("eleTau_SM0/ZL" )) ; InitHist(EWK3 , "", "", kRed + 2, 1001);
TH1F* EWK = refill((TH1F*)exampleFile->Get("eleTau_SM0/VV" )) ; InitHist(EWK , "", "", kRed + 2, 1001);
TH1F* ttbar = refill((TH1F*)exampleFile->Get("eleTau_SM0/TT" )) ; InitHist(ttbar, "", "", kBlue - 8, 1001);
TH1F* Ztt = refill((TH1F*)exampleFile->Get("eleTau_SM0/ZTT")) ; InitHist(Ztt , "", "", kOrange - 4, 1001);
TH1F* ggH = refill((TH1F*)exampleFile->Get("eleTau_SM0/SM120" )) ; InitSignal(ggH); ggH ->Scale(10*16.63*0.071*16.083/ggH ->Integral());
TH1F* qqH = refill((TH1F*)exampleFile->Get("eleTau_SM0/VBF120")) ; InitSignal(qqH); qqH ->Scale(10*1.269*0.071* 1.105/qqH ->Integral());
if(scaled){
rescale(Fakes, 2);
rescale(EWK1 , 3);
rescale(EWK2 , 4);
rescale(EWK3 , 5);
rescale(EWK , 7);
rescale(ttbar, 6);
rescale(Ztt , 1);
rescale(ggH , 8);
rescale(qqH , 9);
}
if(log){
qqH ->Add(ggH );
Fakes->Add(qqH );
EWK1 ->Add(Fakes);
EWK2 ->Add(EWK1 );
EWK3 ->Add(EWK2 );
EWK ->Add(EWK3 );
ttbar->Add(EWK );
Ztt ->Add(ttbar);
}
else{
EWK1 ->Add(Fakes);
EWK2 ->Add(EWK1 );
EWK3 ->Add(EWK2 );
EWK ->Add(EWK3 );
ttbar->Add(EWK );
Ztt ->Add(ttbar);
ggH ->Add(Ztt );
qqH ->Add(ggH );
}
// define canvas
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){
canv->SetLogy(1);
data->SetMinimum(5.0);
data->SetMaximum(500000.);
}
else{
data->SetMaximum(4000.);
}
data->SetNdivisions(505);
data->Draw("e");
if(log){
Ztt->Draw("same");
ttbar->Draw("same");
EWK->Draw("same");
Fakes->Draw("same");
qqH->Draw("same");
}
else{
qqH->Draw("same");
Ztt->Draw("same");
ttbar->Draw("same");
EWK->Draw("same");
Fakes->Draw("same");
}
data->Draw("esame");
canv->RedrawAxis();
CMSPrelim("#tau_{e}#tau_{h}", 0.45, 0.75);
TLegend* leg = new TLegend(0.45, 0.45, 0.9, 0.75);
SetLegendStyle(leg);
leg->AddEntry(qqH , "(10x) H#rightarrow#tau#tau" , "L" );
leg->AddEntry(data , "Observed" , "LP");
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(EWK , "Electroweak" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
leg->Draw();
TPaveText* mssm = new TPaveText(0.78, 0.70, 0.90, 0.74, "NDC");
mssm->SetBorderSize( 0 );
mssm->SetFillStyle( 0 );
mssm->SetTextAlign( 12 );
mssm->SetTextSize ( 0.04 );
mssm->SetTextColor( 1 );
mssm->SetTextFont ( 62 );
mssm->AddText("m_{H}=120");
mssm->Draw();
if(log){
if(scaled) canv->Print("etau_rescaled_novbf_LOG.pdf"); else canv->Print("etau_unscaled_novbf_LOG.pdf");
if(scaled) canv->Print("etau_rescaled_novbf_LOG.png"); else canv->Print("etau_unscaled_novbf_LOG.png");
}
else{
if(scaled) canv->Print("etau_rescaled_novbf.pdf"); else canv->Print("etau_unscaled_novbf.pdf");
if(scaled) canv->Print("etau_rescaled_novbf.png"); else canv->Print("etau_unscaled_novbf.png");
}
}
void comparePValues(const char* filename, const char* channelstr, bool expected, bool observed, double minimum=1e-8, double maximum=1., bool log=true, const char* label="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.8 fb^{-1} at 8 TeV", double legx0=0.2, double legy0=0.2, double legx1=0.6, double legy1=0.4)
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["0jet" ] = kBlue;
colors["1jet" ] = kRed;
colors["2jet" ] = kMagenta;
colors["vbf" ] = kRed;
colors["boost" ] = kGreen;
colors["btag" ] = kRed;
colors["nobtag" ] = kBlue;
colors["em" ] = kBlue;
colors["et" ] = kRed;
colors["mt" ] = kGreen;
colors["mm" ] = kMagenta;
colors["ee" ] = kCyan;
colors["tt" ] = kMagenta+3;
colors["vhtt" ] = kCyan-6;
colors["cmb" ] = kBlack;
colors["htt" ] = kBlack;
colors["ggH" ] = kRed;
colors["bbH" ] = kBlue;
colors["HIG-11-020" ] = kBlue+2;
colors["HIG-11-029" ] = kRed+2;
colors["HIG-12-018" ] = kBlue;
colors["HIG-12-032" ] = kRed+2;
colors["HIG-12-043" ] = kRed;
colors["HIG-12-050" ] = kRed;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x MitLimits/Higgs2Tau/macros/comparePValues.C+(file, chn, exp, obs, type, min, max, log)\n"
<< " * \n"
<< " * Arguments : + file const char* full path to the input file \n"
<< " * + chn const char* list of channels; choose between: 'cmb', 'htt', 'emu', \n"
<< " * 'etau', 'mutau', 'mumu', 'vhtt', 'hgg', 'hww', 'ggH', \n"
<< " * 'bbH', 'nomix[-200, +200]', 'mhmax[-400, -200, +200]' \n"
<< " * 'mhmax[+400, +600, +800]', 'test-0...5', 'saeff', 'gluph' \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + exp bool compare expected limits \n"
<< " * + obs bool compare observed limits \n"
<< " * + type const char* type of plot; choose between 'sm-xsec', 'mssm-xsec' and \n"
<< " * 'mssm-tanb' \n"
<< " * + max double maximum of the plot (default is 20.) \n"
<< " * \n"
<< " * + min double minimum of the plot (default is 0.) \n"
<< " * \n"
<< " * + log bool set log scale yes or no (default is false) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// open input file
TFile* inputFile = new TFile(filename);
if(inputFile->IsZombie()) {
std::cout << "ERROR:: file: " << filename << " does not exist.\n";
}
/// prepare input parameters
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
/// prepare histograms
std::vector<TGraph*> hobs, hexp;
for(unsigned i=0; i<channels.size(); ++i) {
if(observed) hobs.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/observed").c_str()));
if(expected) hexp.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/expected").c_str()));
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Limit Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(1);
canv1->SetGridy(1);
bool firstPlot=true;
for(unsigned int i=0; i<hexp.size(); ++i) {
if(firstPlot) {
if(log) {
canv1->SetLogy(1);
}
hexp[i]->SetMaximum(maximum);
hexp[i]->SetMinimum(minimum);
// format x-axis
std::string x_title;
x_title = std::string("m_{H} [GeV]");
hexp[i]->GetXaxis()->SetTitle(x_title.c_str());
hexp[i]->GetXaxis()->SetLabelFont(62);
hexp[i]->GetXaxis()->SetTitleFont(62);
hexp[i]->GetXaxis()->SetTitleColor(1);
hexp[i]->GetXaxis()->SetTitleOffset(1.05);
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0]-.1, hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
// format y-axis
std::string y_title;
y_title = std::string("Local p-Value");
hexp[i]->GetYaxis()->SetTitle(y_title.c_str());
hexp[i]->GetYaxis()->SetLabelFont(62);
hexp[i]->GetYaxis()->SetTitleOffset(1.05);
hexp[i]->GetYaxis()->SetLabelSize(0.03);
}
hexp[i]->SetLineStyle(11.);
hexp[i]->SetLineWidth( 3.);
hexp[i]->SetLineColor(colors.find(channels[i])->second);
hexp[i]->SetMarkerStyle(20);
hexp[i]->SetMarkerSize(MARKER_SIZE);
hexp[i]->SetMarkerColor(colors.find(channels[i])->second);
hexp[i]->Draw(firstPlot ? "APL" : "PLsame");
firstPlot=false;
}
for(unsigned int i=0; i<hobs.size(); ++i) {
if(firstPlot) {
if(log) {
canv1->SetLogy(1);
}
hobs[i]->SetMaximum(maximum);
hobs[i]->SetMinimum(minimum);
// format x-axis
std::string x_title;
x_title = std::string("m_{H} [GeV]");
hobs[i]->GetXaxis()->SetTitle(x_title.c_str());
hobs[i]->GetXaxis()->SetLabelFont(62);
hobs[i]->GetXaxis()->SetTitleFont(62);
hobs[i]->GetXaxis()->SetTitleColor(1);
hobs[i]->GetXaxis()->SetTitleOffset(1.05);
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0]-.1, hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
// format y-axis
std::string y_title;
y_title = std::string("Local p-value");
hobs[i]->GetYaxis()->SetTitle(y_title.c_str());
hobs[i]->GetYaxis()->SetLabelFont(62);
hobs[i]->GetYaxis()->SetTitleOffset(1.05);
hobs[i]->GetYaxis()->SetLabelSize(0.03);
}
hobs[i]->SetLineStyle(11.);
hobs[i]->SetLineWidth( 3.);
hobs[i]->SetLineColor(colors.find(channels[i])->second);
hobs[i]->SetMarkerStyle(20);
hobs[i]->SetMarkerSize(MARKER_SIZE);
hobs[i]->SetMarkerColor(colors.find(channels[i])->second);
hobs[i]->Draw(firstPlot ? "APL" : "PLsame");
firstPlot=false;
}
canv1->RedrawAxis();
// create the unit line
TGraph* unit = new TGraph();
for(int idx=0; idx<hexp[0]->GetN(); ++idx) {
unit->SetPoint(idx, hexp[0]->GetX()[idx], 1.);
}
// create sigma lines
std::vector<TGraph*> sigmas;
for(unsigned int isigma=0; isigma<5; ++isigma) {
TGraph* sigma = new TGraph();
for(int idx=0; idx<hexp[0]->GetN(); ++idx) {
sigma->SetPoint(idx, hexp[0]->GetX()[idx], ROOT::Math::normal_cdf_c(isigma+1));
}
sigmas.push_back(sigma);
}
unit->SetLineColor(kBlue);
unit->SetLineWidth(3.);
unit->Draw("Lsame");
for(std::vector<TGraph*>::const_iterator sigma = sigmas.begin(); sigma!=sigmas.end(); ++sigma) {
(*sigma)->SetLineColor(kRed);
(*sigma)->SetLineWidth(3.);
(*sigma)->Draw("Lsame");
}
/// 5 sigma
TPaveText * sigma5 = new TPaveText(0.96, 0.25, 1.00, 0.30, "NDC");
sigma5->SetBorderSize( 0 );
sigma5->SetFillStyle( 0 );
sigma5->SetTextAlign( 12 );
sigma5->SetTextSize ( 0.04 );
sigma5->SetTextColor( kRed );
sigma5->SetTextFont ( 62 );
sigma5->AddText("5#sigma");
sigma5->Draw("same");
/// 4 sigma
TPaveText * sigma4 = new TPaveText(0.96, 0.45, 1.00, 0.50, "NDC");
sigma4->SetBorderSize( 0 );
sigma4->SetFillStyle( 0 );
sigma4->SetTextAlign( 12 );
sigma4->SetTextSize ( 0.04 );
sigma4->SetTextColor( kRed );
sigma4->SetTextFont ( 62 );
sigma4->AddText("4#sigma");
sigma4->Draw("same");
/// 3 sigma
TPaveText * sigma3 = new TPaveText(0.96, 0.61, 1.00, 0.66, "NDC");
sigma3->SetBorderSize( 0 );
sigma3->SetFillStyle( 0 );
sigma3->SetTextAlign( 12 );
sigma3->SetTextSize ( 0.04 );
sigma3->SetTextColor( kRed );
sigma3->SetTextFont ( 62 );
sigma3->AddText("3#sigma");
sigma3->Draw("same");
/// 2 sigma
TPaveText * sigma2 = new TPaveText(0.96, 0.73, 1.00, 0.78, "NDC");
sigma2->SetBorderSize( 0 );
sigma2->SetFillStyle( 0 );
sigma2->SetTextAlign( 12 );
sigma2->SetTextSize ( 0.04 );
sigma2->SetTextColor( kRed );
sigma2->SetTextFont ( 62 );
sigma2->AddText("2#sigma");
sigma2->Draw("same");
/// 1 sigma
TPaveText * sigma1 = new TPaveText(0.96, 0.82, 1.00, 0.87, "NDC");
sigma1->SetBorderSize( 0 );
sigma1->SetFillStyle( 0 );
sigma1->SetTextAlign( 12 );
sigma1->SetTextSize ( 0.04 );
sigma1->SetTextColor( kRed );
sigma1->SetTextFont ( 62 );
sigma1->AddText("1#sigma");
sigma1->Draw("same");
CMSPrelim(label, "", 0.15, 0.835);
TLegend* leg0 = new TLegend(legx0, legy0, legx1, legy1);
leg0->SetTextSize(0.03);
leg0->SetBorderSize( 0 );
leg0->SetFillStyle ( 1001 );
leg0->SetFillColor (kWhite);
if(observed) {
for(unsigned int i=0; i<hobs.size(); ++i) {
leg0->AddEntry( hobs[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
}
if(expected) {
for(unsigned int i=0; i<hexp.size(); ++i) {
leg0->AddEntry( hexp[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
}
leg0->Draw("same");
canv1->Print(std::string("singlePValues").append(expected ? "_expected" : "").append(observed ? "_observed.png" : ".png").c_str());
canv1->Print(std::string("singlePValues").append(expected ? "_expected" : "").append(observed ? "_observed.pdf" : ".pdf").c_str());
canv1->Print(std::string("singlePValues").append(expected ? "_expected" : "").append(observed ? "_observed.eps" : ".eps").c_str());
return;
}
void
mssm_xs_times_acc_scan(char* path, std::string filepath, double tanb, std::string category)
{
mssm_xs_tools xs;
xs.SetInput(path);
//TGraph *SM = new TGraph();
TGraph *ggH = new TGraph();
TGraph *bbH = new TGraph();
TGraph *ggA = new TGraph();
TGraph *gg = new TGraph();
TGraph *bbA = new TGraph();
TGraph *ggh = new TGraph();
TGraph *bbh = new TGraph();
TGraph *bb = new TGraph();
TGraph *signi = new TGraph();
TGraph *ggHacc = new TGraph();
TGraph *bbHacc = new TGraph();
TGraph *ggAacc = new TGraph();
TGraph *ggacc = new TGraph();
TGraph *bbAacc = new TGraph();
TGraph *gghacc = new TGraph();
TGraph *bbhacc = new TGraph();
TGraph *bbacc = new TGraph();
double xs_eff_ggH[4];
double xs_eff_bbH[4];
double masses[19];
masses[0]= 90;
masses[1]= 100;
masses[2]= 120;
masses[3]= 130;
masses[4]= 140;
masses[5]= 160;
masses[6]= 180;
masses[7]= 200;
masses[8]= 250;
masses[9]= 300;
masses[10]= 350;
masses[11]= 400;
masses[12]= 450;
masses[13]= 500;
masses[14]= 600;
masses[15]= 700;
masses[16]= 800;
masses[17]= 900;
masses[18]=1000;
TFile* inputFile = new TFile(std::string(filepath+"/"+"htt_mt.inputs-mssm-8TeV-0.root").c_str());
TH1F* h_background = new TH1F();
double ggH_value, bbH_value, ggA_value, bbA_value, ggh_value, bbh_value;;
double mA;
h_background=get<TH1F>(inputFile, std::string("muTau_"+category+"/ZTT").c_str());
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/QCD").c_str()));
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/W").c_str()));
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/ZL").c_str()));
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/ZJ").c_str()));
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/TT").c_str()));
h_background->Add(get<TH1F>(inputFile, std::string("muTau_"+category+"/VV").c_str()));
TH1F* h_ggH = new TH1F();
TH1F* h_bbH = new TH1F();
TH1F* h_ggh = new TH1F();
TH1F* h_bbh = new TH1F();
TH1F* h_ggA = new TH1F();
TH1F* h_bbA = new TH1F();
for(unsigned int idx=0; idx<19; idx++){
mA=masses[idx];
std::cout << "mh = " << xs.Give_Mass_h(mA, tanb) << " mA = " << mA << " mH = " << xs.Give_Mass_H(mA, tanb) << std::endl;
std::cout << "mh = " << closest_mass(xs.Give_Mass_h(mA, tanb)) << " mA = " << mA << " mH = " << closest_mass(xs.Give_Mass_H(mA, tanb)) << std::endl;
//SM->SetPoint(tanb-1, tanb, 1.21*1000);
std::cout << "MSSM Cross Section [ggH]:" << std::endl;
xs_eff_ggH[0] = xs.Give_Xsec_ggFA(mA, tanb)*xs.Give_BR_A_tautau(mA, tanb);
std::cout << " -> xsec(ggA):\t" << xs.Give_Xsec_ggFA(mA, tanb) << "\t --- \t" << xs.Give_BR_A_tautau(mA, tanb) << std::endl;
xs_eff_ggH[1] = xs.Give_Xsec_ggFH(mA, tanb)*xs.Give_BR_H_tautau(mA, tanb);
std::cout << " -> xsec(ggH):\t" << xs.Give_Xsec_ggFH(mA, tanb) << "\t --- \t" << xs.Give_BR_H_tautau(mA, tanb) << std::endl;
xs_eff_ggH[2] = xs.Give_Xsec_ggFh(mA, tanb)*xs.Give_BR_h_tautau(mA, tanb);
std::cout << " -> xsec(ggh):\t" << xs.Give_Xsec_ggFh(mA, tanb) << "\t --- \t" << xs.Give_BR_h_tautau(mA, tanb) << std::endl;
xs_eff_ggH[3] = (xs_eff_ggH[0]+xs_eff_ggH[1]+xs_eff_ggH[2]);//*1.237;
std::cout << "mA: "<< mA << " tanb: "<<tanb<<" -> ggH_xsec(cmb):\t" << xs_eff_ggH[3] << std::endl;
char mass_help[50];
sprintf (mass_help, "%0.0f", mA);
h_ggA = get<TH1F>(inputFile, std::string("muTau_"+category+"/ggH"+mass_help).c_str());
ggA_value=h_ggA->Integral();
std::cout << "acc of ggA " << h_ggA->Integral() << std::endl;
ggA->SetPoint(idx, mA, xs_eff_ggH[0]);
ggAacc->SetPoint(idx, mA, ggA_value);
sprintf (mass_help, "%0.0f", closest_mass(xs.Give_Mass_H(mA, tanb)));
h_ggH = get<TH1F>(inputFile, std::string("muTau_"+category+"/ggH"+mass_help).c_str());
ggH_value=h_ggH->Integral();
std::cout << "acc of ggH " << h_ggH->Integral() << std::endl;
ggH->SetPoint(idx, mA, xs_eff_ggH[1]);
ggHacc->SetPoint(idx, mA, ggH_value);
sprintf (mass_help, "%0.0f", closest_mass(xs.Give_Mass_h(mA, tanb)));
h_ggh = get<TH1F>(inputFile, std::string("muTau_"+category+"/ggH"+mass_help).c_str());
ggh_value=h_ggh->Integral();
std::cout << "acc of ggh " << h_ggh->Integral() << std::endl;
ggh->SetPoint(idx, mA, xs_eff_ggH[2]);
gghacc->SetPoint(idx, mA, ggh_value);
//gg->SetPoint(idx, mA, xs_eff_ggH[2]+xs_eff_ggH[1]+xs_eff_ggH[0]);
if(mA<130) gg->SetPoint(idx, mA, xs_eff_ggH[2]+xs_eff_ggH[0]);
else if(mA==130) gg->SetPoint(idx, mA, xs_eff_ggH[2]+xs_eff_ggH[1]+xs_eff_ggH[0]);
else gg->SetPoint(idx, mA, xs_eff_ggH[1]+xs_eff_ggH[0]);
//ggacc->SetPoint(idx, mA, ggh_value+ggH_value+ggA_value);
if(mA<130) ggacc->SetPoint(idx, mA, ggh_value+ggA_value);
else if(mA==130) ggacc->SetPoint(idx, mA, ggh_value+ggH_value+ggA_value);
else ggacc->SetPoint(idx, mA, ggH_value+ggA_value);
std::cout << std::endl;
std::cout << "MSSM Cross Section [bbH]:" << std::endl;
xs_eff_bbH[0] = xs.GiveXsec_Santander_A(mA, tanb)*xs.Give_BR_A_tautau(mA, tanb);
std::cout << " -> xsec(ggA):\t" << xs.GiveXsec_Santander_A(mA, tanb) << "\t --- \t" << xs.Give_BR_A_tautau(mA, tanb) << std::endl;
xs_eff_bbH[1] = xs.GiveXsec_Santander_H(mA, tanb)*xs.Give_BR_H_tautau(mA, tanb);
std::cout << " -> xsec(bbH):\t" << xs.GiveXsec_Santander_H(mA, tanb) << "\t --- \t" << xs.Give_BR_H_tautau(mA, tanb) << std::endl;
xs_eff_bbH[2] = xs.GiveXsec_Santander_h(mA, tanb)*xs.Give_BR_h_tautau(mA, tanb);
std::cout << " -> xsec(ggh):\t" << xs.GiveXsec_Santander_h(mA, tanb) << "\t --- \t" << xs.Give_BR_h_tautau(mA, tanb) << std::endl;
xs_eff_bbH[3] = (xs_eff_bbH[0]+xs_eff_bbH[1]+xs_eff_bbH[2]);//*1.627;
std::cout << "mA: "<< mA << " tanb: "<<tanb<<" -> bbH_xsec(cmb):\t" << xs_eff_bbH[3] << std::endl;
sprintf (mass_help, "%0.0f", mA);
h_bbA = get<TH1F>(inputFile, std::string("muTau_"+category+"/bbH"+mass_help).c_str());
bbA_value=h_bbA->Integral();
std::cout << "acc of bbA " << h_bbA->Integral() << std::endl;
bbA->SetPoint(idx, mA, xs_eff_bbH[0]);
bbAacc->SetPoint(idx, mA, bbA_value);
sprintf (mass_help, "%0.0f", closest_mass(xs.Give_Mass_H(mA, tanb)));
h_bbH = get<TH1F>(inputFile, std::string("muTau_"+category+"/bbH"+mass_help).c_str());
bbH_value=h_bbH->Integral();
std::cout << "acc of bbH " << h_bbH->Integral() << std::endl;
bbH->SetPoint(idx, mA, xs_eff_bbH[1]);
bbHacc->SetPoint(idx, mA, bbH_value);
sprintf (mass_help, "%0.0f", closest_mass(xs.Give_Mass_h(mA, tanb)));
h_bbh = get<TH1F>(inputFile, std::string("muTau_"+category+"/bbH"+mass_help).c_str());
bbh_value=h_bbh->Integral();
std::cout << "acc of bbh " << h_bbh->Integral() << std::endl;
bbh->SetPoint(idx, mA, xs_eff_bbH[2]);
bbhacc->SetPoint(idx, mA, bbh_value);
//bb->SetPoint(idx, mA, xs_eff_bbH[2]+xs_eff_bbH[1]+xs_eff_bbH[0]);
if(mA<130) bb->SetPoint(idx, mA, xs_eff_bbH[2]+xs_eff_bbH[0]);
else if(mA==130) bb->SetPoint(idx, mA, xs_eff_bbH[2]+xs_eff_bbH[1]+xs_eff_bbH[0]);
else bb->SetPoint(idx, mA, xs_eff_bbH[1]+xs_eff_bbH[0]);
//bbacc->SetPoint(idx, mA, bbh_value+bbH_value+bbA_value);
if(mA<130) bbacc->SetPoint(idx, mA, bbh_value+bbA_value);
else if(mA==130) bbacc->SetPoint(idx, mA, bbh_value+bbH_value+bbA_value);
else bbacc->SetPoint(idx, mA, bbH_value+bbA_value);
std::cout << std::endl;
std::cout << std::endl;
h_ggA->Scale(xs_eff_ggH[0]);
h_ggH->Scale(xs_eff_ggH[1]);
h_ggh->Scale(xs_eff_ggH[2]);
h_bbA->Scale(xs_eff_bbH[0]);
h_bbH->Scale(xs_eff_bbH[1]);
h_bbh->Scale(xs_eff_bbH[2]);
h_ggA->Add(h_ggH);
h_ggA->Add(h_ggh);
h_bbA->Add(h_bbH);
h_bbA->Add(h_bbh);
h_bbA->Add(h_ggA);
double significance=0;
double significance_help=0;
for(int nbin=0; nbin<h_bbA->GetNbinsX()+1; nbin++){
if(h_background->GetBinContent(nbin)+h_bbA->GetBinContent(nbin)!=0) significance=h_bbA->GetBinContent(nbin)/sqrt(h_background->GetBinContent(nbin)+h_bbA->GetBinContent(nbin));
else significance=0;
//if(significance>significance_help){
significance_help+=significance;
//}
}
std::cout << "significance " << significance_help << std::endl;
signi->SetPoint(idx, mA, significance_help);
//destruct TH1Fs
h_ggA->~TH1F();
h_ggH->~TH1F();
h_ggh->~TH1F();
h_bbA->~TH1F();
h_bbH->~TH1F();
h_bbh->~TH1F();
std::cout << std::endl;
std::cout << std::endl;
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "xs*BR", 600, 600);
canv1->cd();
//canv1->SetGridx(1);
//canv1->SetGridy(1);
canv1->SetLeftMargin(0.15);
canv1->SetLogy(1);
// draw a frame to define the range
TH1F* hr=canv1->DrawFrame(ggA->GetX()[0]-.01, 0.0001, ggA->GetX()[ggA->GetN()-1]+.01, 10000);
// format x axis
hr->SetXTitle("m_{A}");
hr->GetXaxis()->SetLabelSize(0.045);
hr->GetXaxis()->SetTitleFont(62);
hr->GetXaxis()->SetLabelFont(62);
hr->GetXaxis()->SetTitleColor(1);
hr->GetXaxis()->SetTitleOffset(1.08);
// format y axis
hr->SetYTitle("#sigma*BR and acc*signal_{eff}*lumi");
hr->GetXaxis()->SetTitleFont(62);
hr->GetYaxis()->SetLabelFont(62);
hr->GetYaxis()->SetLabelSize(0.045);
hr->GetYaxis()->SetTitleOffset(1.6);
hr->GetXaxis()->SetTitleColor(1);
hr->SetNdivisions(505, "X");
//ggA->Draw("PLsame");
ggA->SetLineStyle(3.);
ggA->SetLineWidth(2.);
ggA->SetLineColor(kBlue);
ggA->SetMarkerStyle(23);
ggA->SetMarkerSize(0);
ggA->SetMarkerColor(kBlue);
//ggH->Draw("PLsame");
ggH->SetLineStyle(2.);
ggH->SetLineWidth(2.);
ggH->SetLineColor(kBlue);
ggH->SetMarkerStyle(22);
ggH->SetMarkerSize(0);
ggH->SetMarkerColor(kBlue);
//ggh->Draw("PLsame");
ggh->SetLineStyle(1.);
ggh->SetLineWidth(2.);
ggh->SetLineColor(kBlue);
ggh->SetMarkerStyle(20);
ggh->SetMarkerSize(0);
ggh->SetMarkerColor(kBlue);
//ggAacc->Draw("PLsame");
ggAacc->SetLineStyle(3.);
ggAacc->SetLineWidth(2.);
ggAacc->SetLineColor(kMagenta);
ggAacc->SetMarkerStyle(23);
ggAacc->SetMarkerSize(0);
ggAacc->SetMarkerColor(kMagenta);
//ggHacc->Draw("PLsame");
ggHacc->SetLineStyle(2.);
ggHacc->SetLineWidth(2.);
ggHacc->SetLineColor(kMagenta);
ggHacc->SetMarkerStyle(22);
ggHacc->SetMarkerSize(0);
ggHacc->SetMarkerColor(kMagenta);
//gghacc->Draw("PLsame");
gghacc->SetLineStyle(1.);
gghacc->SetLineWidth(2.);
gghacc->SetLineColor(kMagenta);
gghacc->SetMarkerStyle(20);
gghacc->SetMarkerSize(0);
gghacc->SetMarkerColor(kMagenta);
//bbA->Draw("PLsame");
bbA->SetLineStyle(3.);
bbA->SetLineWidth(2.);
bbA->SetLineColor(kRed);
bbA->SetMarkerStyle(23);
bbA->SetMarkerSize(0);
bbA->SetMarkerColor(kRed);
//bbH->Draw("PLsame");
bbH->SetLineStyle(2.);
bbH->SetLineWidth(2.);
bbH->SetLineColor(kRed);
bbH->SetMarkerStyle(22);
bbH->SetMarkerSize(0);
bbH->SetMarkerColor(kRed);
//bbh->Draw("PLsame");
bbh->SetLineStyle(1.);
bbh->SetLineWidth(2.);
bbh->SetLineColor(kRed);
bbh->SetMarkerStyle(20);
bbh->SetMarkerSize(0);
bbh->SetMarkerColor(kRed);
//bbAacc->Draw("PLsame");
bbAacc->SetLineStyle(3.);
bbAacc->SetLineWidth(2.);
bbAacc->SetLineColor(kOrange);
bbAacc->SetMarkerStyle(23);
bbAacc->SetMarkerSize(0);
bbAacc->SetMarkerColor(kOrange);
//bbHacc->Draw("PLsame");
bbHacc->SetLineStyle(2.);
bbHacc->SetLineWidth(2.);
bbHacc->SetLineColor(kOrange);
bbHacc->SetMarkerStyle(22);
bbHacc->SetMarkerSize(0);
bbHacc->SetMarkerColor(kOrange);
//bbhacc->Draw("PLsame");
bbhacc->SetLineStyle(1.);
bbhacc->SetLineWidth(2.);
bbhacc->SetLineColor(kOrange);
bbhacc->SetMarkerStyle(20);
bbhacc->SetMarkerSize(0);
bbhacc->SetMarkerColor(kOrange);
gg->Draw("PLsame");
gg->SetLineStyle(1.);
gg->SetLineWidth(3.);
gg->SetLineColor(kBlue+2);
gg->SetMarkerStyle(20);
gg->SetMarkerSize(0);
gg->SetMarkerColor(kBlue+2);
ggacc->Draw("PLsame");
ggacc->SetLineStyle(1.);
ggacc->SetLineWidth(3.);
ggacc->SetLineColor(kMagenta);
ggacc->SetMarkerStyle(20);
ggacc->SetMarkerSize(0);
ggacc->SetMarkerColor(kMagenta);
bb->Draw("PLsame");
bb->SetLineStyle(1.);
bb->SetLineWidth(3.);
bb->SetLineColor(kRed+2);
bb->SetMarkerStyle(20);
bb->SetMarkerSize(0);
bb->SetMarkerColor(kRed+2);
bbacc->Draw("PLsame");
bbacc->SetLineStyle(1.);
bbacc->SetLineWidth(3.);
bbacc->SetLineColor(kOrange);
bbacc->SetMarkerStyle(20);
bbacc->SetMarkerSize(0);
bbacc->SetMarkerColor(kOrange);
/*SM->Draw("PLsame");
SM->SetLineStyle(8.);
SM->SetLineWidth(3.);
SM->SetLineColor(kGreen+1);
SM->SetMarkerStyle(20);
SM->SetMarkerSize(0);
SM->SetMarkerColor(kGreen+1);*/
// signi->Draw("PLsame");
signi->SetLineStyle(1.);
signi->SetLineWidth(2.);
signi->SetLineColor(kBlack);
signi->SetMarkerStyle(20);
signi->SetMarkerSize(0);
signi->SetMarkerColor(kBlack);
TLegend* leg0;
/// setup the CMS Preliminary
//std::ostringstream ss;
//ss << mA;
//std::string s(ss.str());
std::string tanb_string = std::to_string((int)tanb);
CMSPrelim(std::string("#events, m^{h}_{max} scenario, tan#beta = " + tanb_string).c_str(), "", 0.15, 0.835);
leg0 = new TLegend(0.58, 0.12, 0.90, 0.32);
leg0->SetBorderSize( 0 );
leg0->SetFillStyle ( 1001 );
leg0->SetFillColor (kWhite);
//leg0->SetHeader( "#sigma * BR" );
//leg0->AddEntry( SM, "ggH_{SM} #rightarrow #tau#tau", "PL" );
//leg0->AddEntry( gghacc, "ggh #sigma*BR", "PL" );
//leg0->AddEntry( ggAacc, "ggA #sigma*BR", "PL" );
//leg0->AddEntry( ggHacc, "ggH #sigma*BR", "PL" );
leg0->AddEntry( gg, "gg #sigma*BR", "PL" );
//leg0->AddEntry( ggh, "ggh acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( ggA, "ggA acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( ggH, "ggH acc*sl_{eff}*lumi", "PL" );
leg0->AddEntry( ggacc, "gg acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( bbh, "bbh #sigma*BR", "PL" );
//leg0->AddEntry( bbA, "bbA #sigma*BR", "PL" );
//leg0->AddEntry( bbH, "bbH #sigma*BR", "PL" );
leg0->AddEntry( bb, "bb #sigma*BR", "PL" );
//leg0->AddEntry( bbhacc, "bbh acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( bbAacc, "bbA acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( bbHacc, "bbH acc*s_{eff}*lumi", "PL" );
leg0->AddEntry( bbacc, "bb acc*s_{eff}*lumi", "PL" );
//leg0->AddEntry( signi, "sum of all bins: s/sqrt(s+b)", "PL" );
leg0->Draw("same");
canv1->Print("xsBRtimesacc.png");
canv1->Print("xsBRtimesacc.pdf");
return;
}
void
postfit_use(const char* inputfile, const char* analysis = "SM", const char* dataset = "2011+2012", const char* extra="", const char* extra2="", float min=0.1, float max=-1., bool log=true)
{
// defining the common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// switch for MSSM/SM
bool MSSM = std::string(analysis) == std::string("MSSM");
// determine label
if (std::string(dataset) == std::string("2011" )){ dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV"; }
if (std::string(dataset) == std::string("2012" )){ dataset = "CMS Preliminary, H#rightarrow#tau#tau, 19.8 fb^{-1} at 8 TeV"; }
if (std::string(dataset) == std::string("2011+2012")){ dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.8 fb^{-1} at 8 TeV"; }
// determine category tag
const char* category_extra = "";
if(std::string(extra2) == std::string("0jet_low" )){ category_extra = "0 jet, low p_{T}"; }
if(std::string(extra2) == std::string("0jet_high" )){ category_extra = "0 jet, high p_{T}"; }
if(std::string(extra2) == std::string("0jet" )){ category_extra = "0 jet"; }
if(std::string(extra2) == std::string("1jet_low" )){ category_extra = "1 jet, low p_{T}"; }
if(std::string(extra2) == std::string("1jet_high" )){ category_extra = "1 jet, high p_{T}"; }
if(std::string(extra2) == std::string("1jet" )){ category_extra = "1 jet"; }
if(std::string(extra2) == std::string("vbf" )){ category_extra = "2 jet (VBF)"; }
if(std::string(extra2) == std::string("nobtag" )){ category_extra = "No B-Tag"; }
if(std::string(extra2) == std::string("btag" )){ category_extra = "B-Tag"; }
TFile* input = new TFile(inputfile);
TH1F* Fakes = refill((TH1F*)input->Get("Fakes" ), "Fakes/QCD");
TH1F* EWK = refill((TH1F*)input->Get("EWK" ), "EWK" );
TH1F* ttbar = refill((TH1F*)input->Get("ttbar" ), "ttbar" );
TH1F* Ztt = refill((TH1F*)input->Get("Ztt" ), "Ztt" );
TH1F* Zmm = refill((TH1F*)input->Get("Zmm" ), "Zmm" );
TH1F* Zee = refill((TH1F*)input->Get("Zee" ), "Zee" );
TH1F* ggH = refill((TH1F*)input->Get("ggH" ), "ggH" );
TH1F* data = (TH1F*)input->Get("data_obs");
// determine channel for etau Z->ee (EWK) will be shown separated from the rest (EWK1)
TH1F* EWK1 = 0;
if(std::string(extra) == std::string("e#tau_{h}")){
EWK1 = refill((TH1F*)input->Get("EWK1"), "EWK1");
}
TH1F* ggH_hww = 0;
if(std::string(extra) == std::string("e#mu") and HWWBG){
ggH_hww= refill((TH1F*)input->Get("ggH_hww" ), "ggH_hww" );
}
TH1F* errorBand = (TH1F*)input->Get("errorBand");
/*
mass plot before and after fit
*/
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
if(log) canv->SetLogy(1);
// reduce the axis range if necessary for linea plots and SM
if(MSSM && !log){ data->GetXaxis()->SetRange(0, data->FindBin(345)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(UPPER_EDGE)); };
if(!MSSM){ data->GetXaxis()->SetRange(0, data->FindBin(345)); }
data->SetNdivisions(505);
data->SetMinimum(min);
if(std::string(extra) == std::string("#mu#mu")){
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Zmm, log)));
data->Draw("e");
if(log){
Zmm ->Draw("same");
Ztt ->Draw("same");
ttbar->Draw("same");
Fakes->Draw("same");
EWK ->Draw("same");
if(ggH) ggH ->Draw("histsame");
}
}
else if(std::string(extra) == std::string("ee")){
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Zee, log)));
data->Draw("e");
if(log){
Zee ->Draw("same");
Ztt ->Draw("same");
ttbar->Draw("same");
Fakes->Draw("same");
EWK ->Draw("same");
if(ggH) ggH ->Draw("histsame");
}
}
else if(std::string(extra) == std::string("e#tau_{h}")){
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log)));
data->Draw("e");
if(log){
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
EWK1 ->Draw("same");
Fakes->Draw("same");
if(ggH) ggH ->Draw("histsame");
}
else{
if(ggH) ggH ->Draw("histsame");
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
EWK1 ->Draw("same");
Fakes->Draw("same");
}
}
else if(std::string(extra) == std::string("e#mu") && HWWBG){
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(ggH_hww, log)));
data->Draw("e");
if(log){
ggH_hww -> Draw("same");
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
Fakes->Draw("same");
if(ggH) ggH ->Draw("histsame");
}
else{
if(ggH) ggH ->Draw("histsame");
ggH_hww -> Draw("same");
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
Fakes->Draw("same");
}
}
else{
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log)));
data->Draw("e");
if(log){
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
Fakes->Draw("same");
if(ggH) ggH ->Draw("histsame");
}
else{
if(ggH) ggH ->Draw("histsame");
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
Fakes->Draw("same");
}
}
if(errorBand){
errorBand->Draw("e2same");
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, extra, 0.17, 0.835);
CMSPrelim(dataset, "", 0.18, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(extra);
chan->Draw();
TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
if(MSSM){
float lower_bound = EWK1 ? 0.45 : 0.50;
TPaveText* massA = new TPaveText(0.55, lower_bound+0.061, 0.95, lower_bound+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m^{h}_{max} (m_{A}=$MA GeV, tan#beta=$TANB)");
massA->Draw();
}
float lower_bound = EWK1 ? 0.60 : 0.65;
TLegend* leg = new TLegend(MSSM ? 0.55 : 0.50, lower_bound, 0.93, 0.90);
SetLegendStyle(leg);
if(MSSM){
leg->AddEntry(ggH , "#phi#rightarrow#tau#tau", "L" );
}
else{
if(ggH){
if(SIGNAL_SCALE!=1){
leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" );
}
else{
leg->AddEntry(ggH , "H(125 GeV)#rightarrow#tau#tau" , "L" );
}
}
}
leg->AddEntry(data , "observed" , "LP");
if(std::string(extra) == std::string("#mu#mu")){
leg->AddEntry(Zmm , "Z#rightarrow#mu#mu" , "F" );
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
leg->AddEntry(EWK , "electroweak" , "F" );
}
else if(std::string(extra) == std::string("ee")){
leg->AddEntry(Zee , "Z#rightarrowee" , "F" );
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
leg->AddEntry(EWK , "electroweak" , "F" );
}
else if(std::string(extra) == std::string("e#tau_{h}")){
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(EWK , "Z#rightarrow ee" , "F" );
leg->AddEntry(EWK1 , "electroweak" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
}
else if(std::string(extra) == std::string("e#mu") && HWWBG){
leg->AddEntry(ggH_hww , "H(125 GeV)#rightarrowWW" , "F" );
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(EWK , "electroweak" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
}
else{
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(EWK , "electroweak" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
}
if(errorBand){
leg->AddEntry(errorBand, "bkg. uncertainty" , "F" );
}
leg->Draw();
/*
prepare output
*/
std::string newName = std::string(inputfile).substr(0, std::string(inputfile).find(".root"));
canv->Print(TString::Format("%s.png", newName.c_str()));
canv->Print(TString::Format("%s.pdf", newName.c_str()));
canv->Print(TString::Format("%s.eps", newName.c_str()));
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* model;
if(CONSERVATIVE_CHI2){
if(std::string(extra) == std::string("#mu#mu")){
model = (TH1F*)Zmm ->Clone("model");
}
else if(std::string(extra) == std::string("ee")){
model = (TH1F*)Zee ->Clone("model");
}
else if(std::string(extra) == std::string("e#mu") && HWWBG){
model = (TH1F*)ggH_hww ->Clone("model");
}
else{
model = (TH1F*)Ztt ->Clone("model");
}
}
else{
model = (TH1F*)errorBand->Clone("model");
}
TH1F* test1 = (TH1F*)data->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
model->SetBinError (ibin+1, CONSERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
std::vector<double> edges;
TH1F* zero = (TH1F*)Ztt->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, errorBand->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/errorBand->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, errorBand->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/errorBand->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, errorBand->GetBinContent(ibin+1)>0 ? errorBand ->GetBinError (ibin+1)/errorBand->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
zero->SetBinContent(ibin+1, 0.);
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
if((std::string(extra) == std::string("#mu#mu") || std::string(extra) == std::string("ee")) && !MSSM){
rat1->GetXaxis()->SetTitle("#bf{D}");
}
else{
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
}
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv0->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
stat1->Draw();
/*
prepare output
*/
newName = std::string(inputfile).substr(0, std::string(inputfile).find(".root")) + "_datamc";
canv0->Print(TString::Format("%s.png", newName.c_str()));
canv0->Print(TString::Format("%s.pdf", newName.c_str()));
canv0->Print(TString::Format("%s.eps", newName.c_str()));
}
void compareShapes(std::string path, const char* channelstr, const char* periodstr, std::string type, std::string category, const char* shapestr1, const char* shapestr2, double minimum=0., double maximum=20., bool log=false, const char* label=" Preliminary, H#rightarrow#tau#tau, L=24.3 fb^{-1}")
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["incl" ] = kBlue;
colors["0jet" ] = kBlue;
colors["0jet-mvis" ] = kBlue+2;
colors["0jet-ichep" ] = kBlue+2;
colors["2jet" ] = kMagenta;
colors["vbf" ] = kRed;
colors["vbf+0jet" ] = kRed;
colors["vbf-mvis" ] = kRed+2;
colors["vbf-ichep" ] = kRed+2;
colors["boost" ] = kGreen;
colors["boost+0jet" ] = kGreen;
colors["boost-mvis" ] = kGreen+2;
colors["boost-ichep"] = kGreen+2;
colors["btag" ] = kRed;
colors["nobtag" ] = kBlue;
colors["emu" ] = kBlue;
colors["em" ] = kBlue;
colors["em-mvis" ] = kBlue+2;
colors["em-ichep" ] = kBlue+2;
colors["etau" ] = kRed;
colors["et" ] = kRed;
colors["et-mvis" ] = kRed+2;
colors["et-ichep" ] = kRed+2;
colors["mutau" ] = kGreen;
colors["mt" ] = kGreen;
colors["mt-mvis" ] = kGreen+2;
colors["mt-ichep" ] = kGreen+2;
colors["mumu" ] = kMagenta;
colors["mm" ] = kMagenta;
colors["mm-mvis" ] = kMagenta+2;
colors["mm-ichep" ] = kMagenta+2;
colors["tautau" ] = kOrange;
colors["tt" ] = kOrange;
colors["tt-mvis" ] = kOrange+2;
colors["tt-ichep" ] = kOrange+2;
colors["vhtt" ] = kMagenta+2;
colors["whtt" ] = kMagenta+0;
colors["zhtt" ] = kCyan+2;
colors["whhh" ] = kBlue;
colors["cmb" ] = kBlack;
colors["cmb-mvis" ] = kGray+2;
colors["cmb-ichep" ] = kGray+3;
colors["cmb+" ] = kGray+2;
colors["htt" ] = kBlack;
colors["htt+" ] = kBlue;
colors["hgg" ] = kRed;
colors["hww" ] = kGreen;
colors["hbb" ] = kOrange;
colors["hmm" ] = kViolet;
colors["4l" ] = kGreen;
colors["llt" ] = kRed;
colors["ltt" ] = kBlue;
colors["hzz4l" ] = kBlue;
colors["hzz2l2q" ] = kMagenta;
colors["hzz2l2q+" ] = kMagenta;
colors["hzz2l2t" ] = kOrange;
colors["hzz2l2n" ] = kPink;
colors["ggH" ] = kRed;
colors["bbH" ] = kBlue;
colors["mvis" ] = kBlue+2;
colors["ichep" ] = kBlue+2;
colors["test-0" ] = kRed+2;
colors["test-1" ] = kGreen+2;
colors["test-2" ] = kGreen;
colors["test-3" ] = kRed+2;
colors["test-4" ] = kBlue;
colors["test-5" ] = kViolet-6;
colors["old" ] = kViolet-6;
colors["cmb-5fb" ] = kBlue;
colors["hpa-5fb" ] = kRed;
colors["hpa-10fb" ] = kBlack;
colors["saeff" ] = kGreen;
colors["gluph" ] = kOrange-3;
colors["nomix-200" ] = kBlue-10;
colors["nomix+200" ] = kBlue +2;
colors["mhmax-400" ] = kGray +2;
colors["mhmax-200" ] = kGray +1;
colors["mhmax+200" ] = kMagenta+ 4;
colors["mhmax+400" ] = kMagenta+ 3;
colors["mhmax+600" ] = kMagenta- 2;
colors["mhmax+800" ] = kMagenta-10;
colors["MSSM-7TeV" ] = kBlue+2;
colors["MSSM-8TeV" ] = kBlue+4;
colors["HIG-11-020" ] = kBlue+2;
colors["HIG-11-029" ] = kRed+2;
colors["HIG-12-018" ] = kBlue;
colors["HIG-12-032" ] = kRed+2;
colors["HIG-12-043" ] = kBlack;
colors["HIG-12-050" ] = kBlack;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x MitLimits/Higgs2Tau/macros/compareShapes.C+(file, category, shape1, shape2, max, min) \n"
<< " * \n"
<< " * Arguments : + path string path to directory where files are stored \n"
<< " * must be 'common' directory \n"
<< " * + chn const char* channels to be combined \n"
<< " * + per const char* periods to be combined \n"
<< " * + type string 'mssm' or 'sm' \n"
<< " * + category string choose which category should be compared, \n"
<< " * e.g. btag, nobtag \n"
<< " * + shape1 const char* list of shapes to be compared to shape2 \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + shape2 const char* list of shapes to be compared to shape1 \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + max double maximum of the plot (default is 20.) \n"
<< " * \n"
<< " * + min double minimum of the plot (default is 0.) \n"
<< " * \n"
<< " * + log bool set log scale yes or no (default is false) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// prepare input parameters
std::vector<std::string> shape1;
string2Vector(cleanupWhitespaces(shapestr1), shape1);
std::vector<std::string> shape2;
string2Vector(cleanupWhitespaces(shapestr2), shape2);
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
std::vector<std::string> periods;
string2Vector(cleanupWhitespaces(periodstr), periods);
/// test input files
std::vector<std::string> filenames;
for(unsigned k=0; k<channels.size(); k++){
for(unsigned i=0; i<periods.size(); i++){
if(type=="mssm"){
filenames.push_back(std::string(path+"/"+"htt_"+channels[k]+".inputs-mssm-"+periods[i]+"-0.root"));
}
else{
filenames.push_back(std::string(path+"/"+"htt_"+channels[k]+".input_"+periods[i]+".root"));
}
}
}
for(unsigned i=0; i<filenames.size(); i++){
TFile* inputFile = new TFile(filenames[i].c_str());
if(inputFile->IsZombie()){
std::cout << "ERROR:: file: " << filenames[i] << " does not exist -> Will be removed from list of files." << std::endl;
filenames.erase(filenames.begin()+i);
}
}
for(unsigned i=0; i<filenames.size(); i++){
TFile* inputFile = new TFile(filenames[i].c_str());
if(inputFile->IsZombie()){
std::cout << "ERROR:: file: " << filenames[i] << " does not exist -> Will be removed from list of files." << std::endl;
filenames.erase(filenames.begin()+i);
}
}
std::vector<TH1F*> hshape1;
std::vector<TH1F*> hshape2;
for(unsigned k=0; k<filenames.size(); k++){
TFile* inputFile = new TFile(filenames[k].c_str());
/// prepare histograms
for(unsigned i=0; i<shape1.size(); ++i){
if(filenames[k].find("_em")!=std::string::npos) hshape1.push_back(get<TH1F>(inputFile, std::string("emu_"+category+"/").append(shape1[i]).c_str()));
if(filenames[k].find("_et")!=std::string::npos) hshape1.push_back(get<TH1F>(inputFile, std::string("eleTau_"+category+"/").append(shape1[i]).c_str()));
if(filenames[k].find("_mm")!=std::string::npos) hshape1.push_back(get<TH1F>(inputFile, std::string("mumu_"+category+"/").append(shape1[i]).c_str()));
if(filenames[k].find("_mt")!=std::string::npos) hshape1.push_back(get<TH1F>(inputFile, std::string("muTau_"+category+"/").append(shape1[i]).c_str()));
if(filenames[k].find("_tt")!=std::string::npos) hshape1.push_back(get<TH1F>(inputFile, std::string("tauTau"+category+"/").append(shape1[i]).c_str()));
}
for(unsigned i=0; i<shape2.size(); ++i){
if(filenames[k].find("_em")!=std::string::npos) hshape2.push_back(get<TH1F>(inputFile, std::string("emu_"+category+"/").append(shape2[i]).c_str()));
if(filenames[k].find("_et")!=std::string::npos) hshape2.push_back(get<TH1F>(inputFile, std::string("eleTau_"+category+"/").append(shape2[i]).c_str()));
if(filenames[k].find("_mm")!=std::string::npos) hshape2.push_back(get<TH1F>(inputFile, std::string("mumu_"+category+"/").append(shape2[i]).c_str()));
if(filenames[k].find("_mt")!=std::string::npos) hshape2.push_back(get<TH1F>(inputFile, std::string("muTau_"+category+"/").append(shape2[i]).c_str()));
if(filenames[k].find("_tt")!=std::string::npos) hshape2.push_back(get<TH1F>(inputFile, std::string("tauTau"+category+"/").append(shape2[i]).c_str()));
}
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Absolute Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(1);
canv1->SetGridy(1);
bool firstPlot=true;
for(unsigned int i=0; i<hshape1.size(); ++i){
if(firstPlot){
if(log){ canv1->SetLogy(1); }
// format x-axis
std::string x_title;
//x_title = std::string("#sigma#timesBR/#sigma#timesBR_{SM}");
x_title = std::string("m_{#tau#tau}");
hshape1[i]->SetXTitle(x_title.c_str());
hshape1[i]->GetXaxis()->SetTitleFont(62);
hshape1[i]->GetXaxis()->SetLabelFont(62);
hshape1[i]->GetXaxis()->SetTitleColor(1);
hshape1[i]->GetXaxis()->SetTitleOffset(1.05);
// format y-axis
std::string y_title;
y_title = std::string("arbitary numbers");
hshape1[i]->SetYTitle(y_title.c_str());
hshape1[i]->GetXaxis()->SetTitleFont(62);
hshape1[i]->GetYaxis()->SetLabelFont(62);
//hshape1[i]->GetYaxis()->SetTitleSize(0.05);
hshape1[i]->GetYaxis()->SetTitleOffset(1.05);
hshape1[i]->GetYaxis()->SetLabelSize(0.03);
hshape1[i]->GetXaxis()->SetRangeUser(0,400);
hshape1[i]->SetMaximum(maximum);
hshape1[i]->SetMinimum(minimum);
}
hshape1[i]->SetLineStyle(1.);
hshape1[i]->SetLineWidth(2.);
hshape1[i]->SetLineColor(kBlue);
//hshape1[i]->SetMarkerStyle(20);
//hshape1[i]->SetMarkerSize(MARKER_SIZE);
//hshape1[i]->SetMarkerColor(kBlue);
firstPlot=false;
if(i>0) hshape1[0]->Add(hshape1[i]);
}
hshape1[0]->Scale(1/hshape1[0]->Integral());
//hshape1[0]->SetMaximum(maximum);
//hshape1[0]->SetMinimum(minimum);
hshape1[0]->SetTitle("");
hshape1[0]->Draw("h");
firstPlot=true;
for(unsigned int i=0; i<hshape2.size(); ++i){
if(firstPlot){
if(log){ canv1->SetLogy(1); }
// format x-axis
std::string x_title;
//x_title = std::string("#sigma#timesBR/#sigma#timesBR_{SM}");
x_title = std::string("m_{#tau#tau}");
hshape2[i]->SetXTitle(x_title.c_str());
hshape2[i]->GetXaxis()->SetTitleFont(62);
hshape2[i]->GetXaxis()->SetLabelFont(62);
hshape2[i]->GetXaxis()->SetTitleColor(1);
hshape2[i]->GetXaxis()->SetTitleOffset(1.05);
// format y-axis
std::string y_title;
y_title = std::string("arbitary numbers");
hshape2[i]->SetYTitle(y_title.c_str());
hshape2[i]->GetXaxis()->SetTitleFont(62);
hshape2[i]->GetYaxis()->SetLabelFont(62);
//hshape2[i]->GetYaxis()->SetTitleSize(0.05);
hshape2[i]->GetYaxis()->SetTitleOffset(1.05);
hshape2[i]->GetYaxis()->SetLabelSize(0.03);
hshape2[i]->GetXaxis()->SetRangeUser(0,400);
hshape2[i]->SetMaximum(maximum);
hshape2[i]->SetMinimum(minimum);
}
hshape2[i]->SetLineStyle(11.);
hshape2[i]->SetLineWidth(3.);
hshape2[i]->SetLineColor(kRed);
hshape2[i]->SetMarkerStyle(20);
hshape2[i]->SetMarkerSize(MARKER_SIZE);
hshape2[i]->SetMarkerColor(kRed);
if(i>0) hshape2[0]->Add(hshape2[i]);
firstPlot=false;
}
hshape2[0]->Scale(1/hshape2[0]->Integral());
//hshape2[0]->SetMaximum(maximum);
//hshape2[0]->SetMinimum(minimum);
hshape2[0]->SetLineStyle(11.);
hshape2[0]->SetLineWidth(3.);
hshape2[0]->SetLineColor(kRed);
hshape2[0]->SetMarkerStyle(20);
hshape2[0]->SetMarkerSize(MARKER_SIZE);
hshape2[0]->SetMarkerColor(kRed);
hshape2[0]->Draw("PLsame");
canv1->RedrawAxis();
TLegend* leg0;
/// setup the CMS Preliminary
CMSPrelim(label, "", 0.15, 0.835);
leg0 = new TLegend(0.45, 0.70, 0.90, 0.90);
leg0->SetBorderSize( 0 );
leg0->SetFillStyle ( 1001 );
leg0->SetFillColor (kWhite);
leg0->SetHeader( std::string(category+" Shapes").c_str() );
std::string shape1cmb;
for(unsigned int i=0; i<shape1.size(); ++i){
if (i==0) shape1cmb=shape1[i];
else shape1cmb=shape1cmb+"+"+shape1[i];
}
std::string shape2cmb;
for(unsigned int i=0; i<shape2.size(); ++i){
if (i==0) shape2cmb=shape2[i];
else shape2cmb=shape2cmb+"+"+shape2[i];
}
leg0->AddEntry( hshape1[0] , std::string(shape1cmb).c_str(), "PL" );
leg0->AddEntry( hshape2[0] , std::string(shape2cmb).c_str(), "PL" );
leg0->Draw("same");
canv1->Print(std::string("CompareShapes-Absolute_"+category).append(".png").c_str());
canv1->Print(std::string("CompareShapes-Absolute_"+category).append(".pdf").c_str());
canv1->Print(std::string("CompareShapes-Absolute_"+category).append(".eps").c_str());
/* not really working atm
/// do the drawing
TCanvas* canv2 = new TCanvas("canv2", "Relative Comparison", 600, 600);
canv2->cd();
canv2->SetGridx(1);
canv2->SetGridy(1);
TH1F* relative = (TH1F*)hshape1[0]->Clone();
//TH1F* relative = new TH1F();
//relative->Add(hshape1[0]);
for(unsigned i=0; i<hshape1[0]->GetXaxis()->GetNbins(); i++){
double content1=hshape1[0]->GetBinContent(i+1);
double content2=hshape2[0]->GetBinContent(i+1);
double content=0;
if(content1!=0){
content=(content1-content2)/content1;
}
std::cout<<i<<" "<<content1<<" "<<content2<<" "<<content<<std::endl;
relative->SetBinContent(i+1, content);
}
std::string x_title;
//x_title = std::string("#sigma#timesBR/#sigma#timesBR_{SM}");
x_title = std::string("m_{#tau#tau}");
relative->SetXTitle(x_title.c_str());
relative->GetXaxis()->SetTitleFont(62);
relative->GetXaxis()->SetLabelFont(62);
relative->GetXaxis()->SetTitleColor(1);
relative->GetXaxis()->SetTitleOffset(1.05);
// format y-axis
std::string y_title;
y_title = std::string("arbitary numbers");
relative->SetYTitle(y_title.c_str());
relative->GetXaxis()->SetTitleFont(62);
relative->GetYaxis()->SetLabelFont(62);
//relative->GetYaxis()->SetTitleSize(0.05);
relative->GetYaxis()->SetTitleOffset(1.05);
relative->GetYaxis()->SetLabelSize(0.03);
relative->GetXaxis()->SetRangeUser(0,500);
relative->SetMaximum(1);
relative->SetMinimum(-1);
relative->SetLineStyle(11.);
relative->SetLineWidth(3.);
relative->SetLineColor(kBlack);
relative->SetMarkerStyle(20);
relative->SetMarkerSize(MARKER_SIZE);
relative->SetMarkerColor(kBlack);
relative->Draw("PL");
canv2->RedrawAxis();
TLegend* leg1;
/// setup the CMS Preliminary
CMSPrelim(label, "", 0.15, 0.835);
leg1 = new TLegend(0.45, 0.60, 0.90, 0.90);
leg1->SetBorderSize( 0 );
leg1->SetFillStyle ( 1001 );
leg1->SetFillColor (kWhite);
leg1->SetHeader( std::string(category+" Shapes").c_str() );
leg1->AddEntry( relative , std::string("Relative to shape1").c_str(), "PL" );
leg1->Draw("same");
canv2->Print(std::string("CompareShapes-Relative").append(".png").c_str());
canv2->Print(std::string("CompareShapes-Relative").append(".pdf").c_str());
canv2->Print(std::string("CompareShapes-Relative").append(".eps").c_str());
*/
return;
}
void makeMuVMassPlot(bool iUseWWType = false) {
SetStyle();
TCanvas *lCan = new TCanvas("A","A",600,600);
// lCan->SetGridx(1);
//lCan->SetGridy(1);
lCan->SetRightMargin(0.14);
double *lTX1 = new double[2];
double *lTX2 = new double[2];
double lMinNLL = 1000;
double lVMin = 0;
double *lMin = new double[36];
if(!iUseWWType) for(int i0 = 0; i0 < 36; i0++) { lMin[i0] = getMinNLL(110+i0*1.); if(lMin[i0] < lVMin) {lVMin = lMin[i0]; lTX1[0] = 110+i0*1.;}}
//lMin[17] = (lMin[16]+lMin[18])/2.;
//lMin[21] = (lMin[20]+lMin[22])/2.;
//lMin[29] = (lMin[28]+lMin[30])/2.;
//lMin[34] = (lMin[33]+lMin[35])/2.;
TFile *lFile = new TFile("/afs/cern.ch/user/p/pharris/public/massscan/cmb+.root");
TTree *lTree = lFile->FindObjectAny("limit");
TH2F *lH = new TH2F("2D","2D",36,109.5,145.5,50,-2.,3.);
float lNLL = 0; lTree->SetBranchAddress("nll" ,&lNLL);
float lMNLL = 0; lTree->SetBranchAddress("deltaNLL",&lMNLL);
double lMH = 0; lTree->SetBranchAddress("mh" ,&lMH);
float lR = 0; lTree->SetBranchAddress("r" ,&lR);
if(iUseWWType) {
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
if(lR < 0.1 && lR > 0) lMin[int(lMH-110)] = -lMNLL;
}
lVMin = 10000;
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
double pMin = lMin[int(lMH-110)] + lMNLL;
if(pMin < lVMin) lVMin = pMin;
}
}
for(int i0 = 0; i0 < lTree->GetEntries(); i0++) {
lTree->GetEntry(i0);
//if(lMH == 125) continue;
lNLL = 0.; //lMin = 0.;
lH->SetBinContent(lH->GetXaxis()->FindBin(lMH),lH->GetYaxis()->FindBin(lR),(lMNLL+lMin[lH->GetXaxis()->FindBin(lMH)-1]-lVMin));
if(lMH == lTX1[0] && lMNLL < lMinNLL) {lMinNLL = lMNLL; lTX2[0] = lR;}
}
TH2F* lHC = lH->Clone("2D_v2");
double lCont[3];
lCont[0] = 1.17;
lCont[1] = 3.0;
lCont[2] = 9.0;
lHC->SetContour(2,lCont);
//lCan->SetLogz();
lHC->Draw("cont z list");
lCan->Update();
lHC->Draw("colz");
TObjArray *lContours = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
int lTotalConts = lContours->GetSize();
double *lTX = new double[2]; lTX[0] = 110; lTX[1] = 145;
double *lTY = new double[2]; lTY[0] = -0.5; lTY[1] = 2.5;
TGraph *lFirst = new TGraph(2,lTX,lTY); lFirst->SetLineColor(kWhite);
lFirst->GetXaxis()->SetRangeUser(110,148);
lFirst->Draw("al"); lFirst->SetTitle("");
lH->GetYaxis()->SetRangeUser(-0.5,2.5);
lFirst->GetXaxis()->SetTitle("m_{H}[GeV]");
lFirst->GetXaxis()->SetTitleOffset(1.0);
lFirst->GetYaxis()->SetTitle("#mu_{best-fit}");
lFirst->GetYaxis()->SetTitleOffset(1.2);
lH->GetXaxis()->SetTitle("m_{H}[GeV]");
lH->GetXaxis()->SetTitleOffset(1.0);
lH->GetYaxis()->SetTitle("#mu_{best-fit}");
lH->GetYaxis()->SetTitleOffset(1.2);
lTX1[1] = lTX1[0]; lTX2[1] = lTX2[1]+0.001;
TGraph *lSecond = new TGraph(1,lTX1,lTX2); lSecond->SetMarkerStyle(34); lSecond->SetMarkerSize(3.5);
//lSecond->Draw("p");
TLegend *lL = new TLegend(0.65,0.15,0.85,0.35); lL->SetBorderSize(0); lL->SetFillColor(0); lL->SetFillStyle(0);
for(i0 = 0; i0 < lTotalConts; i0++){
pContLevel = (TList*)lContours->At(lTotalConts-1.-i0);
// Get first graph from list on curves on this level
std::vector<double> lX;
std::vector<double> lY;
pCurv = (TGraph*)pContLevel->First();
for(int i1 = 0; i1 < pContLevel->GetSize(); i1++){
for(int i2 = 0; i2 < pCurv->GetN(); i2++) {lX.push_back(pCurv->GetX()[i2]); lY.push_back(pCurv->GetY()[i2]);}
//pCurv->GetPoint(0, x0, y0);
pCurv->SetLineColor(kBlack);//kGreen+i0);
pCCurv = (TGraph*)pCurv->Clone();
if(i0 == 0) pCCurv->SetFillColor(0);
if(i0 == 1) pCCurv->SetFillColor(0);
//if(i0 == 1) pCCurv->SetLineStyle(kDashed);
pCCurv->SetLineWidth(3);
pCCurv->GetXaxis()->SetRangeUser(0,3.0);
//if(i0 == 0) pCCurv->Draw("AL");
//if(i0 != -10) pCCurv->Draw("LC");
//l.DrawLatex(x0,y0,val);
pCurv = (TGraph*)pContLevel->After(pCurv); // Get Next graph
}
TGraph *lTotal = new TGraph(lX.size(),&lX[0],&lY[0]);
lTotal->SetLineWidth(3);
lTotal->SetFillColor(kGreen+i0*2);
lTotal->SetFillStyle(3001);
//lTotal->Draw("lf");
//if(i0 == 0) lTotal->Draw("alf");
//if(i0 == 0) lTotal->Draw("alf");
//for(int iX = 0; iX < lTotal->GetN(); iX++) cout << "===> " << lTotal->GetX()[iX] << " -- " << lTotal->GetY()[iX] << endl;
//if(i0 != -10) lTotal->Draw("lfC");
bool pSwitch = false;
int pSign = -1.; if(lTotal->GetX()[0] > lTotal->GetX()[1]) pSign = 1;
double pXOld = lTotal->GetX()[lTotal->GetN()-1];
std::vector<double> pXLeft;
std::vector<double> pXRight;
std::vector<double> pYLeft;
std::vector<double> pYRight;
for(int iX = 0; iX < lTotal->GetN(); iX++) {
double pX = lTotal->GetX()[iX];
if(pSign*pX > pSign*pXOld ) {pSwitch = !pSwitch; pSign *= -1;}
if(!pSwitch) {pXLeft.push_back(lTotal->GetX()[iX]); pYLeft.push_back(lTotal->GetY()[iX]); }
if(pSwitch) {pXRight.push_back(lTotal->GetX()[iX]); pYRight.push_back(lTotal->GetY()[iX]); }
pXOld = pX;
}
TGraph *lLeftTotal = new TGraph(pXLeft.size() ,&pXLeft[0],&pYLeft[0]);
TGraph *lRightTotal = new TGraph(pXRight.size(),&pXRight[0],&pYRight[0]);
lLeftTotal->SetLineColor(kRed);
lRightTotal->SetLineColor(kBlue);
lLeftTotal->SetLineStyle(kDashed);
lRightTotal->SetLineStyle(kDashed);
//lLeftTotal->Draw("l");
//lRightTotal->Draw("l");
TGraphSmooth *lGS0 = new TGraphSmooth("normal");
TGraphSmooth *lGS1 = new TGraphSmooth("normal");
TGraph *lSmooth0 = lGS0->SmoothSuper(lRightTotal,"",0.,0.);
TGraph *lSmooth1 = lGS1->SmoothSuper(lLeftTotal,"",0.,0.) ;
lSmooth0->Draw("l");
lSmooth1->Draw("l");
std::vector<double> pXSmooth;
std::vector<double> pYSmooth;
std::vector<double> pXSmooth1;
std::vector<double> pYSmooth1;
cout << "==" << lSmooth0->GetN() << " -- " <<lSmooth1->GetN() << endl;
for(int iX = 0; iX < lSmooth0->GetN(); iX++) {pXSmooth.push_back(lSmooth0->GetX()[iX]); pYSmooth.push_back(lSmooth0->GetY()[iX]);}
for(int iX = 0; iX < lSmooth1->GetN(); iX++) {pXSmooth.push_back(lSmooth1->GetX()[lSmooth1->GetN()-iX-1]); pYSmooth.push_back(lSmooth1->GetY()[lSmooth1->GetN()-iX-1]);}
for(int iX = 0; iX < lSmooth0->GetN(); iX++) {pXSmooth1.push_back(lSmooth0->GetX()[iX]); pYSmooth1.push_back(lSmooth0->GetY()[iX]);}
for(int iX = 0; iX < lSmooth1->GetN(); iX++) {pXSmooth1.push_back(lSmooth1->GetX()[lSmooth1->GetN()-iX-1]); pYSmooth1.push_back(lSmooth1->GetY()[lSmooth1->GetN()-iX-1]);}
//if(i0 == 1) {pXSmooth1.push_back(lSmooth1->GetX()[0]); pYSmooth1.push_back(lSmooth1->GetY()[0]);}
TGraph *pSmoothShape = new TGraph(pXSmooth.size() ,&pXSmooth [0],&pYSmooth [0]);
TGraph *pSmoothShape1 = new TGraph(pXSmooth1.size(),&pXSmooth1[0],&pYSmooth1[0]);
if(i0 == 1) {TLine *lLine = new TLine(pXSmooth1[0],pYSmooth1[0],pXSmooth1[pXSmooth1.size()-1],pYSmooth1[pYSmooth1.size()-1]); lLine->Draw();}
pSmoothShape1->SetLineColor(kBlack);
pSmoothShape1->SetLineWidth(2);
pSmoothShape->SetFillColor(kGreen+i0*2);
pSmoothShape->SetFillStyle(3001);
pSmoothShape->Draw("lf");
pSmoothShape1->Draw("l");
if(i0 == 0) lL->AddEntry(lTotal,"95% CL","lf");
if(i0 == 1) lL->AddEntry(lTotal,"68% CL","lf");
}
lL->AddEntry(lSecond,"BestFit","p");
lSecond->Draw("lp");
lL->Draw();
std::string masslabel = "m_{H}"; double mass = 125;
TString label = TString::Format("%s = 135 GeV", masslabel.c_str());//, 125.);
TPaveText* textlabel = new TPaveText(0.18, 0.81, 0.50, 0.90, "NDC");
textlabel->SetBorderSize( 0 );
textlabel->SetFillStyle ( 0 );
textlabel->SetTextAlign ( 12 );
textlabel->SetTextSize (0.04 );
textlabel->SetTextColor ( 1 );
textlabel->SetTextFont ( 62 );
textlabel->AddText(label);
//textlabel->Draw();
CMSPrelim("Preliminary, H#rightarrow#tau#tau,L = 24.3 fb^{-1}", "", 0.145, 0.835);
gPad->RedrawAxis();
lCan->Update();
lCan->SaveAs("cmb+_muvmass.png");
lCan->SaveAs("cmb+_muvmass.pdf");
lCan->SaveAs("cmb+_muvmass.eps");
}
void plotNLLMassToys(long injmass){
TString filenamesb=TString("nllsb_")+injmass;
TString filenameb=TString("nllb_")+injmass;
TH1F * H[8];
TH1F * HDiff[8];
TH1F * HDiffFine[8];
TH1F * HSigma[8];
TF1* GScanToy[500];
for(Int_t m=0;m<8;m++){
H[m]=new TH1F(TString("H")+(long)(110+5*m),TString("mass=")+(long)(110+5*m),50,-200,-25);
HDiff[m]=new TH1F(TString("HDiff")+(long)(110+5*m),TString("mass=")+(long)(110+5*m),20,0.0,8);
HDiffFine[m]=new TH1F(TString("HDiffFine")+(long)(110+5*m),TString("mass=")+(long)(110+5*m),1000,0.0,8);
HSigma[m]=new TH1F(TString("HSigma")+(long)(110+5*m),TString("mass=")+(long)(110+5*m),50,10,10);
}
TH1F HMass("HMass","",8,110-2.5,150-2.5);
TH1F HPull("HPull","",11,-5.5,5.5);
TH1F HSigmaLow("HSigmaLow","",8,0,30);
HSigmaLow.GetXaxis()->SetTitle("#sigma_{low}");
TH1F HSigmaHigh("HSigmaHigh","",8,0,30);
HSigmaHigh.GetXaxis()->SetTitle("#sigma_{high}");
TH2F HSigma2D("HSigma2D","",8,0,20,8,0,20);
HSigma2D.GetYaxis()->SetTitle("#sigma_{high}");
HSigma2D.GetXaxis()->SetTitle("#sigma_{low}");
TH2F HBestFitvsSigmaHigh("HBestFitvsSigmaHigh","",8,110-2.5,145+2.5,8,110-2.5,145+2.5);
HBestFitvsSigmaHigh.GetYaxis()->SetTitle("#sigma_{high}");
HBestFitvsSigmaHigh.GetXaxis()->SetTitle("m_{bestfit}");
TH1F HSigmaFull("HSigmaFull","",20,0,50);
HSigmaFull.GetXaxis()->SetTitle("#sigma_{low}+#sigma_{high}");
ifstream file;
file.open((filenamesb+".txt").Data());
ifstream fileb;
fileb.open((filenameb+".txt").Data());
bool GoodToy[500];
int n;
float nll[8];
float nllb[8];
int ngood=0;
while(!file.eof()){
file>>n>>nll[0]>>nll[1]>>nll[2]>>nll[3]>>nll[4]>>nll[5]>>nll[6]>>nll[7];
fileb>>n>>nllb[0]>>nllb[1]>>nllb[2]>>nllb[3]>>nllb[4]>>nllb[5]>>nllb[6]>>nllb[7];
//cout<<n<<nll[0]<<nll[1]<<nll[2]<<nll[3]<<nll[4]<<nll[5]<<nll[6]<<nll[7]<<endl;
GoodToy[n]=1;
for(Int_t m=0;m<8;m++)
if(nll[m]==0.) GoodToy[n]=0;
if(!GoodToy[n])continue;
float minnll=100.;
int minm=0;
float minmass=0.;
for(Int_t m=0;m<8;m++)
if(minnll>nll[m]){
minnll = nll[m];
minm = m;
}
minmass=110+minm*5;
for(Int_t m=0;m<8;m++){
H[m]->Fill(nll[m]);
HDiff[m]->Fill(nll[m]-minnll);
HDiffFine[m]->Fill(nll[m]-minnll);
}
//////scan of each toy
GScanToy[n]=new TF1(TString("GScanToy")+(long)(110+5*m),"(110<=x&&x<115)*([0]+([1]-[0])*(x-110)/5) + (115<=x&&x<120)*([1]+([2]-[1])*(x-115)/5) + (120<=x&&x<125)*([2]+([3]-[2])*(x-120)/5) + (125<=x&&x<130)*([3]+([4]-[3])*(x-125)/5) + (130<=x&&x<135)*([4]+([5]-[4])*(x-130)/5) + (135<=x&&x<140)*([5]+([6]-[5])*(x-135)/5) + (140<=x&&x<145)*([6]+([7]-[6])*(x-140)/5)",110,145);
for(Int_t m=0;m<8;m++){
GScanToy[n]->SetParameter(m,(nll[m]-minnll));
}
//for this toy find the uncertainty
float x1sigmalow=0;
float x1sigmahigh=0;
float y1sigmalow=1000;
float y1sigmahigh=1000;
for(Int_t m=0;m<1000;m++){
float xlow=110+m*(145-110)/1000.;
float xhigh=145+m*(110-145)/1000.;
float ylow=GScanToy[n]->Eval(xlow);
float yhigh=GScanToy[n]->Eval(xhigh);
if(ylow<y1sigmalow && xlow<110+minm*5 && ylow>0.5){
y1sigmalow=ylow;
x1sigmalow=xlow;
}
if(yhigh<y1sigmahigh && xhigh>110+minm*5 && yhigh>0.5){
y1sigmahigh=yhigh;
x1sigmahigh=xhigh;
}
}
//cout<<110+minm*5<<" "<<x1sigmalow<<" "<<x1sigmahigh<<endl;
float sigmamass=0.;
if( x1sigmalow !=0 && x1sigmahigh ==0)sigmamass = minmass - x1sigmalow;
if( x1sigmahigh!=0 && x1sigmalow ==0)sigmamass = x1sigmahigh - minmass;
if( x1sigmalow !=0 && x1sigmahigh !=0)sigmamass = ((minmass - x1sigmalow) + (x1sigmahigh - minmass))/2.;
if(sigmamass!=0.)HPull.Fill((minmass-injmass)/sigmamass);
if( x1sigmalow !=0 ) {
HSigmaLow.Fill(minmass-x1sigmalow);
}
if( x1sigmahigh !=0 ) {
HSigmaHigh.Fill(x1sigmahigh-minmass);
HBestFitvsSigmaHigh.Fill(minmass,x1sigmahigh);
}
if( x1sigmalow !=0 && x1sigmahigh !=0 ) {
HSigma2D.Fill(minmass-x1sigmalow,x1sigmahigh-minmass);
HSigmaFull.Fill(x1sigmahigh-x1sigmalow);
}
/////Find best fit mass
HMass.Fill(110 + minm*5);
ngood++;
}
file.close();
fileb.close();
cout<<"Number of good toys = "<<ngood<<endl;
float MinNLL=1000;
for(Int_t m=0;m<8;m++)
if(MinNLL>H[m]->GetMean())
MinNLL=H[m]->GetMean();
file.open((filenamesb+".txt").Data());
fileb.open((filenameb+".txt").Data());
while(!file.eof()){
file>>n>>nll[0]>>nll[1]>>nll[2]>>nll[3]>>nll[4]>>nll[5]>>nll[6]>>nll[7];
if(!GoodToy[n])continue;
for(Int_t m=0;m<8;m++)
HSigma[m]->Fill(nll[m]-MinNLL);
}
file.close();
fileb.close();
TCanvas C("C","",600,600);
C.Print(filenamesb+".ps[");
//fill what is effectively the asimov dataset
TGraph GScan;
float minnll=100.;
for(Int_t m=0;m<8;m++)
if(minnll>H[m]->GetMean())
minnll=H[m]->GetMean();
const double quantiles[5]={0.05,0.16,0.5,0.84,0.95};
const double xq[8][5];
TLine QLine;
QLine.SetLineColor(2);
///////////////////
for(Int_t m=0;m<8;m++){
HDiffFine[m]->GetQuantiles(5,xq[m],quantiles);
C.Clear();
//HSigma[m]->Draw("pe");
//H[m]->Draw("pe");
//HDiff[m]->Draw("hist");
HDiffFine[m]->Draw("hist");
for(Int_t q=0;q<5;q++){
QLine.DrawLine(xq[m][q],0,xq[m][q],HDiffFine[m]->GetMaximum());
}
C.Print(filenamesb+".ps");
if(m==7)C.Print(filenamesb+"_DNLLDistribution.png");
GScan.SetPoint(m,110+m*5,H[m]->GetMean()-minnll);
}
TGraph* HBands[5];
for(Int_t q=0;q<5;q++){
HBands[q]=new TGraph();
HBands[q]->SetPoint(0,110,0);
for(Int_t m=0;m<8;m++){
HBands[q]->SetPoint(m+1,110+m*5,xq[m][q]);
}
HBands[q]->SetPoint(9,145,0);
}
HBands[0]->SetFillColor(kYellow); HBands[0]->SetLineColor(kYellow); HBands[0]->SetLineWidth(0);
HBands[1]->SetFillColor(kYellow); HBands[1]->SetLineColor(kYellow); HBands[1]->SetLineWidth(0);
HBands[2]->SetFillColor(0); HBands[2]->SetLineColor(kBlue);
HBands[3]->SetFillColor(kGreen); HBands[3]->SetLineColor(kGreen);
HBands[4]->SetFillColor(kYellow); HBands[4]->SetLineColor(kYellow);
/////////////////////Likelihood scan
TH1F HScanFrame("HScanFrame","",1,110,145);
HScanFrame.GetYaxis()->SetRangeUser(0,4);
//HScanFrame.GetYaxis()->SetTitle("#scale[1]{#Delta} -ln(#font[132]{L})");
HScanFrame.GetYaxis()->SetTitle("#scale[1]{#Delta}( -ln L )");
HScanFrame.GetXaxis()->SetTitle("#bf{m_{H} [GeV]}");
TLine line;
line.SetLineColor(2);
C.Clear();
HScanFrame.Draw();
for(Int_t q=4;q>=0;q--){
if(q!=2) HBands[q]->Draw("Fsame");
}
GScan.SetLineColor(kBlue);
GScan.Draw("lsame");
TFile FData("likelihood-mass-scan.root","READ");
TGraph*DataInput=(TGraph*)FData.Get("b+_All_final_1nd/mass_scan");
float mindata=100.;
float minmassdata=0.;
for(Int_t m=0;m<8;m++){
double x; double y;
DataInput->GetPoint(m*5,x,y);
if(mindata>y){
mindata=y;
minmassdata=110+m*5;
}
}
TGraph GData;
for(Int_t m=0;m<8;m++){
double x; double y;
DataInput->GetPoint(m*5,x,y);
GData.SetPoint(m,x,y-mindata);
}
GData.Draw("plsame");
//DataInput->Draw("plsame");
//GScanToy[0]->Draw("lsame");
C.RedrawAxis();
line.DrawLine(110,0.5,145,0.5);
line.DrawLine(110,1.92,145,1.92);
float datasigmahigh=8.55;
float datasigmalow=5.85;
TLine verticalline;
verticalline.SetLineStyle(2);
verticalline.DrawLine(minmassdata-datasigmalow,0,minmassdata-datasigmalow,0.5);
verticalline.DrawLine(minmassdata+datasigmahigh,0,minmassdata+datasigmahigh,0.5);
TLegend legend;
legend.SetFillStyle(0);
legend.SetFillColor(0);
legend.SetBorderSize(0);
legend.AddEntry(&GData,"observed","LP");
legend.AddEntry(&GScan,"H(125 GeV) expected","L");
legend.AddEntry(HBands[3],"#pm 1#sigma expected","F");
legend.AddEntry(HBands[4],"#pm 2#sigma expected","F");
legend.SetX1NDC(0.37);
legend.SetX2NDC(0.85);
legend.SetY1NDC(0.67);
legend.SetY2NDC(0.88);
legend.SetTextSize(.04);
legend.SetTextAlign(12);
legend.Draw();
TLatex text;
text.SetTextColor(2);
text.SetTextSize(0.04);
text.DrawLatex(142,0.5+0.05,"1#sigma");
text.DrawLatex(142,1.92+0.05,"2#sigma");
//CMSPrelim("CMS Preliminary, H#rightarrow#tau#tau, L = 24.3 fb^{-1}"); //#sqrt{s} = 7 - 8 TeV , L = 24.3 fb^{-1}
//CMSPrelim("CMS Prelim., H#rightarrow#tau#tau, #sqrt{s} = 7 - 8 TeV, L = 24.3 fb^{-1}");
//CMSPrelim("");
//CMSPrelim("CMS Preliminary, #sqrt{s}=7 TeV, L=4.9 fb^{-1}, #sqrt{s}=8 TeV, L=19.3 fb^{-1}, H#rightarrow#tau#tau");
CMSPrelim();
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_DNLL.png");
C.Print(filenamesb+"_DNLL.pdf");
//////////////////////Pull distribution
TH1F HMassFrame("HMassFrame","",1,100,155);
HMassFrame.GetYaxis()->SetRangeUser(0,HMass.GetMaximum()*1.3);
HMassFrame.GetYaxis()->SetTitle("# of toys");
HMassFrame.GetXaxis()->SetTitle("m_{H} [GeV]");
cout<<" Fit with 3 gaussians "<<endl;
TF1 Gaus("Gaus","[0]*exp(-0.5*(x-[1])**2/([2]*[2])) + [3]*exp(-0.5*(x-[5])**2/([2]*[2])) + [4]*exp(-0.5*(x-[6])**2/([2]*[2]))",110,145);
Gaus.SetParLimits(0,0,10000);
Gaus.SetParLimits(1,110,145);
Gaus.SetParLimits(2,1,20);
Gaus.SetParLimits(3,0,10000);
Gaus.SetParLimits(4,0,10000);
Gaus.FixParameter(5,110-(injmass-110));
Gaus.FixParameter(6,145+(145-injmass));
C.Clear();
HMass.Fit(&Gaus);
char title[100];
sprintf(title,"Mean = %.1f +- %.1f Sigma = %.1f +- %.1f",Gaus.GetParameter(1),Gaus.GetParError(1),Gaus.GetParameter(2),Gaus.GetParError(2));
HMassFrame.SetTitle(title);
HMassFrame.Draw("hist");
HMass.Draw("histpesame");
Gaus.SetLineColor(4);
Gaus.Draw("lsame");
TF1 GausSig("GausSig","[0]*exp(-0.5*(x-[1])**2/([2]*[2]))",90,160);
GausSig.SetParameter(0,Gaus.GetParameter(0));
GausSig.SetParameter(1,Gaus.GetParameter(1));
GausSig.SetParameter(2,Gaus.GetParameter(2));
GausSig.SetLineColor(2);
GausSig.Draw("lsame");
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_MassUnc.png");
C.Print(filenamesb+"_MassUnc.pdf");
cout<<" Fit with 1 gaussian "<<endl;
C.Clear();
TF1 GausCore("GausCore","[0]*exp(-0.5*(x-[1])**2/([2]*[2]))",110,145);
GausCore.SetParLimits(0,0.1,10000);
GausCore.SetParLimits(1,injmass-5.0,injmass+5.0);
GausCore.SetParLimits(2,1,20);
//HMass.Fit(&GausCore,"","",injmass-5.5,injmass+5.5);
HMass.Fit(&GausCore,"","LL",injmass-10.0,injmass+10.0);
sprintf(title,"Mean = %.1f +- %.1f Sigma = %.1f +- %.1f",GausCore.GetParameter(1),GausCore.GetParError(1),GausCore.GetParameter(2),GausCore.GetParError(2));
HMassFrame.SetTitle(title);
HMassFrame.Draw("hist");
HMass.Draw("histpesame");
GausCore.SetLineColor(2);
GausCore.Draw("lsame");
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_MassUncCore.png");
C.Print(filenamesb+"_MassUncCore.pdf");
C.Clear();
cout<<"# of Pull Toys = "<<HPull.Integral()<<endl;
TF1 GausPull("GausPull","[0]*exp(-0.5*(x-[1])**2/([2]*[2]))",-5,5);
GausPull.SetParLimits(0,0.,1000);
GausPull.SetParLimits(1,-1,1.1);
GausPull.SetParLimits(2,0.2,3);
GausPull.SetLineColor(4);
HPull.Fit(&GausPull,"","I",-2,2);
sprintf(title,"Mean = %.2f +- %.2f Sigma = %.2f +- %.2f",GausPull.GetParameter(1),GausPull.GetParError(1),GausPull.GetParameter(2),GausPull.GetParError(2));
HPull.SetTitle(title);
HPull.GetXaxis()->SetTitle("( m_{best-fit} - m_{injected} )/#sigma_{m}");
HPull.GetYaxis()->SetTitle("# of toys");
HPull.Draw("pe");
GausPull.Draw("lsame");
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_MassPull.png");
C.Print(filenamesb+"_MassPull.pdf");
C.Clear();
TLine sigmaline;
cout<<" # of toys for 2D uncertainty plot "<<HSigma2D.Integral()<<endl;
TF1 SigmaPol("SigmaPol","[0]+[1]*x",0,20);
//HSigma2D.Fit(&SigmaPol);
HSigma2D.Draw("colz");
//SigmaPol.Draw("lsame");
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_sigma2D.png");
C.Clear();
cout<<" # of toys for sigmalow "<<HSigmaLow.Integral()<<endl;
HSigmaLow.Draw();
sigmaline.DrawLine(datasigmalow,0,datasigmalow,HSigmaLow.GetMaximum());
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_sigmaLow.png");
C.Clear();
cout<<" # of toys for sigmahigh "<<HSigmaHigh.Integral()<<endl;
HSigmaHigh.Draw();
sigmaline.DrawLine(datasigmahigh,0,datasigmahigh,HSigmaHigh.GetMaximum());
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_sigmaHigh.png");
C.Clear();
cout<<" # of toys for sigmafull "<<HSigmaFull.Integral()<<endl;
HSigmaFull.Draw();
sigmaline.DrawLine(datasigmalow+datasigmahigh,0,datasigmalow+datasigmahigh,HSigmaFull.GetMaximum());
C.Print(filenamesb+".ps");
C.Print(filenamesb+"_sigmafull.png");
C.Clear();
TF1 SigmaBFitvsSigma("SigmaBFitvsSigma","[0]+[1]*x",0,20);
//HBestFitvsSigmaHigh.Fit(&SigmaBFitvsSigma);
HBestFitvsSigmaHigh.Draw("colz");
//SigmaBFitvsSigma.Draw("lsame");
C.Print(filenamesb+".ps");
C.Print(filenamesb+".ps]");
gROOT->ProcessLine(".q");
}
void compareLimits(const char* filename, const char* channelstr, bool expected, bool observed, const char* type, double minimum=0., double maximum=20., bool log=false, const char* label=" Preliminary, #sqrt{s} = 7+8 TeV, H#rightarrow#tau#tau, L = 10 fb^{-1}", bool legendOnRight = true)
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["incl" ] = kBlue;
colors["0jet" ] = kBlue;
colors["2jet" ] = kMagenta;
colors["vbf" ] = kRed;
colors["boost" ] = kGreen;
colors["emu" ] = kBlue;
colors["em" ] = kBlue;
colors["etau" ] = kRed;
colors["et" ] = kRed;
colors["mutau" ] = kGreen;
colors["mt" ] = kGreen;
colors["mumu" ] = kMagenta;
colors["mm" ] = kMagenta;
colors["tautau" ] = kOrange;
colors["tt" ] = kOrange;
colors["vhtt" ] = kMagenta+2;
colors["whtt" ] = kMagenta+0;
colors["zhtt" ] = kCyan+2;
colors["whhh" ] = kBlue;
colors["cmb" ] = kBlack;
colors["htt" ] = kBlack;
colors["htt+" ] = kBlue;
colors["hgg" ] = kRed;
colors["hww" ] = kGreen;
colors["4l" ] = kGreen;
colors["llt" ] = kRed;
colors["ltt" ] = kBlue;
colors["hzz4l" ] = kBlue;
colors["hzz2l2q" ] = kMagenta;
colors["hzz2l2q+" ] = kMagenta;
colors["hzz2l2t" ] = kOrange;
colors["hzz2l2n" ] = kPink;
colors["ggH" ] = kRed;
colors["bbH" ] = kBlue;
colors["test-0" ] = kBlue+2;
colors["test-1" ] = kRed+2;
colors["test-2" ] = kGreen;
colors["test-3" ] = kRed+2;
colors["test-4" ] = kBlue;
colors["test-5" ] = kViolet-6;
colors["cmb-5fb" ] = kBlue;
colors["hpa-5fb" ] = kRed;
colors["hpa-10fb" ] = kBlack;
colors["saeff" ] = kGreen;
colors["gluph" ] = kOrange-3;
colors["nomix-200" ] = kBlue-10;
colors["nomix+200" ] = kBlue +2;
colors["mhmax-400" ] = kGray +2;
colors["mhmax-200" ] = kGray +1;
colors["mhmax+200" ] = kMagenta+ 4;
colors["mhmax+400" ] = kMagenta+ 3;
colors["mhmax+600" ] = kMagenta- 2;
colors["mhmax+800" ] = kMagenta-10;
colors["HIG-11-020"] = kBlue+2;
colors["HIG-11-029"] = kRed+2;
colors["HIG-12-018"] = kBlue;
colors["HIG-12-032"] = kRed+2;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x MitLimits/Higgs2Tau/macros/compareLimits.C+(file, chn, exp, obs, type, min, max, log) \n"
<< " * \n"
<< " * Arguments : + file const char* full path to the input file \n"
<< " * + chn const char* list of channels; choose between: 'cmb', 'htt', 'emu', \n"
<< " * 'etau', 'mutau', 'mumu', 'vhtt', 'hgg', 'hww', 'ggH', \n"
<< " * 'bbH', 'nomix[-200, +200]', 'mhmax[-400, -200, +200]' \n"
<< " * 'mhmax[+400, +600, +800]', 'test-0...5', 'saeff', 'gluph' \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + exp bool compare expected limits \n"
<< " * + obs bool compare observed limits \n"
<< " * + type const char* type of plot; choose between 'sm-xsec', 'mssm-xsec' and \n"
<< " * 'mssm-tanb' \n"
<< " * + max double maximum of the plot (default is 20.) \n"
<< " * \n"
<< " * + min double minimum of the plot (default is 0.) \n"
<< " * \n"
<< " * + log bool set log scale yes or no (default is false) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// open input file
TFile* inputFile = new TFile(filename); if(inputFile->IsZombie()){ std::cout << "ERROR:: file: " << filename << " does not exist.\n"; }
/// prepare input parameters
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
/// prepare histograms
std::vector<TGraph*> hobs, hexp;
for(unsigned i=0; i<channels.size(); ++i){
if(observed) hobs.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/observed").c_str()));
if(expected) hexp.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/expected").c_str()));
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Limit Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(1);
canv1->SetGridy(1);
bool firstPlot=true;
for(unsigned int i=0; i<hexp.size(); ++i){
if(firstPlot){
if(std::string(type) == std::string("mssm-xsec")){
if(log){ canv1->SetLogy(1); }
hexp[i]->SetMaximum(maximum);
hexp[i]->SetMinimum(minimum);
}
else{
if(log){ canv1->SetLogy(1); }
hexp[i]->SetMaximum(maximum);
hexp[i]->SetMinimum(minimum);
}
// format x-axis
std::string x_title;
if(std::string(type).find("mssm")!=std::string::npos){
x_title = std::string("m_{A} [GeV]");
}
else{
x_title = std::string("m_{H} [GeV]");
}
hexp[i]->GetXaxis()->SetTitle(x_title.c_str());
hexp[i]->GetXaxis()->SetLabelFont(62);
hexp[i]->GetXaxis()->SetTitleFont(62);
hexp[i]->GetXaxis()->SetTitleColor(1);
hexp[i]->GetXaxis()->SetTitleOffset(1.05);
// format y-axis
std::string y_title;
if( std::string(type) == std::string("mssm-xsec") ){
y_title = std::string("#sigma(#phi#rightarrow#tau#tau)_{95% CL} [pb]");
}
else if( std::string(type) == std::string("mssm-tanb") ){
y_title = std::string("#bf{tan#beta}");
}
else{
//y_title = std::string("#sigma(H#rightarrow#tau#tau)_{95% CL} / #sigma(H#rightarrow#tau#tau)_{SM}");
y_title = std::string("95% CL limit on #sigma/#sigma_{SM}");
}
hexp[i]->GetYaxis()->SetTitle(y_title.c_str());
hexp[i]->GetYaxis()->SetLabelFont(62);
hexp[i]->GetYaxis()->SetTitleOffset(1.05);
hexp[i]->GetYaxis()->SetLabelSize(0.03);
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0]-.1, hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
}
hexp[i]->SetLineStyle(11.);
hexp[i]->SetLineWidth( 3.);
hexp[i]->SetLineColor(colors.find(channels[i])->second);
hexp[i]->SetMarkerStyle(20);
hexp[i]->SetMarkerSize(MARKER_SIZE);
hexp[i]->SetMarkerColor(colors.find(channels[i])->second);
hexp[i]->Draw(firstPlot ? "APL" : "PLsame");
//hexp[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
for(unsigned int i=0; i<hobs.size(); ++i){
if(firstPlot){
if(std::string(type) == std::string("mssm-xsec")){
if(log){ canv1->SetLogy(1); }
hobs[i]->SetMaximum(maximum);
hobs[i]->SetMinimum(minimum);
}
else{
if(log){ canv1->SetLogy(1); }
hobs[i]->SetMaximum(maximum);
hobs[i]->SetMinimum(minimum);
}
// format x-axis
std::string x_title;
if(std::string(type).find("mssm")!=std::string::npos){
x_title = std::string("m_{A} [GeV]");
}
else{
x_title = std::string("m_{H} [GeV]");
}
hobs[i]->GetXaxis()->SetTitle(x_title.c_str());
hobs[i]->GetXaxis()->SetLabelFont(62);
hobs[i]->GetXaxis()->SetTitleFont(62);
hobs[i]->GetXaxis()->SetTitleColor(1);
hobs[i]->GetXaxis()->SetTitleOffset(1.05);
// format y-axis
std::string y_title;
if( std::string(type) == std::string("mssm-xsec") ){
y_title = std::string("#sigma(#phi#rightarrow#tau#tau)_{95% CL} [pb]");
}
else if( std::string(type) == std::string("mssm-tanb") ){
y_title = std::string("#bf{tan#beta}");
}
else{
//y_title = std::string("#sigma(H#rightarrow#tau#tau)_{95% CL} / #sigma(H#rightarrow#tau#tau)_{SM}");
y_title = std::string("#sigma(H)_{95% CL} / #sigma(H)_{SM}");
}
hobs[i]->GetYaxis()->SetTitle(y_title.c_str());
hobs[i]->GetYaxis()->SetLabelFont(62);
hobs[i]->GetYaxis()->SetTitleOffset(1.05);
hobs[i]->GetYaxis()->SetLabelSize(0.03);
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0]-.1, hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
}
hobs[i]->SetLineWidth( 3.);
hobs[i]->SetLineColor(colors.find(channels[i])->second);
hobs[i]->SetMarkerStyle(20);
hobs[i]->SetMarkerSize(MARKER_SIZE);
hobs[i]->SetMarkerColor(colors.find(channels[i])->second);
hobs[i]->Draw(firstPlot ? "APL" : "PLsame");
//hobs[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
canv1->RedrawAxis();
bool firstLeg=true;
if(observed){
TLegend* leg1;
if(expected && observed){
/// setup the CMS Preliminary
if (firstLeg) CMSPrelim(label, "", 0.15, 0.835);
leg1 = new TLegend(firstLeg ? 0.60 : 0.20, hobs.size()<5 ? 0.90-0.06*hobs.size() : 0.6, firstLeg ? 0.93 : 0.60, 0.90);
}
else{
/// setup the CMS Preliminary
CMSPrelim(label, "", 0.15, 0.835);
leg1 = new TLegend(legendOnRight ? 0.50 : 0.20, hobs.size()<5 ? 0.90-0.06*hobs.size() : 0.6, legendOnRight ? 0.93 : 0.63, 0.90);
}
leg1->SetBorderSize( 0 );
leg1->SetFillStyle ( 0 );
leg1->SetFillColor ( 0 );
leg1->SetFillColor (kWhite);
leg1->SetHeader( "#bf{Observed Limit}" );
for(unsigned int i=0; i<hobs.size(); ++i){
// skip one of the two split options
if(channels[i] == std::string("hzz2l2q+")){ continue; }
leg1->AddEntry( hobs[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
leg1->Draw("same");
firstLeg=false;
}
if(expected){
TLegend* leg0;
if(expected && observed){
/// setup the CMS Preliminary
if (firstLeg) CMSPrelim(label, "", 0.15, 0.835);
leg0 = new TLegend(firstLeg ? 0.60 : 0.20, hexp.size()<5 ? 0.90-0.06*hexp.size() : 0.8, firstLeg ? 0.94 : 0.60, 0.90);
}
else{
/// setup the CMS Preliminary
CMSPrelim(label, "", 0.15, 0.835);
leg0 = new TLegend(legendOnRight ? 0.50 : 0.20, hexp.size()<5 ? 0.90-0.06*hexp.size() : 0.6, legendOnRight ? 0.94 : 0.64, 0.90);
}
leg0->SetBorderSize( 0 );
leg0->SetFillStyle ( 0 );
leg0->SetFillColor (kWhite);
leg0->SetHeader( "#bf{Expected Limit}" );
for(unsigned int i=0; i<hexp.size(); ++i){
// skip one of the two split options
if(channels[i] == std::string("hzz2l2q+")){ continue; }
leg0->AddEntry( hexp[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
leg0->Draw("same");
firstLeg=false;
}
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.png" : "_sm.png").c_str());
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.pdf").c_str());
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.eps").c_str());
return;
}
void
//HHH_TT_X_notag(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="tauTau_$CATEGORY")
HHH_TT_X_notag(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="tauTau_$CATEGORY")
{
// defining the common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category = ""; const char* category_extra = ""; const char* category_extra2 = "";
if(std::string(directory) == std::string("tauTau_2jet0tag")){ category = "#tau_{h}#tau_{h}"; }
if(std::string(directory) == std::string("tauTau_2jet0tag")){ category_extra= "2-jet 0 b-tag"; }
if(std::string(directory) == std::string("tauTau_2jet1tag" )){ category = "#tau_{h}#tau_{h}"; }
if(std::string(directory) == std::string("tauTau_2jet1tag" )){ category_extra= "2-jet 1 b-tag"; }
if(std::string(directory) == std::string("tauTau_2jet2tag" )){ category = "#tau_{h}#tau_{h}"; }
if(std::string(directory) == std::string("tauTau_2jet2tag" )){ category_extra = "2-jet 2 b-tag"; }
const char* dataset;
#ifdef MSSM
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 4.9 fb^{-1} (7 TeV)";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){
if(std::string(directory).find("btag")!=std::string::npos){
dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 18.3 fb^{-1} (8 TeV)";
}
else{
dataset = "#scale[1.5]{CMS} H#rightarrow hh#rightarrow#tau#tau bb 19.7 fb^{-1} (8 TeV)";
}
}
#else
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS, 19.7 fb^{-1} at 8 TeV";}
#endif
// open example histogram file
TFile* input = new TFile(inputfile.c_str());
#ifdef MSSM
TFile* input2 = new TFile((inputfile+"_$MH_$TANB").c_str());
#endif
TH1F* Fakes = refill((TH1F*)input->Get(TString::Format("%s/QCD" , directory)), "QCD"); InitHist(Fakes, "", "", TColor::GetColor(250,202,255), 1001);
TH1F* EWK1 = refill((TH1F*)input->Get(TString::Format("%s/W" , directory)), "W" ); InitHist(EWK1 , "", "", TColor::GetColor(222,90,106), 1001);
TH1F* EWK2 = refill((TH1F*)input->Get(TString::Format("%s/ZLL" , directory)), "ZLL" ); InitHist(EWK2 , "", "", TColor::GetColor(222,90,106), 1001);
//TH1F* EWK3 = refill((TH1F*)input->Get(TString::Format("%s/ZL" , directory)), "ZL" ); InitHist(EWK3 , "", "", TColor::GetColor(222,90,106), 1001);
TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/VV" , directory)), "VV" ); InitHist(EWK , "", "", TColor::GetColor(222,90,106), 1001);
TH1F* ttbar = refill((TH1F*)input->Get(TString::Format("%s/TT" , directory)), "TT" ); InitHist(ttbar, "", "", TColor::GetColor(155,152,204), 1001);
TH1F* Ztt = refill((TH1F*)input->Get(TString::Format("%s/ZTT" , directory)), "ZTT"); InitHist(Ztt , "", "", TColor::GetColor(248,206,104), 1001);
#ifdef MSSM
TH1F* ggHTohhTo2Tau2B = refill((TH1F*)input2->Get(TString::Format("%s/ggHTohhTo2Tau2B$MH" , directory)), "ggHTohhTo2Tau2B"); InitSignal(ggHTohhTo2Tau2B); ggHTohhTo2Tau2B->Scale($TANB*SIGNAL_SCALE);
// if(std::string(directory)=="tauTau_2jet0tag") ggHTohhTo2Tau2B->Scale(4);
/* TH1F* ggH_SM125 = refill((TH1F*)input->Get(TString::Format("%s/ggH_SM125",directory)),"ggH_SM125");InitSignal(ggH_SM125);ggH_SM125->Scale(SIGNAL_SCALE);
TH1F* qqH_SM125 = refill((TH1F*)input->Get(TString::Format("%s/qqH_SM125",directory)),"qqH_SM125");InitSignal(qqH_SM125);qqH_SM125->Scale(SIGNAL_SCALE);
TH1F* VH_SM125 = refill((TH1F*)input->Get(TString::Format("%s/VH_SM125",directory)),"VH_SM125");InitSignal(VH_SM125);VH_SM125->Scale(SIGNAL_SCALE);
TH1F* WHToBB_SM125 = refill((TH1F*)input->Get(TString::Format("%s/WHToBB_SM125",directory)),"WHToBB_SM125");InitSignal(WHToBB_SM125);WHToBB_SM125->Scale(SIGNAL_SCALE);
TH1F* ZHToBB_SM125 = refill((TH1F*)input->Get(TString::Format("%s/ZHToBB_SM125",directory)),"ZHToBB_SM125");InitSignal(ZHToBB_SM125);ZHToBB_SM125->Scale(SIGNAL_SCALE);
*/
/*
TH1F* ggAToZhToLLTauTau = refill((TH1F*)input2->Get(TString::Format("%s/ggAToZhToLLTauTau$MH",directory)),"ggAToZhToLLTauTau"); InitSignal(ggAToZhToLLTauTau);
TH1F* ggAToZhToLLBB = refill((TH1F*)input2->Get(TString::Format("%s/ggAToZhToLLBB$MH",directory)),"ggAToZhToLLBB"); InitSignal(ggAToZhToLLBB);
TH1F* bbH = refill((TH1F*)input2->Get(TString::Format("%s/bbH$MH" , directory)), "bbH"); InitSignal(bbH);
*/
#endif
#ifdef ASIMOV
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs_asimov", directory)), "data", true);
#else
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data",true);
#endif
InitHist(data, "#bf{m_{H} [GeV]}", "#bf{dN/dm_{H} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)Fakes->Clone("ref");
ref->Add(EWK1 );
ref->Add(EWK2 );
//ref->Add(EWK3 );
ref->Add(EWK );
ref->Add(ttbar);
ref->Add(Ztt );
double unscaled[8];
unscaled[0] = Fakes->Integral();
unscaled[1] = EWK ->Integral();
unscaled[1]+= EWK1 ->Integral();
unscaled[1]+= EWK2 ->Integral();
//unscaled[1]+= EWK3 ->Integral();
unscaled[2] = ttbar->Integral();
unscaled[3] = Ztt ->Integral();
#ifdef MSSM
unscaled[4] = ggHTohhTo2Tau2B ->Integral();
/* unscaled[5] = ggH_SM125->Integral();
unscaled[5]+= qqH_SM125->Integral();
unscaled[5]+= VH_SM125->Integral();
*/
/*
unscaled[5] = ggAToZhToLLTauTau->Integral();
unscaled[6] = ggAToZhToLLBB->Integral();
unscaled[7] = bbH ->Integral();
*/
#endif
if(scaled){
/* Fakes = refill(shape_histos(Fakes, datacard, "QCD"), "QCD");
EWK1 = refill(shape_histos(EWK1, datacard, "W"), "W");
EWK2 = refill(shape_histos(EWK2, datacard, "ZJ"), "ZJ");
EWK = refill(shape_histos(EWK, datacard, "VV"), "VV");
ttbar = refill(shape_histos(ttbar, datacard, "TT"), "TT");
Ztt = refill(shape_histos(Ztt, datacard, "ZTT"), "ZTT");
#ifdef MSSM
ggH = refill(shape_histos(ggH, datacard, "ggH$MH"), "ggH$MH");
bbH = refill(shape_histos(bbH, datacard, "bbH$MH"), "bbH$MH");
#else
ggH = refill(shape_histos(ggH, datacard, "ggH"), "ggH");
qqH = refill(shape_histos(qqH, datacard, "qqH"), "qqH");
VH = refill(shape_histos(VH, datacard, "VH"), "VH");
#endif
*/
rescale(Fakes, 7);
rescale(EWK1 , 3);
rescale(EWK2 , 4);
//rescale(EWK3 , 5);
rescale(EWK , 6);
rescale(ttbar, 2);
rescale(Ztt , 1);
#ifdef MSSM
rescale(ggHTohhTo2Tau2B , 8);
/*
rescale(ggAToZhToLLTauTau,9);
rescale(ggAToZhToLLBB,10);
rescale(bbH , 11);
*/
#endif
}
TH1F* scales[8];
scales[0] = new TH1F("scales-Fakes", "", 8, 0, 8);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (Fakes->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-EWK" , "", 8, 0, 8);
scales[1]->SetBinContent(2, unscaled[1]>0 ? ((EWK ->Integral()
+EWK1 ->Integral()
+EWK2 ->Integral()
//+EWK3 ->Integral()
)/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-ttbar", "", 8, 0, 8);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (ttbar->Integral()/unscaled[2]-1.) : 0.);
scales[3] = new TH1F("scales-Ztt" , "", 8, 0, 8);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (Ztt ->Integral()/unscaled[3]-1.) : 0.);
#ifdef MSSM
scales[4] = new TH1F("scales-ggHTohhTo2Tau2B" , "", 8, 0, 8);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggHTohhTo2Tau2B ->Integral()/unscaled[4]-1.) : 0.);
/* scales[5] = new TH1F("scales-sm","",8,0,8);
scales[5]->SetBinContent(6, unscaled[5]>0 ? ((ggH_SM125->Integral()+qqH_SM125->Integral()+VH_SM125->Integral())/unscaled[5]-1.) : 0.);
*/
/*
scales[5] = new TH1F("scales-ggAToZhToLLTauTau" , "", 8, 0, 8);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (ggAToZhToLLTauTau ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-ggAToZhToLLBB" , "", 8, 0, 8);
scales[6]->SetBinContent(7, unscaled[6]>0 ? (ggAToZhToLLBB ->Integral()/unscaled[6]-1.) : 0.);
scales[7] = new TH1F("scales-bbH" , "", 8, 0, 8);
scales[7]->SetBinContent(8, unscaled[7]>0 ? (bbH ->Integral()/unscaled[7]-1.) : 0.);
*/
#endif
//#ifdef MSSM
// qqH_SM125->Add(ggH_SM125);
// VH_SM125->Add(qqH_SM125);
// Fakes->Add(VH_SM125);
//#endif
Fakes->Add(ttbar);
EWK1 ->Add(Fakes);
EWK2 ->Add(Fakes );
//EWK3 ->Add(EWK2 );
//EWK ->Add(EWK3 );
EWK ->Add(EWK2 );
// ttbar->Add(EWK );
Ztt ->Add(EWK);
/*ggH_SM125->Add(qqH_SM125);
ggH_SM125->Add(VH_SM125);
ggH_SM125->Add(ZHToBB_SM125);
ggH_SM125->Add(WHToBB_SM125);
*/
//if(log){
//#ifdef MSSM
// ggH->Add(bbH);
//#else
// qqH->Add(VH );
// ggH->Add(qqH);
//#endif
// }
//else{
//#ifdef MSSM
// bbH->Add(Ztt);
// ggH->Add(bbH);
//#else
// VH ->Add(Ztt);
// qqH->Add(VH );
// ggH->Add(qqH);
//#endif
// }
/*
Mass plot before and after fit
*/
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(200, data->FindBin(UPPER_EDGE)); } else{ data->GetXaxis()->SetRange(200, data->FindBin(UPPER_EDGE)); };
#else
data->GetXaxis()->SetRange(200, data->FindBin(UPPER_EDGE));
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
data->SetMaximum(max>0 ? max : std::max(std::max(maximum(data, log), maximum(Ztt, log)), maximum(ggHTohhTo2Tau2B, log)));
data->Draw("e");
TH1F* errorBand = (TH1F*)Ztt ->Clone();
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
if(errorBand->GetBinContent(idx)>0){
std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
break;
}
}
if(log){
Ztt ->Draw("histsame");
// ttbar->Draw("histsame");
EWK ->Draw("histsame");
Fakes->Draw("histsame");
ttbar->Draw("histsame");
//#ifdef MSSM
// VH_SM125->Draw("histsame");
//#endif
$DRAW_ERROR
ggHTohhTo2Tau2B ->Draw("histsame");
/* ggH_SM125->SetLineColor(kRed);
ggH_SM125->Draw("histsame");
*/
}
else{
Ztt ->Draw("histsame");
// ttbar->Draw("histsame");
EWK ->Draw("histsame");
Fakes->Draw("histsame");
ttbar->Draw("histsame");
#ifdef MSSM
//VH_SM125->Draw("histsame");
#endif
$DRAW_ERROR
ggHTohhTo2Tau2B ->Draw("histsame");
/*ggH_SM125->SetLineColor(kRed);
ggH_SM125->Draw("histsame");
*/
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "#tau_{h}#tau_{h}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
#if defined MSSM
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "tlbrNDC");
if (strcmp(category_extra2,"")!=0) chan = new TPaveText(0.20, 0.69+0.061, 0.32, 0.74+0.161, "tlbrNDC");
#else
TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC");
#endif
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->AddText(category_extra);
#if defined MSSM
if (strcmp(category_extra2,"")!=0) chan->AddText(category_extra2);
#else
chan->AddText(category_extra2);
#endif
chan->Draw();
/*
TPaveText* cat = new TPaveText(0.20, 0.71+0.061, 0.32, 0.71+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
TPaveText* cat2 = new TPaveText(0.20, 0.66+0.061, 0.32, 0.66+0.161, "NDC");
cat2->SetBorderSize( 0 );
cat2->SetFillStyle( 0 );
cat2->SetTextAlign( 12 );
cat2->SetTextSize ( 0.05 );
cat2->SetTextColor( 1 );
cat2->SetTextFont ( 62 );
cat2->AddText(category_extra2);
cat2->Draw();
*/
#ifdef MSSM
TPaveText* massA = new TPaveText(0.53, 0.44+0.061, 0.95, 0.44+0.151, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("MSSM m^{h}_{mod+} scenario");
massA->AddText("m_{H}=$MH GeV, tan#beta=$TANB");
massA->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.53, 0.60, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(ggHTohhTo2Tau2B , TString::Format("%0.f #times H#rightarrowhh#rightarrow#tau#taubb", SIGNAL_SCALE) , "L" );
//leg->AddEntry(ggH_SM125, TString::Format("%0.f #times SM H(125 GeV) #rightarrow #tau#tau/bb", SIGNAL_SCALE), "L");
#endif
#ifdef ASIMOV
leg->AddEntry(data , "sum(bkg) + H(125)" , "LP");
#else
leg->AddEntry(data , "Observed" , "LP");
#endif
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(EWK , "Electroweak" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
/*#ifdef MSSM
leg->AddEntry(VH_SM125, "SM H(125 GeV) #rightarrow #tau#tau", "F" );
#endif
*/
$ERROR_LEGEND
leg->Draw();
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* model = (TH1F*)Ztt ->Clone("model");
TH1F* test1 = (TH1F*)data->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
model->SetBinError (ibin+1, CONSERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob=0.;
double chi2ndof=0.;
double ksprob=0.;
double ksprobpe=0.;
if(!BLIND_DATA){
chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
}
std::vector<double> edges;
TH1F* zero = (TH1F*)ref->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat1");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? Ztt ->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if(edges.size()>1){
if (edges[edges.size()-2]>0.1) { range = 0.2; }
else if (edges[edges.size()-2]>0.2) { range = 0.5; }
else if (edges[edges.size()-2]>0.5) { range = 1.0; }
else if (edges[edges.size()-2]>1.0) { range = 1.5; }
else if (edges[edges.size()-2]>1.5) { range = 2.0; }
}
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{H} [GeV]}");
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv0->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
if(!BLIND_DATA){
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
}
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
stat1->Draw();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
edges.clear();
TH1F* rat2 = (TH1F*) Ztt->Clone("rat2");
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
rat2->SetBinContent(ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinContent(ibin+1)/ref->GetBinContent(ibin+1) : 0);
rat2->SetBinError (ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinError (ibin+1)/ref->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat2->GetBinContent(ibin+1)-1.)+TMath::Abs(rat2->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
range = 0.1;
std::sort(edges.begin(), edges.end());
if(edges.size()>1){
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
}
#if defined MSSM
if(!log){ rat2->GetXaxis()->SetRange(200, rat2->FindBin(UPPER_EDGE)); } else{ rat2->GetXaxis()->SetRange(200, rat2->FindBin(UPPER_EDGE)); };
#else
rat2->GetXaxis()->SetRange(200, rat2->FindBin(UPPER_EDGE));
#endif
rat2->SetNdivisions(505);
rat2->SetLineColor(kRed+ 3);
rat2->SetMarkerColor(kRed+3);
rat2->SetMarkerSize(1.1);
rat2->SetMaximum(+range);
rat2->SetMinimum(-range);
rat2->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
rat2->GetXaxis()->SetTitle("#bf{m_{H} [GeV]}");
rat2->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->Draw("e2histsame");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[0], "", "", TColor::GetColor(250,202,255), 1001);
InitHist (scales[1], "", "", TColor::GetColor(222,90,106), 1001);
InitHist (scales[2], "", "", TColor::GetColor(155,152,204), 1001);
InitHist (scales[3], "", "", TColor::GetColor(248,206,104), 1001);
InitHist(scales[4],"","",kGreen+2,1001);
/* InitHist(scales[5],"","",kGreen+2,1001);
InitHist(scales[6],"","",kGreen+2,1001);
InitHist(scales[7],"","",kGreen+2,1001);
*/
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Fakes}");
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{EWK}" );
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{ttbar}");
scales[0]->GetXaxis()->SetBinLabel(4, "#bf{Ztt}" );
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggHTohhTo2tau2B}" );
/*
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{ggAToZhToLLTauTau}");
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{ggAToZhToLLBB}");
scales[0]->GetXaxis()->SetBinLabel(8, "#bf{bbH}" );
*/
#endif
scales[0]->SetMaximum(+0.5);
scales[0]->SetMinimum(-0.5);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
scales[1]->Draw("same");
scales[2]->Draw("same");
scales[3]->Draw("same");
scales[4]->Draw("same");
/* scales[5]->Draw("same");
scales[6]->Draw("same");
*/
TH1F* zero_samples = (TH1F*)scales[0]->Clone("zero_samples"); zero_samples->Clear();
zero_samples->SetBinContent(1,0.);
zero_samples->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sfit_%s_%s.png" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.pdf" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.eps" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
if(!log || FULLPLOTS)
{
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
if((!log && scaled) || FULLPLOTS)
{
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
TFile* output = new TFile(TString::Format("%s_%sfit_%s_%s.root", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"), "update");
output->cd();
data ->Write("data_obs");
Fakes->Write("Fakes" );
EWK ->Write("EWK" );
ttbar->Write("ttbar" );
Ztt ->Write("Ztt" );
#ifdef MSSM
ggHTohhTo2Tau2B ->Write("ggHTohhTo2Tau2B" );
/*
ggAToZhToLLTauTau->Write("ggAToZhToLLTauTau");
ggAToZhToLLBB->Write("ggAToZhToLLBB");
bbH ->Write("bbH" );
*/
#endif
output->Close();
delete errorBand;
delete model;
delete test1;
delete zero;
delete rat1;
delete rat2;
delete zero_samples;
delete ref;
}
void test_msv(std::string var="m_sv",int nbins=25, double xmin=0, double xmax=250,std::string xtitle="m_sv", std::string ytitle="Events")
{
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
TH1::SetDefaultSumw2(1);
std::string dir = "/afs/cern.ch/work/a/arapyan/public/svfitsamples/";
double sigscale = 10;
double sigscale1 = 10;
std::stringstream scale; scale << sigscale;
std::stringstream scale1; scale1 << sigscale1;
//Cut definitions
double luminosity = 3000;
std::stringstream lumi; lumi << luminosity;
std::string objcut = "(ptTau1>30 && ptTau2>30 && abs(etaTau1) <4.0 && abs(etaTau1)<4.0 )";
//std::string jetcut = objcut+"*(ptJet1>30 && ptJet2>30 && abs(etaJet1) <4.7 && abs(etaJet2) <4.7 )";
std::string mthcut = objcut+"*( ( (tauCat1==3 && tauCat2==2) || (tauCat2==3 && tauCat1==2) ) )";
//signal region
//std::string vbfcut = ththcut+"*eventWeight*(eventType==0)*"+lumi.str();
//std::string zttcut = ththcut+"*eventWeight*(eventType==1)*"+lumi.str();
//std::string ttbarcut = ththcut+"*eventWeight*(eventType==3)*"+lumi.str();
//std::string ewkcut = ththcut+"*eventWeight*(eventType==2)*"+lumi.str();
//std::string othercut = ththcut+"*eventWeight*(eventType==4 || eventType==2)*"+lumi.str();
//--------------------------------------------------------------------------
//Get the trees
TTree *tree = load(dir+"hh.root");
TTree *tree2 = load(dir+"Bjj-vbf.root");
TTree *tree3 = load(dir+"vbf_bgd.root");
//-------------------------------------------------------------------------
//Get histograms
TCanvas *canv0 = MakeCanvas("canv", "histograms", 600, 600);
canv0->cd();
std::string vardraw;
TH1F *vbf = new TH1F("VBFH","",nbins,xmin,xmax);
vardraw = var+">>"+"VBFH";
tree->Draw(vardraw.c_str(),mthcut.c_str());
InitSignal(vbf);
vbf->SetLineColor(kBlack);
//TH1F *ttbar = new TH1F("TTbar","",nbins,xmin,xmax);
//vardraw = var+">>"+"TTbar";
//tree->Draw(vardraw.c_str(),ttbarcut.c_str());
//InitHist(ttbar, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(155,152,204), 1001);
TH1F *ztt = new TH1F("Ztt","",nbins,xmin,xmax);
vardraw = var+">>"+"Ztt";
tree2->Draw(vardraw.c_str(),mthcut.c_str());
InitHist(ztt, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(248,206,104), 1001);
//TH1F *ewk = new TH1F("Ewk","",nbins,xmin,xmax);
//vardraw = var+">>"+"Ewk";
//tree->Draw(vardraw.c_str(),ewkcut.c_str());
//InitHist(ewk, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
TH1F *other = new TH1F("Other","",nbins,xmin,xmax);
vardraw = var+">>"+"Other";
tree3->Draw(vardraw.c_str(),mthcut.c_str());
InitHist(other, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
delete canv0;
//----------------------------------------------------------------------------
//Print out the yields
/* Double_t error=0.0;
ofstream outfile;
outfile.open("yields_test.txt");
outfile << "Yields for the signal region." << std::endl;
outfile << "VBF " << vbf->IntegralAndError(0,vbf->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "TTbar " << ttbar->IntegralAndError(0,ttbar->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "Ztt " << ztt->IntegralAndError(0,ztt->GetNbinsX(),error) << "+/-" << error << endl;
//outfile << "ewk " << ewk->IntegralAndError(0,ewk->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "other " << other->IntegralAndError(0,other->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "S/sqrt(B) " << vbf->Integral()/(other->Integral()+ztt->Integral()+ttbar->Integral()) << endl;
//--------------------------------------------------------------------------
//continue outputing
//outfile << "Ewk total " << ewk->IntegralAndError(0,ewk->GetNbinsX(),error) << "+/-" << error << endl;
outfile << endl << endl << endl;
outfile << "In the signal region (100,150GeV) " <<endl;
outfile << "VBF " << vbf->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "TTbar " << ttbar->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "Ztt " << ztt->IntegralAndError(5,11,error) << "+/-" << error << endl;
//outfile << "ewk " << ewk->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "other " << other->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile.close();*/
//-----------------------------------------------------------------------
//Draw the histograms
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
//ewk->Add(other); ttbar->Add(ewk);
//ztt->Add(ttbar); vbf->Add(ztt);
other->Add(ztt);
//Error band stat
TH1F* errorBand = (TH1F*)vbf ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
// for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
// if(errorBand->GetBinContent(idx)>0){
// std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
// break;
// }
//}
Float_t n=other->GetEntries();
other->Scale(1.0/n);
n=vbf->GetEntries();
vbf->Scale(1.0/n);
//for (Int_t i=1; i<nbins+1; i++) {
//cout << "i: " << i << " " << other->GetBinCenter(i) << " " << other->Integral(0,i) << " " << other->Integral(i,nbins+1) << endl;
//}
cout << " other " << other->Integral(10,15) << endl;
cout << " htt " << vbf->Integral(10,15) << endl;
//n=ztt->GetEntries();
//ztt->Scale(1.0/n);
other->SetMaximum(1.2*std::max(maximum(vbf, 0), maximum(other, 0)));
//blind(vbf,75,150);
//ttbar->Draw("histsame");
//ewk->Draw("histsame");
other->Draw("hist");
//ztt->Draw("histsame");
vbf->Draw("histsame");
//errorBand->Draw("e2same");
canv->RedrawAxis();
//---------------------------------------------------------------------------
//Adding a legend
TLegend* leg = new TLegend(0.53, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(vbf , "HH" , "F");
//leg->AddEntry(ztt , "bjj-vbf" , "F" );
//leg->AddEntry(ttbar, "t#bar{t}" , "F" );
//leg->AddEntry(ewk , "Electroweak" , "F" );
leg->AddEntry(other, "Other" , "F" );
//leg->AddEntry(errorBand,"bkg. uncertainty","F");
leg->Draw();
//---------------------------------------------------------------------------
//CMS preliminary
const char* dataset = "CMS Preliminary, H#rightarrow#tau#tau, 3.0 ab^{-1} at 14 TeV";
const char* category = "";
CMSPrelim(dataset, "#mu#tau_{h}", 0.17, 0.835);
//CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->Draw();
//-------------------------------------------------------------------------
//Save histograms
canv->Print((var+"_test.png").c_str());
}
void draw_prefit_Sample(std::string inputF, std::string channel, int MaxY, std::string xTitle, std::string nameHisto) {
// gStyle->SetOptStat(0);
SetStyle();
// InitSubPad
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
float SIGNAL_SCALE = 10;
bool scaled = true;
bool log = false;
TFile* input = new TFile(inputF.c_str());
//cout<<"1";
const char* dataset;
// std::string channel = "muTau_btag/";
// std::string channel = "eleTau_inclusive/";
THStack hs("hs", "");
TH1F* data = (TH1F*) input->Get((channel + "data_obs").c_str());
TH1F* zero = (TH1F*) data->Clone("zero");
TH1F* QCD = (TH1F*) input->Get((channel + "QCD").c_str());
InitHist(QCD, "", "", TColor::GetColor(250, 202, 255), 1001);
hs.Add(QCD);
TH1F* W = (TH1F*) input->Get((channel + "W").c_str());
InitHist(W, "", "", 46, 1001);
TH1F* ZJ = (TH1F*) input->Get((channel + "ZJ").c_str());
// InitHist(ZJ, "", "", TColor::GetColor(100, 182, 232), 1001);
W->Add(ZJ);
TH1F* ZL = (TH1F*) input->Get((channel + "ZL").c_str());
// InitHist(ZL, "", "", TColor::GetColor(100, 182, 232), 1001);
W->Add(ZL);
TH1F* VV = (TH1F*) input->Get((channel + "VV").c_str());
// InitHist(VV, "", "", TColor::GetColor(100, 182, 232), 1001);
W->Add(VV);
hs.Add(W);
//// TH1F* ZLL = (TH1F*) input->Get((channel +"ZLL");
// InitHist(ttbar, "", "", TColor::GetColor(155, 152, 204), 1001);
TH1F* TT = (TH1F*) input->Get((channel + "TT").c_str());
InitHist(TT, "", "", 9, 1001);
hs.Add(TT);
TH1F* ZTT = (TH1F*) input->Get((channel + "ZTT").c_str());
InitHist(ZTT, "", "", TColor::GetColor(248, 206, 104), 1001);
TH1F* ZTTLow = (TH1F*) input->Get((channel + "ZTT_lowMass").c_str());
InitHist(ZTTLow, "", "", TColor::GetColor(248, 206, 104), 1001);
ZTT->Add(ZTTLow);
hs.Add(ZTT);
InitData(data);
TH1F* signal = (TH1F*) input->Get((channel + "bba150").c_str());
signal->Scale(10);
InitSignal(signal);
// signal->SetFillColor(kGreen);
// signal->SetLineColor(kGreen);
hs.Add(signal);
canv->cd();
// const char * MMM = xTitle.c_str();
// hs.GetXaxis()->SetLabelSize(9);
zero->Scale(0);
zero->GetXaxis()->SetRangeUser(0,60);
zero->GetXaxis()->SetTitle(xTitle.c_str());
zero->SetMaximum(MaxY);
zero->Draw();
hs.Draw("hsame");
data->SetBinContent(1,0);
data->SetBinContent(2,0);
data->SetBinContent(3,0);
data->SetBinContent(4,0);
data->SetBinContent(5,0);
data->SetBinContent(6,0);
data->SetBinContent(7,0);
data->SetBinContent(8,0);
data->SetBinContent(9,0);
data->SetBinContent(10,0);
data->SetBinContent(11,0);
data->SetBinContent(12,0);
data->SetBinContent(13,0);
data->Draw("PEsame");
const char* dataset;
dataset = "CMS Preliminary, bba1#rightarrow#tau#tau, 19.7 fb^{-1} at 8 TeV";
CMSPrelim(dataset, "", 0.17, 0.835);
TLegend* leg = new TLegend(0.62, 0.58, 0.92, 0.89);
SetLegendStyle(leg);
leg->AddEntry(signal, TString::Format("a1(50 GeV)#rightarrow#tau#tau [XS= 10 bp]", SIGNAL_SCALE), "L");
leg->AddEntry(data, "observed", "LP");
leg->AddEntry(ZTT, "Z#rightarrow#tau#tau", "F");
leg->AddEntry(TT, "t#bar{t}", "F");
leg->AddEntry(W, "electroweak", "F");
leg->AddEntry(QCD, "QCD", "F");
leg->Draw();
// canv->Print(TString::Format( (nameHisto+".pdf").c_str()));
// canv->Print(TString::Format( (nameHisto+".root").c_str()));
canv->Print(TString::Format( (nameHisto+"_Low_.pdf").c_str()));
canv->Print(TString::Format( (nameHisto+"_Low_.root").c_str()));
}
void draw_tt(std::string var="mTT",int nbins=10, double xmin=0, double xmax=200,std::string xtitle="m_{#tau#tau}", std::string ytitle="Events")
{
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
TH1::SetDefaultSumw2(1);
std::string dir = "/afs/cern.ch/work/j/jlawhorn/public/vbf/ntuples/";
double sigscale = 10;
double sigscale1 = 10;
std::stringstream scale; scale << sigscale;
std::stringstream scale1; scale1 << sigscale1;
//Cut definitions
double luminosity = 3000;
std::stringstream lumi; lumi << luminosity;
std::string objcut = "(ptTau1>45 && ptTau2>45 && abs(etaTau1) <4.0 && abs(etaTau1)<4.0 )";
std::string jetcut = objcut+"*(ptJet1>30 && ptJet2>30 && abs(etaJet1) <4.7 && abs(etaJet2) <4.7 )";
std::string ththcut = jetcut+"*(tauCat1==1 && tauCat2==1 && mJJ>500 && abs(dEta)>3.5)";
//signal region
std::string vbfcut = ththcut+"*eventWeight*(eventType==0)*"+lumi.str();
std::string zttcut = ththcut+"*eventWeight*(eventType==1)*"+lumi.str();
std::string ttbarcut = ththcut+"*eventWeight*(eventType==3)*"+lumi.str();
//std::string ewkcut = ththcut+"*eventWeight*(eventType==2)*"+lumi.str();
std::string othercut = ththcut+"*eventWeight*(eventType==4 || eventType==2)*"+lumi.str();
//--------------------------------------------------------------------------
//Get the trees
TTree *tree = load(dir+"vbf_comb.root");
//-------------------------------------------------------------------------
//Get histograms
TCanvas *canv0 = MakeCanvas("canv", "histograms", 600, 600);
canv0->cd();
std::string vardraw;
TH1F *vbf = new TH1F("VBFH","",nbins,xmin,xmax);
vardraw = var+">>"+"VBFH";
tree->Draw(vardraw.c_str(),vbfcut.c_str());
InitSignal(vbf);
vbf->SetLineColor(kBlack);
TH1F *ttbar = new TH1F("TTbar","",nbins,xmin,xmax);
vardraw = var+">>"+"TTbar";
tree->Draw(vardraw.c_str(),ttbarcut.c_str());
InitHist(ttbar, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(155,152,204), 1001);
TH1F *ztt = new TH1F("Ztt","",nbins,xmin,xmax);
vardraw = var+">>"+"Ztt";
tree->Draw(vardraw.c_str(),zttcut.c_str());
InitHist(ztt, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(248,206,104), 1001);
//TH1F *ewk = new TH1F("Ewk","",nbins,xmin,xmax);
//vardraw = var+">>"+"Ewk";
//tree->Draw(vardraw.c_str(),ewkcut.c_str());
//InitHist(ewk, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
TH1F *other = new TH1F("Other","",nbins,xmin,xmax);
vardraw = var+">>"+"Other";
tree->Draw(vardraw.c_str(),othercut.c_str());
InitHist(other, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
delete canv0;
//----------------------------------------------------------------------------
//Print out the yields
Double_t error=0.0;
ofstream outfile;
outfile.open("yields_tt.txt");
outfile << "Yields for the signal region." << std::endl;
outfile << "VBF " << vbf->IntegralAndError(0,vbf->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "TTbar " << ttbar->IntegralAndError(0,ttbar->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "Ztt " << ztt->IntegralAndError(0,ztt->GetNbinsX(),error) << "+/-" << error << endl;
//outfile << "ewk " << ewk->IntegralAndError(0,ewk->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "other " << other->IntegralAndError(0,other->GetNbinsX(),error) << "+/-" << error << endl;
outfile << "S/sqrt(B) " << vbf->Integral()/(other->Integral()+ztt->Integral()+ttbar->Integral()/*+ewk->Integral()*/) << endl;
//--------------------------------------------------------------------------
//continue outputing
//outfile << "Ewk total " << ewk->IntegralAndError(0,ewk->GetNbinsX(),error) << "+/-" << error << endl;
outfile << endl << endl << endl;
outfile << "In the signal region (100,150GeV) " <<endl;
outfile << "VBF " << vbf->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "TTbar " << ttbar->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "Ztt " << ztt->IntegralAndError(5,11,error) << "+/-" << error << endl;
//outfile << "ewk " << ewk->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile << "other " << other->IntegralAndError(5,11,error) << "+/-" << error << endl;
outfile.close();
//-----------------------------------------------------------------------
//Draw the histograms
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
//ewk->Add(other); ttbar->Add(ewk);
//ztt->Add(ttbar); vbf->Add(ztt);
//Error band stat
TH1F* errorBand = (TH1F*)vbf ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
// for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
// if(errorBand->GetBinContent(idx)>0){
// std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
// break;
// }
//}
ztt->SetMaximum(1.2*std::max(maximum(ttbar, 0), maximum(ztt, 0)));
//blind(vbf,75,150);
ztt->Draw("hist");
ttbar->Draw("histsame");
//ewk->Draw("histsame");
other->Draw("histsame");
vbf->Draw("histsame");
//errorBand->Draw("e2same");
canv->RedrawAxis();
//---------------------------------------------------------------------------
//Adding a legend
TLegend* leg = new TLegend(0.53, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(vbf , "VBF Signal" , "F");
leg->AddEntry(ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
//leg->AddEntry(ewk , "Electroweak" , "F" );
leg->AddEntry(other, "Other" , "F" );
//leg->AddEntry(errorBand,"bkg. uncertainty","F");
leg->Draw();
//---------------------------------------------------------------------------
//CMS preliminary
const char* dataset = "CMS Preliminary, H#rightarrow#tau#tau, 3.0 ab^{-1} at 14 TeV";
const char* category = "";
CMSPrelim(dataset, "#tau_{h}#tau_{h}", 0.17, 0.835);
//CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->Draw();
//-------------------------------------------------------------------------
//Save histograms
canv->Print((var+"_tt.png").c_str());
/*
Ratio Data over MC
TCanvas *canv1 = MakeCanvas("canv0", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
*/
/* TH1F* model = (TH1F*)ztt ->Clone("model");
TH1F* test1 = (TH1F*)data->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
//model->SetBinError (ibin+1, CONVERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
model->SetBinError (ibin+1, 0);
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
std::vector<double> edges;
TH1F* zero = (TH1F*)ttbar->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat1");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? Ztt ->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv1->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
//stat1->Draw();
canv1->Print((var+"_ratio.png").c_str());*/
}
void
HTT_EE_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="ee_$CATEGORY")
{
// define common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category = ""; const char* category_extra = ""; const char* category_extra2 = "";
if(std::string(directory) == std::string("ee_0jet_low" )){ category = "ee, 0 jet"; }
if(std::string(directory) == std::string("ee_0jet_low" )){ category_extra = "p_{T}(lep1) low"; }
if(std::string(directory) == std::string("ee_0jet_high" )){ category = "ee, 0 jet"; }
if(std::string(directory) == std::string("ee_0jet_high" )){ category_extra = "p_{T}(lep1) high"; }
if(std::string(directory) == std::string("ee_1jet_low" )){ category = "ee, 1 jet"; }
if(std::string(directory) == std::string("ee_1jet_low" )){ category_extra = "p_{T}(lep1) low"; }
if(std::string(directory) == std::string("ee_1jet_high" )){ category = "ee, 1 jet"; }
if(std::string(directory) == std::string("ee_1jet_high" )){ category_extra = "p_{T}(lep1) high"; }
if(std::string(directory) == std::string("ee_vbf" )){ category = "ee, 2 jet"; }
if(std::string(directory) == std::string("ee_vbf" )){ category_extra = "VBF"; }
if(std::string(directory) == std::string("ee_nobtag" )){ category = "ee"; }
if(std::string(directory) == std::string("ee_nobtag" )){ category_extra = "No B-Tag"; }
if(std::string(directory) == std::string("ee_btag" )){ category = "ee"; }
if(std::string(directory) == std::string("ee_btag" )){ category_extra = "B-Tag"; }
const char* dataset;
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 19.8 fb^{-1} at 8 TeV";}
TFile* input = new TFile(inputfile.c_str());
#ifdef MSSM
TFile* input2 = new TFile((inputfile+"_$MA_$TANB").c_str());
#endif
TH1F* ZTT = refill((TH1F*)input ->Get(TString::Format("%s/ZTT" , directory)), "ZTT" ); InitHist(ZTT , "", "", kOrange - 4, 1001);
TH1F* ZEE = refill((TH1F*)input ->Get(TString::Format("%s/ZEE" , directory)), "ZEE" ); InitHist(ZEE , "", "", kAzure + 2, 1001);
TH1F* TTJ = refill((TH1F*)input ->Get(TString::Format("%s/TTJ" , directory)), "TTJ" ); InitHist(TTJ , "", "", kBlue - 8, 1001);
TH1F* QCD = refill((TH1F*)input ->Get(TString::Format("%s/QCD" , directory)), "QCD" ); InitHist(QCD , "", "", kMagenta - 10, 1001);
TH1F* Dibosons= refill((TH1F*)input ->Get(TString::Format("%s/Dibosons", directory)), "Dibosons"); InitHist(Dibosons, "", "", kGreen - 4, 1001);
TH1F* WJets = refill((TH1F*)input ->Get(TString::Format("%s/WJets" , directory)), "WJets" ); InitHist(WJets , "", "", kRed + 2, 1001);
#ifdef MSSM
TH1F* ggH = refill((TH1F*)input2->Get(TString::Format("%s/ggH$MA" , directory)), "ggH" ); InitSignal(ggH); ggH->Scale($TANB);
TH1F* bbH = refill((TH1F*)input2->Get(TString::Format("%s/bbH$MA" , directory)), "bbH" ); InitSignal(bbH); bbH->Scale($TANB);
#else
#ifndef DROP_SIGNAL
TH1F* ggH = refill((TH1F*)input ->Get(TString::Format("%s/ggH125" , directory)), "ggH" ); InitSignal(ggH); ggH->Scale(SIGNAL_SCALE);
TH1F* qqH = refill((TH1F*)input ->Get(TString::Format("%s/qqH125" , directory)), "qqH" ); InitSignal(qqH); qqH->Scale(SIGNAL_SCALE);
TH1F* VH = refill((TH1F*)input ->Get(TString::Format("%s/VH125" , directory)), "VH" ); InitSignal(VH ); VH ->Scale(SIGNAL_SCALE);
#endif
#endif
#ifdef ASIMOV
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs_asimov", directory)), "data", true);
#else
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
#endif
#ifdef MSSM
InitHist(data, "#bf{m_{#tau#tau} [GeV]}" , "#bf{dN/dm_{#tau#tau} [1/GeV]}"); InitData(data);
#else
InitHist(data, "#bf{D}", "#bf{dN/dD}" ); InitData(data);
#endif
TH1F* ref=(TH1F*)ZTT->Clone("ref");
ref->Add(ZEE);
ref->Add(TTJ);
ref->Add(QCD);
ref->Add(Dibosons);
ref->Add(WJets);
double unscaled[9];
unscaled[0] = ZTT->Integral();
unscaled[1] = ZEE->Integral();
unscaled[2] = TTJ->Integral();
unscaled[3] = QCD->Integral();
unscaled[4] = Dibosons->Integral();
unscaled[5] = WJets->Integral();
#ifdef MSSM
unscaled[6] = ggH->Integral();
unscaled[7] = bbH->Integral();
unscaled[8] = 0;
#else
#ifndef DROP_SIGNAL
unscaled[6] = ggH->Integral();
unscaled[7] = qqH->Integral();
unscaled[8] = VH ->Integral();
#endif
#endif
if(scaled){
rescale(ZTT, 1);
rescale(ZEE, 2);
rescale(TTJ, 3);
rescale(QCD, 4);
rescale(Dibosons, 5);
rescale(WJets, 6);
#ifdef MSSM
rescale(ggH, 7);
rescale(bbH, 8);
#else
#ifndef DROP_SIGNAL
rescale(ggH, 7);
rescale(qqH, 8);
rescale(VH, 9);
#endif
#endif
}
TH1F* scales[9];
scales[0] = new TH1F("scales-ZTT", "", 9, 0, 9);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (ZTT->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-ZEE" , "", 9, 0, 9);
scales[1]->SetBinContent(2, unscaled[1]>0 ? (ZEE->Integral()/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-TTJ", "", 9, 0, 9);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (TTJ->Integral()/unscaled[2]-1.) : 0.);
scales[3] = new TH1F("scales-QCD" , "", 9, 0, 9);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (QCD->Integral()/unscaled[3]-1.) : 0.);
scales[4] = new TH1F("scales-Dibosons", "", 9, 0, 9);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (Dibosons->Integral()/unscaled[4]-1.) : 0.);
scales[5] = new TH1F("scales-WJets" , "", 9, 0, 9);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (WJets->Integral()/unscaled[5]-1.) : 0.);
#ifdef MSSM
scales[6] = new TH1F("scales-ggH" , "", 9, 0, 9);
scales[6]->SetBinContent(7, unscaled[6]>0 ? (ggH->Integral()/unscaled[6]-1.) : 0.);
scales[7] = new TH1F("scales-bbH" , "", 9, 0, 9);
scales[7]->SetBinContent(8, unscaled[7]>0 ? (bbH->Integral()/unscaled[7]-1.) : 0.);
scales[8] = new TH1F("scales-NONE" , "", 9, 0, 9);
scales[8]->SetBinContent(9, 0.);
#else
#ifndef DROP_SIGNAL
scales[6] = new TH1F("scales-ggH" , "", 9, 0, 9);
scales[6]->SetBinContent(7, unscaled[6]>0 ? (ggH->Integral()/unscaled[4]-1.) : 0.);
scales[7] = new TH1F("scales-qqH" , "", 9, 0, 9);
scales[7]->SetBinContent(8, unscaled[7]>0 ? (qqH->Integral()/unscaled[5]-1.) : 0.);
scales[8] = new TH1F("scales-VH" , "", 9, 0, 9);
scales[8]->SetBinContent(9, unscaled[8]>0 ? (VH ->Integral()/unscaled[6]-1.) : 0.);
#endif
#endif
WJets->Add(Dibosons);
QCD->Add(WJets);
TTJ->Add(QCD);
ZTT->Add(TTJ);
ZEE->Add(ZTT);
if(log){
#ifdef MSSM
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
else{
#ifdef MSSM
bbH ->Add(WJets);
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
VH ->Add(WJets);
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
/*
mass plot before and after fit
*/
TCanvas* canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(345)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(UPPER_EDGE)); };
#else
data->GetXaxis()->SetRange(0, data->FindBin(345));
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
#ifndef DROP_SIGNAL
data->SetMaximum(max>0 ? max : std::max(std::max(maximum(data, log), maximum(ZTT, log)), maximum(ggH, log)));
#else
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(ZTT, log)));
#endif
data->Draw("e");
TH1F* errorBand = (TH1F*)ZEE ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(1);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
if(errorBand->GetBinContent(idx)>0){
std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
break;
}
}
if(log){
ZEE->Draw("histsame");
ZTT->Draw("histsame");
TTJ->Draw("histsame");
QCD->Draw("histsame");
WJets->Draw("histsame");
//Dibosons->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
ggH->Draw("histsame");
#endif
}
else{
#ifndef DROP_SIGNAL
ggH ->Draw("histsame");
#endif
ZEE->Draw("histsame");
ZTT->Draw("histsame");
TTJ->Draw("histsame");
QCD->Draw("histsame");
WJets->Draw("histsame");
//Dibosons->Draw("histsame");
$DRAW_ERROR
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "#tau_{e}#tau_{e}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.20, (category_extra2 && category_extra2[0]=='\0') ? 0.65+0.061 : 0.65+0.061, 0.32, 0.75+0.161, "tlbrNDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->AddText(category_extra);
chan->AddText(category_extra2);
chan->Draw();
/* TPaveText* cat = new TPaveText(0.20, 0.71+0.061, 0.32, 0.71+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
*/
#ifdef MSSM
TPaveText* massA = new TPaveText(0.55, 0.50+0.061, 0.95, 0.50+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m^{h}_{max} (m_{A}=$MA GeV, tan#beta=$TANB)");
massA->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.55, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(ggH , "#phi#rightarrow#tau#tau" , "L" );
#else
TLegend* leg = new TLegend(0.50, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
#ifndef DROP_SIGNAL
if(SIGNAL_SCALE!=1){
leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" );
}
else{
leg->AddEntry(ggH , "H(125 GeV)#rightarrow#tau#tau" , "L" );
}
#endif
#endif
#ifdef ASIMOV
leg->AddEntry(data , "sum(bkg) + H(125)" , "LP");
#else
leg->AddEntry(data , "observed" , "LP");
#endif
leg->AddEntry(ZEE , "Z#rightarrowee" , "F" );
leg->AddEntry(ZTT , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(TTJ , "t#bar{t}" , "F" );
leg->AddEntry(QCD , "QCD" , "F" );
leg->AddEntry(WJets, "electroweak" , "F" );
//leg->AddEntry(Dibosons , "Dibosons" , "F" );
$ERROR_LEGEND
leg->Draw();
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* model = (TH1F*)ZEE ->Clone("model");
TH1F* test1 = (TH1F*)data->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
model->SetBinError (ibin+1, CONVERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
std::vector<double> edges;
TH1F* zero = (TH1F*)ref ->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat1");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, ZEE->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/ZEE->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, ZEE->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/ZEE->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, ZEE->GetBinContent(ibin+1)>0 ? ZEE ->GetBinError (ibin+1)/ZEE->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
#ifdef MSSM
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
#else
rat1->GetXaxis()->SetTitle("#bf{D}");
#endif
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv0->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
stat1->Draw();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
edges.clear();
TH1F* rat2 = (TH1F*) ZEE->Clone("rat2");
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
rat2->SetBinContent(ibin+1, ref->GetBinContent(ibin+1)>0 ? ZEE->GetBinContent(ibin+1)/ref->GetBinContent(ibin+1) : 0);
rat2->SetBinError (ibin+1, ref->GetBinContent(ibin+1)>0 ? ZEE->GetBinError (ibin+1)/ref->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat2->GetBinContent(ibin+1)-1.)+TMath::Abs(rat2->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
#if defined MSSM
if(!log){ rat2->GetXaxis()->SetRange(0, rat2->FindBin(345)); } else{ rat2->GetXaxis()->SetRange(0, rat2->FindBin(UPPER_EDGE)); };
#else
rat2->GetXaxis()->SetRange(0, rat2->FindBin(345));
#endif
rat2->SetNdivisions(505);
rat2->SetLineColor(kRed+ 3);
rat2->SetMarkerColor(kRed+3);
rat2->SetMarkerSize(1.1);
rat2->SetMaximum(+range);
rat2->SetMinimum(-range);
rat2->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
#if defined MSSM
rat2->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
#else
rat2->GetXaxis()->SetTitle("#bf{D}");
#endif
rat2->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->Draw("e2histsame");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[0], "", "", kOrange - 4, 1001);
InitHist (scales[1], "", "", kAzure + 2, 1001);
InitHist (scales[2], "", "", kBlue - 8, 1001);
InitHist (scales[3], "", "", kMagenta - 10, 1001);
InitHist (scales[4], "", "", kGreen - 4, 1001);
InitHist (scales[5], "", "", kRed + 2, 1001);
#ifndef DROP_SIGNAL
InitSignal(scales[6]);
InitSignal(scales[7]);
InitSignal(scales[8]);
#endif
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{ZTT}");
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{ZEE}" );
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{TTJ}");
scales[0]->GetXaxis()->SetBinLabel(4, "#bf{QCD}" );
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{Dibosons}");
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{WJets}" );
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(8, "#bf{bbH}" );
scales[0]->GetXaxis()->SetBinLabel(9, "#bf{NONE}" );
#else
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(8, "#bf{qqH}" );
scales[0]->GetXaxis()->SetBinLabel(9, "#bf{VH}" );
#endif
scales[0]->SetMaximum(+0.5);
scales[0]->SetMinimum(-0.5);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
scales[1]->Draw("same");
scales[2]->Draw("same");
scales[3]->Draw("same");
scales[4]->Draw("same");
scales[5]->Draw("same");
#ifndef DROP_SIGNAL
scales[6]->Draw("same");
scales[7]->Draw("same");
scales[8]->Draw("same");
#endif
TH1F* zero_samples = (TH1F*)scales[0]->Clone("zero_samples"); zero_samples->Clear();
zero_samples->SetBinContent(1,0.);
zero_samples->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sfit_%s_%s.png" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.pdf" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.eps" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
if(log || FULLPLOTS)
{
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
if((log && scaled) || FULLPLOTS)
{
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
TFile* output = new TFile(TString::Format("%s_%sfit_%s_%s.root", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"), "update");
output->cd();
data ->Write("data_obs");
ZTT->Write("Ztt" );
ZEE->Write("Zee" );
TTJ->Write("ttbar");
QCD->Write("Fakes");
Dibosons->Write("Dibosons");
WJets->Write("EWK");
#ifdef MSSM
ggH ->Write("ggH");
bbH ->Write("bbH");
#else
#ifndef DROP_SIGNAL
ggH ->Write("ggH");
qqH ->Write("qqH");
VH ->Write("VH" );
#endif
#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
delete errorBand;
delete model;
delete test1;
delete zero;
delete rat1;
delete rat2;
delete zero_samples;
delete ref;
}
void
//HTT_ET_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="eleTau_$CATEGORY")
HTT_ET_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., TString datacard="htt_et_1_7TeV", string inputfile="root/$HISTFILE", const char* directory="eleTau_$CATEGORY")
{
// defining the common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category = ""; const char* category_extra = ""; const char* category_extra2 = "";
if(std::string(directory) == std::string("eleTau_0jet_low" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_0jet_low" )){ category_extra = "0-jet low p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_0jet_medium" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_0jet_medium" )){ category_extra = "0-jet low p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_0jet_high" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_0jet_high" )){ category_extra = "0-jet high p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_1jet_medium" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_1jet_medium" )){ category_extra = "1-jet low p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_1jet_high_lowhiggs" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_1jet_high_lowhiggs" )){ category_extra= "1-jet high p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category_extra= "1-jet high p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_1jet_high_mediumhiggs")){ category_extra2= "boosted"; }
if(std::string(directory) == std::string("eleTau_vbf" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_vbf" )){ category_extra = "VBF tag"; }
if(std::string(directory) == std::string("eleTau_vbf_loose" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_vbf_loose" )){ category_extra = "Loose VBF tag"; }
if(std::string(directory) == std::string("eleTau_vbf_tight" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_vbf_tight" )){ category_extra = "Tight VBF tag"; }
if(std::string(directory) == std::string("eleTau_nobtag" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_nobtag" )){ category_extra = "no b-tag"; }
if(std::string(directory) == std::string("eleTau_btag" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_btag" )){ category_extra = "b-tag"; }
if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category_extra = "no b-tag"; }
if(std::string(directory) == std::string("eleTau_nobtag_low" )){ category_extra2 = "low p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category_extra = "no b-tag"; }
if(std::string(directory) == std::string("eleTau_nobtag_medium" )){ category_extra2 = "medium p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category_extra = "no b-tag"; }
if(std::string(directory) == std::string("eleTau_nobtag_high" )){ category_extra2 = "high p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_btag_low" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_btag_low" )){ category_extra = "b-tag"; }
if(std::string(directory) == std::string("eleTau_btag_low" )){ category_extra2 = "low p_{T}^{#tau_{h}}"; }
if(std::string(directory) == std::string("eleTau_btag_high" )){ category = "e#tau_{h}"; }
if(std::string(directory) == std::string("eleTau_btag_high" )){ category_extra = "b-tag"; }
if(std::string(directory) == std::string("eleTau_btag_high" )){ category_extra2 = "high p_{T}^{#tau_{h}}"; }
const char* dataset;
#ifdef MSSM
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 4.9 fb^{-1} (7 TeV)";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 19.7 fb^{-1} (8 TeV)";}
#else
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "CMS, 4.9 fb^{-1} at 7 TeV";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS, 19.7 fb^{-1} at 8 TeV";}
#endif
TFile* input = new TFile(inputfile.c_str());
#ifdef MSSM
TFile* input2 = new TFile((inputfile+"_$MA_$TANB").c_str());
#endif
TH1F* Fakes = refill((TH1F*)input->Get(TString::Format("%s/QCD" , directory)), "QCD"); InitHist(Fakes, "", "", TColor::GetColor(250,202,255), 1001);
TH1F* EWK0 = refill((TH1F*)input->Get(TString::Format("%s/VV" , directory)), "VV" ); InitHist(EWK0 , "", "", TColor::GetColor(222,90,106), 1001);
TH1F* EWK1 = refill((TH1F*)input->Get(TString::Format("%s/W" , directory)), "W" ); InitHist(EWK1 , "", "", TColor::GetColor(222,90,106), 1001);
#ifdef EXTRA_SAMPLES
TH1F* EWK2 = refill((TH1F*)input->Get(TString::Format("%s/ZJ" , directory)), "ZJ" ); InitHist(EWK2 , "", "", TColor::GetColor(100,182,232), 1001);
TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/ZL" , directory)), "ZL" ); InitHist(EWK , "", "", TColor::GetColor(100,182,232), 1001);
#else
TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/ZLL" , directory)), "ZLL"); InitHist(EWK , "", "", TColor::GetColor(100,182,232), 1001);
#endif
TH1F* ttbar = refill((TH1F*)input->Get(TString::Format("%s/TT" , directory)), "TT" ); InitHist(ttbar, "", "", TColor::GetColor(155,152,204), 1001);
TH1F* Ztt = refill((TH1F*)input->Get(TString::Format("%s/ZTT" , directory)), "ZTT"); InitHist(Ztt , "", "", TColor::GetColor(248,206,104), 1001);
#ifdef MSSM
TH1F* ggH = refill((TH1F*)input2->Get(TString::Format("%s/ggH$MA" , directory)), "ggH"); InitSignal(ggH); ggH->Scale($TANB);
TH1F* bbH = refill((TH1F*)input2->Get(TString::Format("%s/bbH$MA" , directory)), "bbH"); InitSignal(bbH); bbH->Scale($TANB);
#else
#ifndef DROP_SIGNAL
TH1F* ggH = refill((TH1F*)input->Get(TString::Format("%s/ggH125" , directory)), "ggH"); InitSignal(ggH); ggH->Scale(SIGNAL_SCALE);
TH1F* qqH = refill((TH1F*)input->Get(TString::Format("%s/qqH125" , directory)), "qqH"); InitSignal(qqH); qqH->Scale(SIGNAL_SCALE);
TH1F* VH = refill((TH1F*)input->Get(TString::Format("%s/VH125" , directory)), "VH" ); InitSignal(VH ); VH ->Scale(SIGNAL_SCALE);
#endif
#endif
#ifdef ASIMOV
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs_asimov", directory)), "data", true);
#else
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
#endif
InitHist(data, "#bf{m_{#tau#tau} [GeV]}", "#bf{dN/dm_{#tau#tau} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)Fakes->Clone("ref");
ref->Add(EWK0 );
ref->Add(EWK1 );
#ifdef EXTRA_SAMPLES
ref->Add(EWK2 );
#endif
ref->Add(EWK );
ref->Add(ttbar);
ref->Add(Ztt );
double unscaled[7];
unscaled[0] = Fakes->Integral();
unscaled[1] = EWK ->Integral();
unscaled[1]+= EWK0 ->Integral();
unscaled[1]+= EWK1 ->Integral();
#ifdef EXTRA_SAMPLES
unscaled[1]+= EWK2 ->Integral();
#endif
unscaled[2] = ttbar->Integral();
unscaled[3] = Ztt ->Integral();
#ifdef MSSM
unscaled[4] = ggH ->Integral();
unscaled[5] = bbH ->Integral();
unscaled[6] = 0;
#else
#ifndef DROP_SIGNAL
unscaled[4] = ggH ->Integral();
unscaled[5] = qqH ->Integral();
unscaled[6] = VH ->Integral();
#endif
#endif
if(scaled){
/* Fakes = refill(shape_histos(Fakes, datacard, "QCD"), "QCD");
EWK0 = refill(shape_histos(EWK0, datacard, "VV"), "VV");
EWK1 = refill(shape_histos(EWK1, datacard, "W"), "W");
#ifdef EXTRA_SAMPLES
EWK2 = refill(shape_histos(EWK2, datacard, "ZJ"), "ZJ");
EWK = refill(shape_histos(EWK, datacard, "ZL"), "ZL");
#else
// EWK = refill(shape_histos(EWK, datacard, "ZLL"), "ZLL");
#endif
ttbar = refill(shape_histos(ttbar, datacard, "TT"), "TT");
Ztt = refill(shape_histos(Ztt, datacard, "ZTT"), "ZTT");
#ifdef MSSM
ggH = refill(shape_histos(ggH, datacard, "ggH$MA"), "ggH$MA");
bbH = refill(shape_histos(bbH, datacard, "bbH$MA"), "bbH$MA");
#else
#ifndef DROP_SIGNAL
ggH = refill(shape_histos(ggH, datacard, "ggH"), "ggH");
qqH = refill(shape_histos(qqH, datacard, "qqH"), "qqH");
VH = refill(shape_histos(VH, datacard, "VH"), "VH");
#endif
#endif
*/
rescale(Fakes, 7);
rescale(EWK0 , 6);
rescale(EWK1 , 3);
#ifdef EXTRA_SAMPLES
rescale(EWK2 , 4);
rescale(EWK , 5);
#else
rescale(EWK , 4);
#endif
rescale(ttbar, 2);
rescale(Ztt , 1);
#ifdef MSSM
rescale(ggH , 8);
rescale(bbH , 9);
#else
#ifndef DROP_SIGNAL
rescale(ggH , 8);
rescale(qqH , 9);
rescale(VH ,10);
#endif
#endif
}
TH1F* scales[7];
scales[0] = new TH1F("scales-Fakes", "", 7, 0, 7);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (Fakes->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-EWK" , "", 7, 0, 7);
scales[1]->SetBinContent(2, unscaled[1]>0 ? ((EWK ->Integral()
+EWK0 ->Integral()
+EWK1 ->Integral()
#ifdef EXTRA_SAMPLES
+EWK2 ->Integral()
#endif
)/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-ttbar", "", 7, 0, 7);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (ttbar->Integral()/unscaled[2]-1.) : 0.);
scales[3] = new TH1F("scales-Ztt" , "", 7, 0, 7);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (Ztt ->Integral()/unscaled[3]-1.) : 0.);
#ifdef MSSM
scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.);
scales[5] = new TH1F("scales-bbH" , "", 7, 0, 7);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (bbH ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-NONE" , "", 7, 0, 7);
scales[6]->SetBinContent(7, 0.);
#else
#ifndef DROP_SIGNAL
scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.);
scales[5] = new TH1F("scales-qqH" , "", 7, 0, 7);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (qqH ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-VH" , "", 7, 0, 7);
scales[6]->SetBinContent(7, unscaled[6]>0 ? (VH ->Integral()/unscaled[6]-1.) : 0.);
#endif
#endif
EWK0 ->Add(Fakes);
EWK1 ->Add(EWK0 );
#ifdef EXTRA_SAMPLES
EWK2 ->Add(EWK1 );
EWK ->Add(EWK2 );
#else
EWK ->Add(EWK1 );
#endif
ttbar->Add(EWK );
Ztt ->Add(ttbar);
if(log){
#ifdef MSSM
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
else{
#ifdef MSSM
bbH ->Add(Ztt);
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
VH ->Add(Ztt);
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
/*
Mass plot before and after fit
*/
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(345)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(UPPER_EDGE)); };
#else
data->GetXaxis()->SetRange(0, data->FindBin(345));
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
#ifndef DROP_SIGNAL
data->SetMaximum(max>0 ? max : std::max(std::max(maximum(data, log), maximum(Ztt, log)), maximum(ggH, log)));
#else
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log)));
#endif
data->Draw("e");
TH1F* errorBand = (TH1F*)Ztt ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
if(errorBand->GetBinContent(idx)>0){
std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
break;
}
}
if(log){
Ztt ->Draw("histsame");
ttbar->Draw("histsame");
EWK ->Draw("histsame");
EWK1 ->Draw("histsame");
Fakes->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
ggH ->Draw("histsame");
#endif
}
else{
#ifndef DROP_SIGNAL
ggH ->Draw("histsame");
#endif
Ztt ->Draw("histsame");
ttbar->Draw("histsame");
EWK ->Draw("histsame");
EWK1 ->Draw("histsame");
Fakes->Draw("histsame");
$DRAW_ERROR
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "#tau_{e}#tau_{h}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
#if defined MSSM
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "tlbrNDC");
if (category_extra2!="") chan = new TPaveText(0.20, 0.69+0.061, 0.32, 0.74+0.161, "tlbrNDC");
#else
TPaveText* chan = new TPaveText(0.52, 0.35, 0.91, 0.55, "tlbrNDC");
#endif
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->AddText(category_extra);
#if defined MSSM
if (category_extra2!="") chan->AddText(category_extra2);
#else
chan->AddText(category_extra2);
#endif
chan->Draw();
/* TPaveText* cat = new TPaveText(0.20, 0.71+0.061, 0.32, 0.71+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
TPaveText* cat2 = new TPaveText(0.20, 0.66+0.061, 0.32, 0.66+0.161, "NDC");
cat2->SetBorderSize( 0 );
cat2->SetFillStyle( 0 );
cat2->SetTextAlign( 12 );
cat2->SetTextSize ( 0.05 );
cat2->SetTextColor( 1 );
cat2->SetTextFont ( 62 );
cat2->AddText(category_extra2);
cat2->Draw();
*/
#ifdef MSSM
TPaveText* massA = new TPaveText(0.53, 0.44+0.061, 0.95, 0.44+0.151, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("MSSM m^{h}_{max} scenario");
massA->AddText("m_{A}=$MA GeV, tan#beta=$TANB");
massA->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.53, 0.60, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(ggH , "h,A,H#rightarrow#tau#tau" , "L" );
#else
TLegend* leg = new TLegend(0.52, 0.58, 0.92, 0.89);
SetLegendStyle(leg);
#ifndef DROP_SIGNAL
if(SIGNAL_SCALE!=1){
leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" );
}
else{
leg->AddEntry(ggH , "SM H(125 GeV)#rightarrow#tau#tau" , "L" );
}
#endif
#endif
#ifdef ASIMOV
leg->AddEntry(data , "sum(bkg) + H(125)" , "LP");
#else
leg->AddEntry(data , "Observed" , "LP");
#endif
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(EWK , "Z#rightarrow ee" , "F" );
leg->AddEntry(EWK1 , "W+jets" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
$ERROR_LEGEND
leg->Draw();
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* model = (TH1F*)Ztt ->Clone("model");
TH1F* test1 = (TH1F*)data->Clone("test1");
for(int ibin=0; ibin<test1->GetNbinsX(); ++ibin){
//the small value in case of 0 entries in the model is added to prevent the chis2 test from failing
model->SetBinContent(ibin+1, model->GetBinContent(ibin+1)>0 ? model->GetBinContent(ibin+1)*model->GetBinWidth(ibin+1) : 0.01);
model->SetBinError (ibin+1, CONVERVATIVE_CHI2 ? 0. : model->GetBinError (ibin+1)*model->GetBinWidth(ibin+1));
test1->SetBinContent(ibin+1, test1->GetBinContent(ibin+1)*test1->GetBinWidth(ibin+1));
test1->SetBinError (ibin+1, test1->GetBinError (ibin+1)*test1->GetBinWidth(ibin+1));
}
double chi2prob = test1->Chi2Test (model,"PUW"); std::cout << "chi2prob:" << chi2prob << std::endl;
double chi2ndof = test1->Chi2Test (model,"CHI2/NDFUW"); std::cout << "chi2ndf :" << chi2ndof << std::endl;
double ksprob = test1->KolmogorovTest(model); std::cout << "ksprob :" << ksprob << std::endl;
double ksprobpe = test1->KolmogorovTest(model,"DX"); std::cout << "ksprobpe:" << ksprobpe << std::endl;
std::vector<double> edges;
TH1F* zero = (TH1F*)ref->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat1");
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
rat1->SetBinContent(ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinContent(ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
rat1->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? data->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
zero->SetBinContent(ibin+1, 0.);
zero->SetBinError (ibin+1, Ztt->GetBinContent(ibin+1)>0 ? Ztt ->GetBinError (ibin+1)/Ztt->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat1->GetBinContent(ibin+1)-1.)+TMath::Abs(rat1->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
}
float range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+range);
rat1->SetMinimum(-range);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat1->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->SetMarkerSize(0.1);
zero->Draw("e2histsame");
canv0->RedrawAxis();
TPaveText* stat1 = new TPaveText(0.20, 0.76+0.061, 0.32, 0.76+0.161, "NDC");
stat1->SetBorderSize( 0 );
stat1->SetFillStyle( 0 );
stat1->SetTextAlign( 12 );
stat1->SetTextSize ( 0.05 );
stat1->SetTextColor( 1 );
stat1->SetTextFont ( 62 );
stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f", chi2ndof, chi2prob));
//stat1->AddText(TString::Format("#chi^{2}/ndf=%.3f, P(#chi^{2})=%.3f, P(KS)=%.3f", chi2ndof, chi2prob, ksprob));
stat1->Draw();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
edges.clear();
TH1F* rat2 = (TH1F*) Ztt->Clone("rat2");
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
rat2->SetBinContent(ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinContent(ibin+1)/ref->GetBinContent(ibin+1) : 0);
rat2->SetBinError (ibin+1, ref->GetBinContent(ibin+1)>0 ? Ztt->GetBinError (ibin+1)/ref->GetBinContent(ibin+1) : 0);
}
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
edges.push_back(TMath::Abs(rat2->GetBinContent(ibin+1)-1.)+TMath::Abs(rat2->GetBinError(ibin+1)));
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
range = 0.1;
std::sort(edges.begin(), edges.end());
if (edges[edges.size()-2]>0.1) { range = 0.2; }
if (edges[edges.size()-2]>0.2) { range = 0.5; }
if (edges[edges.size()-2]>0.5) { range = 1.0; }
if (edges[edges.size()-2]>1.0) { range = 1.5; }
if (edges[edges.size()-2]>1.5) { range = 2.0; }
#if defined MSSM
if(!log){ rat2->GetXaxis()->SetRange(0, rat2->FindBin(345)); } else{ rat2->GetXaxis()->SetRange(0, rat2->FindBin(UPPER_EDGE)); };
#else
rat2->GetXaxis()->SetRange(0, rat2->FindBin(345));
#endif
rat2->SetNdivisions(505);
rat2->SetLineColor(kRed+ 3);
rat2->SetMarkerColor(kRed+3);
rat2->SetMarkerSize(1.1);
rat2->SetMaximum(+range);
rat2->SetMinimum(-range);
rat2->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
rat2->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat2->Draw();
zero->SetFillStyle( 3013);
zero->SetFillColor(kBlack);
zero->SetLineColor(kBlack);
zero->Draw("e2histsame");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[0], "", "", TColor::GetColor(250,202,255), 1001);
InitHist (scales[1], "", "", TColor::GetColor(222,90,106), 1001);
InitHist (scales[2], "", "", TColor::GetColor(155,152,204), 1001);
InitHist (scales[3], "", "", TColor::GetColor(248,206,104), 1001);
#ifndef DROP_SIGNAL
InitSignal(scales[4]);
InitSignal(scales[5]);
InitSignal(scales[6]);
#endif
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Fakes}");
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{EWK}" );
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{ttbar}");
scales[0]->GetXaxis()->SetBinLabel(4, "#bf{Ztt}" );
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{bbH}" );
scales[0]->GetXaxis()->SetBinLabel(7, "NONE" );
#else
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{qqH}" );
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{VH}" );
#endif
scales[0]->SetMaximum(+0.5);
scales[0]->SetMinimum(-0.5);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Postfit/Prefit-1}");
scales[1]->Draw("same");
scales[2]->Draw("same");
scales[3]->Draw("same");
#ifndef DROP_SIGNAL
scales[4]->Draw("same");
scales[5]->Draw("same");
scales[6]->Draw("same");
#endif
TH1F* zero_samples = (TH1F*)scales[0]->Clone("zero_samples"); zero_samples->Clear();
zero_samples->SetBinContent(1,0.);
zero_samples->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sfit_%s_%s.png" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.pdf" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv ->Print(TString::Format("%s_%sfit_%s_%s.eps" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
if(!log || FULLPLOTS)
{
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
if((!log && scaled) || FULLPLOTS)
{
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"));
}
TFile* output = new TFile(TString::Format("%s_%sfit_%s_%s.root", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : "LIN"), "update");
output->cd();
data ->Write("data_obs");
Fakes->Write("Fakes" );
EWK ->Write("Zee" );
EWK1 ->Write("EWK" );
//EWK ->Write("EWK" );
EWK1 ->Write("EWK1" );
ttbar->Write("ttbar" );
Ztt ->Write("Ztt" );
#ifdef MSSM
ggH ->Write("ggH" );
bbH ->Write("bbH" );
#else
#ifndef DROP_SIGNAL
ggH ->Write("ggH" );
qqH ->Write("qqH" );
VH ->Write("VH" );
#endif
#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
delete errorBand;
delete model;
delete test1;
delete zero;
delete rat1;
delete rat2;
delete zero_samples;
delete ref;
}
void compareLimits(const char* filename, const char* channelstr, bool expected, bool observed, const char* type, double minimum=0., double maximum=20., bool log=false, const char* label="#scale[1.5]{CMS} h,H,A#rightarrow#tau#tau 19.7 fb^{-1} (8 TeV) + 4.9 fb^{-1} (7 TeV)", bool legendOnRight=true, bool legendOnTop=true, bool ggH=true)
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["0jet" ] = kBlue;
colors["1jet" ] = kRed;
colors["2jet" ] = kMagenta;
colors["vbf" ] = kMagenta;
colors["boost" ] = kGreen;
colors["btag" ] = kRed;
colors["nobtag" ] = kBlue;
colors["em" ] = kBlue;
colors["et" ] = kRed;
colors["mt" ] = kGreen;
colors["mm" ] = kMagenta;
colors["ee" ] = kCyan;
colors["tt" ] = kMagenta+3;
colors["vhtt" ] = kCyan-6;
colors["cmb" ] = kBlack;
colors["htt" ] = kBlack;
colors["ggH" ] = kRed;
colors["bbH" ] = kBlue;
colors["HIG-11-020" ] = kBlue+2;
colors["HIG-11-029" ] = kRed+2;
colors["HIG-12-018" ] = kBlue;
colors["HIG-12-032" ] = kRed+2;
colors["HIG-12-043" ] = kRed;
colors["HIG-12-050" ] = kRed;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x MitLimits/Higgs2Tau/macros/compareLimits.C+(file, chn, exp, obs, type, min, max, log) \n"
<< " * \n"
<< " * Arguments : + file const char* full path to the input file \n"
<< " * + chn const char* list of channels; choose between: 'cmb', 'htt', 'emu', \n"
<< " * 'etau', 'mutau', 'mumu', 'vhtt', 'hgg', 'hww', 'ggH', \n"
<< " * 'bbH', 'nomix[-200, +200]', 'mhmax[-400, -200, +200]' \n"
<< " * 'mhmax[+400, +600, +800]', 'test-0...5', 'saeff', 'gluph' \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + exp bool compare expected limits \n"
<< " * + obs bool compare observed limits \n"
<< " * + type const char* type of plot; choose between 'sm-xsec', 'mssm-xsec' and \n"
<< " * 'mssm-tanb' \n"
<< " * + max double maximum of the plot (default is 20.) \n"
<< " * \n"
<< " * + min double minimum of the plot (default is 0.) \n"
<< " * \n"
<< " * + log bool set log scale yes or no (default is false) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// open input file
TFile* inputFile = new TFile(filename); if(inputFile->IsZombie()){ std::cout << "ERROR:: file: " << filename << " does not exist.\n"; }
/// prepare input parameters
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
/// prepare histograms
std::vector<TGraph*> hobs, hexp;
for(unsigned i=0; i<channels.size(); ++i){
if(observed) hobs.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/observed").c_str()));
if(expected) hexp.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/expected").c_str()));
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Limit Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(1);
canv1->SetGridy(1);
if((std::string(type) == std::string("mssm-xsec") || std::string(type) == std::string("mssm-tanb")) && log) canv1->SetLogx(1);
bool firstPlot=true;
for(unsigned int i=0; i<hexp.size(); ++i){
if(firstPlot){
if(log){ canv1->SetLogy(1); }
hexp[i]->SetMaximum(maximum);
hexp[i]->SetMinimum(minimum);
// format x-axis
std::string x_title;
if(std::string(type) == std::string("mssm-tanb")){
x_title = std::string("m_{A} [GeV]");
}
else if(std::string(type) == std::string("mssm-xsec")){
x_title = std::string("m_{#phi} [GeV]");
}
else{
x_title = std::string("m_{H} [GeV]");
}
hexp[i]->GetXaxis()->SetTitle(x_title.c_str());
hexp[i]->GetXaxis()->SetLabelFont(62);
hexp[i]->GetXaxis()->SetTitleFont(62);
hexp[i]->GetXaxis()->SetTitleColor(1);
hexp[i]->GetXaxis()->SetTitleOffset(1.05);
if((std::string(type) == std::string("mssm-xsec") || std::string(type) == std::string("mssm-tanb")) && log){
hexp[i]->GetXaxis()->SetNdivisions(50005, "X");
hexp[i]->GetXaxis()->SetMoreLogLabels();
hexp[i]->GetXaxis()->SetNoExponent();
hexp[i]->GetXaxis()->SetLabelSize(0.040);
}
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0]-.1, hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
if(std::string(type) == std::string("mssm-xsec") || std::string(type) == std::string("mssm-tanb")){
if(log){
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0], hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
}
else{
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0]-.1, hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
}
}
// format y-axis
std::string y_title;
if( std::string(type) == std::string("mssm-xsec") ){
if(ggH) y_title = std::string("95% CL limit on #sigma(gg#rightarrow#phi)#timesBR [pb]");
else y_title = std::string("95% CL limit on #sigma(gg#rightarrowbb#phi)#timesBR [pb]");
}
else if( std::string(type) == std::string("mssm-tanb") ){
y_title = std::string("#bf{tan#beta}");
}
else{
y_title = std::string("95% CL limit on #sigma/#sigma_{SM}");
}
hexp[i]->GetYaxis()->SetTitle(y_title.c_str());
hexp[i]->GetYaxis()->SetLabelFont(62);
hexp[i]->GetYaxis()->SetTitleFont(62);
hexp[i]->GetYaxis()->SetTitleOffset(1.05);
hexp[i]->GetYaxis()->SetLabelSize(0.03);
}
hexp[i]->SetLineStyle(11.);
hexp[i]->SetLineWidth( 3.);
hexp[i]->SetLineColor(colors.find(channels[i])->second);
hexp[i]->SetMarkerStyle(20);
hexp[i]->SetMarkerSize(MARKER_SIZE);
hexp[i]->SetMarkerColor(colors.find(channels[i])->second);
hexp[i]->Draw(firstPlot ? "APL" : "PLsame");
//hexp[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
for(unsigned int i=0; i<hobs.size(); ++i){
if(firstPlot){
if(log){ canv1->SetLogy(1); }
hobs[i]->SetMaximum(maximum);
hobs[i]->SetMinimum(minimum);
// format x-axis
std::string x_title;
if(std::string(type) == std::string("mssm-tanb")){
x_title = std::string("m_{A} [GeV]");
}
else if(std::string(type) == std::string("mssm-xsec")){
x_title = std::string("m_{#phi} [GeV]");
}
else{
x_title = std::string("m_{H} [GeV]");
}
hobs[i]->GetXaxis()->SetTitle(x_title.c_str());
hobs[i]->GetXaxis()->SetLabelFont(62);
hobs[i]->GetXaxis()->SetTitleFont(62);
hobs[i]->GetXaxis()->SetTitleColor(1);
hobs[i]->GetXaxis()->SetTitleOffset(1.05);
if((std::string(type) == std::string("mssm-xsec") || std::string(type) == std::string("mssm-tanb")) && log){
hobs[i]->GetXaxis()->SetNdivisions(50005, "X");
hobs[i]->GetXaxis()->SetMoreLogLabels();
hobs[i]->GetXaxis()->SetNoExponent();
hobs[i]->GetXaxis()->SetLabelSize(0.040);
}
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0]-.1, hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
if(std::string(type) == std::string("mssm-xsec") || std::string(type) == std::string("mssm-tanb")){
if(log){
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0], hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
}
else{
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0]-.1, hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
}
}
// format y-axis
std::string y_title;
if( std::string(type) == std::string("mssm-xsec") ){
if(ggH) y_title = std::string("95% CL limit on #sigma#font[42]{(gg#phi)}#upoint#font[52]{B}#font[42]{(#phi#rightarrow#tau#tau)} [pb]");
else y_title = std::string("95% CL limit on #sigma#font[42]{(bb#phi)}#upoint#font[52]{B}#font[42]{(#phi#rightarrow#tau#tau)} [pb]");
}
else if( std::string(type) == std::string("mssm-tanb") ){
y_title = std::string("#bf{tan#beta}");
}
else{
y_title = std::string("95% CL limit on #sigma/#sigma_{SM}");
}
hobs[i]->GetYaxis()->SetTitle(y_title.c_str());
hobs[i]->GetYaxis()->SetLabelFont(62);
hobs[i]->GetYaxis()->SetTitleOffset(1.05);
hobs[i]->GetYaxis()->SetLabelSize(0.03);
}
hobs[i]->SetLineStyle(11.);
hobs[i]->SetLineWidth( 3.);
hobs[i]->SetLineColor(colors.find(channels[i])->second);
hobs[i]->SetMarkerStyle(20);
hobs[i]->SetMarkerSize(MARKER_SIZE);
hobs[i]->SetMarkerColor(colors.find(channels[i])->second);
hobs[i]->Draw(firstPlot ? "APL" : "PLsame");
//hobs[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
canv1->RedrawAxis();
TPaveText* extra;
if( std::string(type) == std::string("mssm-xsec") ){
extra = new TPaveText(legendOnRight ? 0.6 : 0.18, 0.50, legendOnRight ? 0.95 : 0.605, 0.60, "NDC");
extra->SetBorderSize( 0 );
extra->SetFillStyle ( 0 );
extra->SetTextAlign ( 12 );
extra->SetTextSize (0.04 );
extra->SetTextColor ( 1 );
extra->SetTextFont ( 62 );
if(ggH) extra->AddText("gg#phi");
else extra->AddText("bb#phi");
extra->Draw();
}
bool firstLeg=true;
if(observed){
TLegend* leg1;
if(expected && observed){
/// setup the CMS Preliminary
if(std::string(type) == std::string("mssm-tanb")){
if (firstLeg) CMSPrelim(label, "", 0.15, 0.835);
leg1 = new TLegend(firstLeg ? 0.60 : 0.20, hobs.size()<5 ? 0.20-0.06*hobs.size() : 0.4, firstLeg ? 0.93 : 0.60, 0.20);
}
else{
if (firstLeg) CMSPrelim(label, "", 0.135, 0.835);
leg1 = new TLegend(firstLeg ? 0.20 : 0.20, hobs.size()<5 ? 0.90-0.08*hobs.size() : 0.6, firstLeg ? 0.63 : 0.60, 0.90);
}
}
else{
/// setup the CMS Preliminary
if(std::string(type) == std::string("mssm-tanb")){
CMSPrelim(label, "", 0.15, 0.835);
leg1 = new TLegend(legendOnRight?0.60:0.20, hobs.size()<5 ? (legendOnTop?0.90:0.40)-0.04*hobs.size() : (legendOnTop?0.6:0.2), legendOnRight?0.94:0.45, (legendOnTop?0.90:0.40));
}
else{
CMSPrelim(label, "", 0.135, 0.835);
leg1 = new TLegend(legendOnRight ? 0.50 : 0.20, hobs.size()<5 ? 0.90-0.08*hobs.size() : 0.6, legendOnRight ? 0.94 : 0.64, 0.90);
}
}
if(std::string(type) == std::string("mssm-tanb")) {leg1->SetTextSize(0.03);}
//leg1->SetTextSize(0.02);
leg1->SetBorderSize( 0 );
leg1->SetFillStyle ( 1001 );
//leg1->SetFillColor ( 0 );
leg1->SetFillColor (kWhite);
leg1->SetHeader( "#bf{observed}" );
for(unsigned int i=0; i<hobs.size(); ++i){
leg1->AddEntry( hobs[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
leg1->Draw("same");
firstLeg=false;
}
if(expected){
TLegend* leg0;
if(expected && observed){
/// setup the CMS Preliminary
if(std::string(type) == std::string("mssm-tanb")){
CMSPrelim(label, "", 0.15, 0.835);
leg0 = new TLegend(legendOnRight ? 0.60 : 0.20, hexp.size()<5 ? 0.20-0.06*hexp.size() : 0.4, legendOnRight ? 0.94 : 0.63, 0.20);
}
else{
CMSPrelim(label, "", 0.135, 0.835);
leg0 = new TLegend(legendOnRight ? 0.20 : 0.20, hexp.size()<5 ? 0.75-0.08*hexp.size() : 0.6, legendOnRight ? 0.94 : 0.63, 0.75);
}
}
else{
/// setup the CMS Preliminary
if(std::string(type) == std::string("mssm-tanb")){
CMSPrelim(label, "", 0.15, 0.835);
leg0 = new TLegend(legendOnRight?0.60:0.20, hexp.size()<5 ? (legendOnTop?0.90:0.40)-0.04*hexp.size() : (legendOnTop?0.6:0.2), legendOnRight?0.94:0.45, (legendOnTop?0.90:0.40));
}
else{
CMSPrelim(label, "", 0.135, 0.835);
leg0 = new TLegend(legendOnRight ? 0.50 : 0.20, hexp.size()<5 ? 0.90-0.06*hexp.size() : 0.6, legendOnRight ? 0.74 : 0.63, 0.90);
//leg0 = new TLegend(legendOnRight ? 0.50 : 0.20, hexp.size()<5 ? 0.90-0.08*hexp.size() : 0.6, legendOnRight ? 0.94 : 0.80, 0.90);
}
}
if(std::string(type) == std::string("mssm-tanb")) {leg0->SetTextSize(0.03);}
leg0->SetBorderSize( 0 );
leg0->SetFillStyle ( 1001 );
leg0->SetFillColor (kWhite);
leg0->SetHeader( "#bf{expected}" );
for(unsigned int i=0; i<hexp.size(); ++i){
leg0->AddEntry( hexp[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "PL" );
}
leg0->Draw("same");
firstLeg=false;
}
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.png" : "_sm.png").c_str());
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.pdf").c_str());
canv1->Print(std::string("singleLimits").append(expected ? "_expected" : "").append(observed ? "_observed" : "").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.eps").c_str());
return;
}
void
HBB_HAD_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., string inputfile="root/$HISTFILE", const char* directory="bb_$CATEGORY")
{
// define common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
const char* category_extra = "";
if(std::string(directory) == std::string("bb_had0" )){ category_extra = "all-had_{0}"; }
if(std::string(directory) == std::string("bb_had1" )){ category_extra = "all-had_{1}"; }
if(std::string(directory) == std::string("bb_had2" )){ category_extra = "all-had_{2}"; }
if(std::string(directory) == std::string("bb_had3" )){ category_extra = "all-had_{3}"; }
if(std::string(directory) == std::string("bb_had4" )){ category_extra = "all-had_{4}"; }
if(std::string(directory) == std::string("bb_had5" )){ category_extra = "all-had_{5}"; }
if(std::string(directory) == std::string("bb_lep" )){ category_extra = "semi-lep"; }
const char* dataset;
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "Preliminary, #sqrt{s} = 7 TeV, L = 2.7 fb^{-1}";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "Preliminary, #sqrt{s} = 8 TeV, L = 19.4 fb^{-1}";}
TFile* input = new TFile(inputfile.c_str());
#ifdef MSSM
TFile* input2 = new TFile((inputfile+"_$MA_$TANB").c_str());
#endif
TH1F* Bbb = refill((TH1F*)input->Get(TString::Format("%s/Bbb" , directory)), "Bbb"); InitHist(Bbb, "", "", kMagenta-10, 1001);
TH1F* Cbb = refill((TH1F*)input->Get(TString::Format("%s/Cbb" , directory)), "Cbb"); InitHist(Cbb, "", "", kRed + 2, 1001);
TH1F* Qbb = refill((TH1F*)input->Get(TString::Format("%s/Qbb" , directory)), "Qbb"); InitHist(Qbb, "", "", kBlue - 8, 1001);
TH1F* bbB = refill((TH1F*)input->Get(TString::Format("%s/bbB" , directory)), "bbB"); InitHist(bbB, "", "", kOrange - 4, 1001);
TH1F* bbX = refill((TH1F*)input->Get(TString::Format("%s/bbX" , directory)), "bbX"); InitHist(bbX, "", "", kViolet - 0, 1001);
#ifdef MSSM
//float bbHScale = 1.;
//ggHScale = ($MSSM_SIGNAL_ggH_xseff_A + $MSSM_SIGNAL_ggH_xseff_hH);
//bbHScale = ($MSSM_SIGNAL_bbH_xseff_A + $MSSM_SIGNAL_bbH_xseff_hH);
TH1F* bbH = refill((TH1F*)input2->Get(TString::Format("%s/bbH$MA" , directory)), "bbH" ); InitSignal(bbH); bbH->Scale($TANB); //bbH->Scale(bbHScale);
#endif
#ifdef ASIMOV
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs_asimov", directory)), "data", true);
#else
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
#endif
InitHist(data, "#bf{m_{b#bar{b}} [GeV]}", "#bf{dN/dm_{b#bar{b}} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)Qbb->Clone("ref");
ref->Add(bbX);
ref->Add(Cbb);
ref->Add(bbB);
ref->Add(Bbb);
double unscaled[7];
unscaled[0] = Qbb ->Integral();
unscaled[1] = bbX ->Integral();
unscaled[2] = Cbb ->Integral();
unscaled[3] = bbB ->Integral();
unscaled[4] = Bbb ->Integral();
#ifdef MSSM
unscaled[5] = bbH ->Integral();
unscaled[6] = 0;
#endif
if(scaled){
rescale(Bbb, 1);
rescale(bbB, 4);
rescale(Cbb, 2);
rescale(bbX, 5);
rescale(Qbb, 3);
#ifdef MSSM
rescale(bbH, 6);
#endif
}
TH1F* scales[7];
scales[0] = new TH1F("scales-Qbb", "", 7, 0, 7);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (Qbb ->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-bbX" , "", 7, 0, 7);
scales[1]->SetBinContent(2, unscaled[1]>0 ? (bbX ->Integral()/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-Cbb", "", 7, 0, 7);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (Cbb ->Integral()/unscaled[2]-1.) : 0.);
scales[3] = new TH1F("scales-bbB" , "", 7, 0, 7);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (bbB ->Integral()/unscaled[3]-1.) : 0.);
scales[4] = new TH1F("scales-Bbb" , "", 7, 0, 7);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (Bbb ->Integral()/unscaled[4]-1.) : 0.);
#ifdef MSSM
scales[5] = new TH1F("scales-bbH" , "", 7, 0, 7);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (bbH ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-NONE" , "", 7, 0, 7);
scales[6]->SetBinContent(7, 0.);
#endif
bbX ->Add(Qbb);
Cbb ->Add(bbX);
bbB ->Add(Cbb);
Bbb ->Add(bbB);
if(!log){
#ifdef MSSM
bbH ->Add(Bbb);
#endif
}
/*
mass plot before and after fit
*/
TCanvas* canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(350)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(1000)); };
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Bbb, log)));
data->Draw("e");
TH1F* errorBand = (TH1F*)Bbb ->Clone();
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(1);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
if(log){
Bbb ->Draw("histsame");
bbB ->Draw("histsame");
Cbb ->Draw("histsame");
bbX ->Draw("histsame");
Qbb ->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
bbH ->Draw("histsame");
#endif
}
else{
#ifndef DROP_SIGNAL
bbH ->Draw("histsame");
#endif
Bbb ->Draw("histsame");
bbB ->Draw("histsame");
Cbb ->Draw("histsame");
bbX ->Draw("histsame");
Qbb ->Draw("histsame");
$DRAW_ERROR
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "b#bar{b}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.17, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText("b#bar{b}");
chan->Draw();
TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
#ifdef MSSM
TPaveText* massA = new TPaveText(0.75, 0.48+0.061, 0.85, 0.48+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m_{A}=$MA GeV");
massA->Draw();
TPaveText* tanb = new TPaveText(0.75, 0.44+0.061, 0.85, 0.44+0.161, "NDC");
tanb->SetBorderSize( 0 );
tanb->SetFillStyle( 0 );
tanb->SetTextAlign( 12 );
tanb->SetTextSize ( 0.03 );
tanb->SetTextColor( 1 );
tanb->SetTextFont ( 62 );
tanb->AddText("tan#beta=$TANB");
tanb->Draw();
TPaveText* scen = new TPaveText(0.75, 0.40+0.061, 0.85, 0.40+0.161, "NDC");
scen->SetBorderSize( 0 );
scen->SetFillStyle( 0 );
scen->SetTextAlign( 12 );
scen->SetTextSize ( 0.03 );
scen->SetTextColor( 1 );
scen->SetTextFont ( 62 );
scen->AddText("m^{h}_{max}");
scen->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.55, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(bbH , "#phi#rightarrowb#bar{b}" , "L" );
#endif
#ifdef ASIMOV
leg->AddEntry(data , "sum(bkg) + SM125 GeV signal" , "LP");
#else
leg->AddEntry(data , "observed" , "LP");
#endif
leg->AddEntry(Bbb, "Bbb" , "F" );
leg->AddEntry(bbB, "bbB" , "F" );
leg->AddEntry(Cbb, "Cbb" , "F" );
leg->AddEntry(bbX, "bbX" , "F" );
leg->AddEntry(Qbb, "Qbb" , "F" );
$ERROR_LEGEND
leg->Draw();
//#ifdef MSSM
// TPaveText* mssm = new TPaveText(0.69, 0.85, 0.90, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("(m_{A}=250, tan#beta=5)");
// mssm->Draw();
//#else
// TPaveText* mssm = new TPaveText(0.83, 0.85, 0.95, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("m_{H}=125");
// mssm->Draw();
//#endif
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* zero = (TH1F*)ref ->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat");
rat1->Divide(Bbb);
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
zero->SetBinContent(ibin+1, 0.);
}
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+1.5);
rat1->SetMinimum(-1.5);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{b#bar{b}} [GeV]}");
rat1->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv0->RedrawAxis();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
TH1F* rat2 = (TH1F*) Bbb->Clone("rat2");
rat2->Divide(ref);
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
rat2->SetLineColor(kRed+ 3);
rat2->SetFillColor(kRed-10);
rat2->SetMaximum(+0.3);
rat2->SetMinimum(-0.3);
rat2->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
rat2->GetXaxis()->SetTitle("#bf{m_{b#bar{b}} [GeV]}");
rat2->GetXaxis()->SetRange(0, 28);
rat2->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[4], "", "", kMagenta-10, 1001);
InitHist (scales[2], "", "", kRed + 2, 1001);
InitHist (scales[0], "", "", kBlue - 8, 1001);
InitHist (scales[3], "", "", kOrange - 4, 1001);
InitHist (scales[1], "", "", kViolet - 0, 1001);
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Qbb}");
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{bbX}");
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{Cbb}");
scales[0]->GetXaxis()->SetBinLabel(4, "#bf{bbB}");
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{Bbb}");
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{bbH}" );
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{NONE}" );
#endif
scales[0]->SetMaximum(+1.0);
scales[0]->SetMinimum(-1.0);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
scales[1]->Draw("same");
scales[2]->Draw("same");
scales[3]->Draw("same");
scales[4]->Draw("same");
zero->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sfit_%s_%s.png" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sfit_%s_%s.pdf" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sfit_%s_%s.eps" , directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
if(!log || FULLPLOTS)
{
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
}
if((!log && scaled) || FULLPLOTS)
{
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.png", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.pdf", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sfit_%s_%s.eps", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
}
TFile* output = new TFile(TString::Format("%s_%sfit_%s_%s.root", directory, scaled ? "post" : "pre", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""), "update");
output->cd();
data ->Write("data_obs");
Qbb ->Write("Qbb" );
bbX ->Write("bbX" );
Cbb ->Write("Cbb" );
bbB ->Write("bbB" );
Bbb ->Write("Bbb" );
#ifdef MSSM
bbH ->Write("bbH" );
#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
}
void compareBestFit(const char* filename="test.root", const char* channelstr="boost,vbf,vhtt,cmb+", const char* type="sm", double mass=125, double minimum=-1., double maximum=4.5, const char* label="Preliminary, #sqrt{s}=7-8 TeV, L = 24.3 fb^{-1}, H #rightarrow #tau #tau")
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["0jet" ] = kBlue;
colors["2jet" ] = kMagenta;
colors["vbf" ] = kRed;
colors["boost" ] = kGreen;
colors["btag" ] = kRed;
colors["nobtag" ] = kBlue;
colors["em" ] = kBlue;
colors["et" ] = kRed;
colors["mt" ] = kGreen;
colors["mm" ] = kMagenta;
colors["tt" ] = kOrange;
colors["vhtt" ] = kMagenta+2;
colors["cmb" ] = kBlack;
colors["cmb+" ] = kGray+2;
colors["htt" ] = kBlack;
colors["ggH" ] = kRed;
colors["bbH" ] = kBlue;
colors["mvis" ] = kBlue+2;
colors["test-0" ] = kRed+2;
colors["test-1" ] = kGreen+2;
colors["test-2" ] = kGreen;
colors["test-3" ] = kRed+2;
colors["test-4" ] = kBlue;
colors["test-5" ] = kViolet-6;
colors["HIG-11-020" ] = kBlue+2;
colors["HIG-11-029" ] = kRed+2;
colors["HIG-12-018" ] = kBlue;
colors["HIG-12-032" ] = kRed+2;
colors["HIG-12-043" ] = kBlack;
colors["HIG-12-050" ] = kBlack;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x macros/compareBestFit.C+(file, chn, type) \n"
<< " * \n"
<< " * Arguments : + file const char* full path to the input file \n"
<< " * + chn const char* list of channels; choose between: 'cmb', 'htt', 'em', \n"
<< " * 'et', 'mt', 'mm', 'vhtt', 'hgg', 'hww', 'ggH', \n"
<< " * 'bbH', 'nomix[-200, +200]', 'mhmax[-400, -200, +200]' \n"
<< " * 'mhmax[+400, +600, +800]', 'test-0...5', 'saeff', 'gluph' \n"
<< " * The list should be comma separated and may contain \n"
<< " * whitespaces \n"
<< " * + type const char* type of plot; choose between 'sm' and 'mssm' \n"
<< " * \n"
<< " * + mass double Higgs mass for which the plot should be performed \n"
<< " * \n"
<< " * + minimum double Minimum value for the x-Axis (best fit value) \n"
<< " * \n"
<< " * + maximum double Maximum value for the x-Axis (best fit value) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// open input file
TFile* inputFile = new TFile(filename); if(inputFile->IsZombie()){ std::cout << "ERROR:: file: " << filename << " does not exist.\n"; }
/// prepare input parameters
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
/// prepare histograms
std::vector<TGraph*> hexp;
std::vector<TGraph*> hband;
for(unsigned i=0; i<channels.size(); ++i){
hexp.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/expected").c_str()));
hband.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/innerBand").c_str()));
}
int massid = 0;
for(int i0 = 0; i0 < hexp[hexp.size()-1]->GetN(); i0++) {
double lX = 0; double lY = 0;
hexp[hexp.size()-1]->GetPoint(i0, lX, lY);
if(lX==mass) {massid = i0; break;}
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Best Fit Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(0);
canv1->SetGridy(0);
TLine* SM = new TLine(1, 0, 1, hexp.size());
TLine* ZERO = new TLine(0, 0, 0, hexp.size());
double *lBestFitX = new double[4];
double *lBestFitY = new double[4];
lBestFitX[0] = hexp[hexp.size()-1]->Eval(mass) - hband[hband.size()-1]->GetErrorYlow(massid);
lBestFitX[1] = hexp[hexp.size()-1]->Eval(mass) + hband[hband.size()-1]->GetErrorYhigh(massid);
lBestFitX[3] = hexp[hexp.size()-1]->Eval(mass) - hband[hband.size()-1]->GetErrorYlow(massid);
lBestFitX[2] = hexp[hexp.size()-1]->Eval(mass) + hband[hband.size()-1]->GetErrorYhigh(massid);
lBestFitY[0] = hexp.size();
lBestFitY[1] = hexp.size();
lBestFitY[2] = 0;
lBestFitY[3] = 0;
TGraph* BAND = new TGraph(4,lBestFitX,lBestFitY); BAND->SetFillColor(kYellow);
TLine * BEST = new TLine (hexp[hexp.size()-1]->Eval(mass),0,hexp[hexp.size()-1]->Eval(mass),hexp.size()); BEST->SetLineStyle(kDashed); BEST->SetLineColor(kRed);
bool firstPlot=true;
for(unsigned int i=0; i<hexp.size(); ++i){
double value[1] = {hexp[i]->Eval(mass)};
double position[1] = {hexp.size()-i-0.5};
double x;
double y;
double el=0;
double eh=0;
int k = hexp[i]->GetN();
for(int l=0; l<k; l++){
hexp[i]->GetPoint(l, x, y);
if(x==mass){
el=hband[i]->GetErrorYlow(l);
eh=hband[i]->GetErrorYhigh(l);
break;
}
}
double elow[1] = {el};
double ehigh[1] = {eh};
double help1[1] = {0.0};
double help2[1] = {0.0};
TGraphAsymmErrors *gr = new TGraphAsymmErrors(1, value, position, elow, ehigh, help1, help2);
if(firstPlot){
if(std::string(type) == std::string("mssm")){
gr->SetMaximum(hexp.size());
gr->SetMinimum(0);
}
else{
gr->SetMaximum(hexp.size());
gr->SetMinimum(0);
}
// gr->GetYaxis()->Set(hexp.size(), 0, hexp.size());
// gr = new TGraphAsymmErrors(1, value, position, elow, ehigh, help1, help2);
// std::cout << gr->GetYaxis()->GetNbins() << std::endl;
// format x-axis
std::string x_title;
if(std::string(type).find("mssm")!=std::string::npos){
x_title = std::string("best fit for #sigma(#phi#rightarrow#tau#tau)");
}
else{
x_title = std::string("best fit for #sigma/#sigma_{SM}");
}
gr->GetXaxis()->SetTitle(x_title.c_str());
gr->GetXaxis()->SetLabelFont(62);
gr->GetXaxis()->SetTitleFont(62);
gr->GetXaxis()->SetTitleColor(1);
gr->GetXaxis()->SetTitleOffset(1.05);
gr->GetXaxis()->SetLimits(minimum, maximum);
BAND->GetXaxis()->SetTitle(x_title.c_str());
BAND->GetXaxis()->SetLabelFont(62);
BAND->GetXaxis()->SetTitleFont(62);
BAND->GetXaxis()->SetTitleColor(1);
BAND->GetXaxis()->SetTitleOffset(1.05);
BAND->GetXaxis()->SetLimits(minimum, maximum);
// format y-axis
//BAND->GetYaxis()->Set(hexp.size(), 0, hexp.size());
gr ->GetYaxis()->Set(hexp.size(), 0, hexp.size());
//std::cout<<gr->GetYaxis()->GetBinCenter(hexp.size()-i)<<std::endl;
//BAND->GetYaxis()->SetBinLabel(hexp.size()-1, legendEntry(channels[hexp.size()-1]).c_str());
for(unsigned int j=0; j<hexp.size(); ++j){
gr ->GetYaxis()->SetBinLabel(hexp.size()-j, legendEntry(channels[j]).c_str());
}
gr->GetYaxis()->SetTickLength(0);
gr->GetYaxis()->SetLabelFont(62);
gr->GetYaxis()->SetTitleFont(62);
gr->GetYaxis()->SetLabelSize(0.07);
gr->GetYaxis()->SetTitle("");
gr->GetYaxis()->SetLabelFont(62);
gr->GetYaxis()->SetTitleOffset(1.05);
gr->GetYaxis()->SetLabelSize(0.03);
gr->GetYaxis()->SetLabelOffset(-0.32);
BAND->GetYaxis()->SetLabelFont(62);
BAND->GetYaxis()->SetTitleFont(62);
BAND->GetYaxis()->SetLabelSize(0.07);
BAND->GetYaxis()->SetTitle("");
BAND->GetYaxis()->SetLabelFont(62);
BAND->GetYaxis()->SetTitleOffset(1.05);
BAND->GetYaxis()->SetLabelSize(0.03);
BAND->GetYaxis()->SetLabelOffset(-0.32);
}
BAND->GetYaxis()->SetLabelSize(0.07);
BAND->SetTitle("");
gr ->GetYaxis()->SetLabelSize(0.07);
gr->SetTitle("");
gr->SetLineStyle( 1.);
gr->SetLineWidth( 2.);
//gr->SetLineColor(colorzxs.find(channels[i])->second);
gr->SetLineColor(kBlack);
gr->SetMarkerStyle(kFullCircle);
gr->SetMarkerSize(MARKER_SIZE);
//gr->SetMarkerColor(colors.find(channels[i])->second);
gr->SetMarkerColor(kBlack);
cout << "===> " << gr->GetErrorYhigh(0) << endl;
//cout << "==> "<< BAND->GetYaxis()->GetMaximum() << endl;
if(firstPlot) gr->Draw("AP");
if(firstPlot) {
BAND->Draw("Fsame");
BEST->Draw("l");
TLine *lLine = new TLine(minimum,1.0,maximum,1.0); lLine->SetLineWidth(3); lLine->SetLineColor(kBlue+2);
lLine->Draw();
SM->SetLineWidth(3);
SM->SetLineColor(kGreen+3);
if(std::string(type).find("mssm")==std::string::npos) SM->Draw("same");
}
gr->Draw(firstPlot ? "Psame" : "Psame");
//gr->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
ZERO->SetLineWidth(3);
ZERO->SetLineColor(kBlue);
ZERO->SetLineStyle(11);
//ZERO->Draw("same");
//TPaveText *pt = new TPaveText(2*(maximum+minimum)/3,hexp.size()-0.3,maximum,hexp.size()-0.02);
TPaveText *pt = new TPaveText(0.76, 0.88, 1.0, 1.0, "NDC");
if(std::string(type).find("mssm")!=std::string::npos) pt->AddText(TString::Format("m_{A} = %0.0f GeV" , mass));
else pt->AddText(TString::Format("m_{H} = %0.0f GeV" , mass));
pt->SetBorderSize( 0 );
pt->SetFillStyle( 0 );
pt->SetTextAlign( 12 );
pt->SetTextSize ( 0.03 );
pt->SetTextColor( 1 );
pt->SetTextFont ( 62 );
pt->Draw("same");
canv1->RedrawAxis();
CMSPrelim(label, "", 0.15, 0.835);
canv1->Print(std::string("BestFit").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.png" : "_sm.png").c_str());
canv1->Print(std::string("BestFit").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.pdf").c_str());
canv1->Print(std::string("BestFit").append(std::string(type).find("mssm")!=std::string::npos ? "_mssm.pdf" : "_sm.eps").c_str());
return;
}
void plotModelindependentTanb(const char* filename, const char* channelstr, bool expected, bool observed, double minimum=0., double maximum=20., const char* label="CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV")
{
SetStyle();
std::map<std::string, unsigned int> colors;
colors["BR0p1" ] = kBlue;
colors["BR0p2" ] = kGreen;
colors["BR0p3" ] = kRed;
std::cout << " *******************************************************************************************************\n"
<< " * Usage : root -l \n"
<< " * .x MitLimits/Higgs2Tau/macros/compareLimits.C+(file, chn, exp, obs, type, min, max, log) \n"
<< " * \n"
<< " * Arguments : + file const char* full path to the input file \n"
<< " * \n"
<< " * + chn const char* list of BR please order correct high to low or low to high \n"
<< " * \n"
<< " * + exp bool compare expected limits \n"
<< " * \n"
<< " * + obs bool compare observed limits \n"
<< " * \n"
<< " * + max double maximum of the plot (default is 20.) \n"
<< " * \n"
<< " * + min double minimum of the plot (default is 0.) \n"
<< " * \n"
<< " *******************************************************************************************************\n";
/// open input file
TFile* inputFile = new TFile(filename); if(inputFile->IsZombie()){ std::cout << "ERROR:: file: " << filename << " does not exist.\n"; }
/// prepare input parameters
std::vector<std::string> channels;
string2Vector(cleanupWhitespaces(channelstr), channels);
/// prepare histograms
std::vector<TGraph*> hobs, hexp;
for(int i=0; i<channels.size(); ++i){
if(observed) hobs.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/observed").c_str()));
if(expected) hexp.push_back(get<TGraph>(inputFile, std::string(channels[i]).append("/expected").c_str()));
}
double x1, x2, y1, y2;
TGraphAsymmErrors* Texp = 0;
if(expected){
Texp = new TGraphAsymmErrors();
//Texp->SetPoint(0, 0, 0);
//Texp->SetPointEYlow (0, 0);
//Texp->SetPointEYhigh(0, 100);
for(int i=0; i<hexp[0]->GetN(); i++){
hexp[0] ->GetPoint(i, x1, y1);
hexp[hexp.size()-1]->GetPoint(i, x2, y2);
Texp ->SetPoint(i, x1, y1);
if(y1<y2){
Texp->SetPointEYlow (i, 0);
Texp->SetPointEYhigh(i, y2-y1);
}
else{
Texp->SetPointEYlow (i, y1-y2);
Texp->SetPointEYhigh(i, 0);
}
}
}
TGraphAsymmErrors* Tobs = 0;
if(observed){
Tobs = new TGraphAsymmErrors();
//Tobs->SetPoint(0, 0, 100.);
//Tobs->SetPointEYlow (0, 0);
//Tobs->SetPointEYhigh(0, 100);
for(int i=0; i<hobs[0]->GetN(); i++){
hobs[0] ->GetPoint(i, x1, y1);
hobs[hexp.size()-1]->GetPoint(i, x2, y2);
Tobs ->SetPoint(i, x1, y1);
if(y1<y2){
Tobs->SetPointEYlow (i, 0);
Tobs->SetPointEYhigh(i, y2-y1);
}
else{
Tobs->SetPointEYlow (i, y1-y2);
Tobs->SetPointEYhigh(i, 0);
}
}
}
/// do the drawing
TCanvas* canv1 = new TCanvas("canv1", "Limit Comparison", 600, 600);
canv1->cd();
canv1->SetGridx(1);
canv1->SetGridy(1);
bool firstPlot=true;
for(unsigned int i=0; i<hexp.size(); ++i){
if(firstPlot){
hexp[i]->SetMaximum(maximum);
hexp[i]->SetMinimum(minimum);
// format x-axis
std::string x_title = std::string("m_{A} [GeV]");
hexp[i]->GetXaxis()->SetTitle(x_title.c_str());
hexp[i]->GetXaxis()->SetLabelFont(62);
hexp[i]->GetXaxis()->SetTitleFont(62);
hexp[i]->GetXaxis()->SetTitleColor(1);
hexp[i]->GetXaxis()->SetTitleOffset(1.05);
hexp[i]->GetYaxis()->SetRangeUser(0,maximum);
// format y-axis
std::string y_title = std::string("#bf{tan#beta}");
hexp[i]->GetYaxis()->SetTitle(y_title.c_str());
hexp[i]->GetYaxis()->SetLabelFont(62);
hexp[i]->GetYaxis()->SetTitleOffset(1.05);
hexp[i]->GetYaxis()->SetLabelSize(0.03);
hexp[i]->GetXaxis()->SetLimits(hexp[i]->GetX()[0]-.1, hexp[i]->GetX()[hexp[i]->GetN()-1]+.1);
//hexp[i]->GetXaxis()->SetRangeUser(90,250);
}
hexp[i]->SetLineStyle( 1.);
hexp[i]->SetLineWidth( 4.);
hexp[i]->SetLineColor(colors.find(channels[i])->second);
//hexp[i]->SetMarkerStyle(20);
//hexp[i]->SetMarkerSize(MARKER_SIZE);
//hexp[i]->SetMarkerColor(colors.find(channels[i])->second);
//hexp[i]->Draw(firstPlot ? "APL" : "PLsame");
hexp[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
for(unsigned int i=0; i<hobs.size(); ++i){
if(firstPlot){
hobs[i]->SetMaximum(maximum);
hobs[i]->SetMinimum(minimum);
// format x-axis
std::string x_title = std::string("m_{A} [GeV]");
hobs[i]->GetXaxis()->SetTitle(x_title.c_str());
hobs[i]->GetXaxis()->SetLabelFont(62);
hobs[i]->GetXaxis()->SetTitleFont(62);
hobs[i]->GetXaxis()->SetTitleColor(1);
hobs[i]->GetXaxis()->SetTitleOffset(1.05);
hobs[i]->GetYaxis()->SetRangeUser(0,maximum);
// format y-axis
std::string y_title = std::string("#bf{tan#beta}");
hobs[i]->GetYaxis()->SetTitle(y_title.c_str());
hobs[i]->GetYaxis()->SetLabelFont(62);
hobs[i]->GetYaxis()->SetTitleOffset(1.05);
hobs[i]->GetYaxis()->SetLabelSize(0.03);
hobs[i]->GetXaxis()->SetLimits(hobs[i]->GetX()[0]-.1, hobs[i]->GetX()[hobs[i]->GetN()-1]+.1);
//hobs[i]->GetXaxis()->SetRangeUser(90,250);
}
hobs[i]->SetLineStyle( 1.);
hobs[i]->SetLineWidth( 4.);
hobs[i]->SetLineColor(colors.find(channels[i])->second);
//hobs[i]->SetMarkerStyle(20);
//hobs[i]->SetMarkerSize(MARKER_SIZE);
//hobs[i]->SetMarkerColor(colors.find(channels[i])->second);
//hobs[i]->Draw(firstPlot ? "APL" : "PLsame");
hobs[i]->Draw(firstPlot ? "AL" : "Lsame");
firstPlot=false;
}
canv1->RedrawAxis();
if(expected){
Texp->SetFillStyle(1001.);
Texp->SetFillColor(kGray);
Texp->Draw("3");
}
if(observed){
Tobs->SetFillStyle(1001.);
Tobs->SetFillColor(kCyan);
Tobs->Draw("3same");
}
canv1->RedrawAxis();
TLegend* leg1 = new TLegend(0.1, 0.65, 0.5, 0.9);
CMSPrelim(label, "", 0.15, 0.835);
//leg1->SetTextSize(0.025);
leg1->SetBorderSize( 0 );
leg1->SetFillStyle ( 1001 );
//leg1->SetFillColor ( 0 );
leg1->SetFillColor (kWhite);
leg1->SetHeader("95% CL excluded");
if(expected){
for(unsigned int i=0; i<hexp.size(); ++i){
leg1->AddEntry( hexp[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "L" );
}
leg1->AddEntry( Texp , "limits in between", "F" );
}
if(observed && !expected){
for(unsigned int i=0; i<hobs.size(); ++i){
leg1->AddEntry( hobs[i] , channel(channels[i]) ? legendEntry(channels[i]).c_str() : legendEntry(channels[i]).append("-Channel").c_str(), "L" );
}
leg1->AddEntry( Tobs , "limits in between", "F" );
}
leg1->Draw("same");
canv1->Print("tanb.pdf");
canv1->Print("tanb.png");
canv1->Print("tanb.eps");
return;
}
void draw_obj(std::string var="ptTau1", std::string cut="(ptTau2>45 && abs(etaTau1)<4.0 && abs(etaTau2)<4.0)", int chan_cat=1, int yTau=0, int yB=1, int nbins=10, double xmin=0, double xmax=500,std::string xtitle="leading #tau p_{T}", std::string ytitle="Events")
{
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
TH1::SetDefaultSumw2(1);
std::string dir = "/afs/cern.ch/work/j/jlawhorn/public/comb_ntuples/";
double sigscale = 1000;
double sigscale1 = 10;
std::stringstream scale; scale << sigscale;
std::stringstream scale1; scale1 << sigscale1;
//Cut definitions
double luminosity = 3000;
std::stringstream lumi; lumi << luminosity;
std::string ttcut = "(tauCat1==1 && tauCat2==1 && bTag1>0 && bTag2>0 && ptTau1>45 && ptTau2>45)";
std::string mtcut = "((tauCat1==1 && tauCat2==3)||(tauCat2==1 && tauCat1==3))*(bTag1>0 && bTag2>0 && ptTau1>30 && ptTau2>30)";
std::string etcut = "((tauCat1==1 && tauCat2==2)||(tauCat2==1 && tauCat1==2))*(bTag1>0 && bTag2>0 && ptTau1>30 && ptTau2>30)";
std::string emcut = "((tauCat1==3 && tauCat2==2)||(tauCat2==3 && tauCat1==2))*(bTag1>0 && bTag2>0 && ptTau1>30 && ptTau2>30)";
std::string taucut = "(abs(etaTau1)<4.0 && abs(etaTau2)<4.0)";
std::string bcut = "(ptB1>30 && ptB2>30 && abs(etaB1)<4.0 && abs(etaB2)<4.0)";
std::string optcut = cut;
if (chan_cat==0) { //tt
optcut = cut+"*"+ttcut;
if (yTau==1) optcut+="*"+taucut+"*(ptTau1>45 && ptTau2>45)";
}
else if (chan_cat==1) { //mt
optcut = cut+"*"+mtcut;
if (yTau==1) optcut+="*"+taucut+"*(ptTau1>30 && ptTau2>30)";
}
else if (chan_cat==2) { //et
optcut = cut+"*"+etcut;
if (yTau==1) optcut+="*"+taucut+"*(ptTau1>30 && ptTau2>30)";
}
else if (chan_cat==3) { //em
optcut = cut+"*"+emcut;
if (yTau==1) optcut+="*"+taucut+"*(ptTau1>30 && ptTau2>30)";
}
if (yB==1) optcut+="*"+bcut;
//cout << optcut << endl;
//signal region
std::string hhcut = optcut+"*"+scale.str()+"*eventWeight*(1)*"+lumi.str();
std::string ttbarcut = optcut+"*eventWeight*(1)*"+lumi.str();
std::string hcut = optcut+"*eventWeight*(1)*"+lumi.str();
std::string zjetcut = optcut+"*eventWeight*(eventType==4)*"+lumi.str();
std::string ewkcut = optcut+"*eventWeight*(eventType!=4)*"+lumi.str();
//--------------------------------------------------------------------------
//Get the trees
TTree *ttbartree = load(dir+"tt.root");
TTree *htree = load(dir+"H.root");
TTree *ewktree = load(dir+"EWK.root");
TTree *sigtree = load(dir+"HHToTTBB_14TeV.root");
//-------------------------------------------------------------------------
//Get histograms
TCanvas *canv0 = MakeCanvas("canv", "histograms", 600, 600);
canv0->cd();
std::string vardraw;
TH1F *sig = new TH1F("HH","",nbins,xmin,xmax);
vardraw = var+">>"+"HH";
sigtree->Draw(vardraw.c_str(),hhcut.c_str());
InitSignal(sig);
sig->SetLineColor(kBlack);
TH1F *ttbar = new TH1F("TTbar","",nbins,xmin,xmax);
vardraw = var+">>"+"TTbar";
ttbartree->Draw(vardraw.c_str(),ttbarcut.c_str());
InitHist(ttbar, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(155,152,204), 1001);
TH1F *hbg = new TH1F("H","",nbins,xmin,xmax);
vardraw = var+">>"+"H";
htree->Draw(vardraw.c_str(),hcut.c_str());
InitHist(hbg, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(141,201,159), 1001);
TH1F *zjet = new TH1F("Zjets","",nbins,xmin,xmax);
vardraw = var+">>"+"Zjets";
ewktree->Draw(vardraw.c_str(),zjetcut.c_str());
InitHist(zjet, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(222,90,106), 1001);
TH1F *ewk = new TH1F("EWK","",nbins,xmin,xmax);
vardraw = var+">>"+"EWK";
ewktree->Draw(vardraw.c_str(),ewkcut.c_str());
InitHist(ewk, xtitle.c_str(), ytitle.c_str(), TColor::GetColor(248,206,104), 1001);
cout << sig->GetEntries() << endl;
cout << ttbar->GetEntries() << endl;
cout << hbg->GetEntries() << endl;
cout << zjet->GetEntries() << endl;
cout << ewk->GetEntries() << endl;
delete canv0;
//-----------------------------------------------------------------------
//Draw the histograms
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
zjet->Add(ewk); hbg->Add(zjet); ttbar->Add(hbg);
//Error band stat
TH1F* errorBand = (TH1F*)sig ->Clone("errorBand");
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(13);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
// for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
// if(errorBand->GetBinContent(idx)>0){
// std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
// break;
// }
//}
ttbar->SetMaximum(1.2*std::max(maximum(ttbar, 0), maximum(ewk, 0)));
//blind(sig,75,150);
ttbar->Draw("hist");
hbg->Draw("histsame");
zjet->Draw("histsame");
ewk->Draw("histsame");
sig->Draw("histsame");
//errorBand->Draw("e2same");
canv->RedrawAxis();
//---------------------------------------------------------------------------
//Adding a legend
TLegend* leg = new TLegend(0.53, 0.73, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(sig , TString::Format("%.0f#timeshh#rightarrow#tau#tau bb", sigscale) , "L");
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(hbg , "H" , "F" );
leg->AddEntry(zjet , "Z+jets" , "F" );
leg->AddEntry(ewk , "EWK" , "F" );
//leg->AddEntry(errorBand,"bkg. uncertainty","F");
leg->Draw();
//---------------------------------------------------------------------------
//CMS preliminary
const char* dataset = "CMS Preliminary, HH#rightarrow bb#tau#tau, 3.0 ab^{-1} at 14 TeV";
char category[50];
if (chan_cat==0) sprintf(category,"#tau_{h}#tau_{h}");
if (chan_cat==1) sprintf(category,"#mu#tau_{h}");
if (chan_cat==2) sprintf(category,"e#tau_{h}");
if (chan_cat==3) sprintf(category,"e#mu");
//CMSPrelim(dataset, "#tau_{h}#tau_{h}", 0.17, 0.835);
//CMSPrelim(dataset, "#tau_{h}#tau_{h}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.26, 0.77, 0.37, 0.85, "tlbrNDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(category);
chan->Draw();
//-------------------------------------------------------------------------
//Save histograms
char outfile[50];
if (chan_cat==0) sprintf(outfile, "%s_tt.png", var.c_str());
if (chan_cat==1) sprintf(outfile, "%s_mt.png", var.c_str());
if (chan_cat==2) sprintf(outfile, "%s_et.png", var.c_str());
if (chan_cat==3) sprintf(outfile, "%s_em.png", var.c_str());
canv->Print(outfile);
}
void
HTT_TT_X(bool scaled=true, bool log=false, float min=0., float max=-1., const char* inputfile="root/$HISTFILE", const char* directory="$CATEGORY")
{
// define common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category_extra = "";
if(std::string(directory) == std::string("emu_0jet_low" )){ category_extra = "0 jet, low p_{T}"; }
if(std::string(directory) == std::string("emu_0jet_high" )){ category_extra = "0 jet, high p_{T}"; }
if(std::string(directory) == std::string("emu_boost_low" )){ category_extra = "1 jet, low p_{T}"; }
if(std::string(directory) == std::string("emu_boost_high")){ category_extra = "1 jet, high p_{T}"; }
if(std::string(directory) == std::string("emu_vbf" )){ category_extra = "2 jet (VBF)"; }
if(std::string(directory) == std::string("emu_nobtag" )){ category_extra = "No B-Tag"; }
if(std::string(directory) == std::string("emu_btag" )){ category_extra = "B-Tag"; }
const char* dataset;
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "CMS Preliminary, ZH#rightarrow#lltau#tau, 4.9 fb^{-1} at 7 TeV";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS Preliminary, ZH#rightarrowll#tau#tau, 19.4 fb^{-1} at 8 TeV";}
#ifdef MSSM
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 19.4 fb^{-1} at 8 TeV";}
#endif
TFile* input = new TFile(inputfile);
TH1F* ZZ = refill((TH1F*)input->Get(TString::Format("%s/ZZ" , directory)), "ZZ"); InitHist(ZZ, "", "", kMagenta-10, 1001);
TH1F* GGToZZ2L2L = refill((TH1F*)input->Get(TString::Format("%s/GGToZZ2L2L" , directory)), "GGToZZ2L2L"); InitHist(GGToZZ2L2L, "", "", kMagenta-10, 1001);
TH1F* Zjets = refill((TH1F*)input->Get(TString::Format("%s/Zjets" , directory)), "Zjets" ); InitHist(Zjets , "", "", kRed + 2, 1001);
#ifndef DROP_SIGNAL
TH1F* ZH_htt = refill((TH1F*)input->Get(TString::Format("%s/ZH_htt" , directory)+"125"), "ZH_htt" ); InitSignal(ZH_htt); ZH_htt->Scale(SIGNAL_SCALE);
TH1F* ZH_hww = refill((TH1F*)input->Get(TString::Format("%s/ZH_hww" , directory)+"125"), "ZH_hww" ); InitSignal(ZH_hww); ZH_hww->Scale(SIGNAL_SCALE);
#endif
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
InitHist(data, "#bf{m_{#tau#tau} [GeV]}", "#bf{dN/dm_{#tau#tau} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)ZZ->Clone("ref");
ref->Add(GGToZZ2L2L);
ref->Add(Zjets );
double unscaled[5];
unscaled[0] = ZZ->Integral();
unscaled[1] = GGToZZ2L2L->Integral();
unscaled[2] = Zjets ->Integral();
#ifndef DROP_SIGNAL
unscaled[3] = ZH_htt ->Integral();
unscaled[4] = ZH_hww ->Integral();
#endif
if(scaled){
rescale(ZZ, 1);
rescale(GGToZZ2L2L, 2);
rescale(Zjets, 3);
#ifndef DROP_SIGNAL
rescale(ZH_htt, 4);
rescale(ZH_hww, 5);
#endif
}
TH1F* scales[5];
scales[0] = new TH1F("scales-ZZ", "", 5, 0, 5);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (ZZ->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-GGToZZ2L2L", "", 5, 0, 5);
scales[1]->SetBinContent(2, unscaled[1]>0 ? (GGToZZ2L2L->Integral()/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-Zjets" , "", 5, 0, 5);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (Zjets ->Integral()/unscaled[2]-1.) : 0.);
#ifndef DROP_SIGNAL
scales[3] = new TH1F("scales-ZH_htt" , "", 5, 0, 5);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (ZH_htt ->Integral()/unscaled[3]-1.) : 0.);
scales[4] = new TH1F("scales-ZH_hww" , "", 5, 0, 5);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ZH_hww ->Integral()/unscaled[4]-1.) : 0.);
#endif
GGToZZ2L2L->Add(Zjets);
ZZ ->Add(GGToZZ2L2L);
if(log){
#ifndef DROP_SIGNAL
ZH_htt ->Add(ZH_hww );
#endif
}
else{
#ifndef DROP_SIGNAL
ZH_htt ->Add(ZH_hww);
#endif
}
/*
mass plot before and after fit
*/
TCanvas* canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(350)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(1000)); };
#else
data->GetXaxis()->SetRange(0, data->FindBin(350));
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
float maxZZ=ZZ->GetBinContent(ZZ->GetMaximumBin()); float maxdata=data->GetBinContent(data->GetMaximumBin());
if (maxdata>maxZZ)
data->SetMaximum(1.8*maxdata);
else
data->SetMaximum(1.8*maxZZ);
data->Draw("e");
// TH1F* errorBand = (TH1F*)ZZ ->Clone();
TH1F* errorBand = (TH1F*)Zjets ->Clone();
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(1);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
errorBand ->Scale(0.15);
for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
if(errorBand->GetBinContent(idx)>0){
std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
break;
}
}
//if(log){
ZZ ->Draw("histsame");
Zjets->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
ZH_htt ->Draw("histsame");
#endif
//}
//else{
//#ifndef DROP_SIGNAL
// ggH ->Draw("histsame");
//#endif
// Ztt ->Draw("histsame");
// ttbar->Draw("histsame");
// EWK ->Draw("histsame");
// Fakes->Draw("histsame");
// $DRAW_ERROR
// }
data->Draw("esame");
canv->RedrawAxis();
// //CMSPrelim(dataset, "#tau_{e}#tau_{#mu}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
if (directory=="eett_zh")
chan->AddText("#tau#tau");
else
chan->AddText("#mu#mu#tau#tau");
chan->Draw();
//
// TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
// cat->SetBorderSize( 0 );
// cat->SetFillStyle( 0 );
// cat->SetTextAlign( 12 );
// cat->SetTextSize ( 0.05 );
// cat->SetTextColor( 1 );
// cat->SetTextFont ( 62 );
// cat->AddText(category_extra);
// cat->Draw();
//
//#ifdef MSSM
// TPaveText* massA = new TPaveText(0.75, 0.48+0.061, 0.85, 0.48+0.161, "NDC");
// massA->SetBorderSize( 0 );
// massA->SetFillStyle( 0 );
// massA->SetTextAlign( 12 );
// massA->SetTextSize ( 0.03 );
// massA->SetTextColor( 1 );
// massA->SetTextFont ( 62 );
// massA->AddText("m_{A}=$MAGeV");
// massA->Draw();
//
// TPaveText* tanb = new TPaveText(0.75, 0.44+0.061, 0.85, 0.44+0.161, "NDC");
// tanb->SetBorderSize( 0 );
// tanb->SetFillStyle( 0 );
// tanb->SetTextAlign( 12 );
// tanb->SetTextSize ( 0.03 );
// tanb->SetTextColor( 1 );
// tanb->SetTextFont ( 62 );
// tanb->AddText("tan#beta=$TANB");
// tanb->Draw();
//
// TPaveText* scen = new TPaveText(0.75, 0.40+0.061, 0.85, 0.40+0.161, "NDC");
// scen->SetBorderSize( 0 );
// scen->SetFillStyle( 0 );
// scen->SetTextAlign( 12 );
// scen->SetTextSize ( 0.03 );
// scen->SetTextColor( 1 );
// scen->SetTextFont ( 62 );
// scen->AddText("mhmax");
// scen->Draw();
//#endif
//
//#ifdef MSSM
// TLegend* leg = new TLegend(0.45, 0.65, 0.95, 0.90);
// SetLegendStyle(leg);
// leg->AddEntry(ggH , "#phi#rightarrow#tau#tau" , "L" );
//#else
TLegend* leg = new TLegend(0.50, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
//#ifndef DROP_SIGNAL
// if(SIGNAL_SCALE!=1){
leg->AddEntry(ZH_htt , TString::Format("%.0f#timesZH(125 GeV)#rightarrowll#tau#tau", SIGNAL_SCALE) , "L" );
// }
// else{
// leg->AddEntry(ggH , "H(125 GeV)#rightarrow#tau#tau" , "L" );
// }
//#endif
//#endif
leg->AddEntry(data , "observed" , "LP");
leg->AddEntry(ZZ , "ZZ" , "F" );
leg->AddEntry(Zjets, "Reducible" , "F" );
// leg->AddEntry(EWK , "electroweak" , "F" );
// leg->AddEntry(Fakes, "QCD" , "F" );
$ERROR_LEGEND
leg->Draw();
//
////#ifdef MSSM
//// TPaveText* mssm = new TPaveText(0.69, 0.85, 0.90, 0.90, "NDC");
//// mssm->SetBorderSize( 0 );
//// mssm->SetFillStyle( 0 );
//// mssm->SetTextAlign( 12 );
//// mssm->SetTextSize ( 0.03 );
//// mssm->SetTextColor( 1 );
//// mssm->SetTextFont ( 62 );
//// mssm->AddText("(m_{A}=250, tan#beta=5)");
//// mssm->Draw();
////#else
//// TPaveText* mssm = new TPaveText(0.83, 0.85, 0.95, 0.90, "NDC");
//// mssm->SetBorderSize( 0 );
//// mssm->SetFillStyle( 0 );
//// mssm->SetTextAlign( 12 );
//// mssm->SetTextSize ( 0.03 );
//// mssm->SetTextColor( 1 );
//// mssm->SetTextFont ( 62 );
//// mssm->AddText("m_{H}=125");
//// mssm->Draw();
////#endif
//
// /*
// Ratio Data over MC
// */
// TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
// canv0->SetGridx();
// canv0->SetGridy();
// canv0->cd();
//
// TH1F* zero = (TH1F*)ref ->Clone("zero"); zero->Clear();
// TH1F* rat1 = (TH1F*)data->Clone("rat");
// rat1->Divide(Ztt);
// for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
// if(rat1->GetBinContent(ibin+1)>0){
// // catch cases of 0 bins, which would lead to 0-alpha*0-1
// rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
// }
// zero->SetBinContent(ibin+1, 0.);
// }
// rat1->SetLineColor(kBlack);
// rat1->SetFillColor(kGray );
// rat1->SetMaximum(+0.5);
// rat1->SetMinimum(-0.5);
// rat1->GetYaxis()->CenterTitle();
// rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
// rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
// rat1->Draw();
// zero->SetLineColor(kBlack);
// zero->Draw("same");
// canv0->RedrawAxis();
//
// /*
// Ratio After fit over Prefit
// */
// TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
// canv1->SetGridx();
// canv1->SetGridy();
// canv1->cd();
//
// TH1F* rat2 = (TH1F*) Ztt->Clone("rat2");
// rat2->Divide(ref);
// for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
// if(rat2->GetBinContent(ibin+1)>0){
// // catch cases of 0 bins, which would lead to 0-alpha*0-1
// rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
// }
// }
// rat2->SetLineColor(kRed+ 3);
// rat2->SetFillColor(kRed-10);
// rat2->SetMaximum(+0.3);
// rat2->SetMinimum(-0.3);
// rat2->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
// rat2->GetYaxis()->CenterTitle();
// rat2->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
// rat2->GetXaxis()->SetRange(0, 28);
// rat2->Draw();
// zero->SetLineColor(kBlack);
// zero->Draw("same");
// canv1->RedrawAxis();
//
// /*
// Relative shift per sample
// */
// TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
// canv2->SetGridx();
// canv2->SetGridy();
// canv2->cd();
//
// InitHist (scales[0], "", "", kMagenta-10, 1001);
// InitHist (scales[1], "", "", kRed + 2, 1001);
// InitHist (scales[2], "", "", kBlue - 8, 1001);
// InitHist (scales[3], "", "", kOrange - 4, 1001);
//#ifndef DROP_SIGNAL
// InitSignal(scales[4]);
// InitSignal(scales[5]);
// InitSignal(scales[6]);
//#endif
// scales[0]->Draw();
// scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Fakes}");
// scales[0]->GetXaxis()->SetBinLabel(2, "#bf{EWK}" );
// scales[0]->GetXaxis()->SetBinLabel(3, "#bf{ttbar}");
// scales[0]->GetXaxis()->SetBinLabel(4, "#bf{Ztt}" );
//#ifdef MSSM
// scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
// scales[0]->GetXaxis()->SetBinLabel(6, "#bf{bbH}" );
// scales[0]->GetXaxis()->SetBinLabel(7, "#bf{NONE}" );
//#else
// scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
// scales[0]->GetXaxis()->SetBinLabel(6, "#bf{qqH}" );
// scales[0]->GetXaxis()->SetBinLabel(7, "#bf{VH}" );
//#endif
// scales[0]->SetMaximum(+1.0);
// scales[0]->SetMinimum(-1.0);
// scales[0]->GetYaxis()->CenterTitle();
// scales[0]->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
// scales[1]->Draw("same");
// scales[2]->Draw("same");
// scales[3]->Draw("same");
//#ifndef DROP_SIGNAL
// scales[4]->Draw("same");
// scales[5]->Draw("same");
// scales[6]->Draw("same");
//#endif
// zero->Draw("same");
// canv2->RedrawAxis();
//
// /*
// prepare output
// */
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sscaled_%s_%s.png" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.pdf" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.eps" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
// canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
TFile* output = new TFile(TString::Format("%s_%sscaled_%s_%s.root", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""), "update");
output->cd();
data ->Write("data_obs");
ZZ->Write("ZZ" );
Zjets ->Write("Zjets" );
ZH_htt->Write("ZH_htt" );
ZH_hww ->Write("ZH_hww" );
//#ifdef MSSM
// ggH ->Write("ggH" );
// bbH ->Write("bbH" );
//#else
//#ifndef DROP_SIGNAL
// ggH ->Write("ggH" );
// qqH ->Write("qqH" );
// VH ->Write("VH" );
//#endif
//#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
}
void
postfit(const char* inputfile, const char* analysis = "SM", const char* dataset = "2011+2012", const char* extra="", const char* extra2="", float min=0.1, float max=-1., bool log=true)
{
// defining the common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// switch for MSSM/SM
bool MSSM = std::string(analysis) == std::string("MSSM");
// determine label
if (std::string(dataset) == std::string("2011" )){ dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV"; }
if (std::string(dataset) == std::string("2012" )){
if (std::string(extra) == std::string("#mu#mu") ) dataset = "MS Preliminary, H#rightarrow#tau#tau, 18.7 fb^{-1} at 8 TeV";
else dataset = "MS Preliminary, H#rightarrow#tau#tau, 19.4 fb^{-1} at 8 TeV";
}
if (std::string(dataset) == std::string("2011+2012")){
if (std::string(extra) == std::string("#mu#mu") ) dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 18.6 fb^{-1} at 8 TeV";
else dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 19.4 fb^{-1} at 8 TeV";
if (MSSM) dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV, 12.1 fb^{-1} at 8 TeV";
}
// determine category tag
const char* category_extra = "";
if(std::string(extra2) == std::string("0jet_low" )){ category_extra = "0 jet, low p_{T}"; }
if(std::string(extra2) == std::string("0jet_high" )){ category_extra = "0 jet, high p_{T}"; }
if(std::string(extra2) == std::string("0jet" )){ category_extra = "0 jet"; }
if(std::string(extra2) == std::string("boost_low" )){ category_extra = "1 jet, low p_{T}"; }
if(std::string(extra2) == std::string("boost_high")){ category_extra = "1 jet, high p_{T}"; }
if(std::string(extra2) == std::string("boost" )){ category_extra = "1 jet"; }
if(std::string(extra2) == std::string("vbf" )){ category_extra = "2 jet (VBF)"; }
if(std::string(extra2) == std::string("nobtag" )){ category_extra = "No B-Tag"; }
if(std::string(extra2) == std::string("btag" )){ category_extra = "B-Tag"; }
TFile* input = new TFile(inputfile);
TH1F* Fakes = refill((TH1F*)input->Get("Fakes" ), "Fakes/QCD");
TH1F* EWK = refill((TH1F*)input->Get("EWK" ), "EWK" );
TH1F* ttbar = refill((TH1F*)input->Get("ttbar" ), "ttbar" );
TH1F* Ztt = refill((TH1F*)input->Get("Ztt" ), "Ztt" );
TH1F* Zmm = refill((TH1F*)input->Get("Zmm" ), "Zmm" );
TH1F* ggH = refill((TH1F*)input->Get("ggH" ), "ggH" );
TH1F* data = (TH1F*)input->Get("data_obs");
// determine channel for etau Z->ee (EWK) will be shown separated from the rest (EWK1)
TH1F* EWK1 = 0;
if(std::string(extra) == std::string("e#tau_{h}")){
EWK1 = refill((TH1F*)input->Get("EWK1"), "EWK1");
}
TH1F* errorBand = (TH1F*)input->Get("errorBand");
/*
mass plot before and after fit
*/
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
if(log) canv->SetLogy(1);
// reduce the axis range if necessary for linea plots and SM
if(MSSM && !log){ data->GetXaxis()->SetRange(0, data->FindBin(350)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(490)); };
if(!MSSM){ data->GetXaxis()->SetRange(0, data->FindBin(350)); }
data->SetNdivisions(505);
data->SetMinimum(min);
if(Zmm){
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(EWK, log)));
}
else{
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log)));
}
data->Draw("e");
if(log){
if(Zmm){
EWK ->Draw("same");
ttbar->Draw("same");
Fakes->Draw("same");
Zmm ->Draw("same");
Ztt ->Draw("same");
}
else{
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
if(EWK1){
EWK1->Draw("same");
}
if(Fakes){ Fakes->Draw("same"); }
}
if(ggH) ggH ->Draw("histsame");
}
else{
if(ggH) ggH ->Draw("histsame");
if(Zmm){
EWK->Draw("same");
Fakes->Draw("same");
ttbar->Draw("same");
Zmm->Draw("same");
Ztt->Draw("same");
}
else{
Ztt ->Draw("same");
ttbar->Draw("same");
EWK ->Draw("same");
if(EWK1){
EWK1->Draw("same");
}
if(Fakes){ Fakes->Draw("same"); }
}
}
if(errorBand){
errorBand->Draw("e2same");
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, extra, 0.17, 0.835);
CMSPrelim(dataset, "", 0.18, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText(extra);
chan->Draw();
TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
if(MSSM){
TPaveText* massA = new TPaveText(0.75, 0.48+0.061, 0.85, 0.48+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m_{A}=160GeV");
massA->Draw();
TPaveText* tanb = new TPaveText(0.75, 0.44+0.061, 0.85, 0.44+0.161, "NDC");
tanb->SetBorderSize( 0 );
tanb->SetFillStyle( 0 );
tanb->SetTextAlign( 12 );
tanb->SetTextSize ( 0.03 );
tanb->SetTextColor( 1 );
tanb->SetTextFont ( 62 );
tanb->AddText("tan#beta=20");
tanb->Draw();
TPaveText* scen = new TPaveText(0.75, 0.40+0.061, 0.85, 0.40+0.161, "NDC");
scen->SetBorderSize( 0 );
scen->SetFillStyle( 0 );
scen->SetTextAlign( 12 );
scen->SetTextSize ( 0.03 );
scen->SetTextColor( 1 );
scen->SetTextFont ( 62 );
scen->AddText("mhmax");
scen->Draw();
}
float lower_bound = EWK1 ? 0.60 : 0.65;
TLegend* leg = new TLegend(MSSM ? 0.45 : 0.50, lower_bound, 0.93, 0.90);
SetLegendStyle(leg);
if(MSSM){
leg->AddEntry(ggH , "#phi#rightarrow#tau#tau", "L" );
}
else{
if(ggH){
if(SIGNAL_SCALE!=1){
leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" );
}
else{
leg->AddEntry(ggH , "H(125 GeV)#rightarrow#tau#tau" , "L" );
}
}
}
leg->AddEntry(data , "observed" , "LP");
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
if(Zmm){ leg->AddEntry(Zmm , "Z#rightarrow#mu#mu" , "F" ); }
if(EWK1){
leg->AddEntry(EWK , "Z#rightarrow ee" , "F" );
leg->AddEntry(EWK1 , "electroweak" , "F" );
}
else{
leg->AddEntry(EWK , "electroweak" , "F" );
}
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
if(Fakes){ leg->AddEntry(Fakes, "QCD" , "F" ); }
if(errorBand){
leg->AddEntry(errorBand, "bkg. uncertainty" , "F" );
}
leg->Draw();
/*
TPaveText* ext0 = new TPaveText(0.50, lower_bound-0.08, 0.70, lower_bound-0.03, "NDC");
ext0->SetBorderSize( 0 );
ext0->SetFillStyle( 0 );
ext0->SetTextAlign( 12 );
ext0->SetTextSize ( 0.035 );
ext0->SetTextColor( 1 );
ext0->SetTextFont ( 42 );
ext0->AddText("CMS Preliminary");
ext0->Draw();
TPaveText* ext1 = new TPaveText(0.50, lower_bound-0.13, 0.70, lower_bound-0.08, "NDC");
ext1->SetBorderSize( 0 );
ext1->SetFillStyle( 0 );
ext1->SetTextAlign( 12 );
ext1->SetTextSize ( 0.035 );
ext1->SetTextColor( 1 );
ext1->SetTextFont ( 42 );
ext1->AddText("#sqrt{s} = 7 TeV, L = 4.9 fb^{-1}");
ext1->Draw();
TPaveText* ext2 = new TPaveText(0.50, lower_bound-0.18, 0.70, lower_bound-0.13, "NDC");
ext2->SetBorderSize( 0 );
ext2->SetFillStyle( 0 );
ext2->SetTextAlign( 12 );
ext2->SetTextSize ( 0.035 );
ext2->SetTextColor( 1 );
ext2->SetTextFont ( 42 );
ext2->AddText("#sqrt{s} = 8 TeV, L = 19.4 fb^{-1}");
ext2->Draw();
TPaveText* ext3 = new TPaveText(0.50, lower_bound-0.23, 0.70, lower_bound-0.18, "NDC");
ext3->SetBorderSize( 0 );
ext3->SetFillStyle( 0 );
ext3->SetTextAlign( 12 );
ext3->SetTextSize ( 0.035 );
ext3->SetTextColor( 1 );
ext3->SetTextFont ( 42 );
ext3->AddText("H#rightarrow#tau#tau");
ext3->Draw();
*/
/*
prepare output
*/
std::string newName = std::string(inputfile).substr(0, std::string(inputfile).find(".root"));
//canv->Print(TString::Format("%s%s.png", newName.c_str(), log ? "_LOG" : ""));
//canv->Print(TString::Format("%s%s.pdf", newName.c_str(), log ? "_LOG" : ""));
//canv->Print(TString::Format("%s%s.eps", newName.c_str(), log ? "_LOG" : ""));
canv->Print(TString::Format("%s.png", newName.c_str()));
canv->Print(TString::Format("%s.pdf", newName.c_str()));
canv->Print(TString::Format("%s.eps", newName.c_str()));
}
void
HTT_MT_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., const char* inputfile="root/$HISTFILE", const char* directory="muTau_$CATEGORY")
{
// defining the common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category_extra = "";
if(std::string(directory) == std::string("muTau_0jet_low" )){ category_extra = "0 jet, low p_{T}"; }
if(std::string(directory) == std::string("muTau_0jet_high" )){ category_extra = "0 jet, high p_{T}"; }
if(std::string(directory) == std::string("muTau_boost_low" )){ category_extra = "1 jet, low p_{T}"; }
if(std::string(directory) == std::string("muTau_boost_high")){ category_extra = "1 jet, high p_{T}"; }
if(std::string(directory) == std::string("muTau_vbf" )){ category_extra = "2 jet (VBF)"; }
if(std::string(directory) == std::string("muTau_nobtag" )){ category_extra = "No B-Tag"; }
if(std::string(directory) == std::string("muTau_btag" )){ category_extra = "B-Tag"; }
const char* dataset;
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 4.9 fb^{-1} at 7 TeV";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 19.4 fb^{-1} at 8 TeV";}
#ifdef MSSM
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "CMS Preliminary, H#rightarrow#tau#tau, 12.1 fb^{-1} at 8 TeV";}
#endif
// open example histogram file
TFile* input = new TFile(inputfile);
TH1F* Fakes = refill((TH1F*)input->Get(TString::Format("%s/QCD" , directory)), "QCD"); InitHist(Fakes, "", "", kMagenta-10, 1001);
TH1F* EWK1 = refill((TH1F*)input->Get(TString::Format("%s/W" , directory)), "W" ); InitHist(EWK1 , "", "", kRed + 2, 1001);
#ifdef EXTRA_SAMPLES
TH1F* EWK2 = refill((TH1F*)input->Get(TString::Format("%s/ZJ" , directory)), "ZJ" ); InitHist(EWK2 , "", "", kRed + 2, 1001);
TH1F* EWK3 = refill((TH1F*)input->Get(TString::Format("%s/ZL" , directory)), "ZL" ); InitHist(EWK3 , "", "", kRed + 2, 1001);
#else
TH1F* EWK2 = refill((TH1F*)input->Get(TString::Format("%s/ZLL" , directory)), "ZLL"); InitHist(EWK2 , "", "", kRed + 2, 1001);
#endif
TH1F* EWK = refill((TH1F*)input->Get(TString::Format("%s/VV" , directory)), "VV" ); InitHist(EWK , "", "", kRed + 2, 1001);
TH1F* ttbar = refill((TH1F*)input->Get(TString::Format("%s/TT" , directory)), "TT" ); InitHist(ttbar, "", "", kBlue - 8, 1001);
TH1F* Ztt = refill((TH1F*)input->Get(TString::Format("%s/ZTT" , directory)), "ZTT"); InitHist(Ztt , "", "", kOrange - 4, 1001);
#ifdef MSSM
float ggHScale = 1., bbHScale = 1.; // scenario for MSSM, mhmax, mA=160, tanb=20, A + H for the time being
if(std::string(inputfile).find("7TeV")!=std::string::npos){ ggHScale = ( 9157.9*0.119 + 10180.7*0.120)/1000.;
bbHScale = (23314.3*0.119 + 21999.3*0.120)/1000.; }
if(std::string(inputfile).find("8TeV")!=std::string::npos){ ggHScale = (11815.3*0.119 + 13124.9*0.120)/1000.;
bbHScale = (31087.9*0.119 + 29317.8*0.120)/1000.; }
// float ggHScale = 1., bbHScale = 1.; // scenario for MSSM, mhmax, mA=160, tanb=10, A + H for the time being
// if(std::string(inputfile).find("7TeV")!=std::string::npos){ ggHScale = (2111.4*0.11 + 4022.9*0.11)/1000.;
// bbHScale = (6211.6*0.11 + 5147.0*0.11)/1000.; }
// if(std::string(inputfile).find("8TeV")!=std::string::npos){ ggHScale = (2729.9*0.11 + 5193.2*0.11)/1000.;
// bbHScale = (8282.7*0.11 + 6867.8*0.11)/1000.; }
TH1F* ggH = refill((TH1F*)input->Get(TString::Format("%s/ggH160", directory)), "ggH"); InitSignal(ggH); ggH ->Scale(ggHScale);
TH1F* bbH = refill((TH1F*)input->Get(TString::Format("%s/bbH160", directory)), "bbH"); InitSignal(bbH); bbH ->Scale(bbHScale);
#else
#ifndef DROP_SIGNAL
TH1F* ggH = refill((TH1F*)input->Get(TString::Format("%s/ggH125", directory)), "ggH"); InitSignal(ggH); ggH ->Scale(SIGNAL_SCALE);
TH1F* qqH = refill((TH1F*)input->Get(TString::Format("%s/qqH125", directory)), "qqH"); InitSignal(qqH); qqH ->Scale(SIGNAL_SCALE);
TH1F* VH = refill((TH1F*)input->Get(TString::Format("%s/VH125" , directory)), "VH" ); InitSignal(VH ); VH ->Scale(SIGNAL_SCALE);
#endif
#endif
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
InitHist(data, "#bf{m_{#tau#tau} [GeV]}", "#bf{dN/dm_{#tau#tau} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)Fakes->Clone("ref");
ref->Add(EWK1 );
ref->Add(EWK2 );
#ifdef EXTRA_SAMPLES
ref->Add(EWK3 );
#endif
ref->Add(EWK );
ref->Add(ttbar);
ref->Add(Ztt );
double unscaled[7];
unscaled[0] = Fakes->Integral();
unscaled[1] = EWK ->Integral();
unscaled[1]+= EWK1 ->Integral();
unscaled[1]+= EWK2 ->Integral();
#ifdef EXTRA_SAMPLES
unscaled[1]+= EWK3 ->Integral();
#endif
unscaled[2] = ttbar->Integral();
unscaled[3] = Ztt ->Integral();
#ifdef MSSM
unscaled[4] = ggH ->Integral();
unscaled[5] = bbH ->Integral();
unscaled[6] = 0;
#else
#ifndef DROP_SIGNAL
unscaled[4] = ggH ->Integral();
unscaled[5] = qqH ->Integral();
unscaled[6] = VH ->Integral();
#endif
#endif
if(scaled){
rescale(Fakes, 7);
rescale(EWK1 , 3);
rescale(EWK2 , 4);
#ifdef EXTRA_SAMPLES
rescale(EWK3 , 5);
#endif
rescale(EWK , 6);
rescale(ttbar, 2);
rescale(Ztt , 1);
#ifdef MSSM
rescale(ggH , 8);
rescale(bbH , 9);
#else
#ifndef DROP_SIGNAL
rescale(ggH , 8);
rescale(qqH , 9);
rescale(VH ,10);
#endif
#endif
}
TH1F* scales[7];
scales[0] = new TH1F("scales-Fakes", "", 7, 0, 7);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (Fakes->Integral()/unscaled[0]-1.) : 0.);
scales[1] = new TH1F("scales-EWK" , "", 7, 0, 7);
scales[1]->SetBinContent(2, unscaled[1]>0 ? ((EWK ->Integral()
+EWK1 ->Integral()
+EWK2 ->Integral()
#ifdef EXTRA_SAMPLES
+EWK3 ->Integral()
#endif
)/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-ttbar", "", 7, 0, 7);
scales[2]->SetBinContent(3, unscaled[2]>0 ? (ttbar->Integral()/unscaled[2]-1.) : 0.);
scales[3] = new TH1F("scales-Ztt" , "", 7, 0, 7);
scales[3]->SetBinContent(4, unscaled[3]>0 ? (Ztt ->Integral()/unscaled[3]-1.) : 0.);
#ifdef MSSM
scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.);
scales[5] = new TH1F("scales-bbH" , "", 7, 0, 7);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (bbH ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-NONE" , "", 7, 0, 7);
scales[6]->SetBinContent(7, 0.);
#else
#ifndef DROP_SIGNAL
scales[4] = new TH1F("scales-ggH" , "", 7, 0, 7);
scales[4]->SetBinContent(5, unscaled[4]>0 ? (ggH ->Integral()/unscaled[4]-1.) : 0.);
scales[5] = new TH1F("scales-qqH" , "", 7, 0, 7);
scales[5]->SetBinContent(6, unscaled[5]>0 ? (qqH ->Integral()/unscaled[5]-1.) : 0.);
scales[6] = new TH1F("scales-VH" , "", 7, 0, 7);
scales[6]->SetBinContent(7, unscaled[6]>0 ? (VH ->Integral()/unscaled[6]-1.) : 0.);
#endif
#endif
EWK1 ->Add(Fakes);
EWK2 ->Add(EWK1 );
#ifdef EXTRA_SAMPLES
EWK3 ->Add(EWK2 );
EWK ->Add(EWK3 );
#else
EWK ->Add(EWK2 );
#endif
ttbar->Add(EWK );
Ztt ->Add(ttbar);
if(log){
#ifdef MSSM
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
else{
#ifdef MSSM
bbH ->Add(Ztt);
ggH ->Add(bbH);
#else
#ifndef DROP_SIGNAL
VH ->Add(Ztt);
qqH ->Add(VH );
ggH ->Add(qqH);
#endif
#endif
}
/*
Mass plot before and after fit
*/
TCanvas *canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(350)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(1000)); };
#else
data->GetXaxis()->SetRange(0, data->FindBin(350));
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(Ztt, log)));
data->Draw("e");
TH1F* errorBand = (TH1F*)Ztt ->Clone();
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(1);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
for(int idx=0; idx<errorBand->GetNbinsX(); ++idx){
if(errorBand->GetBinContent(idx)>0){
std::cout << "Uncertainties on summed background samples: " << errorBand->GetBinError(idx)/errorBand->GetBinContent(idx) << std::endl;
break;
}
}
if(log){
Ztt ->Draw("histsame");
ttbar->Draw("histsame");
EWK ->Draw("histsame");
Fakes->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
ggH ->Draw("histsame");
#endif
}
else{
#ifndef DROP_SIGNAL
ggH ->Draw("histsame");
#endif
Ztt ->Draw("histsame");
ttbar->Draw("histsame");
EWK ->Draw("histsame");
Fakes->Draw("histsame");
$DRAW_ERROR
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "#tau_{#mu}#tau_{h}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.16, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText("#mu#tau_{h}");
chan->Draw();
TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
#ifdef MSSM
TPaveText* massA = new TPaveText(0.75, 0.48+0.061, 0.85, 0.48+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m_{A}=160GeV");
massA->Draw();
TPaveText* tanb = new TPaveText(0.75, 0.44+0.061, 0.85, 0.44+0.161, "NDC");
tanb->SetBorderSize( 0 );
tanb->SetFillStyle( 0 );
tanb->SetTextAlign( 12 );
tanb->SetTextSize ( 0.03 );
tanb->SetTextColor( 1 );
tanb->SetTextFont ( 62 );
tanb->AddText("tan#beta=20");
tanb->Draw();
TPaveText* scen = new TPaveText(0.75, 0.40+0.061, 0.85, 0.40+0.161, "NDC");
scen->SetBorderSize( 0 );
scen->SetFillStyle( 0 );
scen->SetTextAlign( 12 );
scen->SetTextSize ( 0.03 );
scen->SetTextColor( 1 );
scen->SetTextFont ( 62 );
scen->AddText("mhmax");
scen->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.45, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
leg->AddEntry(ggH , "#phi#rightarrow#tau#tau" , "L" );
#else
TLegend* leg = new TLegend(0.50, 0.65, 0.95, 0.90);
SetLegendStyle(leg);
#ifndef DROP_SIGNAL
if(SIGNAL_SCALE!=1){
leg->AddEntry(ggH , TString::Format("%.0f#timesH(125 GeV)#rightarrow#tau#tau", SIGNAL_SCALE) , "L" );
}
else{
leg->AddEntry(ggH , "H(125 GeV)#rightarrow#tau#tau" , "L" );
}
#endif
#endif
leg->AddEntry(data , "observed" , "LP");
leg->AddEntry(Ztt , "Z#rightarrow#tau#tau" , "F" );
leg->AddEntry(ttbar, "t#bar{t}" , "F" );
leg->AddEntry(EWK , "electroweak" , "F" );
leg->AddEntry(Fakes, "QCD" , "F" );
$ERROR_LEGEND
leg->Draw();
//#ifdef MSSM
// TPaveText* mssm = new TPaveText(0.69, 0.85, 0.90, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("(m_{A}=120, tan#beta=10)");
// mssm->Draw();
//#else
// TPaveText* mssm = new TPaveText(0.83, 0.85, 0.95, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("m_{H}=125");
// mssm->Draw();
//#endif
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* zero = (TH1F*)ref->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat");
rat1->Divide(Ztt);
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
zero->SetBinContent(ibin+1, 0.);
}
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+0.5);
rat1->SetMinimum(-0.5);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat1->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv0->RedrawAxis();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
TH1F* rat2 = (TH1F*) Ztt->Clone("rat2");
rat2->Divide(ref);
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
rat2->SetLineColor(kRed+ 3);
rat2->SetFillColor(kRed-10);
rat2->SetMaximum(+0.3);
rat2->SetMinimum(-0.3);
rat2->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
rat2->GetXaxis()->SetTitle("#bf{m_{#tau#tau} [GeV]}");
rat2->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[0], "", "", kMagenta-10, 1001);
InitHist (scales[1], "", "", kRed + 2, 1001);
InitHist (scales[2], "", "", kBlue - 8, 1001);
InitHist (scales[3], "", "", kOrange - 4, 1001);
#ifndef DROP_SIGNAL
InitSignal(scales[4]);
InitSignal(scales[5]);
InitSignal(scales[6]);
#endif
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{Fakes}");
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{EWK}" );
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{ttbar}");
scales[0]->GetXaxis()->SetBinLabel(4, "#bf{Ztt}" );
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{bbH}" );
scales[0]->GetXaxis()->SetBinLabel(7, "NONE" );
#else
scales[0]->GetXaxis()->SetBinLabel(5, "#bf{ggH}" );
scales[0]->GetXaxis()->SetBinLabel(6, "#bf{qqH}" );
scales[0]->GetXaxis()->SetBinLabel(7, "#bf{VH}" );
#endif
scales[0]->SetMaximum(+1.0);
scales[0]->SetMinimum(-1.0);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
scales[1]->Draw("same");
scales[2]->Draw("same");
scales[3]->Draw("same");
#ifndef DROP_SIGNAL
scales[4]->Draw("same");
scales[5]->Draw("same");
scales[6]->Draw("same");
#endif
zero->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sscaled_%s_%s.png" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.pdf" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.eps" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
TFile* output = new TFile(TString::Format("%s_%sscaled_%s_%s.root", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""), "update");
output->cd();
data ->Write("data_obs");
Fakes->Write("Fakes" );
EWK ->Write("EWK" );
ttbar->Write("ttbar" );
Ztt ->Write("Ztt" );
#ifdef MSSM
ggH ->Write("ggH" );
bbH ->Write("bbH" );
#else
#ifndef DROP_SIGNAL
ggH ->Write("ggH" );
qqH ->Write("qqH" );
VH ->Write("VH" );
#endif
#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
}
void
HBB_LEP_X(bool scaled=true, bool log=true, float min=0.1, float max=-1., const char* inputfile="root/$HISTFILE", const char* directory="bb_$CATEGORY")
{
// define common canvas, axes pad styles
SetStyle(); gStyle->SetLineStyleString(11,"20 10");
// determine category tag
const char* category_extra = "";
if(std::string(directory) == std::string("bb_had0" )){ category_extra = "all-had_{0}"; }
if(std::string(directory) == std::string("bb_had1" )){ category_extra = "all-had_{1}"; }
if(std::string(directory) == std::string("bb_had2" )){ category_extra = "all-had_{2}"; }
if(std::string(directory) == std::string("bb_had3" )){ category_extra = "all-had_{3}"; }
if(std::string(directory) == std::string("bb_had4" )){ category_extra = "all-had_{4}"; }
if(std::string(directory) == std::string("bb_had5" )){ category_extra = "all-had_{5}"; }
if(std::string(directory) == std::string("bb_lep" )){ category_extra = "semi-lep"; }
const char* dataset;
if(std::string(inputfile).find("7TeV")!=std::string::npos){dataset = "Preliminary, #sqrt{s} = 7 TeV, L = 4.8 fb^{-1}";}
if(std::string(inputfile).find("8TeV")!=std::string::npos){dataset = "Preliminary, #sqrt{s} = 8 TeV, L = 19.4 fb^{-1}";}
TFile* input = new TFile(inputfile);
TH1F* bkgBBB = refill((TH1F*)input->Get(TString::Format("%s/bkgBBB" , directory)), "bkgBBB"); InitHist(bkgBBB, "", "", kMagenta-10, 1001);;
#ifdef MSSM
float bbHScale = 1.; // scenario for MSSM, mhmax, mA=160, tanb=20, A+H for the time being
if(std::string(inputfile).find("7TeV")!=std::string::npos){ bbHScale = (23314.3*0.879 + 21999.3*0.877)/1000.; }
if(std::string(inputfile).find("8TeV")!=std::string::npos){ bbHScale = (31087.9*0.879 + 29317.8*0.877)/1000.; }
// float bbHScale = 1.; // scenario for MSSM, mhmax, mA=160, tanb=10, A+H for the time being
// if(std::string(inputfile).find("7TeV")!=std::string::npos){ bbHScale = (6211.6*0.89 + 5145.0*0.85)/1000.; }
// if(std::string(inputfile).find("8TeV")!=std::string::npos){ bbHScale = (8282.7*0.89 + 6867.8*0.85)/1000.; }
TH1F* bbH = refill((TH1F*)input->Get(TString::Format("%s/bbH160" , directory)), "bbH" ); InitSignal(bbH); bbH->Scale(bbHScale);
#endif
TH1F* data = refill((TH1F*)input->Get(TString::Format("%s/data_obs", directory)), "data", true);
InitHist(data, "#bf{m_{b#bar{b}} [GeV]}", "#bf{dN/dm_{b#bar{b}} [1/GeV]}"); InitData(data);
TH1F* ref=(TH1F*)bkgBBB->Clone("ref");
double unscaled[7];
unscaled[0] = bkgBBB ->Integral();
#ifdef MSSM
unscaled[1] = bbH ->Integral();
unscaled[2] = 0;
#endif
if(scaled){
rescale(bkgBBB, 1);
#ifdef MSSM
rescale(bbH, 2);
#endif
}
TH1F* scales[7];
scales[0] = new TH1F("scales-bkgBBB", "", 3, 0, 3);
scales[0]->SetBinContent(1, unscaled[0]>0 ? (bkgBBB ->Integral()/unscaled[0]-1.) : 0.);
#ifdef MSSM
scales[1] = new TH1F("scales-bbH" , "", 3, 0, 3);
scales[1]->SetBinContent(2, unscaled[1]>0 ? (bbH ->Integral()/unscaled[1]-1.) : 0.);
scales[2] = new TH1F("scales-NONE" , "", 3, 0, 3);
scales[2]->SetBinContent(3, 0.);
#endif
if(!log){
#ifdef MSSM
bbH ->Add(bkgBBB);
#endif
}
/*
mass plot before and after fit
*/
TCanvas* canv = MakeCanvas("canv", "histograms", 600, 600);
canv->cd();
if(log){ canv->SetLogy(1); }
#if defined MSSM
if(!log){ data->GetXaxis()->SetRange(0, data->FindBin(350)); } else{ data->GetXaxis()->SetRange(0, data->FindBin(1000)); };
#endif
data->SetNdivisions(505);
data->SetMinimum(min);
data->SetMaximum(max>0 ? max : std::max(maximum(data, log), maximum(bkgBBB, log)));
data->Draw("e");
TH1F* errorBand = (TH1F*)bkgBBB ->Clone();
errorBand ->SetMarkerSize(0);
errorBand ->SetFillColor(1);
errorBand ->SetFillStyle(3013);
errorBand ->SetLineWidth(1);
if(log){
bkgBBB ->Draw("histsame");
$DRAW_ERROR
#ifndef DROP_SIGNAL
bbH ->Draw("histsame");
#endif
}
else{
#ifndef DROP_SIGNAL
bbH ->Draw("histsame");
#endif
bkgBBB ->Draw("histsame");
$DRAW_ERROR
}
data->Draw("esame");
canv->RedrawAxis();
//CMSPrelim(dataset, "b#bar{b}", 0.17, 0.835);
CMSPrelim(dataset, "", 0.17, 0.835);
TPaveText* chan = new TPaveText(0.20, 0.74+0.061, 0.32, 0.74+0.161, "NDC");
chan->SetBorderSize( 0 );
chan->SetFillStyle( 0 );
chan->SetTextAlign( 12 );
chan->SetTextSize ( 0.05 );
chan->SetTextColor( 1 );
chan->SetTextFont ( 62 );
chan->AddText("b#bar{b}");
chan->Draw();
TPaveText* cat = new TPaveText(0.20, 0.68+0.061, 0.32, 0.68+0.161, "NDC");
cat->SetBorderSize( 0 );
cat->SetFillStyle( 0 );
cat->SetTextAlign( 12 );
cat->SetTextSize ( 0.05 );
cat->SetTextColor( 1 );
cat->SetTextFont ( 62 );
cat->AddText(category_extra);
cat->Draw();
#ifdef MSSM
TPaveText* massA = new TPaveText(0.75, 0.48+0.061, 0.85, 0.48+0.161, "NDC");
massA->SetBorderSize( 0 );
massA->SetFillStyle( 0 );
massA->SetTextAlign( 12 );
massA->SetTextSize ( 0.03 );
massA->SetTextColor( 1 );
massA->SetTextFont ( 62 );
massA->AddText("m_{A}=160GeV");
massA->Draw();
TPaveText* tanb = new TPaveText(0.75, 0.44+0.061, 0.85, 0.44+0.161, "NDC");
tanb->SetBorderSize( 0 );
tanb->SetFillStyle( 0 );
tanb->SetTextAlign( 12 );
tanb->SetTextSize ( 0.03 );
tanb->SetTextColor( 1 );
tanb->SetTextFont ( 62 );
tanb->AddText("tan#beta=20");
tanb->Draw();
TPaveText* scen = new TPaveText(0.75, 0.40+0.061, 0.85, 0.40+0.161, "NDC");
scen->SetBorderSize( 0 );
scen->SetFillStyle( 0 );
scen->SetTextAlign( 12 );
scen->SetTextSize ( 0.03 );
scen->SetTextColor( 1 );
scen->SetTextFont ( 62 );
scen->AddText("mhmax");
scen->Draw();
#endif
#ifdef MSSM
TLegend* leg = new TLegend(0.55, 0.65, 0.94, 0.90);
SetLegendStyle(leg);
leg->AddEntry(bbH , "#phi#rightarrowb#bar{b}" , "L" );
#endif
leg->AddEntry(data, "observed" , "LP");
leg->AddEntry(bkgBBB, "bkgBBB" , "F" );
$ERROR_LEGEND
leg->Draw();
//#ifdef MSSM
// TPaveText* mssm = new TPaveText(0.69, 0.85, 0.90, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("(m_{A}=250, tan#beta=5)");
// mssm->Draw();
//#else
// TPaveText* mssm = new TPaveText(0.83, 0.85, 0.95, 0.90, "NDC");
// mssm->SetBorderSize( 0 );
// mssm->SetFillStyle( 0 );
// mssm->SetTextAlign( 12 );
// mssm->SetTextSize ( 0.03 );
// mssm->SetTextColor( 1 );
// mssm->SetTextFont ( 62 );
// mssm->AddText("m_{H}=125");
// mssm->Draw();
//#endif
/*
Ratio Data over MC
*/
TCanvas *canv0 = MakeCanvas("canv0", "histograms", 600, 400);
canv0->SetGridx();
canv0->SetGridy();
canv0->cd();
TH1F* zero = (TH1F*)ref ->Clone("zero"); zero->Clear();
TH1F* rat1 = (TH1F*)data->Clone("rat");
rat1->Divide(bkgBBB);
for(int ibin=0; ibin<rat1->GetNbinsX(); ++ibin){
if(rat1->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat1->SetBinContent(ibin+1, rat1->GetBinContent(ibin+1)-1.);
}
zero->SetBinContent(ibin+1, 0.);
}
rat1->SetLineColor(kBlack);
rat1->SetFillColor(kGray );
rat1->SetMaximum(+1.5);
rat1->SetMinimum(-1.5);
rat1->GetYaxis()->CenterTitle();
rat1->GetYaxis()->SetTitle("#bf{Data/MC-1}");
rat1->GetXaxis()->SetTitle("#bf{m_{b#bar{b}} [GeV]}");
rat1->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv0->RedrawAxis();
/*
Ratio After fit over Prefit
*/
TCanvas *canv1 = MakeCanvas("canv1", "histograms", 600, 400);
canv1->SetGridx();
canv1->SetGridy();
canv1->cd();
TH1F* rat2 = (TH1F*) bkgBBB->Clone("rat2");
rat2->Divide(ref);
for(int ibin=0; ibin<rat2->GetNbinsX(); ++ibin){
if(rat2->GetBinContent(ibin+1)>0){
// catch cases of 0 bins, which would lead to 0-alpha*0-1
rat2 ->SetBinContent(ibin+1, rat2->GetBinContent(ibin+1)-1.);
}
}
rat2->SetLineColor(kRed+ 3);
rat2->SetFillColor(kRed-10);
rat2->SetMaximum(+0.3);
rat2->SetMinimum(-0.3);
rat2->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
rat2->GetYaxis()->CenterTitle();
rat2->GetXaxis()->SetTitle("#bf{m_{b#bar{b}} [GeV]}");
rat2->GetXaxis()->SetRange(0, 28);
rat2->Draw();
zero->SetLineColor(kBlack);
zero->Draw("same");
canv1->RedrawAxis();
/*
Relative shift per sample
*/
TCanvas *canv2 = MakeCanvas("canv2", "histograms", 600, 400);
canv2->SetGridx();
canv2->SetGridy();
canv2->cd();
InitHist (scales[0], "", "", kMagenta-10, 1001);
scales[0]->Draw();
scales[0]->GetXaxis()->SetBinLabel(1, "#bf{bkgBBB}");
#ifdef MSSM
scales[0]->GetXaxis()->SetBinLabel(2, "#bf{bbH}" );
scales[0]->GetXaxis()->SetBinLabel(3, "#bf{NONE}" );
#endif
scales[0]->SetMaximum(+1.0);
scales[0]->SetMinimum(-1.0);
scales[0]->GetYaxis()->CenterTitle();
scales[0]->GetYaxis()->SetTitle("#bf{Fit/Prefit-1}");
zero->Draw("same");
canv2->RedrawAxis();
/*
prepare output
*/
bool isSevenTeV = std::string(inputfile).find("7TeV")!=std::string::npos;
canv ->Print(TString::Format("%s_%sscaled_%s_%s.png" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.pdf" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv ->Print(TString::Format("%s_%sscaled_%s_%s.eps" , directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv0->Print(TString::Format("%s_datamc_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv1->Print(TString::Format("%s_prefit_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.png", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.pdf", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
canv2->Print(TString::Format("%s_sample_%sscaled_%s_%s.eps", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""));
TFile* output = new TFile(TString::Format("%s_%sscaled_%s_%s.root", directory, scaled ? "re" : "un", isSevenTeV ? "7TeV" : "8TeV", log ? "LOG" : ""), "update");
output->cd();
data ->Write("data_obs");
bkgBBB ->Write("bkgBBB" );
#ifdef MSSM
bbH ->Write("bbH" );
#endif
if(errorBand){
errorBand->Write("errorBand");
}
output->Close();
}
