// show the histogram in first slot, try a Gaussian fit with given parameters
void PRadHistCanvas::UpdateHist(int index, TObject *tob, int range_min, int range_max)
{
--index;
if(index < 0 || index >= canvases.size())
return;
canvases[index]->cd();
canvases[index]->SetGrid();
gPad->SetLogy();
TH1 *hist = (TH1*)tob;
hist->GetXaxis()->SetRangeUser(hist->FindFirstBinAbove(0,1) - 10,
hist->FindLastBinAbove(0,1) + 10);
hist->GetXaxis()->SetLabelSize(HIST_LABEL_SIZE);
hist->GetYaxis()->SetLabelSize(HIST_LABEL_SIZE);
// try to fit gaussian in certain range
if(range_max > range_min
&& hist->Integral(range_min, range_max + 1) > 0)
{
TF1 *fit = new TF1("", "gaus", range_min, range_max);
fit->SetLineColor(kRed);
fit->SetLineWidth(2);
hist->Fit(fit,"qlR");
}
hist->SetFillColor(fillColors[index]);
hist->Draw();
canvases[index]->Refresh();
}
void plotComparison(TFile **input, const string &title, const bool &reverse_order = false)
{
TH1 *qcd = merge("htlep", input, 0, QCD_CHANNELS);
TH1 *ttjets = get("htlep", input[TTJETS], TTJETS);
TH1 *zjets = get("htlep", input[ZJETS], ZJETS);
TH1 *wjets = get("htlep", input[WJETS], WJETS);
TH1 *data = merge("htlep", input, RERECO, RERECO + DATA_CHANNELS);
data->SetFillColor(0);
THStack *stack = new THStack();
stack->Add(qcd);
stack->Add(ttjets);
stack->Add(zjets);
stack->Add(wjets);
if (reverse_order)
{
stack->Draw("h");
data->Draw("h same");
}
else
{
data->Draw("h");
stack->Draw("h same");
}
TLegend *legend = createLegend(title.c_str());
legend->Draw();
}
/**
SetColor/Style Histo
*/
void SetColorAndStyleHisto(TH1 & histo , EColor color){
histo.SetFillColor (color) ;
histo.SetLineColor (color) ;
histo.SetMarkerColor (color) ;
histo.SetMarkerSize (1) ;
histo.SetMarkerStyle (20) ;
}
void parallelMergeClient()
{
// Client program which creates and fills 2 histograms and a TTree.
// Every 1000000 fills the histograms and TTree is send to the server which displays the histogram.
//
// To run this demo do the following:
// - Open at least 2 windows
// - Start ROOT in the first windows
// - Execute in the first window: .x fastMergeServer.C
// - Execute in the other windows: root.exe -b -l -q .x treeClient.C
// (You can put it in the background if wanted).
// If you want to run the hserv.C on a different host, just change
// "localhost" in the TSocket ctor below to the desired hostname.
//
//Author: Fons Rademakers, Philippe Canal
gBenchmark->Start("treeClient");
TParallelMergingFile *file = (TParallelMergingFile*)TFile::Open("mergedClient.root?pmerge=localhost:1095","RECREATE");
file->Write();
file->UploadAndReset(); // We do this early to get assigned an index.
UInt_t idx = file->fServerIdx; // This works on in ACLiC.
TH1 *hpx;
if (idx == 0) {
// Create the histogram
hpx = new TH1F("hpx","This is the px distribution",100,-4,4);
hpx->SetFillColor(48); // set nice fillcolor
} else {
hpx = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
}
Float_t px, py;
TTree *tree = new TTree("tree","tree");
tree->SetAutoFlush(4000000);
tree->Branch("px",&px);
tree->Branch("py",&py);
// Fill histogram randomly
gRandom->SetSeed();
const int kUPDATE = 1000000;
for (int i = 0; i < 25000000; ) {
gRandom->Rannor(px,py);
if (idx%2 == 0)
hpx->Fill(px);
else
hpx->Fill(px,py);
tree->Fill();
++i;
if (i && (i%kUPDATE) == 0) {
file->Write();
}
}
file->Write();
delete file;
gBenchmark->Show("treeClient");
}
void plotter::draw_delta(TH1* hist_, TString file_name){
TH1* hist = (TH1*) hist_->Clone("hist");
TCanvas *c= new TCanvas("Particle Level","",600,600);
gPad->SetLeftMargin(0.15);
hist->SetTitle(file_name);
hist->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
hist->GetYaxis()->SetTitle("#Delta events");
hist->GetYaxis()->SetTitleOffset(1.5);
hist->GetYaxis()->SetNdivisions(505);
hist->SetFillColor(810);
hist->SetLineColor(810);
hist->Draw("HIST");
gPad->RedrawAxis();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
void histogramStyle(TH1& hist, int color, int lineStyle, int markerStyle, float markersize, int filled)
{
hist.SetLineWidth(3);
hist.SetStats(kFALSE);
hist.SetLineColor (color);
hist.SetMarkerColor(color);
hist.SetMarkerStyle(markerStyle);
hist.SetMarkerSize(markersize);
hist.SetLineStyle(lineStyle);
if(filled==1){
hist.SetFillStyle(1001);
hist.SetFillColor(color);
}
else{
hist.SetFillStyle(0);
}
}
void format1Dhisto(TH1& h1, double Ymax, double Ymin, double& col, double& fill, double& style, const char* titx, const char* tity ){
//void format1Dhisto(TH1& h1, string& xTitle, double Ymax, double Ymin){
//h1.SetTitle(";XXXX;XXXX");
if(Ymax!=-1 && Ymin!=-1) h1.GetYaxis()->SetRangeUser(Ymax, Ymin);
//if(Ymax==-1 && Ymin!=-1) h1.GetYaxis()->SetMinimum(Ymin);
h1.SetMarkerColor(col);
h1.SetMarkerStyle();
h1.SetMarkerColor();
h1.SetLineColor(col);
h1.SetFillColor(fill);
h1.SetFillStyle(style);
h1.GetXaxis()->SetTitle(titx);
h1.GetYaxis()->SetTitle(tity);
h1.GetXaxis()->CenterTitle();
h1.GetYaxis()->CenterTitle();
//cout<<"The title is : "<<tit<<endl;
return;
}
void plotter::draw_delta_comparison( TH1* total_, TH1* stat_, std::vector<TH1*> MODEL_DELTA, std::vector<TString> UncertNames, TString category, TString file_name){
TH1* total = (TH1*) total_->Clone();
TH1* stat = (TH1*) stat_->Clone();
std::vector<TH1*> delta;
for(unsigned int i=0; i<MODEL_DELTA.size(); i++){
delta.push_back( (TH1*) MODEL_DELTA[i]->Clone() );
}
TCanvas *c= new TCanvas("c","",600,600);
gPad->SetLeftMargin(0.15);
total->SetTitle("");
total->GetXaxis()->SetTitle("Leading-jet mass [GeV]");
total->GetYaxis()->SetTitle("relative uncertainty [%]");
total->GetYaxis()->SetTitleOffset(1.5);
total->GetYaxis()->SetNdivisions(505);
total->GetYaxis()->SetRangeUser(0, 100);
total->SetFillColor(13);
total->SetFillStyle(3144);
total->SetLineColor(13);
total->SetMarkerStyle(-1);
total->Draw("HIST");
stat->SetLineColor(kBlack);
stat->SetLineWidth(4);
stat->SetMarkerStyle(0);
stat->Draw("B SAME");
Color_t col[] = {kRed-4, kAzure+7, kGreen, 798, kBlue, kOrange-3, kMagenta, kYellow, kAzure, 14, kRed+5, kGreen-8};
int i=0;
for(auto hist: delta){
gPad->SetLeftMargin(0.15);
hist->SetLineColor(col[i]);
hist->SetLineWidth(4);
hist->SetMarkerStyle(0);
hist->Draw("B SAME");
i++;
}
// LEGEND
TLegend *leg = new TLegend(0.4,0.6,0.88,0.88);
leg->SetFillStyle(0);
leg->SetNColumns(2);
if(category == "exp") leg->AddEntry(total, "stat #oplus exp. sys", "f");
else if(category == "model") leg->AddEntry(total, "stat #oplus model sys", "f");
leg->AddEntry(stat, "stat", "l");
for(unsigned int i=0; i<delta.size(); i++){
if (UncertNames[i] == "mass") leg->AddEntry(delta[i],"choice of m_{t}","l");
else if (UncertNames[i] == "stat") leg->AddEntry(delta[i],"statistics","l");
else if (UncertNames[i] == "b-tagging") leg->AddEntry(delta[i],"b tagging","l");
else if (UncertNames[i] == "pile-up") leg->AddEntry(delta[i],"pileup","l");
else if (UncertNames[i] == "jec") leg->AddEntry(delta[i],"jet energy scale","l");
else if (UncertNames[i] == "jer") leg->AddEntry(delta[i],"jet energy resolution","l");
else if (UncertNames[i] == "cor") leg->AddEntry(delta[i],"XCone jet correction","l");
else if (UncertNames[i] == "MuTrigger") leg->AddEntry(delta[i],"muon trigger","l");
else if (UncertNames[i] == "MuID") leg->AddEntry(delta[i],"muon ID","l");
else if (UncertNames[i] == "ElTrigger") leg->AddEntry(delta[i],"electron trigger","l");
else if (UncertNames[i] == "ElID") leg->AddEntry(delta[i],"electron ID","l");
else if (UncertNames[i] == "ElReco") leg->AddEntry(delta[i],"electron reconstruction","l");
else if (UncertNames[i] == "hdamp") leg->AddEntry(delta[i],"h_{damp}","l");
else leg->AddEntry(delta[i],UncertNames[i],"l");
}
leg->Draw();
gPad->RedrawAxis();
c->SaveAs(directory + file_name + ".pdf");
delete c;
}
void plot(int mass) {
double myQCDRelUncert = 0.038;
double myEWKRelUncert = 0.131;
double myFakesRelUncert = 0.238;
double delta = 1.4;
double br = 0.05;
bool debug = false;
bool log = false;
double ymin = 0.001;
double ymax = 48;
static bool bMessage = false;
if (!bMessage) {
cout << "Values used as relative uncertainty (please check):" << endl;
cout << " QCD: " << myQCDRelUncert << endl;
cout << " EWK genuine tau: " << myEWKRelUncert << endl;
cout << " EWK fake tau: " << myFakesRelUncert << endl << endl;
bMessage = true;
}
cout << "Processing mass point: " << mass << " GeV/c2" << endl;
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
gStyle->SetTitleFont(43, "xyz");
gStyle->SetTitleSize(33, "xyz");
gStyle->SetLabelFont(43, "xyz");
gStyle->SetLabelSize(27, "xyz");
//std::string infile = "EPS_data_nodeltaphi/hplus_100.root";
//std::string infile = "EPS_data_deltaphi160/hplus_100.root";
std::stringstream s;
s << "lands_histograms_hplushadronic_m" << mass << ".root";
std::string infile = s.str();
// Canvas
TCanvas *myCanvas = new TCanvas("myCanvas", "",0,0,600,600);
myCanvas->SetHighLightColor(2);
myCanvas->Range(0,0,1,1);
myCanvas->SetFillColor(0);
myCanvas->SetBorderMode(0);
myCanvas->SetBorderSize(2);
if (log)
myCanvas->SetLogy();
myCanvas->SetTickx(1);
myCanvas->SetTicky(1);
myCanvas->SetLeftMargin(0.16);
myCanvas->SetRightMargin(0.05);
myCanvas->SetTopMargin(0.05);
myCanvas->SetBottomMargin(0.08);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->SetFrameFillStyle(0);
myCanvas->SetFrameBorderMode(0);
myCanvas->cd();
Int_t ci;
TFile* f = TFile::Open(infile.c_str());
s.str("");
s << "HW" << mass << "_1";
TH1* hw = (TH1*)f->Get(s.str().c_str());
s.str("");
s << "HH" << mass << "_1";
TH1* hh = (TH1*)f->Get(s.str().c_str());
TH1* data = (TH1*)f->Get("data_obs");
data->SetLineWidth(2);
data->SetMarkerStyle(20);
data->SetMarkerSize(1.2);
TH1* ewktau = (TH1*)f->Get("EWK_Tau");
ci = TColor::GetColor("#993399");
ewktau->SetFillColor(ci);
ewktau->SetLineWidth(0);
TH1* ewkDY = (TH1*)f->Get("EWK_DYx");
TH1* ewkVV = (TH1*)f->Get("EWK_VVx");
ewktau->Add(ewkDY);
ewktau->Add(ewkVV);
//TH1* qcd = (TH1*)f->Get("QCDInv");
TH1* qcd = (TH1*)f->Get("QCD");
ci = TColor::GetColor("#ffcc33");
qcd->SetFillColor(ci);
qcd->SetLineWidth(0);
TH1* fakett = (TH1*)f->Get("fake_tt");
ci = TColor::GetColor("#669900");
fakett->SetFillColor(ci);
fakett->SetLineWidth(0);
TH1* fakeW = (TH1*)f->Get("fake_W");
ci = TColor::GetColor("#cc3300");
fakeW->SetFillColor(ci);
fakeW->SetLineWidth(0);
TH1* faket = (TH1*)f->Get("fake_t");
TH1F *hFrame = new TH1F("hFrame","",20,0,400);
hFrame->SetMinimum(ymin);
if (log)
hFrame->SetMaximum(ymax*1.5);
else
hFrame->SetMaximum(ymax);
hFrame->SetDirectory(0);
hFrame->SetStats(0);
hFrame->SetLineStyle(0);
hFrame->SetMarkerStyle(20);
hFrame->SetXTitle("Transverse mass (#tau jet, E_{T}^{miss}), (GeV/c^{2})");
if (paperStatus)
hFrame->SetXTitle("Transverse mass (#tau_{h}, E_{T}^{miss}), (GeV/c^{2})");
hFrame->SetYTitle("Events / 20 GeV/c^{2}");
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(27);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// signal
hh->Scale(br*br);
hw->Scale(2*br*(1.0-br));
TH1* signal = (TH1*)hh->Clone();
signal->Add(hw);
ci = TColor::GetColor("#ff3399");
signal->SetLineColor(ci);
signal->SetLineStyle(2);
signal->SetLineWidth(2);
// Fakes
TH1* fakes = (TH1*)(fakett->Clone());
fakes->Add(fakeW);
fakes->Add(faket);
// stacked backgrounds
THStack *exp = new THStack();
exp->SetName("exp");
exp->SetTitle("exp");
exp->Add(fakes);
exp->Add(ewktau);
exp->Add(qcd);
exp->Add(signal);
TH1* hExpBkg = (TH1*)fakes->Clone();
hExpBkg->Add(ewktau);
hExpBkg->Add(qcd);
// uncertainty
TH1* uncert = (TH1*)fakeW->Clone();
uncert->Add(fakett);
uncert->Add(ewktau);
uncert->Add(qcd);
uncert->SetFillColor(1);
uncert->SetFillStyle(3344);
uncert->SetLineColor(0);
uncert->SetLineStyle(0);
uncert->SetLineWidth(0);
TH1* hExpBkgTotalUncert = (TH1*)uncert->Clone();
hExpBkgTotalUncert->SetFillStyle(3354);
TH1* hAgreement = (TH1*)data->Clone();
hAgreement->Divide(hExpBkg);
TGraphErrors* hAgreementRelUncert = new TGraphErrors(hAgreement->GetNbinsX());
hAgreementRelUncert->SetLineWidth(2);
hAgreementRelUncert->SetLineColor(kBlack);
for (int i = 1; i <= hFrame->GetNbinsX(); ++i) {
double myQCDTotalUncert = TMath::Power(qcd->GetBinError(i), 2)
+ TMath::Power(qcd->GetBinContent(i)*myQCDRelUncert, 2);
double myEWKTotalUncert = TMath::Power(ewktau->GetBinError(i), 2)
+ TMath::Power(ewktau->GetBinContent(i)*myEWKRelUncert, 2);
double myFakesTotalUncert = TMath::Power(fakes->GetBinError(i), 2)
+ TMath::Power(fakes->GetBinContent(i)*myFakesRelUncert, 2);
hExpBkgTotalUncert->SetBinError(i, TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert));
if (hExpBkg->GetBinContent(i) > 0) {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), data->GetBinContent(i) / hExpBkg->GetBinContent(i));
double myUncertData = 0;
if (data->GetBinContent(i) > 0)
myUncertData = TMath::Power(data->GetBinError(i) / data->GetBinContent(i), 2);
double myUncertBkg = (myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / TMath::Power(hExpBkg->GetBinContent(i), 2);
hAgreementRelUncert->SetPointError(i-1, 0, data->GetBinContent(i) / hExpBkg->GetBinContent(i) * TMath::Sqrt(myUncertData + myUncertBkg));
} else {
hAgreementRelUncert->SetPoint(i-1, hExpBkg->GetBinCenter(i), 0);
hAgreementRelUncert->SetPointError(i-1, 0, 0);
}
if (debug) {
cout << "Point: " << hAgreementRelUncert->GetX()[i-1]-10 << "-" << hAgreementRelUncert->GetX()[i-1]+10
<< " GeV/c2, agreement: " << hAgreementRelUncert->GetY()[i-1] << ", uncert: " << hAgreement->GetBinError(i) << ", " << hAgreementRelUncert->GetErrorY(i-1) << endl;
cout << " bkg. stat. uncert. " << hExpBkg->GetBinError(i) << " (i.e. " << hExpBkg->GetBinError(i) / hExpBkg->GetBinContent(i) * 100.0 << " %)"
<< ", stat+syst uncert. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert)
<< " (i.e. " << TMath::Sqrt(myQCDTotalUncert + myEWKTotalUncert + myFakesTotalUncert) / hExpBkg->GetBinContent(i) * 100.0 << " %)" << endl;
}
}
// Agreement pad
TPad* pad = new TPad("ratiopad","ratiopad",0.,0.,1.,.3);
pad->Draw();
pad->cd();
pad->Range(0,0,1,1);
pad->SetFillColor(0);
pad->SetFillStyle(4000);
pad->SetBorderMode(0);
pad->SetBorderSize(2);
pad->SetTickx(1);
pad->SetTicky(1);
pad->SetLeftMargin(0.16);
pad->SetRightMargin(0.05);
pad->SetTopMargin(0);
pad->SetBottomMargin(0.34);
pad->SetFrameFillStyle(0);
pad->SetFrameBorderMode(0);
// Plot here ratio
if (1.0-delta > 0)
hAgreement->SetMinimum(1.0-delta);
else
hAgreement->SetMinimum(0.);
hAgreement->SetMaximum(1.0+delta);
hAgreement->GetXaxis()->SetLabelOffset(0.007);
hAgreement->GetXaxis()->SetLabelFont(43);
hAgreement->GetXaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelFont(43);
hAgreement->GetYaxis()->SetLabelSize(27);
hAgreement->GetYaxis()->SetLabelOffset(0.007);
hAgreement->GetYaxis()->SetNdivisions(505);
hAgreement->GetXaxis()->SetTitleFont(43);
hAgreement->GetYaxis()->SetTitleFont(43);
hAgreement->GetXaxis()->SetTitleSize(33);
hAgreement->GetYaxis()->SetTitleSize(33);
hAgreement->SetTitleSize(27, "xyz");
hAgreement->GetXaxis()->SetTitleOffset(3.2);
hAgreement->GetYaxis()->SetTitleOffset(1.3);
hAgreement->SetXTitle(hFrame->GetXaxis()->GetTitle());
hAgreement->SetYTitle("Data/#Sigmabkg");
hAgreement->Draw("e2");
// Plot line at zero
TH1* hAgreementLine = dynamic_cast<TH1*>(hAgreement->Clone());
for (int i = 1; i <= hAgreementLine->GetNbinsX(); ++i) {
hAgreementLine->SetBinContent(i,1.0);
hAgreementLine->SetBinError(i,0.0);
}
hAgreementLine->SetLineColor(kRed);
hAgreementLine->SetLineWidth(2);
hAgreementLine->SetLineStyle(3);
hAgreementLine->Draw("hist same");
hAgreement->Draw("same");
hAgreementRelUncert->Draw("[]");
pad->RedrawAxis();
myCanvas->cd();
TPad* plotpad = new TPad("plotpad", "plotpad",0,0.3,1.,1.);
plotpad->Draw();
plotpad->cd();
plotpad->Range(0,0,1,1);
plotpad->SetFillColor(0);
plotpad->SetFillStyle(4000);
plotpad->SetBorderMode(0);
plotpad->SetBorderSize(2);
//if (logy)
// plotpad->SetLogy();
plotpad->SetTickx(1);
plotpad->SetTicky(1);
plotpad->SetLeftMargin(0.16);
plotpad->SetRightMargin(0.05);
plotpad->SetTopMargin(0.065);
plotpad->SetBottomMargin(0.0);
plotpad->SetFrameFillStyle(0);
plotpad->SetFrameBorderMode(0);
hFrame->GetXaxis()->SetTitleSize(0);
hFrame->GetXaxis()->SetLabelSize(0);
hFrame->GetYaxis()->SetTitleFont(43);
hFrame->GetYaxis()->SetTitleSize(33);
hFrame->GetYaxis()->SetTitleOffset(1.3);
// Draw objects
hFrame->Draw();
exp->Draw("hist same");
uncert->Draw("E2 same");
hExpBkgTotalUncert->Draw("E2 same");
// Data
data->Draw("same");
//signal->Draw("same");
TLegend *leg = new TLegend(0.53,0.6,0.87,0.91,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(63);
leg->SetTextSize(18);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(kWhite);
//leg->SetFillStyle(4000); // enabling this will cause the plot to be erased from the pad
TLegendEntry* entry = leg->AddEntry(data, "Data", "P");
s.str("");
s << "with H^{#pm}#rightarrow#tau^{#pm}#nu";
entry = leg->AddEntry(signal, s.str().c_str(), "L");
entry = leg->AddEntry(qcd, "QCD (meas.)", "F");
entry = leg->AddEntry(ewktau, "EWK genuine #tau (meas.)", "F");
entry = leg->AddEntry(fakes, "EWK fake #tau (MC)", "F");
entry = leg->AddEntry(uncert, "stat. uncert.", "F");
entry = leg->AddEntry(hExpBkgTotalUncert, "stat. #oplus syst. uncert.", "F");
leg->Draw();
string myTitle = "CMS Preliminary";
if (paperStatus)
myTitle = "CMS";
TLatex *tex = new TLatex(0.62,0.945,myTitle.c_str());
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.2,0.945,"#sqrt{s} = 7 TeV");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
tex = new TLatex(0.43,0.945,"2.2 fb^{-1}");
tex->SetNDC();
tex->SetTextFont(43);
tex->SetTextSize(27);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "m_{H^{#pm}} = " << mass << " GeV/c^{2}";
tex = new TLatex(0.28,0.865,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
s.str("");
s << "BR(t#rightarrowbH^{#pm})=" << setprecision(2) << br;
tex = new TLatex(0.28,0.805,s.str().c_str());
tex->SetNDC();
tex->SetTextFont(63);
tex->SetTextSize(20);
tex->SetLineWidth(2);
tex->Draw();
plotpad->RedrawAxis();
plotpad->Modified();
s.str("");
s << "mT_datadriven_m" << mass << ".png";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".C";
myCanvas->Print(s.str().c_str());
s.str("");
s << "mT_datadriven_m" << mass << ".eps";
myCanvas->Print(s.str().c_str());
}
void h1draw()
{
TString dir = gROOT->GetTutorialDir();
dir.Append("/hsimple.C");
dir.ReplaceAll("/./","/");
if (gBenchmark->GetBench("hsimple") < 0) gInterpreter->LoadMacro(dir.Data());
TFile *example = (TFile*)gROOT->ProcessLineFast("hsimple(1)");
if (!example) return;
example->ls();
TH1 *hpx = (TH1*)example->Get("hpx");
TCanvas *c1 = new TCanvas("c1","Histogram Drawing Options",200,10,700,900);
TPad *pad1 = new TPad("pad1",
"The pad with the function",0.03,0.62,0.50,0.92);
TPad *pad2 = new TPad("pad2",
"The pad with the histogram",0.51,0.62,0.98,0.92);
TPad *pad3 = new TPad("pad3",
"The pad with the histogram",0.03,0.02,0.97,0.57);
pad1->Draw();
pad2->Draw();
pad3->Draw();
// Draw a global picture title
TPaveLabel *title = new TPaveLabel(0.1,0.94,0.9,0.98,
"Drawing options for one dimensional histograms");
title->SetTextFont(52);
title->Draw();
// Draw histogram hpx in first pad with the default option.
pad1->cd();
pad1->GetFrame()->SetFillColor(18);
hpx->SetFillColor(45);
hpx->DrawCopy();
TPaveLabel *label1 = new TPaveLabel(-3.5,700,-1,800,"Default option");
label1->Draw();
// Draw hpx as a lego. Clicking on the lego area will show
// a "transparent cube" to guide you rotating the lego in real time.
pad2->cd();
hpx->DrawCopy("lego1");
TPaveLabel *label2 = new TPaveLabel(-0.72,0.74,-0.22,0.88,"option Lego1");
label2->Draw();
TPaveLabel *label2a = new TPaveLabel(-0.93,-1.08,0.25,-0.92,
"Click on lego to rotate");
label2a->Draw();
// Draw hpx with its errors and a marker.
pad3->cd();
pad3->SetGridx();
pad3->SetGridy();
hpx->SetMarkerStyle(21);
hpx->Draw("e1p");
TPaveLabel *label3 = new TPaveLabel(2,600,3.5,650,"option e1p");
label3->Draw();
// The following illustrates how to add comments using a PaveText.
// Attributes of text/lines/boxes added to a PaveText can be modified.
// The AddText function returns a pointer to the added object.
TPaveText *pave = new TPaveText(-3.78,500,-1.2,750);
TText *t1=pave->AddText("You can move");
t1->SetTextColor(4);
t1->SetTextSize(0.05);
pave->AddText("Title and Stats pads");
pave->AddText("X and Y axis");
pave->AddText("You can modify bin contents");
pave->Draw();
c1->Update();
}
void makeSystPlot( TFile * f, TString oldFolder, RooWorkspace *WS, string channel, string syst, int toMassNo, int fromMassNo) //massNo 0-51, see xSec7TeV.h
{
RooArgList * hobs = new RooArgList("hobs");
RooRealVar BDT("CMS_vhbb_BDT_Zll", "CMS_vhbb_BDT_Zll", -1, 1);///OLD VARIABLE NAME HERE
hobs->add(*WS->var("CMS_vhbb_BDT_Zll")); ///NEW VARIABLE NAME HERE
RooWorkspace *tempWS = (RooWorkspace*) f->Get(oldFolder.Data());
TString systT(syst);
TString chanT(channel);
bool writeIt = 1;
if(chanT.Contains("QCD") || chanT.Contains("Wj"))
if(!(systT.Contains("stat"))) writeIt = 0;
if((kount < 3) && (channel=="data_obs"))
{
kount++;
std::string namen = channel;
std::cout << "reading WS "<< oldFolder.Data() << std::endl;
std::cout << namen << std::endl;
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,Binning(bins));
std::cout << namen << std::endl;
RooDataHist *DHnom = new RooDataHist(channel.c_str(),"",*hobs,tempHistNom);
WS->import(*(new RooHistPdf(channel.c_str(),"",*hobs,*DHnom)));
}
if (channel!="data_obs")
{
std::string nameUp;
std::string namen;
std::string nameDown;
if((syst == "stat"))
{
if(IFILE.Contains("7TeV"))
{
nameUp = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Up";
namen = channel;
nameDown = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Down";
}
if(IFILE.Contains("8TeV"))
{
nameUp = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Up";
namen = channel;
nameDown = channel + "CMS_vhbb_stats_" + channel + "_" + oldFolder.Data() + "Down";
}
}
else
{
nameUp = channel + "CMS_" + syst + "Up";
namen = channel;
nameDown = channel + "CMS_" + syst + "Down";
}
if((syst == "ZJModel"))
{
if(IFILE.Contains("7TeV"))
{
nameUp = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_7TeVUp";
namen = channel;
nameDown = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_7TeVDown";
}
if(IFILE.Contains("8TeV"))
{
nameUp = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_8TeVUp";
namen = channel;
nameDown = channel + "CMS_vhbb_ZJModel_" + oldFolder.Data() + "_8TeVDown";
}
}
if(writeIt)
{
RooDataHist* tempRooDataHistUp = (RooDataHist*) tempWS->data(nameUp.c_str());
RooDataHist* tempRooDataHistDown = (RooDataHist*) tempWS->data(nameDown.c_str());
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
std::cout << oldFolder.Data() << std::endl;
std::cout << nameUp.c_str() << std::endl;
TH1 *tempHistUp = tempRooDataHistUp->createHistogram(nameUp.c_str(),BDT,Binning(bins));
TH1 *tempHistDown = tempRooDataHistDown->createHistogram(nameDown.c_str(),BDT,Binning(bins));
std::cout << namen.c_str() << std::endl;
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,Binning(bins));
if(chanT.Contains("VH") && IFILE.Contains("7TeV"))
{
tempHistUp->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
tempHistDown->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
tempHistNom->Scale(xSec7ZH[toMassNo]/xSec7ZH[fromMassNo]);
}
if(chanT.Contains("VH") && IFILE.Contains("8TeV"))
{
tempHistUp->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
tempHistDown->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
tempHistNom->Scale(xSec8ZH[toMassNo]/xSec8ZH[fromMassNo]);
}
std::cout<< "channel--> " << channel << std::endl;
tempHistUp->SetLineColor(kRed);
tempHistUp->SetLineWidth(3);
tempHistUp->SetFillColor(0);
tempHistDown->SetLineColor(kBlue);
tempHistDown->SetFillColor(0);
tempHistDown->SetLineWidth(3);
tempHistNom->SetFillColor(0);
tempHistNom->SetMarkerStyle(20);
tempHistUp->SetTitle((channel + syst).c_str());
RooDataHist *DHnom;
RooDataHist *DHup = new RooDataHist(nameUp.c_str(),"",*hobs,tempHistUp);
if(kount2 < 3) DHnom = new RooDataHist(namen.c_str(),"",*hobs,tempHistNom);
RooDataHist *DHdown = new RooDataHist(nameDown.c_str(),"",*hobs,tempHistDown);
WS->import(*(new RooHistPdf(nameUp.c_str(),"",*hobs,*DHup)));
WS->import(*(new RooHistPdf(nameDown.c_str(),"",*hobs,*DHdown)));
if(kount2 < 3){ WS->import(*(new RooHistPdf(namen.c_str(),"",*hobs,*DHnom))); kount2++;}
}
}
}
void EMCDistribution(TString gain = "CALIB", bool log_scale = false)
{
TText *t;
TCanvas *c1 = new TCanvas(
"EMCDistribution_" + gain + TString(log_scale ? "_Log" : "") + cuts,
"EMCDistribution_" + gain + TString(log_scale ? "_Log" : "") + cuts, 1800,
1000);
c1->Divide(8, 8, 0., 0.01);
int idx = 1;
TPad *p;
for (int iphi = 8 - 1; iphi >= 0; iphi--)
{
for (int ieta = 0; ieta < 8; ieta++)
{
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
p->SetGridx(0);
p->SetGridy(0);
TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(log_scale ? "_Log" : "");
TH1 *h = NULL;
if (log_scale)
h = new TH1F(hname,
Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 300,
5e-3, 3096);
else
// h = new TH1F(hname,
// Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 196,
// 1900, 2096);
h = new TH1F(hname,
Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 596,
-96, 500);
h->SetLineWidth(0);
h->SetLineColor(kBlue + 3);
h->SetFillColor(kBlue + 3);
h->GetXaxis()->SetTitleSize(.09);
h->GetXaxis()->SetLabelSize(.08);
h->GetYaxis()->SetLabelSize(.08);
if (log_scale)
QAHistManagerDef::useLogBins(h->GetXaxis());
T->Draw(
"TOWER_" + gain + "_CEMC[].get_energy_power_law_exp()>>" + hname,
Form(
"TOWER_%s_CEMC[].get_bineta()==%d && TOWER_%s_CEMC[].get_binphi()==%d",
gain.Data(), ieta, gain.Data(), iphi),
"");
TText *t = new TText(.9, .9, Form("Col%d Row%d", ieta, iphi));
t->SetTextAlign(33);
t->SetTextSize(.15);
t->SetNDC();
t->Draw();
// return;
}
}
SaveCanvas(c1,
TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false);
}
void EMCDistribution_PeakSample_Fast(bool full_gain = false)
{
const TString gain = "RAW";
TString hname = "EMCDistribution_" + gain + TString(full_gain ? "_FullGain" : "") + cuts;
TH2 *h2 = NULL;
{
if (full_gain)
{
h2 = new TH2F(hname,
Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 100,
.05 * 100, 25 * 100, 64, -.5, 63.5);
QAHistManagerDef::useLogBins(h2->GetXaxis());
}
else
{
h2 = new TH2F(hname,
Form(";Calibrated Tower Energy Sum (ADC);Count / bin"), 260,
-.2 * 100, 5 * 100, 64, -.5, 63.5);
}
T->Draw(
"TOWER_" + gain + "_CEMC[].get_bineta() + 8* TOWER_" + gain + "_CEMC[].get_binphi():(TOWER_RAW_CEMC[].signal_samples[10] - TOWER_RAW_CEMC[].signal_samples[0])*(-1)>>" + hname, "", "goff");
}
TText *t;
TCanvas *c1 = new TCanvas(
"EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts,
"EMCDistribution_PeakSample_Fast_" + TString(full_gain ? "_FullGain" : "") + cuts, 1800, 950);
c1->Divide(8, 8, 0., 0.01);
int idx = 1;
TPad *p;
for (int iphi = 8 - 1; iphi >= 0; iphi--)
{
for (int ieta = 0; ieta < 8; ieta++)
{
p = (TPad *) c1->cd(idx++);
c1->Update();
p->SetLogy();
if (full_gain)
{
p->SetLogx();
}
p->SetGridx(0);
p->SetGridy(0);
TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(full_gain ? "_FullGain" : "");
TH1 *h = h2->ProjectionX(hname, ieta + 8 * iphi + 1,
ieta + 8 * iphi + 1); // axis bin number is encoded as ieta+8*iphi+1
h->SetLineWidth(0);
h->SetLineColor(kBlue + 3);
h->SetFillColor(kBlue + 3);
h->GetXaxis()->SetTitleSize(.09);
h->GetXaxis()->SetLabelSize(.08);
h->GetYaxis()->SetLabelSize(.08);
h->Draw();
if (full_gain)
h->Fit("x*gaus", "M");
else
h->Fit("landau", "M");
double peak = -1;
TF1 *fit = ((TF1 *) (h->GetListOfFunctions()->At(0)));
if (fit)
{
fit->SetLineColor(kRed);
peak = fit->GetParameter(1);
}
cout << Form("Finished <Col%d Row%d> = %.1f", ieta, iphi, peak)
<< endl;
TText *t = new TText(.9, .9,
Form("<Col%d Row%d> = %.1f", ieta, iphi, peak));
t->SetTextAlign(33);
t->SetTextSize(.15);
t->SetNDC();
t->Draw();
}
}
SaveCanvas(c1,
TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false);
}
void diffrac(){
gROOT->Reset();
//gROOT->ProcessLine(".x rootlogon.C");
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:02 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-32.99367,-0.009375,158.1456,0.053125);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
//TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,60.5,1,0,0.06);
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->Draw("");
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetYaxis()->SetNdivisions(305);
/*
TH1 *hFrame2 = new TH2D("hFrame2","",1,-0.5,150.5,1,0,0.05);
hFrame2->SetDirectory(0);
hFrame2->SetStats(0);
hFrame2->SetFillColor(1);
hFrame2->SetFillStyle(0);
hFrame2->SetLineStyle(0);
hFrame2->SetMarkerStyle(20);
hFrame2->SetMarkerSize(1.5);
hFrame2->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame2->GetXaxis()->CenterTitle(true);
hFrame2->GetXaxis()->SetNdivisions(312);
hFrame2->GetXaxis()->SetLabelFont(42);
hFrame2->GetXaxis()->SetLabelOffset(0.01);
hFrame2->GetXaxis()->SetLabelSize(0.045);
hFrame2->GetXaxis()->SetTitleSize(0.055);
hFrame2->GetXaxis()->SetTitleFont(42);
hFrame2->GetYaxis()->SetTitle("Fraction of events");
hFrame2->GetYaxis()->CenterTitle(true);
hFrame2->GetYaxis()->SetLabelFont(42);
hFrame2->GetYaxis()->SetLabelOffset(0.01);
hFrame2->GetYaxis()->SetLabelSize(0.045);
hFrame2->GetYaxis()->SetTitleSize(0.055);
hFrame2->GetYaxis()->SetTitleOffset(1.5);
hFrame2->GetYaxis()->SetTitleFont(42);
hFrame2->GetZaxis()->SetLabelFont(42);
hFrame2->GetZaxis()->SetLabelSize(0.045);
hFrame2->GetZaxis()->SetTitleFont(42);
hFrame2->Draw("");
*/
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0004697663);
diffrac->SetBinContent(2,0.008010118);
diffrac->SetBinContent(3,0.0127921);
diffrac->SetBinContent(4,0.01698988);
diffrac->SetBinContent(5,0.02012166);
diffrac->SetBinContent(6,0.022341);
diffrac->SetBinContent(7,0.02315105);
diffrac->SetBinContent(8,0.02518068);
diffrac->SetBinContent(9,0.02668032);
diffrac->SetBinContent(10,0.02875512);
diffrac->SetBinContent(11,0.03089617);
diffrac->SetBinContent(12,0.0324741);
diffrac->SetBinContent(13,0.03311853);
diffrac->SetBinContent(14,0.03265478);
diffrac->SetBinContent(15,0.03213081);
diffrac->SetBinContent(16,0.03054987);
diffrac->SetBinContent(17,0.0283245);
diffrac->SetBinContent(18,0.02640026);
diffrac->SetBinContent(19,0.02394001);
diffrac->SetBinContent(20,0.02234401);
diffrac->SetBinContent(21,0.02026921);
diffrac->SetBinContent(22,0.01865213);
diffrac->SetBinContent(23,0.01720369);
diffrac->SetBinContent(24,0.01639665);
diffrac->SetBinContent(25,0.01546013);
diffrac->SetBinContent(26,0.01423151);
diffrac->SetBinContent(27,0.01359311);
diffrac->SetBinContent(28,0.01247892);
diffrac->SetBinContent(29,0.01204529);
diffrac->SetBinContent(30,0.01130752);
diffrac->SetBinContent(31,0.01089798);
diffrac->SetBinContent(32,0.01070826);
diffrac->SetBinContent(33,0.009497711);
diffrac->SetBinContent(34,0.009579017);
diffrac->SetBinContent(35,0.008805107);
diffrac->SetBinContent(36,0.008741869);
diffrac->SetBinContent(37,0.008522043);
diffrac->SetBinContent(38,0.00790171);
diffrac->SetBinContent(39,0.007799325);
diffrac->SetBinContent(40,0.007486148);
diffrac->SetBinContent(41,0.006838714);
diffrac->SetBinContent(42,0.006947121);
diffrac->SetBinContent(43,0.006504457);
diffrac->SetBinContent(44,0.0063298);
diffrac->SetBinContent(45,0.006122019);
diffrac->SetBinContent(46,0.006061792);
diffrac->SetBinContent(47,0.005823898);
diffrac->SetBinContent(48,0.005661286);
diffrac->SetBinContent(49,0.005543845);
diffrac->SetBinContent(50,0.005363166);
diffrac->SetBinContent(51,0.005215611);
diffrac->SetBinContent(52,0.00503192);
diffrac->SetBinContent(53,0.004800048);
diffrac->SetBinContent(54,0.004839195);
diffrac->SetBinContent(55,0.004583233);
diffrac->SetBinContent(56,0.004544086);
diffrac->SetBinContent(57,0.004471814);
diffrac->SetBinContent(58,0.004146591);
diffrac->SetBinContent(59,0.004267044);
diffrac->SetBinContent(60,0.003990002);
diffrac->SetBinContent(61,0.004083353);
diffrac->SetBinContent(62,0.003806312);
diffrac->SetBinContent(63,0.003782221);
diffrac->SetBinContent(64,0.003812334);
diffrac->SetBinContent(65,0.003472055);
diffrac->SetBinContent(66,0.00366478);
diffrac->SetBinContent(67,0.003195013);
diffrac->SetBinContent(68,0.003285353);
diffrac->SetBinContent(69,0.00323416);
diffrac->SetBinContent(70,0.0031649);
diffrac->SetBinContent(71,0.003110696);
diffrac->SetBinContent(72,0.003170923);
diffrac->SetBinContent(73,0.002966153);
diffrac->SetBinContent(74,0.002957119);
diffrac->SetBinContent(75,0.002905926);
diffrac->SetBinContent(76,0.002954107);
diffrac->SetBinContent(77,0.002785473);
diffrac->SetBinContent(78,0.002836666);
diffrac->SetBinContent(79,0.002725247);
diffrac->SetBinContent(80,0.002728258);
diffrac->SetBinContent(81,0.002568658);
diffrac->SetBinContent(82,0.002288605);
diffrac->SetBinContent(83,0.002499398);
diffrac->SetBinContent(84,0.002445194);
diffrac->SetBinContent(85,0.002378945);
diffrac->SetBinContent(86,0.00227656);
diffrac->SetBinContent(87,0.002418092);
diffrac->SetBinContent(88,0.002351843);
diffrac->SetBinContent(89,0.002381956);
diffrac->SetBinContent(90,0.002189232);
diffrac->SetBinContent(91,0.002222356);
diffrac->SetBinContent(92,0.002198265);
diffrac->SetBinContent(93,0.002219345);
diffrac->SetBinContent(94,0.002198265);
diffrac->SetBinContent(95,0.002089858);
diffrac->SetBinContent(96,0.001996507);
diffrac->SetBinContent(97,0.001972416);
diffrac->SetBinContent(98,0.001903156);
diffrac->SetBinContent(99,0.001818839);
diffrac->SetBinContent(100,0.001876054);
diffrac->SetBinContent(101,0.001864009);
diffrac->SetBinContent(102,0.001767646);
diffrac->SetBinContent(103,0.001879065);
diffrac->SetBinContent(104,0.001894122);
diffrac->SetBinContent(105,0.001695375);
diffrac->SetBinContent(106,0.001674295);
diffrac->SetBinContent(107,0.001611058);
diffrac->SetBinContent(108,0.001556854);
diffrac->SetBinContent(109,0.001620092);
diffrac->SetBinContent(110,0.001556854);
diffrac->SetBinContent(111,0.001568899);
diffrac->SetBinContent(112,0.001475548);
diffrac->SetBinContent(113,0.001376174);
diffrac->SetBinContent(114,0.001448446);
diffrac->SetBinContent(115,0.001520718);
diffrac->SetBinContent(116,0.001261744);
diffrac->SetBinContent(117,0.001448446);
diffrac->SetBinContent(118,0.001282823);
diffrac->SetBinContent(119,0.001219586);
diffrac->SetBinContent(120,0.001201518);
diffrac->SetBinContent(121,0.001237654);
diffrac->SetBinContent(122,0.001141291);
diffrac->SetBinContent(123,0.001195495);
diffrac->SetBinContent(124,0.001150325);
diffrac->SetBinContent(125,0.001195495);
diffrac->SetBinContent(126,0.0009816912);
diffrac->SetBinContent(127,0.001135269);
diffrac->SetBinContent(128,0.00100277);
diffrac->SetBinContent(129,0.001005782);
diffrac->SetBinContent(130,0.0009003854);
diffrac->SetBinContent(131,0.0008823175);
diffrac->SetBinContent(132,0.0009576006);
diffrac->SetBinContent(133,0.0008732835);
diffrac->SetBinContent(134,0.0008220911);
diffrac->SetBinContent(135,0.000831125);
diffrac->SetBinContent(136,0.0007437967);
diffrac->SetBinContent(137,0.000662491);
diffrac->SetBinContent(138,0.0007046495);
diffrac->SetBinContent(139,0.0007287401);
diffrac->SetBinContent(140,0.0007407854);
diffrac->SetBinContent(141,0.0006263551);
diffrac->SetBinContent(142,0.0006745363);
diffrac->SetBinContent(143,0.000653457);
diffrac->SetBinContent(144,0.0006082872);
diffrac->SetBinContent(145,0.0005420381);
diffrac->SetBinContent(146,0.0005631173);
diffrac->SetBinContent(147,0.0005059022);
diffrac->SetBinContent(148,0.0005781739);
diffrac->SetBinContent(149,0.0005239701);
diffrac->SetBinContent(150,0.0004547097);
diffrac->SetBinContent(151,0.0004697663);
diffrac->SetBinContent(152,0.0004547097);
diffrac->SetBinContent(153,0.0004396531);
diffrac->SetBinContent(154,0.0004697663);
diffrac->SetBinContent(155,0.0003884606);
diffrac->SetBinContent(156,0.0003613587);
diffrac->SetBinContent(157,0.0003523247);
diffrac->SetBinContent(158,0.0003703927);
diffrac->SetBinContent(159,0.0003794266);
diffrac->SetBinContent(160,0.0003041436);
diffrac->SetBinContent(161,0.0003192002);
diffrac->SetBinContent(162,0.000280053);
diffrac->SetBinContent(163,0.0002770417);
diffrac->SetBinContent(164,0.0002228379);
diffrac->SetBinContent(165,0.0002529511);
diffrac->SetBinContent(166,0.0002469285);
diffrac->SetBinContent(167,0.0002318718);
diffrac->SetBinContent(168,0.0003041436);
diffrac->SetBinContent(169,0.0002198265);
diffrac->SetBinContent(170,0.0002499398);
diffrac->SetBinContent(171,0.0001565888);
diffrac->SetBinContent(172,0.0001656227);
diffrac->SetBinContent(173,0.0001535775);
diffrac->SetBinContent(174,0.0001626114);
diffrac->SetBinContent(175,0.0001987473);
diffrac->SetBinContent(176,0.0001445435);
diffrac->SetBinContent(177,0.0001174416);
diffrac->SetBinContent(178,0.0001445435);
diffrac->SetBinContent(179,0.0001415322);
diffrac->SetBinContent(180,0.0001445435);
diffrac->SetBinContent(181,0.0001264755);
diffrac->SetBinContent(182,6.62491e-05);
diffrac->SetBinContent(183,7.227174e-05);
diffrac->SetBinContent(184,0.0001053963);
diffrac->SetBinContent(185,9.033968e-05);
diffrac->SetBinContent(186,8.732835e-05);
diffrac->SetBinContent(187,6.022645e-05);
diffrac->SetBinContent(188,9.3351e-05);
diffrac->SetBinContent(189,8.732835e-05);
diffrac->SetBinContent(190,8.431703e-05);
diffrac->SetBinContent(191,9.033968e-05);
diffrac->SetBinContent(192,4.215852e-05);
diffrac->SetBinContent(193,6.62491e-05);
diffrac->SetBinContent(194,7.528306e-05);
diffrac->SetBinContent(195,4.215852e-05);
diffrac->SetBinContent(196,4.516984e-05);
diffrac->SetBinContent(197,3.613587e-05);
diffrac->SetBinContent(198,6.022645e-05);
diffrac->SetBinContent(199,4.516984e-05);
diffrac->SetBinContent(200,3.011323e-05);
diffrac->SetBinContent(201,0.000457721);
diffrac->SetBinError(1,3.761141e-05);
diffrac->SetBinError(2,0.0001553095);
diffrac->SetBinError(3,0.000196268);
diffrac->SetBinError(4,0.0002261902);
diffrac->SetBinError(5,0.0002461561);
diffrac->SetBinError(6,0.0002593761);
diffrac->SetBinError(7,0.0002640365);
diffrac->SetBinError(8,0.0002753673);
diffrac->SetBinError(9,0.0002834485);
diffrac->SetBinError(10,0.0002942634);
diffrac->SetBinError(11,0.0003050219);
diffrac->SetBinError(12,0.0003127139);
diffrac->SetBinError(13,0.0003158015);
diffrac->SetBinError(14,0.0003135827);
diffrac->SetBinError(15,0.0003110566);
diffrac->SetBinError(16,0.0003033076);
diffrac->SetBinError(17,0.0002920517);
diffrac->SetBinError(18,0.0002819569);
diffrac->SetBinError(19,0.0002684979);
diffrac->SetBinError(20,0.0002593936);
diffrac->SetBinError(21,0.0002470569);
diffrac->SetBinError(22,0.000236997);
diffrac->SetBinError(23,0.000227609);
diffrac->SetBinError(24,0.0002222062);
diffrac->SetBinError(25,0.0002157671);
diffrac->SetBinError(26,0.0002070161);
diffrac->SetBinError(27,0.0002023196);
diffrac->SetBinError(28,0.0001938506);
diffrac->SetBinError(29,0.0001904528);
diffrac->SetBinError(30,0.000184528);
diffrac->SetBinError(31,0.0001811555);
diffrac->SetBinError(32,0.0001795718);
diffrac->SetBinError(33,0.0001691173);
diffrac->SetBinError(34,0.0001698397);
diffrac->SetBinError(35,0.0001628343);
diffrac->SetBinError(36,0.0001622485);
diffrac->SetBinError(37,0.0001601956);
diffrac->SetBinError(38,0.000154255);
diffrac->SetBinError(39,0.0001532524);
diffrac->SetBinError(40,0.000150144);
diffrac->SetBinError(41,0.0001435046);
diffrac->SetBinError(42,0.0001446376);
diffrac->SetBinError(43,0.0001399536);
diffrac->SetBinError(44,0.0001380618);
diffrac->SetBinError(45,0.0001357769);
diffrac->SetBinError(46,0.0001351074);
diffrac->SetBinError(47,0.0001324297);
diffrac->SetBinError(48,0.0001305678);
diffrac->SetBinError(49,0.0001292064);
diffrac->SetBinError(50,0.0001270835);
diffrac->SetBinError(51,0.0001253231);
diffrac->SetBinError(52,0.0001230964);
diffrac->SetBinError(53,0.0001202268);
diffrac->SetBinError(54,0.0001207161);
diffrac->SetBinError(55,0.0001174802);
diffrac->SetBinError(56,0.0001169774);
diffrac->SetBinError(57,0.0001160434);
diffrac->SetBinError(58,0.000111744);
diffrac->SetBinError(59,0.0001133554);
diffrac->SetBinError(60,0.0001096138);
diffrac->SetBinError(61,0.0001108887);
diffrac->SetBinError(62,0.0001070609);
diffrac->SetBinError(63,0.0001067215);
diffrac->SetBinError(64,0.0001071455);
diffrac->SetBinError(65,0.000102252);
diffrac->SetBinError(66,0.0001050516);
diffrac->SetBinError(67,9.808779e-05);
diffrac->SetBinError(68,9.946486e-05);
diffrac->SetBinError(69,9.868688e-05);
diffrac->SetBinError(70,9.762446e-05);
diffrac->SetBinError(71,9.678486e-05);
diffrac->SetBinError(72,9.77173e-05);
diffrac->SetBinError(73,9.450948e-05);
diffrac->SetBinError(74,9.436545e-05);
diffrac->SetBinError(75,9.354508e-05);
diffrac->SetBinError(76,9.431739e-05);
diffrac->SetBinError(77,9.15858e-05);
diffrac->SetBinError(78,9.242357e-05);
diffrac->SetBinError(79,9.059027e-05);
diffrac->SetBinError(80,9.064031e-05);
diffrac->SetBinError(81,8.794918e-05);
diffrac->SetBinError(82,8.301643e-05);
diffrac->SetBinError(83,8.675536e-05);
diffrac->SetBinError(84,8.580948e-05);
diffrac->SetBinError(85,8.463906e-05);
diffrac->SetBinError(86,8.279768e-05);
diffrac->SetBinError(87,8.533261e-05);
diffrac->SetBinError(88,8.415556e-05);
diffrac->SetBinError(89,8.469261e-05);
diffrac->SetBinError(90,8.11941e-05);
diffrac->SetBinError(91,8.180606e-05);
diffrac->SetBinError(92,8.136146e-05);
diffrac->SetBinError(93,8.175061e-05);
diffrac->SetBinError(94,8.136146e-05);
diffrac->SetBinError(95,7.932992e-05);
diffrac->SetBinError(96,7.75379e-05);
diffrac->SetBinError(97,7.706868e-05);
diffrac->SetBinError(98,7.570348e-05);
diffrac->SetBinError(99,7.40075e-05);
diffrac->SetBinError(100,7.516251e-05);
diffrac->SetBinError(101,7.492083e-05);
diffrac->SetBinError(102,7.295857e-05);
diffrac->SetBinError(103,7.522281e-05);
diffrac->SetBinError(104,7.552359e-05);
diffrac->SetBinError(105,7.145152e-05);
diffrac->SetBinError(106,7.100594e-05);
diffrac->SetBinError(107,6.965209e-05);
diffrac->SetBinError(108,6.847035e-05);
diffrac->SetBinError(109,6.984711e-05);
diffrac->SetBinError(110,6.847035e-05);
diffrac->SetBinError(111,6.873472e-05);
diffrac->SetBinError(112,6.665847e-05);
diffrac->SetBinError(113,6.437472e-05);
diffrac->SetBinError(114,6.604346e-05);
diffrac->SetBinError(115,6.767106e-05);
diffrac->SetBinError(116,6.164024e-05);
diffrac->SetBinError(117,6.604346e-05);
diffrac->SetBinError(118,6.2153e-05);
diffrac->SetBinError(119,6.06017e-05);
diffrac->SetBinError(120,6.015112e-05);
diffrac->SetBinError(121,6.104895e-05);
diffrac->SetBinError(122,5.862419e-05);
diffrac->SetBinError(123,6.000018e-05);
diffrac->SetBinError(124,5.885576e-05);
diffrac->SetBinError(125,6.000018e-05);
diffrac->SetBinError(126,5.437084e-05);
diffrac->SetBinError(127,5.846931e-05);
diffrac->SetBinError(128,5.495148e-05);
diffrac->SetBinError(129,5.503393e-05);
diffrac->SetBinError(130,5.207063e-05);
diffrac->SetBinError(131,5.154554e-05);
diffrac->SetBinError(132,5.369957e-05);
diffrac->SetBinError(133,5.128098e-05);
diffrac->SetBinError(134,4.975521e-05);
diffrac->SetBinError(135,5.002785e-05);
diffrac->SetBinError(136,4.732665e-05);
diffrac->SetBinError(137,4.466513e-05);
diffrac->SetBinError(138,4.606438e-05);
diffrac->SetBinError(139,4.684519e-05);
diffrac->SetBinError(140,4.723075e-05);
diffrac->SetBinError(141,4.342991e-05);
diffrac->SetBinError(142,4.506935e-05);
diffrac->SetBinError(143,4.435955e-05);
diffrac->SetBinError(144,4.279894e-05);
diffrac->SetBinError(145,4.040113e-05);
diffrac->SetBinError(146,4.117922e-05);
diffrac->SetBinError(147,3.90312e-05);
diffrac->SetBinError(148,4.172611e-05);
diffrac->SetBinError(149,3.972207e-05);
diffrac->SetBinError(150,3.700375e-05);
diffrac->SetBinError(151,3.761141e-05);
diffrac->SetBinError(152,3.700375e-05);
diffrac->SetBinError(153,3.638595e-05);
diffrac->SetBinError(154,3.761141e-05);
diffrac->SetBinError(155,3.420205e-05);
diffrac->SetBinError(156,3.298739e-05);
diffrac->SetBinError(157,3.257243e-05);
diffrac->SetBinError(158,3.339718e-05);
diffrac->SetBinError(159,3.380201e-05);
diffrac->SetBinError(160,3.026342e-05);
diffrac->SetBinError(161,3.100346e-05);
diffrac->SetBinError(162,2.904014e-05);
diffrac->SetBinError(163,2.888359e-05);
diffrac->SetBinError(164,2.590438e-05);
diffrac->SetBinError(165,2.759923e-05);
diffrac->SetBinError(166,2.726869e-05);
diffrac->SetBinError(167,2.642425e-05);
diffrac->SetBinError(168,3.026342e-05);
diffrac->SetBinError(169,2.572875e-05);
diffrac->SetBinError(170,2.743445e-05);
diffrac->SetBinError(171,2.171496e-05);
diffrac->SetBinError(172,2.233257e-05);
diffrac->SetBinError(173,2.150514e-05);
diffrac->SetBinError(174,2.212861e-05);
diffrac->SetBinError(175,2.44641e-05);
diffrac->SetBinError(176,2.086305e-05);
diffrac->SetBinError(177,1.88057e-05);
diffrac->SetBinError(178,2.086305e-05);
diffrac->SetBinError(179,2.064459e-05);
diffrac->SetBinError(180,2.086305e-05);
diffrac->SetBinError(181,1.95156e-05);
diffrac->SetBinError(182,1.412435e-05);
diffrac->SetBinError(183,1.475241e-05);
diffrac->SetBinError(184,1.781522e-05);
diffrac->SetBinError(185,1.649369e-05);
diffrac->SetBinError(186,1.621647e-05);
diffrac->SetBinError(187,1.346704e-05);
diffrac->SetBinError(188,1.676633e-05);
diffrac->SetBinError(189,1.621647e-05);
diffrac->SetBinError(190,1.593442e-05);
diffrac->SetBinError(191,1.649369e-05);
diffrac->SetBinError(192,1.126734e-05);
diffrac->SetBinError(193,1.412435e-05);
diffrac->SetBinError(194,1.505661e-05);
diffrac->SetBinError(195,1.126734e-05);
diffrac->SetBinError(196,1.16628e-05);
diffrac->SetBinError(197,1.043153e-05);
diffrac->SetBinError(198,1.346704e-05);
diffrac->SetBinError(199,1.16628e-05);
diffrac->SetBinError(200,9.522638e-06);
diffrac->SetBinError(201,3.712608e-05);
diffrac->SetEntries(332232);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(0);
diffrac->SetLineWidth(2);
diffrac->SetMarkerStyle(20);
diffrac->SetMarkerSize(1.5);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("hist same");
TH1 *diffrac = new TH1D("diffrac","diffrac",200,0,200);
diffrac->SetBinContent(1,0.0001535956);
diffrac->SetBinContent(2,0.002138746);
diffrac->SetBinContent(3,0.003918136);
diffrac->SetBinContent(4,0.006984252);
diffrac->SetBinContent(5,0.01149359);
diffrac->SetBinContent(6,0.01725487);
diffrac->SetBinContent(7,0.02335522);
diffrac->SetBinContent(8,0.02994824);
diffrac->SetBinContent(9,0.03493575);
diffrac->SetBinContent(10,0.03668616);
diffrac->SetBinContent(11,0.03929439);
diffrac->SetBinContent(12,0.03968852);
diffrac->SetBinContent(13,0.03844526);
diffrac->SetBinContent(14,0.0360341);
diffrac->SetBinContent(15,0.03434745);
diffrac->SetBinContent(16,0.03306942);
diffrac->SetBinContent(17,0.03029311);
diffrac->SetBinContent(18,0.02782978);
diffrac->SetBinContent(19,0.02716903);
diffrac->SetBinContent(20,0.02540413);
diffrac->SetBinContent(21,0.02289154);
diffrac->SetBinContent(22,0.02272345);
diffrac->SetBinContent(23,0.02145412);
diffrac->SetBinContent(24,0.02181927);
diffrac->SetBinContent(25,0.02003698);
diffrac->SetBinContent(26,0.01887487);
diffrac->SetBinContent(27,0.01739977);
diffrac->SetBinContent(28,0.01641734);
diffrac->SetBinContent(29,0.01567544);
diffrac->SetBinContent(30,0.01542621);
diffrac->SetBinContent(31,0.01473069);
diffrac->SetBinContent(32,0.01400618);
diffrac->SetBinContent(33,0.01286146);
diffrac->SetBinContent(34,0.01269917);
diffrac->SetBinContent(35,0.0127919);
diffrac->SetBinContent(36,0.01181527);
diffrac->SetBinContent(37,0.01151387);
diffrac->SetBinContent(38,0.01042421);
diffrac->SetBinContent(39,0.01025613);
diffrac->SetBinContent(40,0.009320064);
diffrac->SetBinContent(41,0.009027363);
diffrac->SetBinContent(42,0.008412981);
diffrac->SetBinContent(43,0.00834053);
diffrac->SetBinContent(44,0.007647901);
diffrac->SetBinContent(45,0.007917418);
diffrac->SetBinContent(46,0.007523286);
diffrac->SetBinContent(47,0.006679959);
diffrac->SetBinContent(48,0.006526363);
diffrac->SetBinContent(49,0.006004718);
diffrac->SetBinContent(50,0.005914879);
diffrac->SetBinContent(51,0.006233662);
diffrac->SetBinContent(52,0.006123537);
diffrac->SetBinContent(53,0.005494665);
diffrac->SetBinContent(54,0.005019388);
diffrac->SetBinContent(55,0.004778851);
diffrac->SetBinContent(56,0.004686114);
diffrac->SetBinContent(57,0.004355739);
diffrac->SetBinContent(58,0.004112304);
diffrac->SetBinContent(59,0.004112304);
diffrac->SetBinContent(60,0.004187653);
diffrac->SetBinContent(61,0.003448656);
diffrac->SetBinContent(62,0.003593557);
diffrac->SetBinContent(63,0.003376205);
diffrac->SetBinContent(64,0.003054524);
diffrac->SetBinContent(65,0.002628513);
diffrac->SetBinContent(66,0.003097994);
diffrac->SetBinContent(67,0.002509694);
diffrac->SetBinContent(68,0.002495204);
diffrac->SetBinContent(69,0.002547368);
diffrac->SetBinContent(70,0.002153236);
diffrac->SetBinContent(71,0.002222789);
diffrac->SetBinContent(72,0.001904006);
diffrac->SetBinContent(73,0.002008335);
diffrac->SetBinContent(74,0.001762002);
diffrac->SetBinContent(75,0.001617101);
diffrac->SetBinContent(76,0.001834453);
diffrac->SetBinContent(77,0.001770696);
diffrac->SetBinContent(78,0.001463505);
diffrac->SetBinContent(79,0.001312808);
diffrac->SetBinContent(80,0.001193988);
diffrac->SetBinContent(81,0.001240357);
diffrac->SetBinContent(82,0.001307011);
diffrac->SetBinContent(83,0.001101251);
diffrac->SetBinContent(84,0.001008514);
diffrac->SetBinContent(85,0.0008838991);
diffrac->SetBinContent(86,0.0009969223);
diffrac->SetBinContent(87,0.0008896952);
diffrac->SetBinContent(88,0.001011412);
diffrac->SetBinContent(89,0.0008867972);
diffrac->SetBinContent(90,0.0007563858);
diffrac->SetBinContent(91,0.000681037);
diffrac->SetBinContent(92,0.0005911981);
diffrac->SetBinContent(93,0.0007360996);
diffrac->SetBinContent(94,0.0006259745);
diffrac->SetBinContent(95,0.0004955631);
diffrac->SetBinContent(96,0.000486869);
diffrac->SetBinContent(97,0.0004462966);
diffrac->SetBinContent(98,0.0003970301);
diffrac->SetBinContent(99,0.0003448656);
diffrac->SetBinContent(100,0.0002782109);
diffrac->SetBinContent(101,0.0003042931);
diffrac->SetBinContent(102,0.0002550266);
diffrac->SetBinContent(103,0.0003361715);
diffrac->SetBinContent(104,0.0001854739);
diffrac->SetBinContent(105,0.0003158853);
diffrac->SetBinContent(106,0.0002144542);
diffrac->SetBinContent(107,0.0001767798);
diffrac->SetBinContent(108,0.0001477995);
diffrac->SetBinContent(109,0.0001506976);
diffrac->SetBinContent(110,0.0001362074);
diffrac->SetBinContent(111,0.0002463325);
diffrac->SetBinContent(112,0.0001391054);
diffrac->SetBinContent(113,0.0002173522);
diffrac->SetBinContent(114,9.853302e-05);
diffrac->SetBinContent(115,0.0001420035);
diffrac->SetBinContent(116,0.0001159212);
diffrac->SetBinContent(117,8.983893e-05);
diffrac->SetBinContent(118,6.085863e-05);
diffrac->SetBinContent(119,6.375666e-05);
diffrac->SetBinContent(120,6.375666e-05);
diffrac->SetBinContent(121,5.79606e-05);
diffrac->SetBinContent(122,6.665469e-05);
diffrac->SetBinContent(123,4.926651e-05);
diffrac->SetBinContent(124,4.347045e-05);
diffrac->SetBinContent(125,4.636848e-05);
diffrac->SetBinContent(126,5.216454e-05);
diffrac->SetBinContent(127,3.477636e-05);
diffrac->SetBinContent(128,3.767439e-05);
diffrac->SetBinContent(129,2.318424e-05);
diffrac->SetBinContent(130,2.028621e-05);
diffrac->SetBinContent(131,3.187833e-05);
diffrac->SetBinContent(132,2.608227e-05);
diffrac->SetBinContent(133,3.477636e-05);
diffrac->SetBinContent(134,1.738818e-05);
diffrac->SetBinContent(135,1.738818e-05);
diffrac->SetBinContent(136,8.69409e-06);
diffrac->SetBinContent(137,1.449015e-05);
diffrac->SetBinContent(138,1.449015e-05);
diffrac->SetBinContent(139,2.89803e-06);
diffrac->SetBinContent(140,5.79606e-06);
diffrac->SetBinContent(141,8.69409e-06);
diffrac->SetBinContent(142,1.159212e-05);
diffrac->SetBinContent(143,2.89803e-06);
diffrac->SetBinContent(144,1.159212e-05);
diffrac->SetBinContent(145,2.89803e-06);
diffrac->SetBinContent(146,2.89803e-06);
diffrac->SetBinContent(147,5.79606e-06);
diffrac->SetBinContent(149,8.69409e-06);
diffrac->SetBinContent(151,5.79606e-06);
diffrac->SetBinContent(152,8.69409e-06);
diffrac->SetBinContent(154,2.89803e-06);
diffrac->SetBinContent(155,2.89803e-06);
diffrac->SetBinContent(157,5.79606e-06);
diffrac->SetBinContent(170,2.89803e-06);
diffrac->SetBinContent(173,5.79606e-06);
diffrac->SetBinContent(178,2.89803e-06);
diffrac->SetBinError(1,2.109798e-05);
diffrac->SetBinError(2,7.872833e-05);
diffrac->SetBinError(3,0.0001065593);
diffrac->SetBinError(4,0.0001422694);
diffrac->SetBinError(5,0.0001825069);
diffrac->SetBinError(6,0.0002236183);
diffrac->SetBinError(7,0.0002601617);
diffrac->SetBinError(8,0.000294603);
diffrac->SetBinError(9,0.00031819);
diffrac->SetBinError(10,0.0003260638);
diffrac->SetBinError(11,0.0003374556);
diffrac->SetBinError(12,0.0003391438);
diffrac->SetBinError(13,0.0003337896);
diffrac->SetBinError(14,0.0003231531);
diffrac->SetBinError(15,0.0003154995);
diffrac->SetBinError(16,0.0003095742);
diffrac->SetBinError(17,0.0002962943);
diffrac->SetBinError(18,0.0002839921);
diffrac->SetBinError(19,0.0002806005);
diffrac->SetBinError(20,0.0002713336);
diffrac->SetBinError(21,0.0002575662);
diffrac->SetBinError(22,0.0002566189);
diffrac->SetBinError(23,0.0002493485);
diffrac->SetBinError(24,0.0002514615);
diffrac->SetBinError(25,0.0002409725);
diffrac->SetBinError(26,0.0002338802);
diffrac->SetBinError(27,0.0002245552);
diffrac->SetBinError(28,0.0002181237);
diffrac->SetBinError(29,0.0002131382);
diffrac->SetBinError(30,0.0002114371);
diffrac->SetBinError(31,0.0002066155);
diffrac->SetBinError(32,0.0002014704);
diffrac->SetBinError(33,0.0001930619);
diffrac->SetBinError(34,0.0001918399);
diffrac->SetBinError(35,0.0001925391);
diffrac->SetBinError(36,0.0001850432);
diffrac->SetBinError(37,0.0001826679);
diffrac->SetBinError(38,0.0001738093);
diffrac->SetBinError(39,0.0001724023);
diffrac->SetBinError(40,0.0001643467);
diffrac->SetBinError(41,0.0001617454);
diffrac->SetBinError(42,0.0001561444);
diffrac->SetBinError(43,0.0001554706);
diffrac->SetBinError(44,0.0001488753);
diffrac->SetBinError(45,0.0001514758);
diffrac->SetBinError(46,0.0001476574);
diffrac->SetBinError(47,0.0001391356);
diffrac->SetBinError(48,0.0001375267);
diffrac->SetBinError(49,0.0001319161);
diffrac->SetBinError(50,0.0001309255);
diffrac->SetBinError(51,0.0001344074);
diffrac->SetBinError(52,0.0001332148);
diffrac->SetBinError(53,0.0001261892);
diffrac->SetBinError(54,0.0001206082);
diffrac->SetBinError(55,0.0001176829);
diffrac->SetBinError(56,0.0001165354);
diffrac->SetBinError(57,0.0001123524);
diffrac->SetBinError(58,0.0001091677);
diffrac->SetBinError(59,0.0001091677);
diffrac->SetBinError(60,0.0001101633);
diffrac->SetBinError(61,9.997153e-05);
diffrac->SetBinError(62,0.0001020502);
diffrac->SetBinError(63,9.891584e-05);
diffrac->SetBinError(64,9.40856e-05);
diffrac->SetBinError(65,8.727835e-05);
diffrac->SetBinError(66,9.475273e-05);
diffrac->SetBinError(67,8.528287e-05);
diffrac->SetBinError(68,8.503632e-05);
diffrac->SetBinError(69,8.59206e-05);
diffrac->SetBinError(70,7.899458e-05);
diffrac->SetBinError(71,8.026026e-05);
diffrac->SetBinError(72,7.428234e-05);
diffrac->SetBinError(73,7.629033e-05);
diffrac->SetBinError(74,7.145862e-05);
diffrac->SetBinError(75,6.845733e-05);
diffrac->SetBinError(76,7.291296e-05);
diffrac->SetBinError(77,7.16347e-05);
diffrac->SetBinError(78,6.512512e-05);
diffrac->SetBinError(79,6.168108e-05);
diffrac->SetBinError(80,5.882358e-05);
diffrac->SetBinError(81,5.995491e-05);
diffrac->SetBinError(82,6.154477e-05);
diffrac->SetBinError(83,5.6493e-05);
diffrac->SetBinError(84,5.406205e-05);
diffrac->SetBinError(85,5.061192e-05);
diffrac->SetBinError(86,5.375045e-05);
diffrac->SetBinError(87,5.077759e-05);
diffrac->SetBinError(88,5.413967e-05);
diffrac->SetBinError(89,5.069482e-05);
diffrac->SetBinError(90,4.681911e-05);
diffrac->SetBinError(91,4.442596e-05);
diffrac->SetBinError(92,4.139215e-05);
diffrac->SetBinError(93,4.6187e-05);
diffrac->SetBinError(94,4.259217e-05);
diffrac->SetBinError(95,3.789666e-05);
diffrac->SetBinError(96,3.756276e-05);
diffrac->SetBinError(97,3.596361e-05);
diffrac->SetBinError(98,3.392057e-05);
diffrac->SetBinError(99,3.161377e-05);
diffrac->SetBinError(100,2.839478e-05);
diffrac->SetBinError(101,2.969597e-05);
diffrac->SetBinError(102,2.718593e-05);
diffrac->SetBinError(103,3.121274e-05);
diffrac->SetBinError(104,2.318424e-05);
diffrac->SetBinError(105,3.025632e-05);
diffrac->SetBinError(106,2.49298e-05);
diffrac->SetBinError(107,2.263434e-05);
diffrac->SetBinError(108,2.069607e-05);
diffrac->SetBinError(109,2.089799e-05);
diffrac->SetBinError(110,1.986789e-05);
diffrac->SetBinError(111,2.671852e-05);
diffrac->SetBinError(112,2.007814e-05);
diffrac->SetBinError(113,2.509768e-05);
diffrac->SetBinError(114,1.689827e-05);
diffrac->SetBinError(115,2.028621e-05);
diffrac->SetBinError(116,1.832875e-05);
diffrac->SetBinError(117,1.613555e-05);
diffrac->SetBinError(118,1.328044e-05);
diffrac->SetBinError(119,1.359297e-05);
diffrac->SetBinError(120,1.359297e-05);
diffrac->SetBinError(121,1.296038e-05);
diffrac->SetBinError(122,1.389846e-05);
diffrac->SetBinError(123,1.194888e-05);
diffrac->SetBinError(124,1.122402e-05);
diffrac->SetBinError(125,1.159212e-05);
diffrac->SetBinError(126,1.22953e-05);
diffrac->SetBinError(127,1.003907e-05);
diffrac->SetBinError(128,1.0449e-05);
diffrac->SetBinError(129,8.196866e-06);
diffrac->SetBinError(130,7.667466e-06);
diffrac->SetBinError(131,9.611678e-06);
diffrac->SetBinError(132,8.69409e-06);
diffrac->SetBinError(133,1.003907e-05);
diffrac->SetBinError(134,7.098695e-06);
diffrac->SetBinError(135,7.098695e-06);
diffrac->SetBinError(136,5.019535e-06);
diffrac->SetBinError(137,6.480192e-06);
diffrac->SetBinError(138,6.480192e-06);
diffrac->SetBinError(139,2.89803e-06);
diffrac->SetBinError(140,4.098433e-06);
diffrac->SetBinError(141,5.019535e-06);
diffrac->SetBinError(142,5.79606e-06);
diffrac->SetBinError(143,2.89803e-06);
diffrac->SetBinError(144,5.79606e-06);
diffrac->SetBinError(145,2.89803e-06);
diffrac->SetBinError(146,2.89803e-06);
diffrac->SetBinError(147,4.098433e-06);
diffrac->SetBinError(149,5.019535e-06);
diffrac->SetBinError(151,4.098433e-06);
diffrac->SetBinError(152,5.019535e-06);
diffrac->SetBinError(154,2.89803e-06);
diffrac->SetBinError(155,2.89803e-06);
diffrac->SetBinError(157,4.098433e-06);
diffrac->SetBinError(170,2.89803e-06);
diffrac->SetBinError(173,4.098433e-06);
diffrac->SetBinError(178,2.89803e-06);
diffrac->SetEntries(345062);
diffrac->SetDirectory(0);
diffrac->SetFillColor(1);
diffrac->SetFillStyle(0);
diffrac->SetLineStyle(2);
diffrac->SetLineWidth(3);
diffrac->SetMarkerStyle(20);
diffrac->GetXaxis()->SetTitle("M");
diffrac->GetXaxis()->SetLabelFont(42);
diffrac->GetXaxis()->SetLabelOffset(0.01);
diffrac->GetXaxis()->SetLabelSize(0.045);
diffrac->GetXaxis()->SetTitleSize(0.055);
diffrac->GetXaxis()->SetTitleFont(42);
diffrac->GetYaxis()->SetTitle("Fraction of events");
diffrac->GetYaxis()->SetLabelFont(42);
diffrac->GetYaxis()->SetLabelOffset(0.01);
diffrac->GetYaxis()->SetLabelSize(0.045);
diffrac->GetYaxis()->SetTitleSize(0.055);
diffrac->GetYaxis()->SetTitleOffset(1.6);
diffrac->GetYaxis()->SetTitleFont(42);
diffrac->GetZaxis()->SetLabelFont(42);
diffrac->GetZaxis()->SetLabelSize(0.045);
diffrac->GetZaxis()->SetTitleFont(42);
diffrac->Draw("p same");
TLegend *leg = new TLegend(0.61,0.67,0.91,0.87,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetTextSize(0.035);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(2);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("diffrac","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("diffrac","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("diffrac","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"diffrac");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
void makePlot(double canvasSizeX, double canvasSizeY,
TH1* histogramTTH,
TH1* histogramData,
TH1* histogramTT,
TH1* histogramTTV,
TH1* histogramEWK,
TH1* histogramRares,
TH1* histogramBgrSum,
TH1* histogramBgrUncertainty,
const std::string& xAxisTitle, double xAxisOffset,
bool useLogScale, double yMin, double yMax, const std::string& yAxisTitle, double yAxisOffset,
const std::string& outputFileName)
{
TH1* histogramTTH_density = 0;
if ( histogramTTH ) {
if ( histogramData ) checkCompatibleBinning(histogramTTH, histogramData);
histogramTTH_density = divideHistogramByBinWidth(histogramTTH);
}
TH1* histogramData_density = 0;
if ( histogramData ) {
histogramData_density = divideHistogramByBinWidth(histogramData);
}
TH1* histogramTT_density = 0;
if ( histogramTT ) {
if ( histogramData ) checkCompatibleBinning(histogramTT, histogramData);
histogramTT_density = divideHistogramByBinWidth(histogramTT);
}
TH1* histogramTTV_density = 0;
if ( histogramTTV ) {
if ( histogramData ) checkCompatibleBinning(histogramTTV, histogramData);
histogramTTV_density = divideHistogramByBinWidth(histogramTTV);
}
TH1* histogramEWK_density = 0;
if ( histogramEWK ) {
if ( histogramData ) checkCompatibleBinning(histogramEWK, histogramData);
histogramEWK_density = divideHistogramByBinWidth(histogramEWK);
}
TH1* histogramRares_density = 0;
if ( histogramRares ) {
if ( histogramData ) checkCompatibleBinning(histogramRares, histogramData);
histogramRares_density = divideHistogramByBinWidth(histogramRares);
}
TH1* histogramBgrSum_density = 0;
if ( histogramBgrSum ) {
if ( histogramData ) checkCompatibleBinning(histogramBgrSum, histogramData);
histogramBgrSum_density = divideHistogramByBinWidth(histogramBgrSum);
}
TH1* histogramBgrUncertainty_density = 0;
if ( histogramBgrUncertainty ) {
if ( histogramData ) checkCompatibleBinning(histogramBgrUncertainty, histogramData);
histogramBgrUncertainty_density = divideHistogramByBinWidth(histogramBgrUncertainty);
}
TCanvas* canvas = new TCanvas("canvas", "", canvasSizeX, canvasSizeY);
canvas->SetFillColor(10);
canvas->SetFillStyle(4000);
canvas->SetFillColor(10);
canvas->SetTicky();
canvas->SetBorderSize(2);
canvas->SetLeftMargin(0.12);
canvas->SetBottomMargin(0.12);
TPad* topPad = new TPad("topPad", "topPad", 0.00, 0.35, 1.00, 1.00);
topPad->SetFillColor(10);
topPad->SetTopMargin(0.065);
topPad->SetLeftMargin(0.15);
topPad->SetBottomMargin(0.03);
topPad->SetRightMargin(0.05);
topPad->SetLogy(useLogScale);
TPad* bottomPad = new TPad("bottomPad", "bottomPad", 0.00, 0.00, 1.00, 0.35);
bottomPad->SetFillColor(10);
bottomPad->SetTopMargin(0.02);
bottomPad->SetLeftMargin(0.15);
bottomPad->SetBottomMargin(0.31);
bottomPad->SetRightMargin(0.05);
bottomPad->SetLogy(false);
canvas->cd();
topPad->Draw();
topPad->cd();
TAxis* xAxis_top = histogramData_density->GetXaxis();
xAxis_top->SetTitle(xAxisTitle.data());
xAxis_top->SetTitleOffset(xAxisOffset);
xAxis_top->SetLabelColor(10);
xAxis_top->SetTitleColor(10);
TAxis* yAxis_top = histogramData_density->GetYaxis();
yAxis_top->SetTitle(yAxisTitle.data());
yAxis_top->SetTitleOffset(yAxisOffset);
yAxis_top->SetTitleSize(0.085);
yAxis_top->SetLabelSize(0.05);
yAxis_top->SetTickLength(0.04);
TLegend* legend = new TLegend(0.66, 0.45, 0.94, 0.92, NULL, "brNDC");
legend->SetFillStyle(0);
legend->SetBorderSize(0);
legend->SetFillColor(10);
legend->SetTextSize(0.055);
histogramData_density->SetTitle("");
histogramData_density->SetStats(false);
histogramData_density->SetMaximum(yMax);
histogramData_density->SetMinimum(yMin);
histogramData_density->SetMarkerStyle(20);
histogramData_density->SetMarkerSize(2);
histogramData_density->SetMarkerColor(kBlack);
histogramData_density->SetLineColor(kBlack);
legend->AddEntry(histogramData_density, "Observed", "p");
histogramData_density->Draw("ep");
legend->AddEntry(histogramTTH_density, "t#bar{t}H", "l");
histogramTT_density->SetTitle("");
histogramTT_density->SetStats(false);
histogramTT_density->SetMaximum(yMax);
histogramTT_density->SetMinimum(yMin);
histogramTT_density->SetFillColor(kMagenta - 10);
legend->AddEntry(histogramTT_density, "t#bar{t}+jets", "f");
histogramTTV_density->SetFillColor(kOrange - 4);
legend->AddEntry(histogramTTV_density, "t#bar{t}+V", "f");
histogramEWK_density->SetFillColor(kRed + 2);
legend->AddEntry(histogramEWK_density, "EWK", "f");
histogramRares_density->SetFillColor(kBlue - 8);
legend->AddEntry(histogramRares_density, "Rares", "f");
THStack* histogramStack_density = new THStack("stack", "");
histogramStack_density->Add(histogramRares_density);
histogramStack_density->Add(histogramEWK_density);
histogramStack_density->Add(histogramTTV_density);
histogramStack_density->Add(histogramTT_density);
histogramStack_density->Draw("histsame");
histogramBgrUncertainty_density->SetFillColor(kBlack);
histogramBgrUncertainty_density->SetFillStyle(3344);
histogramBgrUncertainty_density->Draw("e2same");
legend->AddEntry(histogramBgrUncertainty_density, "Uncertainty", "f");
histogramTTH_density->SetLineWidth(2);
histogramTTH_density->SetLineStyle(1);
histogramTTH_density->SetLineColor(kBlue);
histogramTTH_density->Draw("histsame");
histogramData_density->Draw("epsame");
histogramData_density->Draw("axissame");
legend->Draw();
addLabel_CMS_luminosity(0.2050, 0.9225, 0.6850);
canvas->cd();
bottomPad->Draw();
bottomPad->cd();
TH1* histogramRatio = (TH1*)histogramData->Clone("histogramRatio");
histogramRatio->Reset();
if ( !histogramRatio->GetSumw2N() ) histogramRatio->Sumw2();
checkCompatibleBinning(histogramRatio, histogramBgrSum);
histogramRatio->Divide(histogramData, histogramBgrSum);
int numBins_bottom = histogramRatio->GetNbinsX();
for ( int iBin = 1; iBin <= numBins_bottom; ++iBin ) {
double binContent = histogramRatio->GetBinContent(iBin);
if ( histogramData && histogramData->GetBinContent(iBin) >= 0. ) histogramRatio->SetBinContent(iBin, binContent - 1.0);
else histogramRatio->SetBinContent(iBin, -10.);
}
histogramRatio->SetTitle("");
histogramRatio->SetStats(false);
histogramRatio->SetMinimum(-0.50);
histogramRatio->SetMaximum(+0.50);
histogramRatio->SetMarkerStyle(histogramData_density->GetMarkerStyle());
histogramRatio->SetMarkerSize(histogramData_density->GetMarkerSize());
histogramRatio->SetMarkerColor(histogramData_density->GetMarkerColor());
histogramRatio->SetLineColor(histogramData_density->GetLineColor());
histogramRatio->Draw("ep");
TAxis* xAxis_bottom = histogramRatio->GetXaxis();
xAxis_bottom->SetTitle(xAxis_top->GetTitle());
xAxis_bottom->SetLabelColor(1);
xAxis_bottom->SetTitleColor(1);
xAxis_bottom->SetTitleOffset(1.20);
xAxis_bottom->SetTitleSize(0.13);
xAxis_bottom->SetLabelOffset(0.02);
xAxis_bottom->SetLabelSize(0.10);
xAxis_bottom->SetTickLength(0.055);
TAxis* yAxis_bottom = histogramRatio->GetYaxis();
yAxis_bottom->SetTitle("#frac{Data - Simulation}{Simulation}");
yAxis_bottom->SetTitleOffset(0.80);
yAxis_bottom->SetNdivisions(505);
yAxis_bottom->CenterTitle();
yAxis_bottom->SetTitleSize(0.09);
yAxis_bottom->SetLabelSize(0.10);
yAxis_bottom->SetTickLength(0.04);
TH1* histogramRatioUncertainty = (TH1*)histogramBgrUncertainty->Clone("histogramRatioUncertainty");
if ( !histogramRatioUncertainty->GetSumw2N() ) histogramRatioUncertainty->Sumw2();
checkCompatibleBinning(histogramRatioUncertainty, histogramBgrUncertainty);
histogramRatioUncertainty->Divide(histogramBgrSum);
int numBins = histogramRatioUncertainty->GetNbinsX();
for ( int iBin = 1; iBin <= numBins; ++iBin ) {
double binContent = histogramRatioUncertainty->GetBinContent(iBin);
histogramRatioUncertainty->SetBinContent(iBin, binContent - 1.0);
}
histogramRatioUncertainty->SetFillColor(histogramBgrUncertainty_density->GetFillColor());
//histogramRatioUncertainty->SetFillStyle(histogramBgrUncertainty_density->GetFillStyle());
histogramRatioUncertainty->SetFillStyle(3644);
TF1* line = new TF1("line","0", xAxis_bottom->GetXmin(), xAxis_bottom->GetXmax());
line->SetLineStyle(3);
line->SetLineWidth(1);
line->SetLineColor(kBlack);
line->Draw("same");
histogramRatioUncertainty->Draw("e2same");
histogramRatio->Draw("epsame");
canvas->Update();
size_t idx = outputFileName.find(".");
std::string outputFileName_plot(outputFileName, 0, idx);
if ( useLogScale ) outputFileName_plot.append("_log");
else outputFileName_plot.append("_linear");
if ( idx != std::string::npos ) canvas->Print(std::string(outputFileName_plot).append(std::string(outputFileName, idx)).data());
canvas->Print(std::string(outputFileName_plot).append(".png").data());
canvas->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas->Print(std::string(outputFileName_plot).append(".root").data());
delete histogramTTH_density;
delete histogramData_density;
delete histogramTT_density;
delete histogramTTV_density;
delete histogramEWK_density;
delete histogramRares_density;
delete histogramBgrSum_density;
//delete histogramBgrUncertainty_density;
delete histogramStack_density;
delete legend;
delete topPad;
delete histogramRatio;
delete histogramRatioUncertainty;
delete line;
delete bottomPad;
delete canvas;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& sample, int massPoint, const std::string& channel, double k,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( massPoint == 90 ) idxPad = 1;
if ( massPoint == 125 ) idxPad = 2;
if ( massPoint == 200 ) idxPad = 3;
if ( massPoint == 300 ) idxPad = 4;
if ( massPoint == 500 ) idxPad = 5;
if ( massPoint == 800 ) idxPad = 6;
if ( !(idxPad >= 1 && idxPad <= 6) ) {
std::cerr << "Invalid sample = " << sample << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 800);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.165);
canvas_new->SetRightMargin(0.015);
canvas_new->SetLogx(true);
canvas_new->SetLogy(true);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramCA = 0;
TH1* histogramSVfit = 0;
TH1* histogramSVfitMEMkEq0 = 0;
TH1* histogramSVfitMEMkNeq0 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
std::cout << "(mean = " << tmpHistogram->GetMean() << ", rms = " << tmpHistogram->GetRMS() << ": rms/mean = " << (tmpHistogram->GetRMS()/tmpHistogram->GetMean()) << ")" << std::endl;
if ( tmpHistogram->GetLineColor() == 416 ) histogramCA = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 600 ) histogramSVfit = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 616 ) histogramSVfitMEMkEq0 = tmpHistogram;
if ( tmpHistogram->GetLineColor() == 632 ) histogramSVfitMEMkNeq0 = tmpHistogram;
}
}
if ( !(histogramCA && histogramSVfit && histogramSVfitMEMkEq0 && histogramSVfitMEMkNeq0) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
//gStyle->SetLineStyleString(2,"40 10 10 10 10 10 10 10");
//gStyle->SetLineStyleString(3,"25 15");
//gStyle->SetLineStyleString(4,"60 25");
//int colors[4] = { kBlack, kGreen - 6, kBlue - 7, kMagenta - 7 };
int colors[4] = { 28, kGreen - 6, kBlue - 7, kBlack };
//int lineStyles[4] = { 2, 3, 4, 1 };
int lineStyles[4] = { 7, 1, 1, 1 };
//int lineWidths[4] = { 3, 3, 4, 3 };
int lineWidths[4] = { 3, 3, 1, 1 };
int markerStyles[4] = { 20, 25, 21, 24 };
int markerSizes[4] = { 2, 2, 2, 2 };
histogramCA->SetFillColor(0);
histogramCA->SetFillStyle(0);
histogramCA->SetLineColor(colors[0]);
histogramCA->SetLineStyle(lineStyles[0]);
histogramCA->SetLineWidth(lineWidths[0]);
histogramCA->SetMarkerColor(colors[0]);
histogramCA->SetMarkerStyle(markerStyles[0]);
histogramCA->SetMarkerSize(markerSizes[0]);
histogramSVfit->SetFillColor(0);
histogramSVfit->SetFillStyle(0);
histogramSVfit->SetLineColor(colors[1]);
histogramSVfit->SetLineStyle(lineStyles[1]);
histogramSVfit->SetLineWidth(lineWidths[1]);
histogramSVfit->SetMarkerColor(colors[1]);
histogramSVfit->SetMarkerStyle(markerStyles[1]);
histogramSVfit->SetMarkerSize(markerSizes[1]);
histogramSVfitMEMkEq0->SetFillColor(0);
histogramSVfitMEMkEq0->SetFillStyle(0);
histogramSVfitMEMkEq0->SetLineColor(colors[2]);
histogramSVfitMEMkEq0->SetLineStyle(lineStyles[2]);
histogramSVfitMEMkEq0->SetLineWidth(lineWidths[2]);
histogramSVfitMEMkEq0->SetMarkerColor(colors[2]);
histogramSVfitMEMkEq0->SetMarkerStyle(markerStyles[2]);
histogramSVfitMEMkEq0->SetMarkerSize(markerSizes[2]);
// CV: fix pathological bins at high mass for which dN/dm increases
int numBins = histogramSVfitMEMkEq0->GetNbinsX();
for ( int idxBin = 1; idxBin <= numBins; ++idxBin ) {
double binCenter = histogramSVfitMEMkEq0->GetBinCenter(idxBin);
if ( (channel == "#tau_{h}#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#tau_{h}#tau_{h}" && massPoint == 800 && binCenter > 2000.) ||
(channel == "#mu#tau_{h}" && massPoint == 500 && binCenter > 1500.) ||
(channel == "#mu#tau_{h}" && massPoint == 800 && binCenter > 2500.) ) {
histogramSVfitMEMkEq0->SetBinContent(idxBin, 0.);
}
}
histogramSVfitMEMkNeq0->SetFillColor(0);
histogramSVfitMEMkNeq0->SetFillStyle(0);
histogramSVfitMEMkNeq0->SetLineColor(colors[3]);
histogramSVfitMEMkNeq0->SetLineStyle(lineStyles[3]);
histogramSVfitMEMkNeq0->SetLineWidth(lineWidths[3]);
histogramSVfitMEMkNeq0->SetMarkerColor(colors[3]);
histogramSVfitMEMkNeq0->SetMarkerStyle(markerStyles[3]);
histogramSVfitMEMkNeq0->SetMarkerSize(markerSizes[3]);
TAxis* xAxis = histogramCA->GetXaxis();
xAxis->SetTitle("m_{#tau#tau} [GeV]");
xAxis->SetTitleOffset(1.15);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.055);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(510);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramCA->GetYaxis();
yAxis->SetTitle("dN/dm_{#tau#tau} [1/GeV]");
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
double massPoint_double = 0.;
if ( massPoint == 90 ) massPoint_double = 91.2;
else massPoint_double = massPoint;
double dLog = (TMath::Log(5.*massPoint_double) - TMath::Log(50.))/25.; // xMin = 50, xMax = 5*massPoint, numBins = 25
double binWidth = TMath::Exp(TMath::Log(massPoint_double) + 0.5*dLog) - TMath::Exp(TMath::Log(massPoint_double) - 0.5*dLog);
double sf_binWidth = 1./binWidth;
std::cout << "massPoint = " << massPoint << ": sf_binWidth = " << sf_binWidth << std::endl;
histogramCA->SetTitle("");
histogramCA->SetStats(false);
histogramCA->SetMaximum(sf_binWidth*0.79);
histogramCA->SetMinimum(sf_binWidth*1.1e-4);
histogramCA->Draw("hist");
histogramSVfit->Draw("histsame");
//histogramSVfitMEMkEq0->Draw("histsame");
histogramSVfitMEMkEq0->Draw("epsame");
//histogramSVfitMEMkNeq0->Draw("histsame");
histogramSVfitMEMkNeq0->Draw("epsame");
histogramCA->Draw("axissame");
//TPaveText* label_sample = new TPaveText(0.21, 0.86, 0.46, 0.94, "NDC");
TPaveText* label_sample = new TPaveText(0.1700, 0.9475, 0.4600, 1.0375, "NDC");
label_sample->SetFillStyle(0);
label_sample->SetBorderSize(0);
label_sample->AddText(sample.data());
label_sample->SetTextFont(42);
label_sample->SetTextSize(0.055);
label_sample->SetTextColor(1);
label_sample->SetTextAlign(13);
label_sample->Draw();
//TLegend* legend_new = new TLegend(0.225, 0.52, 0.41, 0.82, NULL, "brNDC");
TLegend* legend_new = new TLegend(0.30, 0.30, 0.80, 0.80, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramCA, "CA", "l");
legend_new->AddEntry(histogramSVfit, "SVfit", "l");
//legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "l");
legend_new->AddEntry(histogramSVfitMEMkEq0, "SVfitMEM (k=0)", "p");
//legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM(k=%1.0f)", k), "l");
legend_new->AddEntry(histogramSVfitMEMkNeq0, Form("SVfitMEM (k=%1.0f)", k), "p");
//legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.895, label_channel_y0, 0.975, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
std::string channel_string;
if ( channel == "e#mu" ) channel_string = "emu";
else if ( channel == "#mu#tau_{h}" ) channel_string = "muhad";
else if ( channel == "#tau_{h}#tau_{h}" ) channel_string = "hadhad";
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
std::string outputFileName_legend = Form("makeSVfitMEM_PerformancePlots_legend_%s.pdf", channel_string.data());
makePlot_legend(legend_new, outputFilePath, outputFileName_legend);
delete label_sample;
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
void ConnectToServer(const TInetAddress *hostb, Int_t port)
{
// Called by the Bonjour resolver with the host and port to which
// we can connect.
// Connect only once...
TBonjourResolver *resolver = (TBonjourResolver*) gTQSender;
TInetAddress host = *hostb;
delete resolver;
printf("ConnectToServer: host = %s, port = %d\n", host.GetHostName(), port);
//--- Here starts original hclient.C code ---
// Open connection to server
TSocket *sock = new TSocket(host.GetHostName(), port);
// Wait till we get the start message
char str[32];
sock->Recv(str, 32);
// server tells us who we are
int idx = !strcmp(str, "go 0") ? 0 : 1;
Float_t messlen = 0;
Float_t cmesslen = 0;
if (idx == 1)
sock->SetCompressionLevel(1);
TH1 *hpx;
if (idx == 0) {
// Create the histogram
hpx = new TH1F("hpx","This is the px distribution",100,-4,4);
hpx->SetFillColor(48); // set nice fillcolor
} else {
hpx = new TH2F("hpxpy","py vs px",40,-4,4,40,-4,4);
}
TMessage::EnableSchemaEvolutionForAll(gEvo);
TMessage mess(kMESS_OBJECT);
//TMessage mess(kMESS_OBJECT | kMESS_ACK);
// Fill histogram randomly
gRandom->SetSeed();
Float_t px, py;
const int kUPDATE = 1000;
for (int i = 0; i < 25000; i++) {
gRandom->Rannor(px,py);
if (idx == 0)
hpx->Fill(px);
else
hpx->Fill(px,py);
if (i && (i%kUPDATE) == 0) {
mess.Reset(); // re-use TMessage object
mess.WriteObject(hpx); // write object in message buffer
sock->Send(mess); // send message
messlen += mess.Length();
cmesslen += mess.CompLength();
}
}
sock->Send("Finished"); // tell server we are finished
if (cmesslen > 0)
printf("Average compression ratio: %g\n", messlen/cmesslen);
gBenchmark->Show("hclient");
// Close the socket
sock->Close();
}
void makeSystPlot( TFile * f, TString oldFolder, RooWorkspace *WS, string channel, string syst, int toMassNo, int fromMassNo, int rightBinNo, int addRightBin, int addRightBinm1) //massNo 0-51, see xSec7TeV.h
{
std::cout << "oldFolder, channel , addRightBin, addRightBinm1: " << oldFolder << " , " <<channel << " , " << addRightBin << " , "<< addRightBinm1 << std::endl;
RooArgList * hobs = new RooArgList("hobs");
// RooRealVar BDT("BDT", "BDT", -1, 1);///OLD VARIABLE NAME HERE
RooRealVar BDT("CMS_vhbb_BDT_Wln", "CMS_vhbb_BDT_Wln", -1, 1);///OLD VARIABLE NAME HERE
hobs->add(*WS->var("CMS_vhbb_BDT_Wln")); ///NEW VARIABLE NAME HERE
RooWorkspace *tempWS = (RooWorkspace*) f->Get(oldFolder.Data());
TString systT(syst);
TString chanT(channel);
if((kount < 3) && (channel=="data_obs"))
{
kount++;
std::string namen = channel;
std::cout << oldFolder.Data() << std::endl;
std::cout << namen << std::endl;
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,RooFit::Binning(bins));
tempHistNom->Rebin(rebin);
if(addRightBin == 1)
{
float err0 = tempHistNom->GetBinError(rightBinNo);
float con0 = tempHistNom->GetBinContent(rightBinNo);
float err1 = tempHistNom->GetBinError(rightBinNo-1);
float con1 = tempHistNom->GetBinContent(rightBinNo-1);
tempHistNom->SetBinContent(rightBinNo,0);
tempHistNom->SetBinError(rightBinNo,0);
tempHistNom->SetBinContent(rightBinNo-1,con0+con1);
tempHistNom->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1));
}
if(addRightBinm1 == 1)
{
float err0 = tempHistNom->GetBinError(rightBinNo-1);
float con0 = tempHistNom->GetBinContent(rightBinNo-1);
float err1 = tempHistNom->GetBinError(rightBinNo-2);
float con1 = tempHistNom->GetBinContent(rightBinNo-2);
tempHistNom->SetBinContent(rightBinNo-1,0);
tempHistNom->SetBinError(rightBinNo-1,0);
tempHistNom->SetBinContent(rightBinNo-2,con0+con1);
tempHistNom->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1));
}
RooDataHist *DHnom = new RooDataHist(channel.c_str(),"",*hobs,tempHistNom);
WS->import(*(new RooHistPdf(channel.c_str(),"",*hobs,*DHnom)));
}
if (channel!="data_obs")
{
std::string nameUp;
std::string namen;
std::string nameDown;
if(syst == "stat")
{
if(oldFolder.Contains("Wenu"))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_WenuUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_WenuDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_WenuUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_WenuDown";
}
}
else
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_WmunuUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_WmunuDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_WmunuUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_WmunuDown";
}
}
}
else
{
nameUp = channel + "_CMS_" + syst + "Up";
namen = channel;
nameDown = channel + "_CMS_" + syst + "Down";
}
if((syst == "stat") && (oldFolder.Contains("2")))
{
if(oldFolder.Contains("Wenu"))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu2Up";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu2Down";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wenu2Up";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wenu2Down";
}
}
else
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmunu2Up";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmunu2Down";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wmunu2Up";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wmunu2Down";
}
}
}
if(systT.Contains("Model"))
{
nameUp = channel + "_CMS_vhbb_WModelUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_WModelDown";
}
if( systT.Contains("stat") && (oldFolder.Contains("Wenu")) && IFILE.Contains("8TeV") && !(oldFolder.Contains("2")))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu_8TeVDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wenu_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wenu_8TeVDown";
}
}
if( systT.Contains("stat") && (oldFolder.Contains("Wmunu")) && IFILE.Contains("8TeV") && !(oldFolder.Contains("2")))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmnu_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmnu_8TeVDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wmnu_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wmnu_8TeVDown";
}
}
if( systT.Contains("stat") && (oldFolder.Contains("Wenu")) && IFILE.Contains("8TeV") && (oldFolder.Contains("2")))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wenu2_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wenu2_8TeVDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wenu2_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wenu2_8TeVDown";
}
}
if( systT.Contains("stat") && (oldFolder.Contains("Wmunu")) && IFILE.Contains("8TeV") && (oldFolder.Contains("2")))
{
nameUp = channel + "_CMS_vhbb_stat" + channel + "_Wmnu2_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_stat" + channel + "_Wmnu2_8TeVDown";
if(channel == "s_Top")
{
nameUp = channel + "_CMS_vhbb_statsTop_Wmnu2_8TeVUp";
namen = channel;
nameDown = channel + "_CMS_vhbb_statsTop_Wmnu2_8TeVDown";
}
}
RooDataHist* tempRooDataHistUp = (RooDataHist*) tempWS->data(nameUp.c_str());
RooDataHist* tempRooDataHistDown = (RooDataHist*) tempWS->data(nameDown.c_str());
RooDataHist* tempRooDataHistNom = (RooDataHist*) tempWS->data(namen.c_str());
std::cout << oldFolder.Data() << std::endl;
std::cout << nameUp.c_str() << std::endl;
TH1 *tempHistUp = tempRooDataHistUp->createHistogram(nameUp.c_str(),BDT,RooFit::Binning(bins));
TH1 *tempHistDown = tempRooDataHistDown->createHistogram(nameDown.c_str(),BDT,RooFit::Binning(bins));
TH1 *tempHistNom = tempRooDataHistNom->createHistogram(namen.c_str(),BDT,RooFit::Binning(bins));
if(chanT.Contains("WH") && IFILE.Contains("7TeV"))
{
tempHistUp->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]);
tempHistDown->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]);
tempHistNom->Scale(xSec7WH[toMassNo]/xSec7WH[fromMassNo]);
}
if(chanT.Contains("WH") && IFILE.Contains("8TeV"))
{
tempHistUp->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]);
tempHistDown->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]);
tempHistNom->Scale(xSec8WH[toMassNo]/xSec8WH[fromMassNo]);
}
std::cout<< "channel--> " << channel << std::endl;
tempHistUp->SetLineColor(kRed);
tempHistUp->SetLineWidth(3);
tempHistUp->SetFillColor(0);
tempHistDown->SetLineColor(kBlue);
tempHistDown->SetFillColor(0);
tempHistDown->SetLineWidth(3);
tempHistNom->SetFillColor(0);
tempHistNom->SetMarkerStyle(20);
tempHistUp->SetTitle((channel + syst).c_str());
tempHistNom->Rebin(rebin);
tempHistUp->Rebin(rebin);
tempHistDown->Rebin(rebin);
if(addRightBin == 1)
{
float err0 = tempHistNom->GetBinError(rightBinNo);
float con0 = tempHistNom->GetBinContent(rightBinNo);
float err1 = tempHistNom->GetBinError(rightBinNo-1);
float con1 = tempHistNom->GetBinContent(rightBinNo-1);
tempHistNom->SetBinContent(rightBinNo,0);
tempHistNom->SetBinError(rightBinNo,0);
tempHistNom->SetBinContent(rightBinNo-1,con0+con1);
tempHistNom->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1));
err0 = tempHistUp->GetBinError(rightBinNo);
con0 = tempHistUp->GetBinContent(rightBinNo);
err1 = tempHistUp->GetBinError(rightBinNo-1);
con1 = tempHistUp->GetBinContent(rightBinNo-1);
tempHistUp->SetBinContent(rightBinNo,0);
tempHistUp->SetBinError(rightBinNo,0);
tempHistUp->SetBinContent(rightBinNo-1,con0+con1);
tempHistUp->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1));
err0 = tempHistDown->GetBinError(rightBinNo);
con0 = tempHistDown->GetBinContent(rightBinNo);
err1 = tempHistDown->GetBinError(rightBinNo-1);
con1 = tempHistDown->GetBinContent(rightBinNo-1);
tempHistDown->SetBinContent(rightBinNo,0);
tempHistDown->SetBinError(rightBinNo,0);
tempHistDown->SetBinContent(rightBinNo-1,con0+con1);
tempHistDown->SetBinError(rightBinNo-1,sqrt(err0*err0+err1*err1));
}
if(addRightBinm1 == 1)
{
float err0 = tempHistNom->GetBinError(rightBinNo-1);
float con0 = tempHistNom->GetBinContent(rightBinNo-1);
float err1 = tempHistNom->GetBinError(rightBinNo-2);
float con1 = tempHistNom->GetBinContent(rightBinNo-2);
tempHistNom->SetBinContent(rightBinNo-1,0);
tempHistNom->SetBinError(rightBinNo-1,0);
tempHistNom->SetBinContent(rightBinNo-2,con0+con1);
tempHistNom->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1));
err0 = tempHistUp->GetBinError(rightBinNo-1);
con0 = tempHistUp->GetBinContent(rightBinNo-1);
err1 = tempHistUp->GetBinError(rightBinNo-2);
con1 = tempHistUp->GetBinContent(rightBinNo-2);
tempHistUp->SetBinContent(rightBinNo-1,0);
tempHistUp->SetBinError(rightBinNo-1,0);
tempHistUp->SetBinContent(rightBinNo-2,con0+con1);
tempHistUp->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1));
err0 = tempHistDown->GetBinError(rightBinNo-1);
con0 = tempHistDown->GetBinContent(rightBinNo-1);
err1 = tempHistDown->GetBinError(rightBinNo-2);
con1 = tempHistDown->GetBinContent(rightBinNo-2);
tempHistDown->SetBinContent(rightBinNo-1,0);
tempHistDown->SetBinError(rightBinNo-1,0);
tempHistDown->SetBinContent(rightBinNo-2,con0+con1);
tempHistDown->SetBinError(rightBinNo-2,sqrt(err0*err0+err1*err1));
}
RooDataHist *DHnom;
RooDataHist *DHup = new RooDataHist(nameUp.c_str(),"",*hobs,tempHistUp);
if(kount2 < 3) DHnom = new RooDataHist(namen.c_str(),"",*hobs,tempHistNom);
RooDataHist *DHdown = new RooDataHist(nameDown.c_str(),"",*hobs,tempHistDown);
WS->import(*(new RooHistPdf(nameUp.c_str(),"",*hobs,*DHup)));
WS->import(*(new RooHistPdf(nameDown.c_str(),"",*hobs,*DHdown)));
if(kount2 < 3){ WS->import(*(new RooHistPdf(namen.c_str(),"",*hobs,*DHnom))); kount2++;}
}
}
//------------------------------------------
TH1* GetHistoClSize(int npix,int id,TObjArray* harr)
{
// book histos
TH1* h = 0;
if (!harr) harr = &histoArr;
//
if (npix<1) {
if (harr->GetEntriesFast()>=id && (h=(TH1*)harr->At(id))) return h;
h = new TH1F("npixAll","npixAll",150,0.5,54.5);
h->SetDirectory(0);
h->SetLineColor(kRed);
harr->AddAtAndExpand(h, kNPixAll);
//
h = new TH1F("npixSpl","npixSpl",150,0.5,54.5);
h->SetLineColor(kBlue);
h->SetDirectory(0);
harr->AddAtAndExpand(h, kNPixSPL);
//
h = (TH1*)harr->At(id);
if (!h) {printf("Unknown histo id=%d\n",id); exit(1);}
return h;
}
//
int idh = npix*10+id;
if (harr->GetEntriesFast()>=idh && (h=(TH1*)harr->At(idh))) return h;
//
const int nbin=100;
const double kdiff=80;
// need to create set of histos
//
h = new TH1F(Form("dxy_npix%d",npix),Form("dr_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDR);
//
h = new TH1F(Form("dtxODD_npix%d",npix),Form("dtxODD_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
h->SetLineColor(kRed);
harr->AddAtAndExpand(h, npix*10 + kDTXodd);
h = new TH1F(Form("dtxEVN_npix%d",npix),Form("dtxEVN_npix%d",npix),nbin,-kdiff,kdiff);
h->SetDirectory(0);
h->SetLineColor(kBlue);
harr->AddAtAndExpand(h, npix*10 + kDTXeven);
//
h = new TH1F(Form("dtz_npix%d",npix),Form("dtz_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kGreen);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTZ);
//
//
h = new TH1F(Form("SPL_dtxODD_npix%d",npix),Form("SPL_dtxODD_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kMagenta);
h->SetFillColor(kMagenta);
h->SetFillStyle(3001);
h->SetLineStyle(2);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTXoddSPL);
h = new TH1F(Form("SPL_dtxEVN_npix%d",npix),Form("SPL_dtxEVN_npix%d",npix),nbin,-kdiff,kdiff);
h->SetLineColor(kCyan);
h->SetFillColor(kCyan);
h->SetFillStyle(3006);
h->SetLineStyle(2);
h->SetDirectory(0);
harr->AddAtAndExpand(h, npix*10 + kDTXevenSPL);
//
h = new TH1F(Form("SPL_dtz_npix%d",npix),Form("SPLdtz_npix%d",npix),nbin,-kdiff,kdiff);
harr->AddAtAndExpand(h, npix*10 + kDTZSPL);
h->SetDirectory(0);
//
h->SetLineColor(kGreen+2);
h->SetFillColor(kGreen+2);
h->SetLineStyle(2);
h->SetFillStyle(3001);
h = (TH1*)harr->At(idh);
if (!h) {printf("Unknown histo id=%d\n",idh); exit(1);}
return h;
}
void makePlot(const std::string& inputFilePath, const std::string& canvasName, const std::string& histogram, const std::string& channel, const std::string& xAxisTitle, const std::string& yAxisTitle,
const std::string& inputFileName, const std::string& outputFilePath, const std::string& outputFileName)
{
std::string inputFileName_full = Form("%s%s", inputFilePath.data(), inputFileName.data());
TFile* inputFile = new TFile(inputFileName_full.data());
if ( !inputFile ) {
std::cerr << "Failed to open input file = " << inputFileName_full << " !!" << std::endl;
assert(0);
}
inputFile->ls();
TCanvas* canvas = dynamic_cast<TCanvas*>(inputFile->Get(canvasName.data()));
if ( !canvas ) {
std::cerr << "Failed to load canvas = " << canvasName << " !!" << std::endl;
assert(0);
}
int idxPad = -1;
if ( histogram == "mVis" ) idxPad = 1;
if ( histogram == "mTauTau" ) idxPad = 2;
if ( !(idxPad >= 1 && idxPad <= 2) ) {
std::cerr << "Invalid histogram = " << histogram << " !!" << std::endl;
assert(0);
}
TVirtualPad* pad = canvas->GetPad(idxPad);
std::cout << "pad = " << pad << ": ClassName = " << pad->ClassName() << std::endl;
TCanvas* canvas_new = new TCanvas("canvas_new", "canvas_new", 900, 850);
canvas_new->SetFillColor(10);
canvas_new->SetBorderSize(2);
canvas_new->SetTopMargin(0.065);
canvas_new->SetLeftMargin(0.17);
canvas_new->SetBottomMargin(0.155);
canvas_new->SetRightMargin(0.045);
canvas_new->SetLogx(false);
canvas_new->SetLogy(false);
canvas_new->Draw();
canvas_new->cd();
//TList* pad_primitives = canvas->GetListOfPrimitives();
TList* pad_primitives = pad->GetListOfPrimitives();
TH1* histogramDYJets = 0;
TH1* histogramHiggs125 = 0;
TH1* histogramHiggs200 = 0;
TH1* histogramHiggs300 = 0;
TIter pad_nextObj(pad_primitives);
while ( TObject* obj = pad_nextObj() ) {
std::string objName = "";
if ( dynamic_cast<TNamed*>(obj) ) objName = (dynamic_cast<TNamed*>(obj))->GetName();
std::cout << "obj = " << obj << ": name = " << objName << ", type = " << obj->ClassName() << std::endl;
TH1* tmpHistogram = dynamic_cast<TH1*>(obj);
if ( tmpHistogram ) {
std::cout << "tmpHistogram:"
<< " fillColor = " << tmpHistogram->GetFillColor() << ", fillStyle = " << tmpHistogram->GetFillStyle() << ","
<< " lineColor = " << tmpHistogram->GetLineColor() << ", lineStyle = " << tmpHistogram->GetLineStyle() << ", lineWidth = " << tmpHistogram->GetLineWidth() << ","
<< " markerColor = " << tmpHistogram->GetMarkerColor() << ", markerStyle = " << tmpHistogram->GetMarkerStyle() << ", markerSize = " << tmpHistogram->GetMarkerSize() << ","
<< " integral = " << tmpHistogram->Integral() << std::endl;
if ( tmpHistogram->GetFillColor() == 0 ) histogramDYJets = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 632 ) histogramHiggs125 = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 616 ) histogramHiggs200 = tmpHistogram;
if ( tmpHistogram->GetFillColor() == 600 ) histogramHiggs300 = tmpHistogram;
}
}
if ( !(histogramDYJets && histogramHiggs125 && histogramHiggs200 && histogramHiggs300) ) {
std::cerr << "Failed to load histograms !!" << std::endl;
assert(0);
}
int lineColors[4] = { 1, 2, 6, 4 };
int lineStyles[4] = { 1, 1, 1, 1 };
int lineWidths[4] = { 2, 2, 2, 2 };
int fillColors[4] = { 10, 2, 6, 4 };
int fillStyles[4] = { 0, 3002, 3004, 3005 };
histogramDYJets->SetFillColor(fillColors[0]);
histogramDYJets->SetFillStyle(fillStyles[0]);
histogramDYJets->SetLineColor(lineColors[0]);
histogramDYJets->SetLineStyle(lineStyles[0]);
histogramDYJets->SetLineWidth(lineWidths[0]);
histogramHiggs125->SetFillColor(fillColors[1]);
histogramHiggs125->SetFillStyle(fillStyles[1]);
histogramHiggs125->SetLineColor(lineColors[1]);
histogramHiggs125->SetLineStyle(lineStyles[1]);
histogramHiggs125->SetLineWidth(lineWidths[1]);
histogramHiggs200->SetFillColor(fillColors[2]);
histogramHiggs200->SetFillStyle(fillStyles[2]);
histogramHiggs200->SetLineColor(lineColors[2]);
histogramHiggs200->SetLineStyle(lineStyles[2]);
histogramHiggs200->SetLineWidth(lineWidths[2]);
histogramHiggs300->SetFillColor(fillColors[3]);
histogramHiggs300->SetFillStyle(fillStyles[3]);
histogramHiggs300->SetLineColor(lineColors[3]);
histogramHiggs300->SetLineStyle(lineStyles[3]);
histogramHiggs300->SetLineWidth(lineWidths[3]);
TAxis* xAxis = histogramHiggs300->GetXaxis();
if ( histogram == "mVis" ) xAxis->SetRangeUser(0,350);
else xAxis->SetRangeUser(0,450);
xAxis->SetTitle(xAxisTitle.data());
xAxis->SetTitleOffset(1.00);
xAxis->SetTitleSize(0.070);
xAxis->SetTitleFont(42);
xAxis->SetLabelOffset(0.010);
xAxis->SetLabelSize(0.050);
xAxis->SetLabelFont(42);
xAxis->SetTickLength(0.040);
xAxis->SetNdivisions(505);
//double xMin = 20.;
//double xMax = xAxis->GetXmax();
//xAxis->SetRangeUser(xMin, xMax);
TAxis* yAxis = histogramHiggs300->GetYaxis();
yAxis->SetTitle(yAxisTitle.data());
yAxis->SetTitleOffset(1.20);
yAxis->SetTitleSize(0.070);
yAxis->SetTitleFont(42);
yAxis->SetLabelOffset(0.010);
yAxis->SetLabelSize(0.055);
yAxis->SetLabelFont(42);
yAxis->SetTickLength(0.040);
yAxis->SetNdivisions(505);
histogramHiggs300->SetTitle("");
histogramHiggs300->SetStats(false);
histogramHiggs300->SetMaximum(1.2*histogramDYJets->GetMaximum());
histogramHiggs300->SetMinimum(0.);
histogramHiggs300->Draw("hist");
histogramHiggs200->Draw("histsame");
histogramHiggs125->Draw("histsame");
histogramDYJets->Draw("histsame");
histogramHiggs300->Draw("axissame");
TLegend* legend_new = new TLegend(0.50, 0.62, 0.87, 0.92, NULL, "brNDC");
legend_new->SetFillColor(10);
legend_new->SetFillStyle(0);
legend_new->SetBorderSize(0);
legend_new->SetTextFont(42);
legend_new->SetTextSize(0.055);
legend_new->SetTextColor(1);
legend_new->SetMargin(0.20);
legend_new->AddEntry(histogramDYJets, "Z/#gamma* #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs125, "H(125 GeV) #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs200, "H(200 GeV) #rightarrow #tau#tau", "f");
legend_new->AddEntry(histogramHiggs300, "H(300 GeV) #rightarrow #tau#tau", "f");
legend_new->Draw();
double label_channel_y0;
if ( channel == "e#mu" ) label_channel_y0 = 0.9275;
else if ( channel == "#mu#tau_{h}" ) label_channel_y0 = 0.9400;
else if ( channel == "#tau_{h}#tau_{h}" ) label_channel_y0 = 0.9350;
else {
std::cerr << "Invalid channel = " << channel << " !!" << std::endl;
assert(0);
}
TPaveText* label_channel = new TPaveText(0.855, label_channel_y0, 0.945, label_channel_y0 + 0.055, "NDC");
label_channel->SetFillStyle(0);
label_channel->SetBorderSize(0);
label_channel->AddText(channel.data());
label_channel->SetTextFont(62);
label_channel->SetTextSize(0.055);
label_channel->SetTextColor(1);
label_channel->SetTextAlign(31);
label_channel->Draw();
canvas_new->Update();
std::string outputFileName_full = Form("%s%s", outputFilePath.data(), outputFileName.data());
size_t idx = outputFileName_full.find_last_of('.');
std::string outputFileName_plot = std::string(outputFileName_full, 0, idx);
canvas_new->Print(std::string(outputFileName_plot).append(".pdf").data());
//canvas_new->Print(std::string(outputFileName_plot).append(".root").data());
delete legend_new;
delete label_channel;
delete canvas_new;
delete inputFile;
}
void trigeff(){
gROOT->Reset();
//=========Macro generated from canvas: cEvtSel/EvtSel
//========= (Wed Apr 14 17:19:34 2010) by ROOT version5.22/00d
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",550,600);
/*
TCanvas *cEvtSel = new TCanvas("cEvtSel", "EvtSel",0,22,550,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
cEvtSel->Range(-13.62658,-0.215625,63.58861,1.221875);
cEvtSel->SetFillColor(0);
cEvtSel->SetBorderMode(0);
cEvtSel->SetBorderSize(0);
cEvtSel->SetTickx(1);
cEvtSel->SetTicky(1);
cEvtSel->SetLeftMargin(0.17);
cEvtSel->SetRightMargin(0.04);
cEvtSel->SetTopMargin(0.05);
cEvtSel->SetBottomMargin(0.15);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
cEvtSel->SetFrameLineColor(0);
cEvtSel->SetFrameBorderMode(0);
*/
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->Draw("");
hFrame1->GetXaxis()->SetNdivisions(312);
/*
TH1 *hFrame1 = new TH2D("hFrame1","",1,-0.5,60.5,1,0,1.15);
hFrame1->SetDirectory(0);
hFrame1->SetStats(0);
hFrame1->SetFillColor(1);
hFrame1->SetFillStyle(0);
hFrame1->SetLineStyle(0);
hFrame1->SetMarkerStyle(20);
hFrame1->SetMarkerSize(1.5);
hFrame1->GetXaxis()->SetTitle("Charged-particle multiplicity");
hFrame1->GetXaxis()->CenterTitle(true);
hFrame1->GetXaxis()->SetNdivisions(312);
hFrame1->GetXaxis()->SetLabelFont(42);
hFrame1->GetXaxis()->SetLabelOffset(0.01);
hFrame1->GetXaxis()->SetLabelSize(0.045);
hFrame1->GetXaxis()->SetTitleSize(0.055);
hFrame1->GetXaxis()->SetTitleFont(42);
hFrame1->GetYaxis()->SetTitle("Selection efficiency");
hFrame1->GetYaxis()->CenterTitle(true);
hFrame1->GetYaxis()->SetLabelFont(42);
hFrame1->GetYaxis()->SetLabelOffset(0.01);
hFrame1->GetYaxis()->SetLabelSize(0.045);
hFrame1->GetYaxis()->SetTitleSize(0.055);
hFrame1->GetYaxis()->SetTitleOffset(1.6);
hFrame1->GetYaxis()->SetTitleFont(42);
hFrame1->GetZaxis()->SetLabelFont(42);
hFrame1->GetZaxis()->SetLabelSize(0.045);
hFrame1->GetZaxis()->SetTitleFont(42);
hFrame1->Draw("");
*/
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.007879584);
trigeff->SetBinContent(2,0.3524112);
trigeff->SetBinContent(3,0.5050529);
trigeff->SetBinContent(4,0.5978595);
trigeff->SetBinContent(5,0.6587795);
trigeff->SetBinContent(6,0.7034895);
trigeff->SetBinContent(7,0.7451056);
trigeff->SetBinContent(8,0.7911818);
trigeff->SetBinContent(9,0.8363224);
trigeff->SetBinContent(10,0.873251);
trigeff->SetBinContent(11,0.9012649);
trigeff->SetBinContent(12,0.9177872);
trigeff->SetBinContent(13,0.9395182);
trigeff->SetBinContent(14,0.9502278);
trigeff->SetBinContent(15,0.9600504);
trigeff->SetBinContent(16,0.9667429);
trigeff->SetBinContent(17,0.9722969);
trigeff->SetBinContent(18,0.977478);
trigeff->SetBinContent(19,0.9801504);
trigeff->SetBinContent(20,0.9840849);
trigeff->SetBinContent(21,0.9843521);
trigeff->SetBinContent(22,0.9856779);
trigeff->SetBinContent(23,0.9894354);
trigeff->SetBinContent(24,0.9892805);
trigeff->SetBinContent(25,0.9913111);
trigeff->SetBinContent(26,0.9934833);
trigeff->SetBinContent(27,0.9907814);
trigeff->SetBinContent(28,0.9928126);
trigeff->SetBinContent(29,0.990099);
trigeff->SetBinContent(30,0.9918119);
trigeff->SetBinContent(31,0.994504);
trigeff->SetBinContent(32,0.9938513);
trigeff->SetBinContent(33,0.993073);
trigeff->SetBinContent(34,0.9965539);
trigeff->SetBinContent(35,0.9955737);
trigeff->SetBinContent(36,0.9952005);
trigeff->SetBinContent(37,0.9940288);
trigeff->SetBinContent(38,0.9946929);
trigeff->SetBinContent(39,0.9973046);
trigeff->SetBinContent(40,0.9959936);
trigeff->SetBinContent(41,0.9964897);
trigeff->SetBinContent(42,0.9943966);
trigeff->SetBinContent(43,0.9940175);
trigeff->SetBinContent(44,0.9947941);
trigeff->SetBinContent(45,0.9960804);
trigeff->SetBinContent(46,0.9970282);
trigeff->SetBinContent(47,0.9963936);
trigeff->SetBinContent(48,0.9968187);
trigeff->SetBinContent(49,0.9956733);
trigeff->SetBinContent(50,0.996085);
trigeff->SetBinContent(51,0.9988466);
trigeff->SetBinContent(52,0.9982079);
trigeff->SetBinContent(53,0.99625);
trigeff->SetBinContent(54,0.9962802);
trigeff->SetBinContent(55,0.9980328);
trigeff->SetBinContent(56,0.9960396);
trigeff->SetBinContent(57,0.9993271);
trigeff->SetBinContent(58,0.9978261);
trigeff->SetBinContent(59,0.9950843);
trigeff->SetBinContent(60,0.9992459);
trigeff->SetBinContent(61,0.9977925);
trigeff->SetBinContent(62,0.9960599);
trigeff->SetBinContent(63,0.9952456);
trigeff->SetBinContent(64,0.9960661);
trigeff->SetBinContent(65,0.9965428);
trigeff->SetBinContent(66,0.995094);
trigeff->SetBinContent(67,0.9962441);
trigeff->SetBinContent(68,0.9990842);
trigeff->SetBinContent(69,0.9981413);
trigeff->SetBinContent(70,0.9981007);
trigeff->SetBinContent(71,0.9980676);
trigeff->SetBinContent(72,0.9990512);
trigeff->SetBinContent(73,0.9969636);
trigeff->SetBinContent(74,0.9959432);
trigeff->SetBinContent(75,0.9969008);
trigeff->SetBinContent(76,0.994929);
trigeff->SetBinContent(77,0.9978425);
trigeff->SetBinContent(78,0.9989396);
trigeff->SetBinContent(79,0.9955996);
trigeff->SetBinContent(80,0.9988975);
trigeff->SetBinContent(81,0.998829);
trigeff->SetBinContent(82,0.9960682);
trigeff->SetBinContent(83,0.9963986);
trigeff->SetBinContent(84,0.995098);
trigeff->SetBinContent(85,0.9962169);
trigeff->SetBinContent(86,0.9973615);
trigeff->SetBinContent(87,0.9987562);
trigeff->SetBinContent(88,0.9987212);
trigeff->SetBinContent(89,0.9987374);
trigeff->SetBinContent(90,0.9986264);
trigeff->SetBinContent(91,0.9972973);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,0.9959459);
trigeff->SetBinContent(94,0.9945504);
trigeff->SetBinContent(95,0.9985612);
trigeff->SetBinContent(96,1);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9968454);
trigeff->SetBinContent(99,0.9983471);
trigeff->SetBinContent(100,0.9968);
trigeff->SetBinContent(101,0.9983871);
trigeff->SetBinContent(102,0.9966044);
trigeff->SetBinContent(103,0.9984);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,0.9946996);
trigeff->SetBinContent(106,0.9946333);
trigeff->SetBinContent(107,0.9981343);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,0.9962963);
trigeff->SetBinContent(110,0.9923225);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,0.9979633);
trigeff->SetBinContent(113,0.9978166);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,0.9980237);
trigeff->SetBinContent(116,0.9952494);
trigeff->SetBinContent(117,0.9979253);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,0.9950125);
trigeff->SetBinContent(121,0.9975728);
trigeff->SetBinContent(122,0.9921466);
trigeff->SetBinContent(123,0.9974874);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,0.9974874);
trigeff->SetBinContent(126,0.9969419);
trigeff->SetBinContent(127,0.994723);
trigeff->SetBinContent(128,0.9940299);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,0.9966667);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,0.9931507);
trigeff->SetBinContent(134,0.9963504);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,0.9959677);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,0.9959514);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,0.9955556);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,0.989418);
trigeff->SetBinContent(147,0.9940828);
trigeff->SetBinContent(148,1);
trigeff->SetBinContent(149,0.9942857);
trigeff->SetBinContent(150,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(153,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,0.9923077);
trigeff->SetBinContent(156,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(158,1);
trigeff->SetBinContent(159,1);
trigeff->SetBinContent(160,0.9901961);
trigeff->SetBinContent(161,1);
trigeff->SetBinContent(162,1);
trigeff->SetBinContent(163,1);
trigeff->SetBinContent(164,1);
trigeff->SetBinContent(165,0.9767442);
trigeff->SetBinContent(166,1);
trigeff->SetBinContent(167,1);
trigeff->SetBinContent(168,1);
trigeff->SetBinContent(169,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(171,1);
trigeff->SetBinContent(172,1);
trigeff->SetBinContent(173,0.9807692);
trigeff->SetBinContent(174,1);
trigeff->SetBinContent(175,0.9850746);
trigeff->SetBinContent(176,1);
trigeff->SetBinContent(177,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinContent(179,1);
trigeff->SetBinContent(180,1);
trigeff->SetBinContent(181,1);
trigeff->SetBinContent(182,1);
trigeff->SetBinContent(183,1);
trigeff->SetBinContent(184,1);
trigeff->SetBinContent(185,1);
trigeff->SetBinContent(186,1);
trigeff->SetBinContent(187,1);
trigeff->SetBinContent(188,1);
trigeff->SetBinContent(189,1);
trigeff->SetBinContent(190,1);
trigeff->SetBinContent(191,1);
trigeff->SetBinContent(192,1);
trigeff->SetBinContent(193,1);
trigeff->SetBinContent(194,1);
trigeff->SetBinContent(195,0.9333333);
trigeff->SetBinContent(196,1);
trigeff->SetBinContent(197,0.9230769);
trigeff->SetBinContent(198,1);
trigeff->SetBinContent(199,1);
trigeff->SetBinContent(200,1);
trigeff->SetBinContent(201,1);
trigeff->SetBinError(1,0.0006283812);
trigeff->SetBinError(2,0.005498682);
trigeff->SetBinError(3,0.0054516);
trigeff->SetBinError(4,0.005047444);
trigeff->SetBinError(5,0.004707652);
trigeff->SetBinError(6,0.004447388);
trigeff->SetBinError(7,0.004290336);
trigeff->SetBinError(8,0.003953715);
trigeff->SetBinError(9,0.003594607);
trigeff->SetBinError(10,0.003181503);
trigeff->SetBinError(11,0.002795854);
trigeff->SetBinError(12,0.002534088);
trigeff->SetBinError(13,0.002203234);
trigeff->SetBinError(14,0.002035759);
trigeff->SetBinError(15,0.001857668);
trigeff->SetBinError(16,0.001750359);
trigeff->SetBinError(17,0.001668633);
trigeff->SetBinError(18,0.001566698);
trigeff->SetBinError(19,0.001548763);
trigeff->SetBinError(20,0.001441238);
trigeff->SetBinError(21,0.001500853);
trigeff->SetBinError(22,0.001498831);
trigeff->SetBinError(23,0.001345494);
trigeff->SetBinError(24,0.001388057);
trigeff->SetBinError(25,0.001289631);
trigeff->SetBinError(26,0.001166616);
trigeff->SetBinError(27,0.001415891);
trigeff->SetBinError(28,0.0013075);
trigeff->SetBinError(29,0.001557715);
trigeff->SetBinError(30,0.001464586);
trigeff->SetBinError(31,0.001225565);
trigeff->SetBinError(32,0.001306868);
trigeff->SetBinError(33,0.001471707);
trigeff->SetBinError(34,0.001037251);
trigeff->SetBinError(35,0.001224911);
trigeff->SetBinError(36,0.001279626);
trigeff->SetBinError(37,0.001443898);
trigeff->SetBinError(38,0.0014146);
trigeff->SetBinError(39,0.001017398);
trigeff->SetBinError(40,0.001264398);
trigeff->SetBinError(41,0.001238902);
trigeff->SetBinError(42,0.001549757);
trigeff->SetBinError(43,0.00165428);
trigeff->SetBinError(44,0.001565537);
trigeff->SetBinError(45,0.001383086);
trigeff->SetBinError(46,0.001211415);
trigeff->SetBinError(47,0.001360627);
trigeff->SetBinError(48,0.001296707);
trigeff->SetBinError(49,0.001526394);
trigeff->SetBinError(50,0.001476827);
trigeff->SetBinError(51,0.0008151083);
trigeff->SetBinError(52,0.00103375);
trigeff->SetBinError(53,0.001528058);
trigeff->SetBinError(54,0.001515765);
trigeff->SetBinError(55,0.001134653);
trigeff->SetBinError(56,0.00161362);
trigeff->SetBinError(57,0.000672721);
trigeff->SetBinError(58,0.001253744);
trigeff->SetBinError(59,0.001853399);
trigeff->SetBinError(60,0.0007538634);
trigeff->SetBinError(61,0.001273096);
trigeff->SetBinError(62,0.001758596);
trigeff->SetBinError(63,0.001936339);
trigeff->SetBinError(64,0.001755834);
trigeff->SetBinError(65,0.001725618);
trigeff->SetBinError(66,0.001997934);
trigeff->SetBinError(67,0.001874404);
trigeff->SetBinError(68,0.0009153315);
trigeff->SetBinError(69,0.001313103);
trigeff->SetBinError(70,0.001341757);
trigeff->SetBinError(71,0.001365069);
trigeff->SetBinError(72,0.0009483164);
trigeff->SetBinError(73,0.001750424);
trigeff->SetBinError(74,0.002024279);
trigeff->SetBinError(75,0.001786534);
trigeff->SetBinError(76,0.00226206);
trigeff->SetBinError(77,0.001523934);
trigeff->SetBinError(78,0.001059883);
trigeff->SetBinError(79,0.002195374);
trigeff->SetBinError(80,0.001101928);
trigeff->SetBinError(81,0.001170274);
trigeff->SetBinError(82,0.002265586);
trigeff->SetBinError(83,0.002075545);
trigeff->SetBinError(84,0.002444966);
trigeff->SetBinError(85,0.00218004);
trigeff->SetBinError(86,0.001863254);
trigeff->SetBinError(87,0.001243007);
trigeff->SetBinError(88,0.001277954);
trigeff->SetBinError(89,0.001261829);
trigeff->SetBinError(90,0.001372683);
trigeff->SetBinError(91,0.001908515);
trigeff->SetBinError(93,0.00233586);
trigeff->SetBinError(94,0.002717361);
trigeff->SetBinError(95,0.001437813);
trigeff->SetBinError(98,0.0022271);
trigeff->SetBinError(99,0.001651526);
trigeff->SetBinError(100,0.002259118);
trigeff->SetBinError(101,0.001611602);
trigeff->SetBinError(102,0.002396962);
trigeff->SetBinError(103,0.001598719);
trigeff->SetBinError(105,0.00305204);
trigeff->SetBinError(106,0.003090155);
trigeff->SetBinError(107,0.00186393);
trigeff->SetBinError(109,0.00261406);
trigeff->SetBinError(110,0.003824007);
trigeff->SetBinError(112,0.002034585);
trigeff->SetBinError(113,0.002181021);
trigeff->SetBinError(115,0.001974331);
trigeff->SetBinError(116,0.003351189);
trigeff->SetBinError(117,0.002072536);
trigeff->SetBinError(120,0.003517911);
trigeff->SetBinError(121,0.002424237);
trigeff->SetBinError(122,0.004516325);
trigeff->SetBinError(123,0.002509404);
trigeff->SetBinError(125,0.002509404);
trigeff->SetBinError(126,0.003053424);
trigeff->SetBinError(127,0.003721576);
trigeff->SetBinError(128,0.004208913);
trigeff->SetBinError(130,0.003327773);
trigeff->SetBinError(133,0.004826582);
trigeff->SetBinError(134,0.003642969);
trigeff->SetBinError(136,0.00402412);
trigeff->SetBinError(140,0.004040379);
trigeff->SetBinError(142,0.004434557);
trigeff->SetBinError(146,0.007442916);
trigeff->SetBinError(147,0.005899627);
trigeff->SetBinError(149,0.005697936);
trigeff->SetBinError(155,0.007662665);
trigeff->SetBinError(160,0.009755745);
trigeff->SetBinError(165,0.01625201);
trigeff->SetBinError(173,0.01904496);
trigeff->SetBinError(175,0.01481357);
trigeff->SetBinError(195,0.06440612);
trigeff->SetBinError(197,0.0739053);
trigeff->SetEntries(385140);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(0);
trigeff->SetLineWidth(2);
trigeff->SetMarkerStyle(20);
trigeff->SetMarkerSize(1.5);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("hist same");
TH1 *trigeff = new TH1D("trigeff","trigeff",200,0,200);
trigeff->SetBinContent(1,0.009007478);
trigeff->SetBinContent(2,0.2935561);
trigeff->SetBinContent(3,0.4702609);
trigeff->SetBinContent(4,0.6518799);
trigeff->SetBinContent(5,0.7428357);
trigeff->SetBinContent(6,0.8347119);
trigeff->SetBinContent(7,0.8777911);
trigeff->SetBinContent(8,0.904666);
trigeff->SetBinContent(9,0.9195271);
trigeff->SetBinContent(10,0.9292373);
trigeff->SetBinContent(11,0.9375605);
trigeff->SetBinContent(12,0.9489987);
trigeff->SetBinContent(13,0.9535653);
trigeff->SetBinContent(14,0.9493052);
trigeff->SetBinContent(15,0.9572732);
trigeff->SetBinContent(16,0.9589076);
trigeff->SetBinContent(17,0.9627003);
trigeff->SetBinContent(18,0.9629964);
trigeff->SetBinContent(19,0.9683917);
trigeff->SetBinContent(20,0.9674429);
trigeff->SetBinContent(21,0.9771153);
trigeff->SetBinContent(22,0.9762201);
trigeff->SetBinContent(23,0.9766491);
trigeff->SetBinContent(24,0.9828982);
trigeff->SetBinContent(25,0.9802921);
trigeff->SetBinContent(26,0.9826494);
trigeff->SetBinContent(27,0.9759428);
trigeff->SetBinContent(28,0.9843614);
trigeff->SetBinContent(29,0.9879452);
trigeff->SetBinContent(30,0.9855582);
trigeff->SetBinContent(31,0.9875656);
trigeff->SetBinContent(32,0.9883436);
trigeff->SetBinContent(33,0.9886389);
trigeff->SetBinContent(34,0.9900587);
trigeff->SetBinContent(35,0.9925793);
trigeff->SetBinContent(36,0.9926954);
trigeff->SetBinContent(37,0.9905261);
trigeff->SetBinContent(38,0.993372);
trigeff->SetBinContent(39,0.9899301);
trigeff->SetBinContent(40,0.9913687);
trigeff->SetBinContent(41,0.9920382);
trigeff->SetBinContent(42,0.9901091);
trigeff->SetBinContent(43,0.9941278);
trigeff->SetBinContent(44,0.9865421);
trigeff->SetBinContent(45,0.9902138);
trigeff->SetBinContent(46,0.9965451);
trigeff->SetBinContent(47,0.9961106);
trigeff->SetBinContent(48,0.9951392);
trigeff->SetBinContent(49,0.9951969);
trigeff->SetBinContent(50,0.9960957);
trigeff->SetBinContent(51,0.9981439);
trigeff->SetBinContent(52,0.9962282);
trigeff->SetBinContent(53,0.9973698);
trigeff->SetBinContent(54,0.9976959);
trigeff->SetBinContent(55,0.9933735);
trigeff->SetBinContent(56,0.9956897);
trigeff->SetBinContent(57,0.9953642);
trigeff->SetBinContent(58,0.9902303);
trigeff->SetBinContent(59,0.9985925);
trigeff->SetBinContent(60,0.9986178);
trigeff->SetBinContent(61,0.9991604);
trigeff->SetBinContent(62,0.9983897);
trigeff->SetBinContent(63,0.9940273);
trigeff->SetBinContent(64,0.9952786);
trigeff->SetBinContent(65,0.9977998);
trigeff->SetBinContent(66,0.9972015);
trigeff->SetBinContent(67,0.9908467);
trigeff->SetBinContent(68,1);
trigeff->SetBinContent(69,0.9988636);
trigeff->SetBinContent(70,0.9933155);
trigeff->SetBinContent(71,0.9986979);
trigeff->SetBinContent(72,0.9969651);
trigeff->SetBinContent(73,0.9971223);
trigeff->SetBinContent(74,0.9967213);
trigeff->SetBinContent(75,0.9982111);
trigeff->SetBinContent(76,0.9968504);
trigeff->SetBinContent(77,0.9967374);
trigeff->SetBinContent(78,0.9980237);
trigeff->SetBinContent(79,0.9977974);
trigeff->SetBinContent(80,1);
trigeff->SetBinContent(81,0.997669);
trigeff->SetBinContent(82,0.9977876);
trigeff->SetBinContent(83,0.9921671);
trigeff->SetBinContent(84,0.9942857);
trigeff->SetBinContent(85,1);
trigeff->SetBinContent(86,1);
trigeff->SetBinContent(87,0.9967532);
trigeff->SetBinContent(88,1);
trigeff->SetBinContent(89,0.9967427);
trigeff->SetBinContent(90,0.9961832);
trigeff->SetBinContent(91,1);
trigeff->SetBinContent(92,1);
trigeff->SetBinContent(93,1);
trigeff->SetBinContent(94,1);
trigeff->SetBinContent(95,1);
trigeff->SetBinContent(96,0.9940828);
trigeff->SetBinContent(97,1);
trigeff->SetBinContent(98,0.9927536);
trigeff->SetBinContent(99,1);
trigeff->SetBinContent(100,0.9896907);
trigeff->SetBinContent(101,0.990566);
trigeff->SetBinContent(102,0.988764);
trigeff->SetBinContent(103,1);
trigeff->SetBinContent(104,1);
trigeff->SetBinContent(105,1);
trigeff->SetBinContent(106,1);
trigeff->SetBinContent(107,1);
trigeff->SetBinContent(108,1);
trigeff->SetBinContent(109,1);
trigeff->SetBinContent(110,1);
trigeff->SetBinContent(111,1);
trigeff->SetBinContent(112,1);
trigeff->SetBinContent(113,1);
trigeff->SetBinContent(114,1);
trigeff->SetBinContent(115,1);
trigeff->SetBinContent(116,1);
trigeff->SetBinContent(117,1);
trigeff->SetBinContent(118,1);
trigeff->SetBinContent(119,1);
trigeff->SetBinContent(120,1);
trigeff->SetBinContent(121,1);
trigeff->SetBinContent(122,1);
trigeff->SetBinContent(123,1);
trigeff->SetBinContent(124,1);
trigeff->SetBinContent(125,1);
trigeff->SetBinContent(126,1);
trigeff->SetBinContent(127,1);
trigeff->SetBinContent(128,1);
trigeff->SetBinContent(129,1);
trigeff->SetBinContent(130,1);
trigeff->SetBinContent(131,1);
trigeff->SetBinContent(132,1);
trigeff->SetBinContent(133,1);
trigeff->SetBinContent(134,1);
trigeff->SetBinContent(135,1);
trigeff->SetBinContent(136,1);
trigeff->SetBinContent(137,1);
trigeff->SetBinContent(138,1);
trigeff->SetBinContent(139,1);
trigeff->SetBinContent(140,1);
trigeff->SetBinContent(141,1);
trigeff->SetBinContent(142,1);
trigeff->SetBinContent(143,1);
trigeff->SetBinContent(144,1);
trigeff->SetBinContent(145,1);
trigeff->SetBinContent(146,1);
trigeff->SetBinContent(147,1);
trigeff->SetBinContent(149,1);
trigeff->SetBinContent(151,1);
trigeff->SetBinContent(152,1);
trigeff->SetBinContent(154,1);
trigeff->SetBinContent(155,1);
trigeff->SetBinContent(157,1);
trigeff->SetBinContent(170,1);
trigeff->SetBinContent(173,1);
trigeff->SetBinContent(178,1);
trigeff->SetBinError(1,0.001231687);
trigeff->SetBinError(2,0.009082424);
trigeff->SetBinError(3,0.009308539);
trigeff->SetBinError(4,0.007834723);
trigeff->SetBinError(5,0.00598166);
trigeff->SetBinError(6,0.004397977);
trigeff->SetBinError(7,0.003418236);
trigeff->SetBinError(8,0.002747754);
trigeff->SetBinError(9,0.002375778);
trigeff->SetBinError(10,0.002196995);
trigeff->SetBinError(11,0.002011941);
trigeff->SetBinError(12,0.001831367);
trigeff->SetBinError(13,0.001784029);
trigeff->SetBinError(14,0.001916823);
trigeff->SetBinError(15,0.001817566);
trigeff->SetBinError(16,0.001819683);
trigeff->SetBinError(17,0.001818542);
trigeff->SetBinError(18,0.001890354);
trigeff->SetBinError(19,0.00177814);
trigeff->SetBinError(20,0.001864436);
trigeff->SetBinError(21,0.001663154);
trigeff->SetBinError(22,0.00170007);
trigeff->SetBinError(23,0.00173455);
trigeff->SetBinError(24,0.001481362);
trigeff->SetBinError(25,0.001655051);
trigeff->SetBinError(26,0.001603857);
trigeff->SetBinError(27,0.00195356);
trigeff->SetBinError(28,0.00163551);
trigeff->SetBinError(29,0.001474872);
trigeff->SetBinError(30,0.001623358);
trigeff->SetBinError(31,0.00154461);
trigeff->SetBinError(32,0.001534909);
trigeff->SetBinError(33,0.00158181);
trigeff->SetBinError(34,0.001491233);
trigeff->SetBinError(35,0.001286982);
trigeff->SetBinError(36,0.001328752);
trigeff->SetBinError(37,0.00152958);
trigeff->SetBinError(38,0.001348444);
trigeff->SetBinError(39,0.00166985);
trigeff->SetBinError(40,0.001624111);
trigeff->SetBinError(41,0.001586005);
trigeff->SetBinError(42,0.001827581);
trigeff->SetBinError(43,0.001420028);
trigeff->SetBinError(44,0.002227847);
trigeff->SetBinError(45,0.001874108);
trigeff->SetBinError(46,0.00114964);
trigeff->SetBinError(47,0.001293933);
trigeff->SetBinError(48,0.001462021);
trigeff->SetBinError(49,0.001515213);
trigeff->SetBinError(50,0.001377697);
trigeff->SetBinError(51,0.0009272125);
trigeff->SetBinError(52,0.001331017);
trigeff->SetBinError(53,0.001174711);
trigeff->SetBinError(54,0.001150746);
trigeff->SetBinError(55,0.001991336);
trigeff->SetBinError(56,0.001625642);
trigeff->SetBinError(57,0.001748087);
trigeff->SetBinError(58,0.00259828);
trigeff->SetBinError(59,0.0009945236);
trigeff->SetBinError(60,0.0009766661);
trigeff->SetBinError(61,0.000839278);
trigeff->SetBinError(62,0.001137741);
trigeff->SetBinError(63,0.002250715);
trigeff->SetBinError(64,0.0021065);
trigeff->SetBinError(65,0.001554078);
trigeff->SetBinError(66,0.001613457);
trigeff->SetBinError(67,0.003221342);
trigeff->SetBinError(69,0.001135718);
trigeff->SetBinError(70,0.002979388);
trigeff->SetBinError(71,0.001301235);
trigeff->SetBinError(72,0.00214274);
trigeff->SetBinError(73,0.00203191);
trigeff->SetBinError(74,0.002314579);
trigeff->SetBinError(75,0.001787308);
trigeff->SetBinError(76,0.002223598);
trigeff->SetBinError(77,0.00230327);
trigeff->SetBinError(78,0.001974331);
trigeff->SetBinError(79,0.002200216);
trigeff->SetBinError(81,0.002328284);
trigeff->SetBinError(82,0.002209941);
trigeff->SetBinError(83,0.00450458);
trigeff->SetBinError(84,0.004029049);
trigeff->SetBinError(87,0.003241478);
trigeff->SetBinError(89,0.00325202);
trigeff->SetBinError(90,0.003809503);
trigeff->SetBinError(96,0.005899627);
trigeff->SetBinError(98,0.007220074);
trigeff->SetBinError(100,0.010256);
trigeff->SetBinError(101,0.009389357);
trigeff->SetBinError(102,0.01117265);
trigeff->SetEntries(369636);
trigeff->SetDirectory(0);
trigeff->SetFillColor(1);
trigeff->SetFillStyle(0);
trigeff->SetLineStyle(2);
trigeff->SetLineWidth(3);
trigeff->SetMarkerStyle(20);
trigeff->GetXaxis()->SetTitle("M");
trigeff->GetXaxis()->SetLabelFont(42);
trigeff->GetXaxis()->SetLabelOffset(0.01);
trigeff->GetXaxis()->SetLabelSize(0.045);
trigeff->GetXaxis()->SetTitleSize(0.055);
trigeff->GetXaxis()->SetTitleFont(42);
trigeff->GetYaxis()->SetTitle("Selection efficiency");
trigeff->GetYaxis()->SetLabelFont(42);
trigeff->GetYaxis()->SetLabelOffset(0.01);
trigeff->GetYaxis()->SetLabelSize(0.045);
trigeff->GetYaxis()->SetTitleSize(0.055);
trigeff->GetYaxis()->SetTitleOffset(1.6);
trigeff->GetYaxis()->SetTitleFont(42);
trigeff->GetZaxis()->SetLabelFont(42);
trigeff->GetZaxis()->SetLabelSize(0.045);
trigeff->GetZaxis()->SetTitleFont(42);
trigeff->Draw("p same");
TLegend *leg = new TLegend(0.57,0.22,1,0.42,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry=leg->AddEntry("trigeff","PYTHIA 7 TeV","l");
entry->SetLineColor(1);
entry->SetLineWidth(2);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
//entry=leg->AddEntry("trigeff","(Atlas tune)","");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(21);
entry->SetMarkerSize(1);
entry=leg->AddEntry("trigeff","PHOJET 7 TeV","p");
entry->SetLineColor(1);
entry->SetLineStyle(1);
entry->SetLineWidth(1);
entry->SetMarkerColor(1);
entry->SetMarkerStyle(20);
entry->SetMarkerSize(1);
leg->Draw();
printFinalCanvases(cEvtSel,"trigeff");
/*
TLatex * tex = new TLatex(0.85,0.9,"CMS");
tex->SetNDC();
tex->SetTextSize(0.04);
tex->SetLineWidth(2);
tex->Draw();
cEvtSel->Modified();
cEvtSel->cd();
cEvtSel->SetSelected(cEvtSel);
*/
}
void stackPlotter::moveDirHistsToStacks(TDirectory* tdir, TString histname, int color){
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks" << std::endl;
// get metainfo from directory, else exit TODO
metaInfo tMI;
tMI.extractFrom(tdir);
if(debug) {
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo color=" << tMI.color << std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendname=" << tMI.legendname<< std::endl;
std::cout << "stackPlotter::moveDirHistsToStacks || metaInfo legendorder=" << tMI.legendorder << std::endl;
}
TIter histIter(tdir->GetListOfKeys());
TObject* cHistObj;
TKey* cHistKey;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Iterating through histograms." << std::endl;
// loop through keys in the directory
while((cHistKey = (TKey*) histIter())) {
if(histname != cHistKey->GetName()) continue;
cHistObj=tdir->Get(cHistKey->GetName());
if(!cHistObj->InheritsFrom(TH1::Class())) continue;
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || Found histogram "
<< cHistKey->GetName() << std::endl;
// prepare the histogram to be added to the stack
TH1* cHist = (TH1*) cHistObj->Clone();
cHist->SetDirectory(0);
TString mapName = cHist->GetName();
std::pair<Int_t,TH1*> newEntry(tMI.legendorder,cHist);
// initialize the stack info if needed
if(!stacksLegEntries_.count(mapName)) {
std::vector<std::pair<Int_t,TH1*> > legInfo(0);
legInfo.push_back(newEntry);
stacksLegEntries_[mapName] = legInfo;
}
cHist->SetFillColor(color);
cHist->SetFillStyle(1001);
cHist->SetMarkerStyle(kNone);
cHist->SetMarkerColor(kBlack);
cHist->SetLineColor(kBlack);
cHist->SetTitle(mapName);
cHist->SetName(tMI.legendname);
std::vector<std::pair<Int_t,TH1*> > legEntries = stacksLegEntries_[mapName];
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
for(size_t i=0; i < legEntries.size(); i++) {
if(legEntries.at(i).second == cHist && legEntries.at(i).first == tMI.legendorder) break;
if(legEntries.at(i).first >= tMI.legendorder) {
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || i is " << i << std::endl;
stacksLegEntries_[mapName].insert(stacksLegEntries_[mapName].begin()+i,newEntry);
break;
}
if(i==legEntries.size()-1) {
stacksLegEntries_[mapName].push_back(newEntry);
break;
}
}
if(debug)
std::cout << "stackPlotter::moveDirHistsToStacks || legEntries size is " << legEntries.size() << std::endl;
}
}
histoBook* histoBook::set( string opt, vector<string> params ){
//cout << "Setting : " << opt << endl;
//for ( int i = 0; i < params.size(); i++ ){
// cout << params[ i ] << " ";
//}
//cout << endl;
// force the param name to lowercase
transform(opt.begin(), opt.end(), opt.begin(), ::tolower);
TH1* h = get( styling );
if ( h ){
if ( "title" == opt ){
h->SetTitle( cParam(params, 0) );
} else if ( "x" == opt ){
h->GetXaxis()->SetTitle( cParam(params, 0) );
} else if ( "y" == opt ){
h->GetYaxis()->SetTitle( cParam(params, 0) );
} else if ( "legend" == opt ){
legend->AddEntry( h, cParam(params, 0), cParam(params, 1, "lpf") );
legend->Draw();
} else if ( "draw" == opt ){
drawOption = cParam(params, 0);
} else if ( "linecolor" == opt ){
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetLineColor( c );
} else if ( "fillcolor" == opt ){
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetFillColor( c );
} else if ( "linewidth" == opt ){
h->SetLineWidth( dParam( params, 0) );
} else if ( "domain" == opt ){
double min = dParam( params, 0);
double max = dParam( params, 1);
h->GetXaxis()->SetRangeUser( min, max );
} else if ( "dynamicdomain" == opt ){
double thresh = dParam( params, 0);
int min = (int)dParam( params, 1);
int max = (int)dParam( params, 2);
int axis = (int)dParam( params, 3); // 1 = x, 2 = y
if ( 1 != axis && 2 != axis )
axis = 1;
if ( thresh >= 0) {
if ( -1 >= min )
min = h->FindFirstBinAbove( thresh, axis );
if ( -1 >= max )
max = h->FindLastBinAbove( thresh, axis );
}
if ( 1 == axis )
h->GetXaxis()->SetRange( min, max );
else if ( 2 == axis )
h->GetYaxis()->SetRange( min, max );
} else if ( "range" == opt ){
double min = dParam( params, 0);
double max = dParam( params, 1);
h->GetYaxis()->SetRangeUser( min, max );
} else if ( "markercolor" == opt ) {
int c = color( cParam( params, 0) );
if ( c < 0 )
c = (int) dParam( params, 0);
h->SetMarkerColor( c );
} else if ( "markerstyle" == opt ) {
h->SetMarkerStyle( (int)dParam( params, 0) );
} else if ( "legend" == opt ){
// p1 - alignmentX
// p2 - alignmentY
// p3 - width
// p4 - height
// make sure option is valid
double p1 = dParam( params, 0);
double p2 = dParam( params, 1);
if ( !(legendAlignment::center == p1 || legendAlignment::left == p1 || legendAlignment::right == p1) )
p1 = legendAlignment::best;
if ( !(legendAlignment::center == p2 || legendAlignment::top == p2 || legendAlignment::bottom == p2) )
p2 = legendAlignment::best;
placeLegend( p1, p2, dParam( params, 3), dParam( params, 3) );
} else if ( "numberofticks" == opt ){
// p1 - # of primary divisions
// p2 - # of secondary divisions
// p3 - axis : 0 or 1 = x, 2 = y
double p1 = dParam( params, 0);
double p2 = dParam( params, 1);
double p3 = dParam( params, 2);
if ( p2 == -1 )
p2 = 0;
if ( 2 == (int)p3 )
h->GetYaxis()->SetNdivisions( (int) p1, (int) p2, 0, true );
else
h->GetXaxis()->SetNdivisions( (int) p1, (int) p2, 0, true );
} else if ( "logy" == opt ){
gPad->SetLogy( (int)dParam( params, 0 ) );
} else if ( "logx" == opt ){
gPad->SetLogx( (int)dParam( params, 0 ) );
} else if ( "logz" == opt ){
gPad->SetLogz( (int)dParam( params, 0 ) );
}
}
return this;
}
void binary( string inFile = "allSim.root", int cSpecies = 1, bool cutDedx = false ){
TCanvas * c = new TCanvas( "c", "c", 800, 800 );
string outName = "rpBinaryPid.pdf";
c->Print( (outName+"[").c_str() );
TFile * f = new TFile( inFile.c_str(), "READ" );
string rOutName = "rootBinaryPid.root";
TFile * fOut = new TFile( rOutName.c_str(), "RECREATE" );
vector<double>effVsP;
vector<double>pureVsP;
c->Divide( 2, 2 );
for ( int i = 0; i < 70; i++ ){
stringstream sstr;
sstr << "h_dedx_tof_p3_b" << i;
TH2* sum = (TH2*)f->Get( sstr.str().c_str() );
sstr.str("");
sstr << "h_dedx_tof_p0_b" << i;
TH2* p0 = (TH2*)f->Get( sstr.str().c_str() );
sstr.str("");
sstr << "h_dedx_tof_p1_b" << i;
TH2* p1 = (TH2*)f->Get( sstr.str().c_str() );
sstr.str("");
sstr << "h_dedx_tof_p2_b" << i;
TH2* p2 = (TH2*)f->Get( sstr.str().c_str() );
pidBinary * pid = new pidBinary( sum, cSpecies, p0, p1, p2 );
pid->cutDedx( cutDedx );
c->cd( 3 );
gPad->SetLogz(1);
sum->Draw("colz");
c->cd( 4 );
gPad->SetLogx(1);
TH1* pX = sum->ProjectionX();
TH1* pY = sum->ProjectionY();
pY->SetFillColor( kBlue );
pY->SetLineColor( kBlue );
pY->Draw("hbar");
c->cd(1);
gPad->SetLogy(1);
pX->SetFillColor( kBlue );
pX->SetLineColor( kBlue );
pX->Draw("h");
c->cd(2);
sstr.str("");
sstr << "eff_" << i;
TH1D* eff = pid->efficiency( sstr.str(), 0.0, 5.0, 0.1 );
sstr.str("");
sstr << "pure_" << i;
TH1D* pure = pid->purity( sstr.str(), 0.0, 5.0, 0.1 );
gStyle->SetOptStat( 0 );
eff->SetTitle( "Efficiecy (Blue), Purity (Red)" );
eff->GetYaxis()->SetRangeUser(0, 1.05);
eff->SetLineWidth( 2 );
eff->Draw();
pure->SetLineColor( kRed );
pure->SetLineWidth( 2 );
pure->Draw("same");
effVsP.push_back( pid->efficiency() );
pureVsP.push_back( pid->purity( ) );
c->Print( outName.c_str());
}
int nBins = (3.7 - 0.2) / 0.05;
TH1D * hEffVsP = new TH1D( "hEffVsP", "Efficiency Vs. P; P [GeV]", nBins, 0.2, 3.7 );
for ( int i = 0; i < effVsP.size(); i++ ){
hEffVsP->SetBinContent( i, effVsP[ i ] );
}
TH1D * hPureVsP = new TH1D( "hPureVsP", "Purity Vs. P; P [GeV]", nBins, 0.2, 3.7 );
for ( int i = 0; i < pureVsP.size(); i++ ){
hPureVsP->SetBinContent( i, pureVsP[ i ] );
}
c->Divide( 1 );
c->cd( 0 );
hEffVsP->GetYaxis()->SetRangeUser( 0.0, 1.05);
hEffVsP->SetLineWidth( 2 );
hEffVsP->SetTitle( "Efficiency (Blue), Purity (Red)" );
hEffVsP->Draw( "");
hPureVsP->SetLineColor( kRed );
hPureVsP->SetLineWidth( 2 );
hPureVsP->Draw( "same" );
c->Print( outName.c_str());
c->Print( (outName+"]").c_str() );
fOut->Write();
}
void mk_sigaccanplots(string flavor = "112", bool tdrstyle = false)
{
setTDRStyle(tdrstyle);
// gStyle->SetOptFit(1100); // chi2 and prob, not parameters
gStyle->SetOptFit(0); // chi2 and prob, not parameters
// gStyle->SetOptStat("irme"); // integral, RMS, mean, # of entries
gStyle->SetStatFontSize(0.005);
gStyle->SetStatY(0.4);
float unused = 0.9, simtxt_y = 0.97;
if (tdrstyle == false) {
simtxt_y = 0.93;
}
TLatex *tex = new TLatex(unused, simtxt_y, "CMS simulation at #sqrt{s} = 8 TeV");
tex->SetNDC();
tex->SetTextAlign(12); // Left-adjusted
tex->SetTextFont(42);
float textsiz = 0.06;
tex->SetTextSize(0.05);
tex->SetLineWidth(2);
// for(int k=0; k<3; k++){
// for(int k=0; k<2; k++){
for(int k=2; k<3; k++){
//Which plots to make
//define input variables
vector <TFile* > filelist_kin;
// string uncert="btagup";
// if(k==1) uncert="btagdown";
string uncert="up";
if(k==1) uncert="down";
if(k==2) uncert="";
// filelist_kin.push_back(TFile::Open(("Acc_Gluino_NoLumi_pt110_8TeVxsec_BtagMap_2500GeV"+uncert+".root").c_str()));
// filelist_kin.push_back(TFile::Open("Acc_Gluino_NoLumi_pt60_pt110_8TeVxsec_BtagMap.root"));
// filelist_kin.push_back(TFile::Open(("Acc_RPV112" + uncert + ".root").c_str()));
filelist_kin.push_back(TFile::Open(("Acc_RPV" + flavor + uncert + "_Sph4.root").c_str()));
// filelist_kin.push_back(TFile::Open(("Acc_Gluino_NoLumi_pt60_pt110_8TeVxsec_BtagMap" + uncert + ".root").c_str()));
TFile f1(("RPV_" + flavor + "_accandwdithtest"+uncert+".root").c_str(), "recreate");
f1.cd();
string nameIN;
string cuts;
string prefix;
string postfix;
string folder;
string ptcut;
folder="plots_paper/";
postfix=".pdf";
/////////////Plots for each Mass separatly//////////////
/////////////----------------------------------------/////////////
for (int p = 0; p < 2; p++) {
// ptcut="112";
// if(p==1) ptcut="" + flavor;
ptcut="60";
if (p==1) {
ptcut="110";
textsiz = 0.045;
}
// string histname = string("GausWidth_vs_Mass_112") + ptcut;
string histname = string("GausWidth_vs_Mass_" + flavor) + "_" + ptcut;
cout<< histname << endl;
TGraphErrors *h_GluinoHist_Fit = (TGraphErrors*) filelist_kin[0]->Get(histname.c_str())->Clone();
histname = string("GausAcceptance_vs_Mass_" + flavor) + "_" + ptcut;
// histname = string("GausAcceptance_vs_Mass_112") + ptcut;
cout<< histname << endl;
TGraphErrors *h_GluinoHist_MCcomb = (TGraphErrors*) filelist_kin[0]->Get(histname.c_str())->Clone();
// histname = string("FullAcceptance_vs_Mass_" + flavor) + "_" + ptcut;
histname = string("GausMean_vs_Mass_" + flavor) + "_" + ptcut;
// histname = string("GausAcceptance_vs_Mass_112") + ptcut;
cout<< histname << endl;
// TGraphErrors *h_FullAccept = (TGraphErrors*) filelist_kin[0]->Get(histname.c_str())->Clone();
TGraph *h_FullAccept = (TGraph*) filelist_kin[0]->Get(histname.c_str())->Clone();
histname = string("GausMeanOffset_vs_Mass_" + flavor) + "_" + ptcut;
cout<< histname << endl;
TGraph *h_MeanOffset = (TGraph*) filelist_kin[0]->Get(histname.c_str())->Clone();
TCanvas * cGluinoFitsOpti = new TCanvas(("RPV_"+flavor +ptcut).c_str(), ("RPV_" + ptcut+"_"+cuts).c_str(), 800, 600);
//h_GluinoHist_Fit->SetFillColor(kOrange-2);
// h_GluinoHist_Fit->SetLineColor(kBlack);
string title;
string systematic = "pile-up";
// title="Gaussian Width vs. Mass for Light-ptcut RPV";
string tag = "qqb", sphericity = " Sphericity #geq 0.4";
if (flavor.compare("112") == 0)
tag = "qqq";
else if (ptcut.compare("60") == 0)
sphericity = "";
string titlepart = "Hadronic RPV #tilde{g} #rightarrow " + tag;
string titleln2 = "\\Delta = 110 GeV";
string titleln3 = "6^{th}-jet p_{T} #geq " + ptcut + " GeV";
title = titlepart;
// title = "Width for " + titlepart;
/*
if(k==0){
title="RPV gluino #bf{" + systematic + " up} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino #bf{" + systematic + " up} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
if(k==1){
title="RPV gluino #bf{" + systematic + " down} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino #bf{" + systematic + " down} m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
if(k==2){
title="RPV gluino m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 60 GeV}";
if (i>=5 || p==0) title="RPV gluino m="+to_string(masses[i])+", ptcut = "+ptcut+", #Delta = 110 GeV, #bf{6^{th} Jet p_{T} = 110 GeV}";
}
*/
h_GluinoHist_Fit->SetTitle(title.c_str());
float titpos = 0.2, titly = 0.89, headpos = 0.64;
if (tdrstyle == false) {
titpos -= 0.05;
titly -= 0.05;
headpos = 0.45;
}
TLatex *tex2 = new TLatex(titpos, titly, title.c_str());
tex2->SetNDC();
tex2->SetTextAlign(12); // Left-adjusted
tex2->SetTextFont(42);
tex2->SetTextSize(textsiz);
tex2->SetLineWidth(2);
TLatex *tex3 = new TLatex(titpos, titly - 0.07, titleln2.c_str());
tex3->SetNDC();
tex3->SetTextAlign(12);
tex3->SetTextFont(42);
tex3->SetTextSize(textsiz);
tex3->SetLineWidth(2);
TLatex *tex3a = new TLatex(titpos, titly - 0.14, titleln3.c_str());
tex3a->SetNDC();
tex3a->SetTextAlign(12);
tex3a->SetTextFont(42);
tex3a->SetTextSize(textsiz);
tex3a->SetLineWidth(2);
TLatex *tex4 = NULL;
if (sphericity.size() > 0) {
tex4 = new TLatex(titpos - 0.01, titly - 0.22, sphericity.c_str());
tex4->SetNDC();
tex4->SetTextAlign(12);
tex4->SetTextFont(42);
tex4->SetTextSize(textsiz);
tex4->SetLineWidth(2);
}
float legx = 0.65;
if (tdrstyle == false) {
legx = 0.56;
}
TLegend *leg = new TLegend(legx, 0.2, legx + 0.3, 0.4);
leg->SetBorderSize(1);
leg->SetTextFont(62);
leg->SetLineColor(kBlack);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(1001);
//leg->SetHeader();
// leg->AddEntry(h_GluinoHist_Fit, "#splitline{Acceptance as function}{of gluino mass}","l");
h_GluinoHist_Fit->SetMarkerStyle(1);
h_GluinoHist_Fit->SetMarkerColor(kWhite);
// h_GluinoHist_Fit->SetMarkerColor(kGreen + 3);
h_GluinoHist_Fit->SetMarkerSize(0.004);
// h_GluinoHist_Fit->SetTitleSize(0.01);
TF1 *fitfunc = h_GluinoHist_Fit->GetFunction("GausWidth");
string fitnamew = "fitcopy" + ptcut;
TF1* fitfunccopy = (TF1 *) fitfunc->Clone(fitnamew.c_str());
if (fitfunc == NULL)
cout << "Can't get fit func\n";
else {
fitfunc->Delete();
fitfunccopy->SetLineWidth(3);
fitfunccopy->SetLineColor(kGreen + 3);
// fitfunc->SetLineStyle(3); // Dotted
}
float labsiz = 0.055;
h_GluinoHist_Fit->GetXaxis()->SetLabelFont(62);
h_GluinoHist_Fit->GetXaxis()->SetTitleFont(62);
h_GluinoHist_Fit->GetYaxis()->SetLabelFont(62);
h_GluinoHist_Fit->GetYaxis()->SetTitleFont(62);
h_GluinoHist_Fit->GetYaxis()->SetTitle("Gaussian width [GeV]");
float offset = 0.8;
if (tdrstyle == false) {
h_GluinoHist_Fit->GetXaxis()->SetTitleOffset(offset);
h_GluinoHist_Fit->GetYaxis()->SetTitleOffset(offset);
}
h_GluinoHist_Fit->GetXaxis()->SetTitle("Gluino mass [GeV]");
h_GluinoHist_Fit->GetXaxis()->SetTitleSize(labsiz);
h_GluinoHist_Fit->GetYaxis()->SetTitleSize(labsiz);
if (tdrstyle == false) {
float axsize = 0.04;
h_GluinoHist_Fit->GetXaxis()->SetLabelSize(axsize);
h_GluinoHist_Fit->GetYaxis()->SetLabelSize(axsize);
}
if (flavor.compare("113_223") == 0 && ptcut == "60")
h_GluinoHist_Fit->GetYaxis()->SetRangeUser(14.0, 50.0);
h_GluinoHist_Fit->Draw("APX"); // X eliminates error bars
// h_GluinoHist_Fit->Draw("AP");
// TH1 *fithist = (TH1 *) fitfunccopy->GetHistogram()->Clone(fitnamew.c_str());
TH1 *fithist = (TH1 *) fitfunccopy->GetHistogram()->Clone();
int fillcolor = kGreen + 2;
int fillstyle = 3013;
if (fithist != NULL) {
int numBins = fithist->GetNbinsX();
for (int cnt = 1; cnt <= numBins; ++cnt) {
setErr(fithist, cnt, flavor, "width");
}
fithist->SetFillColor(fillcolor);
fithist->SetFillStyle(fillstyle);
fithist->Draw("CE3SAME");
}
fitfunccopy->Draw("CSAME");
// h_GluinoHist_Fit->Draw("P"); // Draw points over fit line
leg->AddEntry(fitfunccopy, "Gaussian width", "L");
leg->AddEntry(fithist, "Uncertainty", "F");
leg->Draw();
tex->SetX(headpos);
tex->Draw();
tex2->Draw();
tex3->Draw();
tex3a->Draw();
if (tex4 != NULL)
tex4->Draw();
cGluinoFitsOpti->Write();
cGluinoFitsOpti->SaveAs((folder + "RPVwidth" +flavor + ptcut+uncert+postfix).c_str());
TCanvas * cGluinoFitsOpt2 = new TCanvas(("RPVacc_"+flavor +ptcut).c_str(), ("RPV_" + ptcut+"_"+cuts).c_str(), 800, 600);
// title="Acc. x Eff. for " + titlepart;
title= titlepart;
tex2->SetText(titpos,titly, title.c_str());
TLegend *leg2 = new TLegend(legx, 0.2, legx + 0.3, 0.4);
leg2->SetBorderSize(1);
leg2->SetTextFont(62);
leg2->SetTextSize(0.04);
leg2->SetLineColor(kBlack);
leg2->SetLineStyle(1);
leg2->SetLineWidth(1);
leg2->SetFillColor(0);
leg2->SetFillStyle(1001);
TF1 *fitfuncA = h_GluinoHist_MCcomb->GetFunction("total");
string fitname = "fitcopyA" + ptcut;
TF1* fitfunccopyA = (TF1 *) fitfuncA->Clone(fitname.c_str());
if (fitfuncA == NULL)
cout << "Can't get fit func\n";
else {
fitfuncA->Delete();
fitfunccopyA->SetLineWidth(3);
fitfunccopyA->SetLineColor(kGreen + 3);
// fitfunc->SetLineStyle(3); // Dotted
}
h_GluinoHist_MCcomb->SetMarkerStyle(1);
// h_GluinoHist_MCcomb->SetMarkerColor(kBlack);
h_GluinoHist_MCcomb->SetMarkerColor(kWhite);
h_GluinoHist_MCcomb->SetTitle(title.c_str());
h_GluinoHist_MCcomb->GetXaxis()->SetLabelFont(62);
h_GluinoHist_MCcomb->GetXaxis()->SetTitleFont(62);
h_GluinoHist_MCcomb->GetYaxis()->SetLabelFont(62);
// h_GluinoHist_MCcomb->GetYaxis()->SetLabelSize(62);
h_GluinoHist_MCcomb->GetYaxis()->SetTitleFont(62);
h_GluinoHist_MCcomb->GetYaxis()->SetTitle("Acceptance x Efficiency");
if (tdrstyle == false) {
h_GluinoHist_MCcomb->GetXaxis()->SetTitleOffset(offset);
h_GluinoHist_MCcomb->GetYaxis()->SetTitleOffset(offset + 0.35);
}
// h_GluinoHist_MCcomb->GetYaxis()->SetTitleOffset(1.4);
h_GluinoHist_MCcomb->GetXaxis()->SetTitle("Gluino mass [GeV]");
h_GluinoHist_MCcomb->GetXaxis()->SetTitleSize(labsiz);
if (tdrstyle == false)
labsiz -= 0.01;
h_GluinoHist_MCcomb->GetYaxis()->SetTitleSize(labsiz);
if (tdrstyle == false) {
float axsize = 0.035;
h_GluinoHist_MCcomb->GetXaxis()->SetLabelSize(axsize);
h_GluinoHist_MCcomb->GetYaxis()->SetLabelSize(axsize);
}
if (flavor.compare("113_223") == 0) {
float ylimit = 0.05;
if ( ptcut == "110")
ylimit = 0.022;
// gStyle->SetStatY(0.8);
h_GluinoHist_MCcomb->GetYaxis()->SetRangeUser(0.0, ylimit);
}
// h_GluinoHist_MCcomb->Draw("AL");
h_GluinoHist_MCcomb->Draw("APX");
// fitfunccopyA->Draw("C same");
// TH1 *fithistA = (TH1 *) fitfunccopyA->GetHistogram()->Clone(fitname.c_str());
TH1 *fithistA = (TH1 *) fitfunccopyA->GetHistogram()->Clone();
if (fithistA != NULL) {
int numBins = fithistA->GetNbinsX();
for (int cnt = 1; cnt <= numBins; ++cnt) {
setErr(fithistA, cnt, flavor, "acceptance");
}
fithistA->SetFillColor(fillcolor);
fithistA->SetFillStyle(fillstyle);
fithistA->Draw("CE3SAME");
}
fitfunccopyA->Draw("CSAME");
// h_GluinoHist_MCcomb->Draw("P"); // Draw points over fit line
tex->SetX(headpos);
tex->Draw();
tex2->Draw();
tex3->Draw();
tex3a->Draw();
leg2->AddEntry(fitfunccopyA, "Acc. x Eff.", "L");
leg2->AddEntry(fithistA, "Uncertainty", "F");
leg2->Draw();
if (tex4 != NULL)
tex4->Draw();
cGluinoFitsOpt2->Write();
cGluinoFitsOpt2->SaveAs((folder + "RPVacc" +flavor + ptcut+uncert+postfix).c_str());
/*
gStyle->SetStatY(0.4);
TCanvas * cGluinoFitsOpt3 = new TCanvas(("RPVfullacc_"+flavor +ptcut).c_str(), ("RPVfull_" + ptcut+"_"+cuts).c_str(), 800, 600);
title="Gaussian Mean for " + titlepart;
tex2->SetText(titpos, 0.89, title.c_str());
// title="Full Acceptance for " + titlepart;
h_FullAccept->SetMarkerStyle(1);
// h_FullAccept->SetMarkerColor(kWhite);
h_FullAccept->SetLineColor(kRed);
h_FullAccept->SetLineWidth(2.0);
// h_FullAccept->SetTitle(title.c_str());
// h_FullAccept->GetYaxis()->SetTitle("Acceptance");
h_FullAccept->GetYaxis()->SetTitle("Gaussian Mean [GeV]");
h_FullAccept->GetXaxis()->SetTitleOffset(1.3);
h_FullAccept->GetXaxis()->SetTitle("Gluino Mass [GeV]");
h_FullAccept->GetXaxis()->SetTitleSize(labsiz);
h_FullAccept->GetYaxis()->SetTitleSize(labsiz);
h_FullAccept->GetXaxis()->SetLabelSize(axsize);
h_FullAccept->GetYaxis()->SetLabelSize(axsize);
h_FullAccept->Draw("AL");
// h_FullAccept->Draw("APX");
// leg->Draw();
// h_GluinoHist_MCcomb->SetFillColor(10);
// h_GluinoHist_MCcomb->SetLineColor(kBlack);
// h_GluinoHist_MCcomb->Draw("samehist");
// f_GluinoGauss->SetLineColor(kRed);
//f_GluinoGauss->Draw("same");
//f_GluinoP4->Draw("same");
tex->SetX(titpos);
tex->Draw();
tex2->Draw();
tex3->Draw();
tex3a->Draw();
if (tex4 != NULL)
tex4->Draw();
f1.cd();
cGluinoFitsOpt3->Write();
cGluinoFitsOpt3->SaveAs((folder + "RPVmean" +flavor + ptcut+uncert+postfix).c_str());
gStyle->SetStatY(0.4);
TCanvas *cMeanOffset = new TCanvas(("RPVMeanOffset_"+flavor +ptcut).c_str(),
("RPVMeanOffset_" + ptcut + "_" + cuts).c_str(), 800, 600);
axsize = 0.035;
title="Mass Deviation for " + titlepart;
titpos = 0.35;
tex2->SetText(titpos, 0.89, title.c_str());
h_MeanOffset->SetMarkerStyle(1);
h_MeanOffset->SetLineColor(kRed);
h_MeanOffset->SetLineWidth(2.0);
h_MeanOffset->GetYaxis()->SetTitleOffset(1.3);
h_MeanOffset->GetYaxis()->SetTitle("Fractional Mass Deviation");
h_MeanOffset->GetXaxis()->SetTitleOffset(1.3);
h_MeanOffset->GetXaxis()->SetTitle("Gluino Mass [GeV]");
h_MeanOffset->GetXaxis()->SetTitleSize(labsiz);
h_MeanOffset->GetYaxis()->SetTitleSize(labsiz);
h_MeanOffset->GetXaxis()->SetLabelSize(axsize);
h_MeanOffset->GetYaxis()->SetLabelSize(axsize);
TLine *max = new TLine(0.5, 0.1, 0.5, 0.9);
max->SetLineColor(kGreen + 2);
max->SetLineWidth(3);
h_MeanOffset->Draw("AL");
max->DrawLineNDC(0.16, 0.49, 0.98, 0.49);
tex->SetX(titpos);
tex->Draw();
tex2->Draw();
tex3->SetX(titpos);
tex3->Draw();
tex3a->SetX(titpos);
tex3a->Draw();
if (tex4 != NULL) {
tex4->SetX(titpos);
tex4->Draw();
}
f1.cd();
cMeanOffset->Write();
cMeanOffset->SaveAs((folder + "RPVmassdev" +flavor + ptcut+uncert+postfix).c_str());
*/
}
}
}
/**
* Process a single eta bin
*
* @param measured Input collection of measured data
* @param corrections Input collection of correction data
* @param method Unfolding method to use
* @param regParam Regularisation parameter
* @param out Output directory.
*
* @return Stack of histograms or null
*/
THStack* ProcessBin(TCollection* measured,
TCollection* corrections,
UInt_t method,
Double_t regParam,
TDirectory* out)
{
Printf(" Processing %s ...", measured->GetName());
// Try to get the data
TH1* inRaw = GetH1(measured, "rawDist");
TH1* inTruth = GetH1(corrections, "truth");
TH1* inTruthA = GetH1(corrections, "truthAccepted");
TH1* inTrgVtx = GetH1(corrections, "triggerVertex");
TH2* inResp = GetH2(corrections, "response");
if (!inRaw || !inTruth || !inTruthA || !inTrgVtx || !inResp)
return 0;
// Make output directory
TDirectory* dir = out->mkdir(measured->GetName());
dir->cd();
// Copy the input to the output
TH1* outRaw = static_cast<TH1*>(inRaw ->Clone("measured"));
TH1* outTruth = static_cast<TH1*>(inTruth ->Clone("truth"));
TH1* outTruthA = static_cast<TH1*>(inTruthA ->Clone("truthAccepted"));
TH1* outTrgVtx = static_cast<TH1*>(inTrgVtx ->Clone("triggerVertex"));
TH2* outResp = static_cast<TH2*>(inResp ->Clone("response"));
// Make our response matrix
RooUnfoldResponse matrix(0, 0, inResp);
// Store regularization parameter
Double_t r = regParam;
RooUnfold::Algorithm algo = (RooUnfold::Algorithm)method;
RooUnfold* unfolder = RooUnfold::New(algo, &matrix, inRaw, r);
unfolder->SetVerbose(0);
// Do the unfolding and get the result
TH1* res = unfolder->Hreco();
res->SetDirectory(0);
// Make a copy to store on the output
TH1* outUnfold = static_cast<TH1*>(res->Clone("unfolded"));
TString tit(outUnfold->GetTitle());
tit.ReplaceAll("Unfold Reponse matrix", "Unfolded P(#it{N}_{ch})");
outUnfold->SetTitle(tit);
// Clone the unfolded results and divide by the trigger/vertex
// bias correction
TH1* outCorr = static_cast<TH1*>(outUnfold->Clone("corrected"));
outCorr->Divide(inTrgVtx);
tit.ReplaceAll("Unfolded", "Corrected");
outCorr->SetTitle(tit);
// Now normalize the output to integral=1
TH1* hists[] = { outRaw, outUnfold, outCorr, 0 };
TH1** phist = hists;
while (*phist) {
TH1* h = *phist;
if (h) {
Double_t intg = h->Integral(1, h->GetXaxis()->GetXmax());
h->Scale(1. / intg, "width");
}
phist++;
}
// And make ratios
TH1* ratioTrue = static_cast<TH1*>(outCorr->Clone("ratioCorrTruth"));
tit = ratioTrue->GetTitle();
tit.ReplaceAll("Corrected", "Corrected/MC 'truth'");
ratioTrue->SetTitle(tit);
ratioTrue->Divide(outTruth);
ratioTrue->SetYTitle("P_{corrected}(#it{N}_{ch})/P_{truth}(#it{N}_{ch})");
TH1* ratioAcc = static_cast<TH1*>(outUnfold->Clone("ratioUnfAcc"));
tit = ratioAcc->GetTitle();
tit.ReplaceAll("Unfolded", "Unfolded/MC selected");
ratioAcc->SetTitle(tit);
ratioAcc->Divide(outTruthA);
ratioAcc->SetYTitle("P_{unfolded}(#it{N}_{ch})/P_{MC}(#it{N}_{ch})");
// Make a stack
tit = measured->GetName();
tit.ReplaceAll("m", "-");
tit.ReplaceAll("p", "+");
tit.ReplaceAll("d", ".");
tit.ReplaceAll("_", "<#it{#eta}<");
THStack* stack = new THStack("all", tit);
stack->Add(outTruth, "E2");
stack->Add(outTruthA, "E2");
stack->Add(outRaw, "E1");
stack->Add(outUnfold, "E1");
stack->Add(outCorr, "E1");
dir->Add(stack);
// Rest of the function is devoted to making the output look nice
outRaw ->SetDirectory(dir);
outTruth ->SetDirectory(dir);
outTruthA->SetDirectory(dir);
outTrgVtx->SetDirectory(dir);
outResp ->SetDirectory(dir);
outUnfold->SetDirectory(dir);
outCorr ->SetDirectory(dir);
outRaw ->SetMarkerStyle(20); // Measured is closed
outTruth ->SetMarkerStyle(24); // MC is open
outTruthA->SetMarkerStyle(24); // MC is open
outTrgVtx->SetMarkerStyle(20); // Derived is closed
outUnfold->SetMarkerStyle(20); // Derived is closed
outCorr ->SetMarkerStyle(20); // Derived is closed
outRaw ->SetMarkerSize(0.9);
outTruth ->SetMarkerSize(1.6);
outTruthA->SetMarkerSize(1.4);
outTrgVtx->SetMarkerSize(1.0);
outUnfold->SetMarkerSize(0.9);
outCorr ->SetMarkerSize(1.0);
outRaw ->SetMarkerColor(kColorMeasured);
outTruth ->SetMarkerColor(kColorTruth);
outTruthA->SetMarkerColor(kColorAccepted);
outTrgVtx->SetMarkerColor(kColorTrgVtx);
outUnfold->SetMarkerColor(kColorUnfolded);
outCorr ->SetMarkerColor(kColorCorrected);
outRaw ->SetFillColor(kColorError);
outTruth ->SetFillColor(kColorError);
outTruthA->SetFillColor(kColorError);
outTrgVtx->SetFillColor(kColorError);
outUnfold->SetFillColor(kColorError);
outCorr ->SetFillColor(kColorError);
outRaw ->SetFillStyle(0);
outTruth ->SetFillStyle(1001);
outTruthA->SetFillStyle(1001);
outTrgVtx->SetFillStyle(0);
outUnfold->SetFillStyle(0);
outCorr ->SetFillStyle(0);
outRaw ->SetLineColor(kBlack);
outTruth ->SetLineColor(kBlack);
outTruthA->SetLineColor(kBlack);
outTrgVtx->SetLineColor(kBlack);
outUnfold->SetLineColor(kBlack);
outCorr ->SetLineColor(kBlack);
// Legend
TLegend* l = StackLegend(stack);
l->AddEntry(outRaw, "Raw", "lp");
l->AddEntry(outTruth, "MC 'truth'", "fp");
l->AddEntry(outTruthA, "MC 'truth' accepted", "fp");
l->AddEntry(outUnfold, "Unfolded", "lp");
l->AddEntry(outCorr, "Corrected", "lp");
return stack;
}
void makeStack(TString myVar, TString myCut, TString myName, TString myAxisNameX, TString myAxisNameY,
vector<const Sample*>& listOfSignals, vector<const Sample*>& listOfSamples, vector<const Sample*> listOfDatasets,
TString inFileName,
bool isBlind, bool isLog, bool drawSignal, bool drawLegend,
int nBins, float xLow, float xHigh,
float* xlowVec)
{
// prepare the input file
TFile* infile = new TFile(inFileName, "READ");
infile -> cd();
// prepare the stack
THStack *hs = new THStack("hs","");
// prepare the histos pointers
TH1F* hist[20];
// prepare the tree pointers
TTree* tree[20];
// prepare the legend
TLegend* leg = new TLegend(.7485,.7225,.9597,.9604);
leg->SetFillColor(0);
// prepare the colors
Int_t col[20] = {46,2,12,5,3,4,9,7,47,49,49,50,51,52,53,54,55,56,57,58};
// prepare the cut
if (isBlind) myCut += "*(phoMetDeltaPhi < 2.9)";
// prepare the Y axis lable
if (xlowVec != 0) myAxisNameY = "Events/" + myAxisNameY;
else {
float binWidth = (xHigh-xLow)/nBins;
TString tempString;
tempString.Form("%.2f ",binWidth);
myAxisNameY = "Events/" + tempString + myAxisNameY;
}
// prepare the legend strings
vector<TString> theLegends;
// loop through the datasets and produce the plots
TH1F* hdata;
TH1F* hsignal;
//prepare data and signal histos
if (xlowVec != 0) hdata = new TH1F("hdata","",nBins,xlowVec);
else hdata = new TH1F("hdata","",nBins,xLow,xHigh);
if (xlowVec != 0) hsignal = new TH1F("hsignal","",nBins,xlowVec);
else hsignal = new TH1F("hsignal","",nBins,xLow,xHigh);
TTree* treedata[20];
for (UInt_t iDatas=0; iDatas < listOfDatasets.size(); iDatas++) {
//get the tree
treedata[iDatas] = (TTree*) infile -> Get(listOfDatasets.at(iDatas)->Name()->Data());
//fill the histogram
if ( iDatas == 0 ) treedata[iDatas] -> Draw(myVar + " >> hdata","evt_weight*kf_weight*pu_weight" + myCut);
else treedata[iDatas] -> Draw(myVar + " >>+ hdata","evt_weight*kf_weight*pu_weight" + myCut);
if ( isBlind && iDatas == 0 ) leg -> AddEntry(hdata, "DATA (19.8 fb^{-1})", "pl");
}//end loop on datasets
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinError (iBin,hdata->GetBinError(iBin)/hdata->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hdata->SetBinContent(iBin,hdata->GetBinContent(iBin)/hdata->GetBinWidth(iBin));
}
TTree* treesignal[20];
for (UInt_t iSignal=0; iSignal < listOfSignals.size(); iSignal++) {
//get the tree
treesignal[iSignal] = (TTree*) infile -> Get(listOfSignals.at(iSignal)->Name()->Data());
//fill the histogram
TString thisScale = Form("%f *", *(listOfSignals.at(iSignal)->Scale()));
if ( iSignal == 0 ) treesignal[iSignal] -> Draw(myVar + " >> hsignal",thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
else treesignal[iSignal] -> Draw(myVar + " >>+ hsignal",thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
if ( drawSignal && iSignal == 0 ) leg -> AddEntry(hsignal, "Signal", "l");
}//end loop on signals
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hsignal->SetBinError (iBin,hsignal->GetBinError(iBin)/hsignal->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hsignal->SetBinContent(iBin,hsignal->GetBinContent(iBin)/hsignal->GetBinWidth(iBin));
}
hsignal -> SetLineColor(49);
hsignal -> SetLineWidth(4.0);
int theHistCounter = 0;
// loop through the samples and produce the plots
for (UInt_t iSample=0; iSample < listOfSamples.size(); iSample++) {
//determine if the histo is first of the series
bool isFirstOfSerie = (*listOfSamples.at(iSample)->Legend()).CompareTo(" ");
bool isLastOfSerie = false;
if (iSample == listOfSamples.size() - 1) isLastOfSerie = true;
if (iSample < listOfSamples.size() - 1 && (*listOfSamples.at(iSample+1)->Legend()).CompareTo(" ") != 0) isLastOfSerie = true;
//get the tree
tree[iSample] = (TTree*) infile -> Get(listOfSamples.at(iSample)->Name()->Data());
//if sample first of the list create a new histogram
if (isFirstOfSerie) {
TString thisHistName = "h_" + *(listOfSamples.at(iSample)->Name());
//variable bin histo
if (xlowVec != 0) hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xlowVec);
//fixed bin histo
else hist[theHistCounter] = new TH1F(thisHistName,thisHistName,nBins,xLow,xHigh);
hist[theHistCounter] -> Sumw2();
hist[theHistCounter] -> SetFillColor(col[theHistCounter]);
hist[theHistCounter] -> SetFillStyle(1001);
theLegends.push_back(*listOfSamples.at(iSample)->Legend());
}
//fill the histogram
TString thisScale = Form("%f *", *(listOfSamples.at(iSample)->Scale()));
if (isFirstOfSerie) tree[iSample] -> Draw(myVar + " >> " + TString(hist[theHistCounter] -> GetName()),thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
else tree[iSample] -> Draw(myVar + " >>+ " + TString(hist[theHistCounter] -> GetName()),thisScale + "evt_weight*kf_weight*pu_weight" + myCut);
//add the histogram to the stack if the last of the series:
//either last sample or ~ sample followed by non ~ sample
if (isLastOfSerie) {
if (xlowVec != 0) {
for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinError (iBin,hist[theHistCounter]->GetBinError(iBin)/hist[theHistCounter]->GetBinWidth(iBin));
for (int iBin = 1; iBin <= nBins; iBin++) hist[theHistCounter]->SetBinContent(iBin,hist[theHistCounter]->GetBinContent(iBin)/hist[theHistCounter]->GetBinWidth(iBin));
}
hs -> Add(hist[theHistCounter]);
theHistCounter++;
}
}//end loop on samples
//Fix the legend
for (int iHisto = theHistCounter-1; iHisto >= 0; iHisto--) {
leg -> AddEntry(hist[iHisto], theLegends[iHisto], "f");
}
//get the maximum to properly set the frame
float theMax = hdata -> GetBinContent(hdata -> GetMaximumBin()) + hdata -> GetBinError(hdata -> GetMaximumBin());
TH1* theMCSum = (TH1*) hs->GetStack()->Last();
float theMaxMC = theMCSum->GetBinContent(theMCSum->GetMaximumBin()) + theMCSum->GetBinError(theMCSum->GetMaximumBin());
if (theMaxMC > theMax) theMax = theMaxMC;
//prepare the ratio band and plot
TH1* theMCRatioBand = makeRatioBand(theMCSum);
TH1* theRatioPlot = makeRatioPlot(hdata,theMCSum);
TCanvas* can = new TCanvas();
can -> SetLogy(isLog);
TPad *pad1 = new TPad("pad1","top pad",0,0.30,1,1);
pad1->SetBottomMargin(0.02);
pad1->SetLeftMargin(0.13);
pad1->Draw();
TPad *pad2 = new TPad("pad2","bottom pad",0,0.0,1,0.30);
pad2->SetTopMargin(0.02);
pad2->SetLeftMargin(0.13);
pad2->SetBottomMargin(0.4);
pad2->SetGridy();
pad2->Draw();
pad1->cd();
hs->Draw("hist");
hdata->Draw("same,pe");
if (drawSignal) hsignal->Draw("same,hist");
if (drawLegend) leg->Draw("same");
//hs->GetXaxis()->SetTitle(myAxisNameX);
hs->GetYaxis()->SetTitle(myAxisNameY);
hs->GetXaxis()->SetLabelSize(0.04);
hs->GetYaxis()->SetLabelSize(0.04);
hs->GetXaxis()->SetLabelOffset(0.025);
hs->GetYaxis()->SetLabelOffset(0.035);
//hs->GetXaxis()->SetTitleOffset(1.1);
hs->GetYaxis()->SetTitleOffset(1.1);
hs->SetMaximum(theMax);
if (isLog) hs->SetMinimum(0.01);
pad2->cd();
theMCRatioBand->GetXaxis()->SetTitle(myAxisNameX);
theMCRatioBand->GetXaxis()->SetTitleSize(0.16);
theMCRatioBand->GetXaxis()->SetTitleOffset(1.1);
theMCRatioBand->GetXaxis()->SetLabelSize(0.12);
theMCRatioBand->GetXaxis()->SetLabelOffset(0.07);
theMCRatioBand->GetYaxis()->SetTitle("Data/MC");
theMCRatioBand->GetYaxis()->SetTitleSize(0.10);
theMCRatioBand->GetYaxis()->SetTitleOffset(0.6);
theMCRatioBand->GetYaxis()->SetLabelSize(0.06);
theMCRatioBand->GetYaxis()->SetLabelOffset(0.03);
theMCRatioBand->SetFillStyle(3001);
theMCRatioBand->SetFillColor(kBlue);
theMCRatioBand->SetLineWidth(1);
theMCRatioBand->SetLineColor(kBlack);
theMCRatioBand->SetMarkerSize(0.1);
theMCRatioBand->SetMaximum(4.);
theMCRatioBand->SetMinimum(0.);
theMCRatioBand->Draw("E2");
TLine *line = new TLine(xLow,1,xHigh,1);
line->SetLineColor(kBlack);
line->Draw("same");
theRatioPlot->Draw("same,pe");
can->cd();
can->Modified();
can -> SaveAs(myName + ".pdf","pdf");
//cleanup the memory allocation
delete theMCSum;
delete hs;
delete leg;
delete hdata;
delete pad1;
delete pad2;
delete can;
delete theMCRatioBand;
delete theRatioPlot;
infile -> Close();
delete infile;
return;
}
TH1* GetCentK(TDirectory* top, Double_t c1, Double_t c2, Int_t s,
TLegend* l)
{
TString dname; dname.Form("cent%06.2f_%06.2f", c1, c2);
dname.ReplaceAll(".", "d");
TDirectory* d = top->GetDirectory(dname);
if (!d) {
Warning("GetCetnK", "Directory %s not found in %s",
dname.Data(), top->GetName());
return;
}
TDirectory* det = d->GetDirectory("details");
if (!det) {
Warning("GetCetnK", "Directory details not found in %s",
d->GetName());
d->ls();
return;
}
TObject* o = det->Get("scalar");
if (!o) {
Warning("GetCetnK", "Object scalar not found in %s",
det->GetName());
return;
}
if (!o->IsA()->InheritsFrom(TH1::Class())) {
Warning("GetCetnK", "Object %s is not a TH1, but a %s",
o->GetName(), o->ClassName());
return;
}
TH1* h = static_cast<TH1*>(o->Clone());
Color_t col = cc[(s-1)%10];
h->SetLineColor(col);
h->SetMarkerColor(col);
h->SetFillColor(col);
h->SetFillStyle(1001);
// h->SetTitle(Form("%5.2f-%5.2f%% #times %d", c1, c2, s));
h->SetTitle(Form("%2.0f-%2.0f%% + %d", c1, c2, s-1));
TF1* f = new TF1("", "[0]",-2.2,2.2);
f->SetParameter(0,s-1);
f->SetLineColor(col);
f->SetLineStyle(7);
f->SetLineWidth(1);
// h->Scale(s);
h->Add(f);
h->GetListOfFunctions()->Add(f);
f->SetParameter(0,s);
for (Int_t i = 1; i <= h->GetNbinsX(); i++) {
if (TMath::Abs(h->GetBinCenter(i)) > 2) {
h->SetBinContent(i,0);
h->SetBinError(i,0);
}
}
TLegendEntry* e = l->AddEntry(h, h->GetTitle(), "f");
e->SetFillColor(col);
e->SetFillStyle(1001);
e->SetLineColor(col);
return h;
}
/**
* Extract ALICE PbPb @ 5.02TeV over |eta|<2
*
* @param filename Input file name
* @param outname Output file name
* @param reweigh Whether it is reweighed
*/
void
Extract(const char* filename="dndneta.pbpb502.20151124.root",
const char* outname="TRACKLETS_5023_PbPb.input",
Bool_t reweigh=false)
{
if (filename == 0) return;
TFile* file = TFile::Open(filename, "READ");
TObjArray* arr = static_cast<TObjArray*>(file->Get("TObjArray"));
// Now count number of bins
Int_t nBins = 0;
TIter next(arr);
TObject* obj = 0;
while ((obj = next())) {
if (TString(obj->GetName()).Contains("DataCorrSignal"))
nBins++;
}
Info("ExtractdNdeta", "Defining %d centrality bins", nBins);
TArrayD c(nBins+1);
if (nBins == 5) {
c[0] = 0; c[1] = 10; c[2] = 20; c[3] = 40; c[4] = 60; c[5] = 80;
}
else if (nBins >= 9) {
c[0] = 0; c[1] = 5; c[2] = 10; c[3] = 20; c[4] = 30; c[5] = 40;
c[6] = 50; c[7] = 60; c[8] = 70; c[9] = 80;
if (nBins >= 10) c[10] = 90;
if (nBins >= 11) c[11] = 100;
}
THStack* all = new THStack("all","all");
std::ofstream out(outname);
std::ostream& o = out; // std::cout;
// std::ostream& o = std::cout;
o << "*author: SHAHOYAN : 2015\n"
<< "*title: Full centrality dependence of the charged "
<< "particle pseudo-rapidity density over the widest "
<< "possible pseudo-rapidity range in Pb-Pb collisions "
<< "at 5.02 TeV\n"
<< "*detector: TRACKLETS\n"
<< "*experiment: CERN-LHC-TRACKLETS\n"
<< "*comment: CERN-LHC: We present the charged particle pseudo-rapidity "
<< "density of charged particles in Pb-Pb collisions at sqrt(s)/nucleon "
"= 5.02 over the widest possible pseudo-rapidity and centrality range "
<< "possible.\n" << std::endl;
for (Int_t i = 0; i < nBins; i++) {
TString hName = Form("bin%d_DataCorrSignal_PbPb",i);
TH1* h = static_cast<TH1*>(arr->FindObject(hName));
if (!h) {
hName.ReplaceAll("PbPb", "PBPB");
h = static_cast<TH1*>(arr->FindObject(hName));
if (!h) {
Warning("", "Histogram (%s) missing for bin %d", hName.Data(), i);
arr->Print();
continue;
}
}
Color_t col = PbPbColor(c[i], c[i+1]);
h->SetLineColor(col);
h->SetMarkerColor(col);
h->SetFillColor(col);
all->Add(h);
Info("","Making GSE for %0d%% to %3d%% (%d)",
Int_t(c[i]), Int_t(c[i+1]), col);
MakeGSE(o, h, c[i], c[i+1], reweigh);
}
// all->Draw("nostack");
o << "*E" << std::endl;
out.close();
TCanvas* can = new TCanvas("c","C", 1600, 800);
can->SetRightMargin(0.2);
can->SetTopMargin(0.01);
TLegend* cl = new TLegend(1-can->GetRightMargin(),
can->GetBottomMargin(),.99,
1-can->GetTopMargin());
cl->SetFillStyle(0);
cl->SetBorderSize(0);
gROOT->LoadMacro("$HOME/GraphSysErr/GraphSysErr.C+");
TList* ll = GraphSysErr::Import(outname);
// ll->ls();
TIter next(ll);
TObject* obj = 0;
Bool_t first = true;
TH1* frame = 0;
Double_t min=100000, max=0;
Int_t i = 0;
while ((obj = next())) {
if (c[i+1] > 80) break;
GraphSysErr* g = static_cast<GraphSysErr*>(obj);
Color_t col = PbPbColor(c[i], c[i+1]);
TLegendEntry* e = cl->AddEntry("", Form("%4.1f-%4.1f%%", c[i], c[i+1]),
"F");
e->SetFillColor(col);
e->SetFillStyle(1001);
g->SetLineColor(col);
g->SetMarkerColor(col);
g->SetFillColor(col);
// g->Print("qual");
g->SetDataOption(GraphSysErr::kNoTick);
g->SetSumOption(GraphSysErr::kBox);
g->SetSumLineColor(col);
g->SetSumFillColor(col);
g->SetCommonSumOption(GraphSysErr::kBox);
g->SetCommonSumLineColor(col);
g->SetCommonSumFillColor(col);
g->SetName(Form("tracklets%03dd%02d_%03dd%02d",
Int_t(c[i]), Int_t(c[i]*100) % 100,
Int_t(c[i+1]), Int_t(c[i+1]*100) % 100));
g->SetTitle(Form("%4.1f - %4.1f%%", c[i], c[i+1]));
if (first) g->Draw("combine stat quad axis xbase=2.5");
else g->Draw("combine stat quad xbase=2.5");
if (!frame)
frame = g->GetMulti()->GetHistogram();
first = false;
Double_t mn, mx;
g->GetMinMax("combine stat quad", mn, mx);
FindLeastLargest(g, c[i], c[i+1]);
min = TMath::Min(min, mn);
max = TMath::Max(max, mx);
i++;
}
frame->SetMinimum(min*.9);
frame->SetMaximum(max*1.1);
cl->Draw();
TFile* outFile = TFile::Open(Form("PbPb5023midRapidity%s.root",
reweigh ? "Reweighed" : "Normal"),
"RECREATE");
ll->Write("container",TObject::kSingleKey);
outFile->Write();
can->SaveAs(Form("PbPb5023midRapidity%s.png",
reweigh ? "Reweighed" : "Normal"));
}
void EMCDistribution_ADC(bool log_scale = true)
{
TString gain = "RAW";
TText *t;
TCanvas *c1 = new TCanvas(
"EMCDistribution_ADC_" + gain + TString(log_scale ? "_Log" : "") + cuts,
"EMCDistribution_ADC_" + gain + TString(log_scale ? "_Log" : "") + cuts,
1800, 1000);
c1->Divide(8, 8, 0., 0.01);
int idx = 1;
TPad *p;
for (int iphi = 8 - 1; iphi >= 0; iphi--)
{
for (int ieta = 0; ieta < 8; ieta++)
{
p = (TPad *) c1->cd(idx++);
c1->Update();
if (log_scale)
{
p->SetLogz();
}
p->SetGridx(0);
p->SetGridy(0);
TString hname = Form("hEnergy_ieta%d_iphi%d", ieta, iphi) + TString(log_scale ? "_Log" : "");
TH1 *h = NULL;
if (log_scale)
h = new TH2F(hname,
Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 24, -.5,
23.5,
// 128+64, 0, 3096);
4098, -1, 4097);
// else
// h = new TH2F(hname,
// Form(";Calibrated Tower Energy Sum (GeV);Count / bin"), 100,
// -.050, .5,128,0,2048);
h->SetLineWidth(0);
h->SetLineColor(kBlue + 3);
h->SetFillColor(kBlue + 3);
h->GetXaxis()->SetTitleSize(.09);
h->GetXaxis()->SetLabelSize(.08);
h->GetYaxis()->SetLabelSize(.08);
h->GetYaxis()->SetRangeUser(0, 4096);
// if (log_scale)
// QAHistManagerDef::useLogBins(h->GetYaxis());
TString sdraw = "TOWER_" + gain + "_CEMC[].signal_samples[]:fmod(Iteration$,24)>>" + hname;
TString scut =
Form(
"TOWER_%s_CEMC[].get_bineta()==%d && TOWER_%s_CEMC[].get_binphi()==%d",
gain.Data(), ieta, gain.Data(), iphi);
cout << "T->Draw(\"" << sdraw << "\",\"" << scut << "\");" << endl;
T->Draw(sdraw, scut, "colz");
TText *t = new TText(.9, .9, Form("Col%d Row%d", ieta, iphi));
t->SetTextAlign(33);
t->SetTextSize(.15);
t->SetNDC();
t->Draw();
// return;
}
}
SaveCanvas(c1,
TString(_file0->GetName()) + TString("_DrawPrototype3EMCalTower_") + TString(c1->GetName()), false);
}
