TH1D * myReweightor(TH2D* ttMtop2D, std::pair<TF1, WeightFunctionCreator*> weightFunc, TString Name){
TH1D * res = new TH1D(Name, Name,
ttMtop2D->GetYaxis()->GetNbins(), ttMtop2D->GetYaxis()->GetXmin(),
ttMtop2D->GetYaxis()->GetXmax());
for(int i = 1; i < (res->GetXaxis()->GetNbins() + 1); i++){
double nSignal = 0;
gROOT->cd();
TH1* hithrecbin = ttMtop2D->ProjectionX("_pX", i, i, "o");
hithrecbin->Multiply(&(weightFunc.first), 1);
nSignal = hithrecbin->Integral();
if (hithrecbin != NULL)
delete hithrecbin;
res->SetBinContent(i, nSignal);
}
return res;
}
void plot_MistagRate_allSamples(string sample="TTbar_", int wjets_hadtau_only=0){
//
// icomp=0: only show own results
// 1: show also Koushik's results
//
//
///////////////////////////////////////////////////////////////////////////////////////////
////Some cosmetic work for official documents.
gStyle->SetOptStat(0); ///to avoid the stat. on the plots
gROOT->LoadMacro("tdrstyle.C");
// setTDRStyle();
gROOT->LoadMacro("CMS_lumi_v2.C");
char tempname[200];
char tempname2[200];
int W = 800;
int H = 600;
int H_ref = 600;
int W_ref = 800;
float T = 0.08*H_ref;
float B = 0.12*H_ref;
float L = 0.12*W_ref;
float R = 0.04*W_ref;
TCanvas* c1 = new TCanvas("name","name",10,10,W,H);
c1->SetFillColor(0);
c1->SetBorderMode(0);
c1->SetFrameFillStyle(0);
c1->SetFrameBorderMode(0);
c1->SetLeftMargin( L/W );
c1->SetRightMargin( R/W );
c1->SetTopMargin( T/H );
c1->SetBottomMargin( B/H );
c1->SetTickx(0);
c1->SetTicky(0);
Float_t legendX1 = .15; //.50;
Float_t legendX2 = .50; //.70;
Float_t legendY1 = .55; //.65;
Float_t legendY2 = .88;
TLegend* catLeg1 = new TLegend(legendX1,legendY1,legendX2,legendY2);
catLeg1->SetTextSize(0.042);
catLeg1->SetTextFont(42);
catLeg1->SetFillColor(0);
catLeg1->SetLineColor(0);
catLeg1->SetBorderSize(0);
TH1D * temp_tt_tauH, * temp_wj_tauH, *temp_tt_muH, * temp_wj_muH;
//
// From W+jets
TFile file_WJet("Stack/TauBtaggedRate_WJet_stacked.root","R");
temp_wj_tauH = (TH1D*)file_WJet.Get("TauBtaggedRate")->Clone();
TH1D * wj_tauH = new TH1D("wj_tauH","WJet -- Tau mistag",temp_wj_tauH->GetNbinsX(),temp_wj_tauH->GetXaxis()->GetXmin(),temp_wj_tauH->GetXaxis()->GetXmax());
for(int ibin=0;ibin<wj_tauH->GetNbinsX()+2;ibin++){
double con = (double)temp_wj_tauH->GetBinContent(ibin);
double err = (double)temp_wj_tauH->GetBinError(ibin);
cout << "con: " << con << " err: " << err << endl;
wj_tauH->SetBinContent(ibin,con);
wj_tauH->SetBinError(ibin,err);
}
//
// From ttbar
TFile file_TTbar("Stack/TauBtaggedRate_TTbar_stacked.root","R");
temp_tt_tauH = (TH1D*)file_TTbar.Get("TauBtaggedRate")->Clone();
TH1D * tt_tauH = new TH1D("tt_tauH","WJet -- Tau mistag",temp_tt_tauH->GetNbinsX(),temp_tt_tauH->GetXaxis()->GetXmin(),temp_tt_tauH->GetXaxis()->GetXmax());
for(int ibin=0;ibin<tt_tauH->GetNbinsX()+2;ibin++){
double con = (double)temp_tt_tauH->GetBinContent(ibin);
double err = (double)temp_tt_tauH->GetBinError(ibin);
cout << "con: " << con << " err: " << err << endl;
tt_tauH->SetBinContent(ibin,con);
tt_tauH->SetBinError(ibin,err);
}
//
// From W+jets - predictions
TFile file_WJet_mu("../TauHad2/Stack/TauBtaggedRate_WJet_stacked.root","R");
temp_wj_muH = (TH1D*)file_WJet_mu.Get("TauBtaggedRate")->Clone();
TH1D * wj_muH = new TH1D("wj_muH","WJet -- Tau mistag",temp_wj_muH->GetNbinsX(),temp_wj_muH->GetXaxis()->GetXmin(),temp_wj_muH->GetXaxis()->GetXmax());
for(int ibin=0;ibin<wj_muH->GetNbinsX()+2;ibin++){
double con = (double)temp_wj_muH->GetBinContent(ibin);
double err = (double)temp_wj_muH->GetBinError(ibin);
cout << "con: " << con << " err: " << err << endl;
wj_muH->SetBinContent(ibin,con);
wj_muH->SetBinError(ibin,err);
}
//
// From ttbar - predictions
TFile file_TTbar_mu("../TauHad2/Stack/TauBtaggedRate_TTbar_stacked.root","R");
temp_tt_muH = (TH1D*)file_TTbar_mu.Get("TauBtaggedRate")->Clone();
TH1D * tt_muH = new TH1D("tt_muH","WJet -- Tau mistag",temp_tt_muH->GetNbinsX(),temp_tt_muH->GetXaxis()->GetXmin(),temp_tt_muH->GetXaxis()->GetXmax());
for(int ibin=0;ibin<tt_muH->GetNbinsX()+2;ibin++){
double con = (double)temp_tt_muH->GetBinContent(ibin);
double err = (double)temp_tt_muH->GetBinError(ibin);
cout << "con: " << con << " err: " << err << endl;
tt_muH->SetBinContent(ibin,con);
tt_muH->SetBinError(ibin,err);
}
// catLeg1->SetHeader("Prob. of #mu from #tau ");
//...........................................................................//
// TTbar ....................................................................//
//...........................................................................//
double XUp = 350. , maxVal=1.;
wj_tauH->GetXaxis()->SetRangeUser(30.,XUp);
wj_tauH->SetMaximum(maxVal);
wj_tauH->SetTitle("");
wj_tauH->GetXaxis()->SetLabelFont(42);
wj_tauH->GetXaxis()->SetLabelOffset(0.007);
wj_tauH->GetXaxis()->SetLabelSize(0.04);
wj_tauH->GetXaxis()->SetTitleSize(0.05);
wj_tauH->GetXaxis()->SetTitleOffset(1.0);
wj_tauH->GetXaxis()->SetTitleFont(42);
wj_tauH->GetYaxis()->SetLabelFont(42);
wj_tauH->GetYaxis()->SetLabelOffset(0.007);
wj_tauH->GetYaxis()->SetLabelSize(0.04);
wj_tauH->GetYaxis()->SetTitleSize(0.05);
wj_tauH->GetYaxis()->SetTitleOffset(1.0);
wj_tauH->GetYaxis()->SetTitleFont(42);
wj_tauH->GetXaxis()->SetTitle("p_{T}(#tau jet)");
wj_tauH->GetYaxis()->SetTitle("b-tagging mistag rate");
wj_tauH->GetXaxis()->SetRangeUser(30.,XUp);
wj_tauH->SetMaximum(maxVal);
wj_tauH->SetLineColor(1);
wj_tauH->Draw();
tt_tauH->SetLineColor(2);
// thist.SetFillColor(0);
// thist.SetLineWidth(3);
if (!wjets_hadtau_only) tt_tauH->Draw("same");
wj_muH->SetLineColor(8);
// wj_muH->SetMarkerStyle(20);
if (!wjets_hadtau_only) {
wj_muH->GetXaxis()->SetRangeUser(30.,500.);
wj_muH->Draw("same");
}
tt_muH->SetLineColor(4);
if (!wjets_hadtau_only){
tt_muH->GetXaxis()->SetRangeUser(30.,500.);
tt_muH->Draw("same");
}
// sanity plot
TH1 * sanityH = static_cast<TH1D*>(wj_tauH->Clone("sanity"));
sanityH->Add(tt_muH);
TH1 * tempH = static_cast<TH1D*>(wj_tauH->Clone("sanity"));
tempH->Multiply(tt_muH);
sanityH->Add(tempH,-1);
sanityH->SetLineColor(34);
if (!wjets_hadtau_only){
sanityH->GetXaxis()->SetRangeUser(30.,500.);
sanityH->Draw("same");
}
//
// TLegend
sprintf(tempname,"(a) #tau_{h}-jets in t#bar{t}");
if (!wjets_hadtau_only) catLeg1->AddEntry(tt_tauH,tempname,"l");
if (wjets_hadtau_only)
sprintf(tempname,"#tau_{h}-jets in W+jets");
else
sprintf(tempname,"(b) #tau_{h}-jets in W+jets");
catLeg1->AddEntry(wj_tauH,tempname,"l");
sprintf(tempname,"(c) #mu-jets in t#bar{t}");
if (!wjets_hadtau_only) catLeg1->AddEntry(tt_muH,tempname,"l");
sprintf(tempname,"(d) #mu-jets in W+jets");
if (!wjets_hadtau_only) catLeg1->AddEntry(wj_muH,tempname,"l");
//sprintf(tempname,"blue+(1 - blue)*red ");
if (!wjets_hadtau_only){
sprintf(tempname,"(e) #mu-jets (t#bar{t}) + #tau_{h}-jets (W+jets)");
catLeg1->AddEntry(sanityH,tempname,"l");
TH1F *sanityHdummy = (TH1F*) sanityH->Clone();
sanityHdummy->SetLineColor(0);
sprintf(tempname,"= (c) + [1-(c)]#times(b)");
catLeg1->AddEntry(sanityHdummy,tempname,"l");
}
catLeg1->Draw();
if (wjets_hadtau_only) {
sprintf(tempname,"TauBtaggedRate_allSamples_hadtau_Wjets.png");
c1->Print(tempname);
sprintf(tempname,"TauBtaggedRate_allSamples_hadtau_Wjets.pdf");
c1->Print(tempname);
} else {
sprintf(tempname,"TauBtaggedRate_allSamples.png");
c1->Print(tempname);
sprintf(tempname,"TauBtaggedRate_allSamples.pdf");
c1->Print(tempname);
}
}
TH1 *
UnfoldMe_MB2(const Char_t *data, const Char_t *mc, const Char_t *anatag, Int_t bin, Bool_t useMBcorr , Bool_t usecorrfit , Bool_t ismc , Float_t smooth , Int_t iter , Int_t regul , Float_t weight , Bool_t bayesian , Int_t nloop )
{
// MF comments:
// usedMBcorr: changes the matrix used for unfonding, from effMatrix to bin matrix (I think this is just to use mult dependent v s mb correction_)
// usecorrfit: if I understand correctly, fits the response matrix and uses fit to extrapolate it
TFile *fdt =0;
if (ismc)
fdt = TFile::Open(data);
else
fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form(responseMatrix, bin));
TH2 *hmatmc = 0;
if (useMBcorr){
hmatmc = (TH2 *)lmc->FindObject("effMatrix");
std::cout << "USING MB" << std::endl;
}
else {
hmatmc = (TH2 *)lmc->FindObject(Form(responseMatrix, bin));
}
TH1 *hdata = hmatdt->ProjectionY("hdata");
// TH1 *hdata = hmatdt->ProjectionY("htrue"); // For truth Only Calculations
hdata->Sumw2();
hdata->SetBinContent(1, 0.);
hdata->SetBinError(1, 0.);
// hdata->Scale(1. / hdata->Integral());
hdata->SetMarkerStyle(25);
TH1 *htrue = hmatdt->ProjectionX("htrue");
htrue->Sumw2();
// htrue->Scale(1. / htrue->Integral());
htrue->SetMarkerStyle(7);
htrue->SetMarkerColor(2);
htrue->SetBinContent(1, 0.);
htrue->SetBinError(1, 0.);
TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr");
TH1 *hinit = (TH1 *)hdata->Clone("hinit");
TH1 *hresu = (TH1 *)hdata->Clone("hresu");
TH1 *hbias = (TH1 *)hdata->Clone("hbias");
hresu->SetMarkerStyle(20);
hresu->SetMarkerColor(4);
hresu->Reset();
TH1 *hnum = hcorr->ProjectionY("hnum");
TH1 *hden = hcorr->ProjectionY("hden");
TH1 *heff = hcorr->ProjectionY("heff");
hnum->Reset();
hnum->Sumw2();
hden->Reset();
hden->Sumw2();
heff->Reset();
for (Int_t i = 0; i < heff->GetNbinsX(); i++) {
Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1);
if (int1 <= 0.) continue;
Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1);
hnum->SetBinContent(i + 1, int2);
hnum->SetBinError(i + 1, TMath::Sqrt(int2));
hden->SetBinContent(i + 1, int1);
hden->SetBinError(i + 1, TMath::Sqrt(int1));
}
TCanvas *cEfficiency = new TCanvas("cEfficiency", "cEfficiency");
cEfficiency->SetLogx();
cEfficiency->SetLogy();
heff->Divide(hnum, hden, 1., 1., "B");
heff->Draw();
#if 0
for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) {
heff->SetBinContent(ii + 1, 1.);
heff->SetBinError(ii + 1, 0.);
}
#endif
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
hcorr->SetBinContent(i + 1, 1, 0.);
hcorr->SetBinError(i + 1, 1, 0.);
}
for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) {
hcorr->SetBinContent(1, i + 1, 0.);
hcorr->SetBinError(1, i + 1, 0.);
}
TH2 *hcorrfit = ReturnCorrFromFit(hcorr);
// Docs from AliUnfolding
//Int_t AliUnfolding::Unfold(TH2* correlation, TH1* efficiency, TH1* measured, TH1* initialConditions, TH1* result, Bool_t check)
// unfolds with unfolding method fgMethodType
//
// parameters:
// correlation: response matrix as measured vs. generated
// efficiency: (optional) efficiency that is applied on the unfolded spectrum, i.e. it has to be in unfolded variables. If 0 no efficiency is applied.
// measured: the measured spectrum
// initialConditions: (optional) initial conditions for the unfolding. if 0 the measured spectrum is used as initial conditions.
// result: target for the unfolded result
// check: depends on the unfolding method, see comments in specific functions
for (Int_t iloop = 0; iloop < nloop; iloop++) {
if (bayesian) {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
AliUnfolding::SetBayesianParameters(smooth, iter);
} else {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
AliUnfolding::SetChi2Regularization(AliUnfolding::RegularizationType(regul), weight);
}
AliUnfolding::SetSkip0BinInChi2(kTRUE);
AliUnfolding::SetSkipBinsBegin(1);
AliUnfolding::SetNbins(150, 150);
AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu);
hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop));
}
printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1));
printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1));
TCanvas *cUnfolded = new TCanvas ("cUnfolded", "cUnfolded", 400, 800);
cUnfolded->Divide(1, 2);
cUnfolded->cd(1)->SetLogx();
cUnfolded->cd(1)->SetLogy();
hdata->Draw();
hresu->Draw("same");
htrue->Draw("same");
cUnfolded->cd(2)->SetLogx();
cUnfolded->cd(2)->DrawFrame(1., 0, 300., 10);
TH1 *hrat = (TH1 *)hresu->Clone("hrat");
hrat->Divide(htrue);
hrat->Draw("same");
TH1 *htrig = (TH1 *)hresu->Clone("htrig");
htrig->Multiply(heff);
Float_t dndeta_resu = 0.;
Float_t integr_resu = 0.;
Float_t dndeta_trig = 0.;
Float_t integr_trig = 0.;
for (Int_t i = 1; i < hresu->GetNbinsX(); i++) {
dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1);
integr_resu += hresu->GetBinContent(i + 1);
dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1);
integr_trig += htrig->GetBinContent(i + 1);
}
cUnfolded->SaveAs("unfold_efficiency.pdf");
integr_eff = integr_trig / integr_resu;
integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu);
dndeta_eff = dndeta_trig / dndeta_resu;
dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu);
printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err);
printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err);
return hresu;
}
TH1 *
UnfoldMe(Char_t *data, Char_t *mc, Char_t *anatag, Int_t bin, Bool_t useMBcorr = kTRUE, Bool_t usecorrfit = kFALSE, Bool_t ismc = kFALSE, Float_t smooth = 0.001, Int_t iter = 50, Int_t regul = AliUnfolding::kPowerLaw, Float_t weight = 100., Bool_t bayesian = kTRUE, Int_t nloop = 1)
{
if (ismc)
TFile *fdt = TFile::Open(data);
else
TFile *fdt = TFile::Open(data);
TFile *fmc = TFile::Open(mc);
TList *ldt = (TList *)fdt->Get(Form("clist_%s", anatag));
TList *lmc = (TList *)fmc->Get(Form("clist_%s", anatag));
TH2 *hmatdt = (TH2 *)ldt->FindObject(Form("b%d_corrMatrix", bin));
if (useMBcorr)
TH2 *hmatmc = (TH2 *)lmc->FindObject("effMatrix");
else
TH2 *hmatmc = (TH2 *)lmc->FindObject(Form("b%d_corrMatrix", bin));
TH1 *hdata = hmatdt->ProjectionY("hdata");
hdata->Sumw2();
hdata->SetBinContent(1, 0.);
hdata->SetBinError(1, 0.);
// hdata->Scale(1. / hdata->Integral());
hdata->SetMarkerStyle(25);
TH1 *htrue = hmatdt->ProjectionX("htrue");
htrue->Sumw2();
// htrue->Scale(1. / htrue->Integral());
htrue->SetMarkerStyle(7);
htrue->SetMarkerColor(2);
htrue->SetBinContent(1, 0.);
htrue->SetBinError(1, 0.);
TH2 *hcorr = (TH2 *)hmatmc->Clone("hcorr");
TH1 *hinit = (TH1 *)hdata->Clone("hinit");
TH1 *hresu = (TH1 *)hdata->Clone("hresu");
TH1 *hbias = (TH1 *)hdata->Clone("hbias");
hresu->SetMarkerStyle(20);
hresu->SetMarkerColor(4);
hresu->Reset();
TH1 *hnum = hcorr->ProjectionY("hnum");
TH1 *hden = hcorr->ProjectionY("hden");
TH1 *heff = hcorr->ProjectionY("heff");
hnum->Reset();
hnum->Sumw2();
hden->Reset();
hden->Sumw2();
heff->Reset();
for (Int_t i = 0; i < heff->GetNbinsX(); i++) {
Float_t int1 = hcorr->Integral(i + 1, i + 1, 0, -1);
if (int1 <= 0.) continue;
Float_t int2 = hcorr->Integral(i + 1, i + 1, 2, -1);
hnum->SetBinContent(i + 1, int2);
hnum->SetBinError(i + 1, TMath::Sqrt(int2));
hden->SetBinContent(i + 1, int1);
hden->SetBinError(i + 1, TMath::Sqrt(int1));
}
new TCanvas("cEfficiency");
heff->Divide(hnum, hden, 1., 1., "B");
heff->Draw();
#if 0
for (Int_t ii = 0; ii < heff->GetNbinsX(); ii++) {
heff->SetBinContent(ii + 1, 1.);
heff->SetBinError(ii + 1, 0.);
}
#endif
for (Int_t i = 0; i < hcorr->GetNbinsX(); i++) {
hcorr->SetBinContent(i + 1, 1, 0.);
hcorr->SetBinError(i + 1, 1, 0.);
}
for (Int_t i = 0; i < hcorr->GetNbinsY(); i++) {
hcorr->SetBinContent(1, i + 1, 0.);
hcorr->SetBinError(1, i + 1, 0.);
}
TH2 *hcorrfit = ReturnCorrFromFit(hcorr);
for (Int_t iloop = 0; iloop < nloop; iloop++) {
if (bayesian) {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kBayesian);
AliUnfolding::SetBayesianParameters(smooth, iter);
} else {
AliUnfolding::SetUnfoldingMethod(AliUnfolding::kChi2Minimization);
AliUnfolding::SetChi2Regularization(regul, weight);
}
AliUnfolding::SetSkip0BinInChi2(kTRUE);
AliUnfolding::SetSkipBinsBegin(1);
AliUnfolding::SetNbins(150, 150);
AliUnfolding::Unfold(usecorrfit ? hcorrfit : hcorr, heff, hdata, hinit, hresu);
hinit = (TH1 *)hresu->Clone(Form("hinit_%d", iloop));
}
printf("hdata->Integral(2, -1) = %f\n", hdata->Integral(2, -1));
printf("hresu->Integral(2, -1) = %f\n", hresu->Integral(2, -1));
TCanvas *cUnfolded = new TCanvas ("cUnfolded", "", 400, 800);
cUnfolded->Divide(1, 2);
cUnfolded->cd(1)->SetLogx();
cUnfolded->cd(1)->SetLogy();
hdata->Draw();
hresu->Draw("same");
htrue->Draw("same");
cUnfolded->cd(2)->SetLogx();
cUnfolded->cd(2)->DrawFrame(1., 0.75, 300., 1.25);
TH1 *hrat = (TH1 *)hresu->Clone("hrat");
hrat->Divide(htrue);
hrat->Draw("same");
TH1 *htrig = (TH1 *)hresu->Clone("htrig");
htrig->Multiply(heff);
Float_t dndeta_resu = 0.;
Float_t integr_resu = 0.;
Float_t dndeta_trig = 0.;
Float_t integr_trig = 0.;
for (Int_t i = 1; i < hresu->GetNbinsX(); i++) {
dndeta_resu += hresu->GetBinContent(i + 1) * hresu->GetBinLowEdge(i + 1);
integr_resu += hresu->GetBinContent(i + 1);
dndeta_trig += htrig->GetBinContent(i + 1) * htrig->GetBinLowEdge(i + 1);
integr_trig += htrig->GetBinContent(i + 1);
}
// dndeta_resu /= integr_resu;
// dndeta_trig /= integr_trig;
integr_eff = integr_trig / integr_resu;
integr_eff_err = TMath::Sqrt(integr_eff * (1. - integr_eff) / integr_resu);
dndeta_eff = dndeta_trig / dndeta_resu;
dndeta_eff_err = TMath::Sqrt(dndeta_eff * (1. - dndeta_eff) / dndeta_resu);
printf("INEL > 0 efficiency: %.3f +- %.3f\n", integr_eff, integr_eff_err);
printf("dN/dEta correction: %.3f +- %.3f\n", dndeta_eff, dndeta_eff_err);
return hresu;
}
///////////////////////
// Begin Main function:
void mkROOTaqgcMuLT0_Para(){
//////////////////////////////////////
// Set MC normalization scale factors:
const double intLUMI = 19297;
const double WWA_scale = 2.1*0.01362 * intLUMI/198777;
const double WWA2_scale = 2.1*0.01409 * intLUMI/199183;
const double LT0_p8m5_scale = 2.1*0.0809985 * intLUMI/184603 ;
const double LT0_p5m5_scale = 2.1*0.0443325 * intLUMI/149975;
const double LT0_p3m5_scale = 2.1*0.029308 * intLUMI/97015;
const double LT0_m3m5_scale = 2.1*0.0290669 * intLUMI/154634;
const double LT0_m5m5_scale = 2.1*0.0440545 * intLUMI/199930;
const double LT0_m8m5_scale = 2.1*0.0806445 * intLUMI/196613;
///////////////////////////////////////////////////////////////////////////////////
// Specify what kinematical distribution to observe, as well as histogram settings:
//
plotVar_t pv = {"Photon_Et[iPhoton12]",30,450,10,3,"Photon ET (GeV)"};
if ( !strlen(pv.plotvar) ) break;
std::cout << TString(pv.plotvar) << "\t"<<pv.MINRange<<"\t" << pv.MAXRange<<"\t" << pv.NBINS<<"\tTHE CUT " << endl;
////////////////////////////////
// Specify event selection cuts:
TCut the_cutKfac("effwt*puwt*(iPhoton12>-1&&Photon_Et[iPhoton12]>30.&&Photon_dRlep[iPhoton12]>0.5&&i12Jet2>-1&&i12Jet1>-1&&JetPFCor_dRpho12[i12Jet1]>0.5&&JetPFCor_dRpho12[i12Jet2]>0.5&&abs(W_muon_eta)<2.1&&abs(JetPFCor_dphiMET[i12Jet1])>0.4&& abs(JetPFCor_dphiMET[i12Jet2])>0.4&&JetPFCor_bDiscriminatorCSV[i12Jet1]<0.679&&JetPFCor_bDiscriminatorCSV[i12Jet2]<0.679&&abs(JetPFCor_Eta[i12Jet1]-JetPFCor_Eta[i12Jet2])<1.4&&abs(Photon_Eta[iPhoton12])<1.44421&&W_muon_pt>25&&event_met_pfmet>35.&&c2jMass12>70.&&c2jMass12<100.&&W_mt>30.&&abs(W_muon_dz000)<0.02&&abs(W_muon_dzPV)<0.5&&((i12Jet3>-1)? JetPFCor_dRpho12[i12Jet3]>0.5: 1 )&&((i12Jet4>-1)? JetPFCor_dRpho12[i12Jet4]>0.5: 1 ))");
//mva2jWWAmuA1>0.32
///////////////////////////
// Create output ROOT file:
TFile f("para_mu_LT0_WWA_PhotonEt.root", "RECREATE");
//////////////////////////////////////////////////
// Create file pointers for each sample ROOT file:
TFile *wwaShape_file,*wwa2Shape_file;
TFile *LT0_m8m5_file,*LT0_m5m5_file,*LT0_m3m5_file,*LT0_p3m5_file,*LT0_p5m5_file,*LT0_p8m5_file;
//////////////////////////////
// Open each sample ROOT file:
wwaShape_file = new TFile("InData_New/RD_mu_qq_wpwma_wp_qq_wm_lvl.root");
wwa2Shape_file = new TFile("InData_New/RD_mu_qq_wpwma_wp_lvl_wm_qq.root");
LT0_m8m5_file = new TFile("InData_New/RD_mu_LT0_m8m11MG_CMSSW532.root");
LT0_m5m5_file = new TFile("InData_New/RD_mu_LT0_m5m11MG_CMSSW532.root");
LT0_m3m5_file = new TFile("InData_New/RD_mu_LT0_m3m11MG_CMSSW532.root");
LT0_p3m5_file = new TFile("InData_New/RD_mu_LT0_p3m11MG_CMSSW532.root");
LT0_p5m5_file = new TFile("InData_New/RD_mu_LT0_p5m11MG_CMSSW532.root");
LT0_p8m5_file = new TFile("InData_New/RD_mu_LT0_p8m11MG_CMSSW532.root");
///////////////////////////////////////////////////
// Retrieve ROOT tree with kinematic distributions:
TTree* treewwa = (TTree*) wwaShape_file->Get("WJet");
TTree* treewwa2 = (TTree*) wwa2Shape_file->Get("WJet");
TTree* treeLT0_m8m5 = (TTree*) LT0_m8m5_file->Get("WJet");
TTree* treeLT0_m5m5 = (TTree*) LT0_m5m5_file->Get("WJet");
TTree* treeLT0_m3m5 = (TTree*) LT0_m3m5_file->Get("WJet");
TTree* treeLT0_p3m5 = (TTree*) LT0_p3m5_file->Get("WJet");
TTree* treeLT0_p5m5 = (TTree*) LT0_p5m5_file->Get("WJet");
TTree* treeLT0_p8m5 = (TTree*) LT0_p8m5_file->Get("WJet");
////////////////////////////////////////////////////////////
// Create kinematic-distribution histograms for each sample:
TH1* th1wwa = new TH1D("th1wwa", "th1wwa", pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* th1wwa2 = new TH1D("th1wwa2", "th1wwa2", pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_80 = new TH1D("signal_lt0_80","signal_lt0_80",pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_50 = new TH1D("signal_lt0_50","signal_lt0_50",pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_30 = new TH1D("signal_lt0_30","signal_lt0_30",pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_m30 = new TH1D("signal_lt0_m30","signal_lt0_-30",pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_m50 = new TH1D("signal_lt0_m50","signal_lt0_-50",pv.NBINS, pv.MINRange, pv.MAXRange);
TH1* signal_lt0_m80 = new TH1D("signal_lt0_m80","signal_lt0_-80",pv.NBINS, pv.MINRange, pv.MAXRange);
/////////////////////////////////////////////////////////////////////////
// Specify histograms to store Sum of Squares of Weights for each sample:
th1wwa->Sumw2();
th1wwa2->Sumw2();
///////////////////////////////////////////////////////////////////////////////////
// Fill kinematical distribution for each sample according to event selection cuts:
std::cout<<"Fill SM WWA Histogram..."<<std::endl;
treewwa->Draw(TString(pv.plotvar)+TString(">>th1wwa"), the_cutKfac, "goff");
th1wwa->AddBinContent(pv.NBINS,th1wwa->GetBinContent(pv.NBINS+1));th1wwa->SetBinContent(pv.NBINS+1,0.);
treewwa2->Draw(TString(pv.plotvar)+TString(">>th1wwa2"), the_cutKfac, "goff");
th1wwa2->AddBinContent(pv.NBINS,th1wwa2->GetBinContent(pv.NBINS+1));th1wwa2->SetBinContent(pv.NBINS+1,0.);
std::cout<<"Fill aQGC_1 WWA Histogram..."<<std::endl;
treeLT0_m8m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m80"), the_cutKfac, "goff");
std::cout<<"Fill aQGC_2 WWA Histogram..."<<std::endl;
treeLT0_m5m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m50"), the_cutKfac, "goff");
std::cout<<"Fill aQGC_3 WWA Histogram..."<<std::endl;
treeLT0_m3m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_m30"), the_cutKfac, "goff");
std::cout<<"Fill aQGC_4 WWA Histogram..."<<std::endl;
treeLT0_p3m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_30"), the_cutKfac, "goff");
std::cout<<"Fill aQGC_5 WWA Histogram..."<<std::endl;
treeLT0_p5m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_50"), the_cutKfac, "goff");
std::cout<<"Fill aQGC_6 WWA Histogram..."<<std::endl;
treeLT0_p8m5->Draw(TString(pv.plotvar)+TString(">>signal_lt0_80"), the_cutKfac, "goff");
signal_lt0_80->AddBinContent(pv.NBINS,signal_lt0_80->GetBinContent(pv.NBINS+1));signal_lt0_80->SetBinContent(pv.NBINS+1,0.);
signal_lt0_50->AddBinContent(pv.NBINS,signal_lt0_50->GetBinContent(pv.NBINS+1));signal_lt0_50->SetBinContent(pv.NBINS+1,0.);
signal_lt0_30->AddBinContent(pv.NBINS,signal_lt0_30->GetBinContent(pv.NBINS+1));signal_lt0_30->SetBinContent(pv.NBINS+1,0.);
signal_lt0_m30->AddBinContent(pv.NBINS,signal_lt0_m30->GetBinContent(pv.NBINS+1));signal_lt0_m30->SetBinContent(pv.NBINS+1,0.);
signal_lt0_m50->AddBinContent(pv.NBINS,signal_lt0_m50->GetBinContent(pv.NBINS+1));signal_lt0_m50->SetBinContent(pv.NBINS+1,0.);
signal_lt0_m80->AddBinContent(pv.NBINS,signal_lt0_m80->GetBinContent(pv.NBINS+1));signal_lt0_m80->SetBinContent(pv.NBINS+1,0.);
/////////////////////////
// Normalize each sample:
std::cout<<"\nScale Histograms..."<<std::endl;
th1wwa->Scale(WWA_scale);
th1wwa2->Scale(WWA2_scale);
signal_lt0_m80->Scale(LT0_m8m5_scale);
signal_lt0_m50->Scale(LT0_m5m5_scale);
signal_lt0_m30->Scale(LT0_m3m5_scale);
signal_lt0_30->Scale(LT0_p3m5_scale);
signal_lt0_50->Scale(LT0_p5m5_scale);
signal_lt0_80->Scale(LT0_p8m5_scale);
///////////////////////////
// Combine certain samples:
th1wwa->Add(th1wwa2,1);
signal_lt0_80->Divide(th1wwa);
signal_lt0_50->Divide(th1wwa);
signal_lt0_30->Divide(th1wwa);
signal_lt0_m30->Divide(th1wwa);
signal_lt0_m50->Divide(th1wwa);
signal_lt0_m80->Divide(th1wwa);
///////////////////////////
//Fill Parabolic Histogram:
TH1* bin_1 = new TH1D("bin_1","bin_1",17, -8.5E-11, 8.5E-11);
TH1* bin_2 = new TH1D("bin_2","bin_2",17, -8.5E-11, 8.5E-11);
TH1* bin_3 = new TH1D("bin_3","bin_3",17, -8.5E-11, 8.5E-11);
TH1* bin_4 = new TH1D("bin_4","bin_4",17, -8.5E-11, 8.5E-11);
TH1* bin_5 = new TH1D("bin_5","bin_5",17, -8.5E-11, 8.5E-11);
TH1* bin_6 = new TH1D("bin_6","bin_6",17, -8.5E-11, 8.5E-11);
TH1* bin_7 = new TH1D("bin_7","bin_7",17, -8.5E-11, 8.5E-11);
TH1* bin_8 = new TH1D("bin_8","bin_8",17, -8.5E-11, 8.5E-11);
TH1* bin_9 = new TH1D("bin_9","bin_9",17, -8.5E-11, 8.5E-11);
TH1* bin_10 = new TH1D("bin_10","bin_10",17, -8.5E-11, 8.5E-11);
bin_1->SetBinContent(1,signal_lt0_m80->GetBinContent(1));
bin_1->SetBinContent(4,signal_lt0_m50->GetBinContent(1));
bin_1->SetBinContent(6,signal_lt0_m30->GetBinContent(1));
bin_1->SetBinContent(9,1);
bin_1->SetBinContent(12,signal_lt0_30->GetBinContent(1));
bin_1->SetBinContent(14,signal_lt0_50->GetBinContent(1));
bin_1->SetBinContent(17,signal_lt0_80->GetBinContent(1));
bin_2->SetBinContent(1,signal_lt0_m80->GetBinContent(2));
bin_2->SetBinContent(4,signal_lt0_m50->GetBinContent(2));
bin_2->SetBinContent(6,signal_lt0_m30->GetBinContent(2));
bin_2->SetBinContent(9,1);
bin_2->SetBinContent(12,signal_lt0_30->GetBinContent(2));
bin_2->SetBinContent(14,signal_lt0_50->GetBinContent(2));
bin_2->SetBinContent(17,signal_lt0_80->GetBinContent(2));
bin_3->SetBinContent(1,signal_lt0_m80->GetBinContent(3));
bin_3->SetBinContent(4,signal_lt0_m50->GetBinContent(3));
bin_3->SetBinContent(6,signal_lt0_m30->GetBinContent(3));
bin_3->SetBinContent(9,1);
bin_3->SetBinContent(12,signal_lt0_30->GetBinContent(3));
bin_3->SetBinContent(14,signal_lt0_50->GetBinContent(3));
bin_3->SetBinContent(17,signal_lt0_80->GetBinContent(3));
bin_4->SetBinContent(1,signal_lt0_m80->GetBinContent(4));
bin_4->SetBinContent(4,signal_lt0_m50->GetBinContent(4));
bin_4->SetBinContent(6,signal_lt0_m30->GetBinContent(4));
bin_4->SetBinContent(9,1);
bin_4->SetBinContent(12,signal_lt0_30->GetBinContent(4));
bin_4->SetBinContent(14,signal_lt0_50->GetBinContent(4));
bin_4->SetBinContent(17,signal_lt0_80->GetBinContent(4));
bin_5->SetBinContent(1,signal_lt0_m80->GetBinContent(5));
bin_5->SetBinContent(4,signal_lt0_m50->GetBinContent(5));
bin_5->SetBinContent(6,signal_lt0_m30->GetBinContent(5));
bin_5->SetBinContent(9,1);
bin_5->SetBinContent(12,signal_lt0_30->GetBinContent(5));
bin_5->SetBinContent(14,signal_lt0_50->GetBinContent(5));
bin_5->SetBinContent(17,signal_lt0_80->GetBinContent(5));
bin_6->SetBinContent(1,signal_lt0_m80->GetBinContent(6));
bin_6->SetBinContent(4,signal_lt0_m50->GetBinContent(6));
bin_6->SetBinContent(6,signal_lt0_m30->GetBinContent(6));
bin_6->SetBinContent(9,1);
bin_6->SetBinContent(12,signal_lt0_30->GetBinContent(6));
bin_6->SetBinContent(14,signal_lt0_50->GetBinContent(6));
bin_6->SetBinContent(17,signal_lt0_80->GetBinContent(6));
bin_7->SetBinContent(1,signal_lt0_m80->GetBinContent(7));
bin_7->SetBinContent(4,signal_lt0_m50->GetBinContent(7));
bin_7->SetBinContent(6,signal_lt0_m30->GetBinContent(7));
bin_7->SetBinContent(9,1);
bin_7->SetBinContent(12,signal_lt0_30->GetBinContent(7));
bin_7->SetBinContent(14,signal_lt0_50->GetBinContent(7));
bin_7->SetBinContent(17,signal_lt0_80->GetBinContent(7));
bin_8->SetBinContent(1,signal_lt0_m80->GetBinContent(8));
bin_8->SetBinContent(4,signal_lt0_m50->GetBinContent(8));
bin_8->SetBinContent(6,signal_lt0_m30->GetBinContent(8));
bin_8->SetBinContent(9,1);
bin_8->SetBinContent(12,signal_lt0_30->GetBinContent(8));
bin_8->SetBinContent(14,signal_lt0_50->GetBinContent(8));
bin_8->SetBinContent(17,signal_lt0_80->GetBinContent(8));
bin_9->SetBinContent(1,signal_lt0_m80->GetBinContent(9));
bin_9->SetBinContent(4,signal_lt0_m50->GetBinContent(9));
bin_9->SetBinContent(6,signal_lt0_m30->GetBinContent(9));
bin_9->SetBinContent(9,1);
bin_9->SetBinContent(12,signal_lt0_30->GetBinContent(9));
bin_9->SetBinContent(14,signal_lt0_50->GetBinContent(9));
bin_9->SetBinContent(17,signal_lt0_80->GetBinContent(9));
bin_10->SetBinContent(1,signal_lt0_m80->GetBinContent(10));
bin_10->SetBinContent(4,signal_lt0_m50->GetBinContent(10));
bin_10->SetBinContent(6,signal_lt0_m30->GetBinContent(10));
bin_10->SetBinContent(9,1);
bin_10->SetBinContent(12,signal_lt0_30->GetBinContent(10));
bin_10->SetBinContent(14,signal_lt0_50->GetBinContent(10));
bin_10->SetBinContent(17,signal_lt0_80->GetBinContent(10));
////////////////
// Fit function:
Char_t para_fit[] = "[0]+[1]*x+[2]*x^2";
Char_t fitopt[] = "QMR";
Double_t xmin = -8E-5;
Double_t xmax = 8E-5;
Double_t p[3][10];
TF1 *pfit = new TF1("pfit",para_fit,xmin,xmax);
// pfit->SetParLimits(1,0.0,1E15);
// pfit->FixParameter(0,0.0);
/////////////////
// Fit histogram:
bin_1->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][0] = pfit->GetParameter(0);
p[1][0] = pfit->GetParameter(1);
p[2][0] = pfit->GetParameter(2);
bin_2->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][1] = pfit->GetParameter(0);
p[1][1] = pfit->GetParameter(1);
p[2][1] = pfit->GetParameter(2);
bin_3->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][2] = pfit->GetParameter(0);
p[1][2] = pfit->GetParameter(1);
p[2][2] = pfit->GetParameter(2);
bin_4->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][3] = pfit->GetParameter(0);
p[1][3] = pfit->GetParameter(1);
p[2][3] = pfit->GetParameter(2);
bin_5->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][4] = pfit->GetParameter(0);
p[1][4] = pfit->GetParameter(1);
p[2][4] = pfit->GetParameter(2);
bin_6->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][5] = pfit->GetParameter(0);
p[1][5] = pfit->GetParameter(1);
p[2][5] = pfit->GetParameter(2);
bin_7->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][6] = pfit->GetParameter(0);
p[1][6] = pfit->GetParameter(1);
p[2][6] = pfit->GetParameter(2);
bin_8->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][7] = pfit->GetParameter(0);
p[1][7] = pfit->GetParameter(1);
p[2][7] = pfit->GetParameter(2);
bin_9->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][8] = pfit->GetParameter(0);
p[1][8] = pfit->GetParameter(1);
p[2][8] = pfit->GetParameter(2);
bin_10->Fit(pfit,fitopt,"sames",xmin,xmax);
p[0][9] = pfit->GetParameter(0);
p[1][9] = pfit->GetParameter(1);
p[2][9] = pfit->GetParameter(2);
/////////////////////////////
// Fill parameter histograms:
TH1* p0 = new TH1D("p0","Parameter 0",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* p1 = new TH1D("p1","Parameter 1",pv.NBINS,pv.MINRange,pv.MAXRange);
for(Int_t i=1;i<=pv.NBINS;i++){
p0->SetBinContent(i,p[0][i-1]);
p1->SetBinContent(i,p[1][i-1]);
}
/*
///////////////////
// Fit pT-function:
Char_t pt_fit[] = "[0]+[1]*x+[2]*x^2";
Char_t fitopt[] = "QMR";
Double_t xmin = 150;//45;
Double_t xmax = 1050;//275;
Double_t pt[2][3];
TF1 *ptfit = new TF1("ptfit",pt_fit,xmin,xmax);
p0->Fit(ptfit,fitopt,"sames",xmin,xmax);
pt[0][0] = ptfit->GetParameter(0);
pt[0][1] = ptfit->GetParameter(1);
pt[0][2] = ptfit->GetParameter(2);
p1->Fit(ptfit,fitopt,"sames",xmin,xmax);
pt[1][0] = ptfit->GetParameter(0);
pt[1][1] = ptfit->GetParameter(1);
pt[1][2] = ptfit->GetParameter(2);
*/
////////////////
// Closure test:
// ratio = 1 + (pt[0][0]+pt[0][1]*pt+pt[0][2]*pt^2)*KOW + (pt[1][0]+pt[1][1]*pt+[1][2]*pt^2)*KOW^2
TH1* test = new TH1D("test","Test aQGC Photon ET",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* test2 = new TH1D("test2","Test aQGC Photon ET",pv.NBINS,pv.MINRange,pv.MAXRange);
for(Int_t j=1;j<=pv.NBINS;j++){
Double_t value,bincent;
TAxis* xaxis = test->GetXaxis();
bincent = xaxis->GetBinCenter(j);
value = p[0][j-1]+p[1][j-1]*(8E-11)+p[2][j-1]*pow(8E-11,2);
test->SetBinContent(j,value);
test2->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-8E-11)+p[2][j-1]*pow(-8E-11,2));
}
// test->SetBinContent(8,1+p[0][7]*(8E-11)+p[1][7]*pow(8E-11,2));
// test2->SetBinContent(8,1+p[0][7]*(-8E-11)+p[1][7]*pow(-8E-11,2));
TH1D* test_r = (TH1D*)test->Clone("test_r");
TH1D* test2_r = (TH1D*)test2->Clone("test2_r");
test_r->Divide(signal_lt0_80);
test2_r->Divide(signal_lt0_m80);
test->Multiply(th1wwa);
test2->Multiply(th1wwa);
test->Add(th1wwa,-1);
test2->Add(th1wwa,-1);
/////////////////////
// Simulate new aQGC:
TH1* signal_lt0_18 = new TH1D("signal_lt0_18","signal_lt0_1p8",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_20 = new TH1D("signal_lt0_20","signal_lt0_2p0",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_22 = new TH1D("signal_lt0_22","signal_lt0_2p2",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_24 = new TH1D("signal_lt0_24","signal_lt0_2p4",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_26 = new TH1D("signal_lt0_26","signal_lt0_2p6",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_28 = new TH1D("signal_lt0_28","signal_lt0_2p8",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_32 = new TH1D("signal_lt0_32","signal_lt0_3p2",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_34 = new TH1D("signal_lt0_34","signal_lt0_3p4",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_36 = new TH1D("signal_lt0_36","signal_lt0_3p6",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_38 = new TH1D("signal_lt0_38","signal_lt0_3p8",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m18 = new TH1D("signal_lt0_m18","signal_lt0_-1p8",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m20 = new TH1D("signal_lt0_m20","signal_lt0_-2p0",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m22 = new TH1D("signal_lt0_m22","signal_lt0_-2p2",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m24 = new TH1D("signal_lt0_m24","signal_lt0_-2p4",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m26 = new TH1D("signal_lt0_m26","signal_lt0_-2p6",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m28 = new TH1D("signal_lt0_m28","signal_lt0_-2p8",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m32 = new TH1D("signal_lt0_m32","signal_lt0_-3p2",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m34 = new TH1D("signal_lt0_m34","signal_lt0_-3p4",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m36 = new TH1D("signal_lt0_m36","signal_lt0_-3p6",pv.NBINS,pv.MINRange,pv.MAXRange);
TH1* signal_lt0_m38 = new TH1D("signal_lt0_m38","signal_lt0_-3p8",pv.NBINS,pv.MINRange,pv.MAXRange);
signal_lt0_18->Sumw2();
signal_lt0_20->Sumw2();
signal_lt0_22->Sumw2();
signal_lt0_24->Sumw2();
signal_lt0_26->Sumw2();
signal_lt0_28->Sumw2();
signal_lt0_32->Sumw2();
signal_lt0_34->Sumw2();
signal_lt0_36->Sumw2();
signal_lt0_38->Sumw2();
signal_lt0_m18->Sumw2();
signal_lt0_m20->Sumw2();
signal_lt0_m22->Sumw2();
signal_lt0_m24->Sumw2();
signal_lt0_m26->Sumw2();
signal_lt0_m28->Sumw2();
signal_lt0_m32->Sumw2();
signal_lt0_m34->Sumw2();
signal_lt0_m36->Sumw2();
signal_lt0_m38->Sumw2();
for(Int_t j=1;j<=pv.NBINS;j++){
Double_t bincent;
TAxis* xaxis = test->GetXaxis();
bincent = xaxis->GetBinCenter(j);
signal_lt0_m50->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-5.E-11)+p[2][j-1]*pow(-5.E-11,2));
signal_lt0_m30->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.E-11)+p[2][j-1]*pow(-3.E-11,2));
signal_lt0_m80->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-8.E-11)+p[2][j-1]*pow(-8.E-11,2));
signal_lt0_m28->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.8E-11)+p[2][j-1]*pow(-2.8E-11,2));
signal_lt0_m26->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.6E-11)+p[2][j-1]*pow(-2.6E-11,2));
signal_lt0_m24->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.4E-11)+p[2][j-1]*pow(-2.4E-11,2));
signal_lt0_m22->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.2E-11)+p[2][j-1]*pow(-2.2E-11,2));
signal_lt0_m20->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-2.E-11)+p[2][j-1]*pow(-2.E-11,2));
signal_lt0_m18->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-1.8E-11)+p[2][j-1]*pow(-1.8E-11,2));
signal_lt0_m32->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.2E-11)+p[2][j-1]*pow(-3.2E-11,2));
signal_lt0_m34->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.4E-11)+p[2][j-1]*pow(-3.4E-11,2));
signal_lt0_m36->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.6E-11)+p[2][j-1]*pow(-3.6E-11,2));
signal_lt0_m38->SetBinContent(j,p[0][j-1]+p[1][j-1]*(-3.8E-11)+p[2][j-1]*pow(-3.8E-11,2));
signal_lt0_50->SetBinContent(j,p[0][j-1]+p[1][j-1]*(5.E-11)+p[2][j-1]*pow(5.E-11,2));
signal_lt0_30->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.E-11)+p[2][j-1]*pow(3.E-11,2));
signal_lt0_80->SetBinContent(j,p[0][j-1]+p[1][j-1]*(8.E-11)+p[2][j-1]*pow(8.E-11,2));
signal_lt0_28->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.8E-11)+p[2][j-1]*pow(2.8E-11,2));
signal_lt0_26->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.6E-11)+p[2][j-1]*pow(2.6E-11,2));
signal_lt0_24->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.4E-11)+p[2][j-1]*pow(2.4E-11,2));
signal_lt0_22->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.2E-11)+p[2][j-1]*pow(2.2E-11,2));
signal_lt0_20->SetBinContent(j,p[0][j-1]+p[1][j-1]*(2.E-11)+p[2][j-1]*pow(2.E-11,2));
signal_lt0_18->SetBinContent(j,p[0][j-1]+p[1][j-1]*(1.8E-11)+p[2][j-1]*pow(1.8E-11,2));
signal_lt0_32->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.2E-11)+p[2][j-1]*pow(3.2E-11,2));
signal_lt0_34->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.4E-11)+p[2][j-1]*pow(3.4E-11,2));
signal_lt0_36->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.6E-11)+p[2][j-1]*pow(3.6E-11,2));
signal_lt0_38->SetBinContent(j,p[0][j-1]+p[1][j-1]*(3.8E-11)+p[2][j-1]*pow(3.8E-11,2));
}
/*
signal_lt0_m50->SetBinContent(8,1+p[0][7]*(-5.E-11)+p[1][7]*pow(-5.E-11,2));
signal_lt0_m30->SetBinContent(8,1+p[0][7]*(-3.E-11)+p[1][7]*pow(-3.E-11,2));
signal_lt0_m80->SetBinContent(8,1+p[0][7]*(-8.E-11)+p[1][7]*pow(-8.E-11,2));
signal_lt0_m28->SetBinContent(8,1+p[0][7]*(-2.8E-11)+p[1][7]*pow(-2.8E-11,2));
signal_lt0_m26->SetBinContent(8,1+p[0][7]*(-2.6E-11)+p[1][7]*pow(-2.6E-11,2));
signal_lt0_m24->SetBinContent(8,1+p[0][7]*(-2.4E-11)+p[1][7]*pow(-2.4E-11,2));
signal_lt0_m22->SetBinContent(8,1+p[0][7]*(-2.2E-11)+p[1][7]*pow(-2.2E-11,2));
signal_lt0_m20->SetBinContent(8,1+p[0][7]*(-2.E-11)+p[1][7]*pow(-2.E-11,2));
signal_lt0_m18->SetBinContent(8,1+p[0][7]*(-1.8E-11)+p[1][7]*pow(-1.8E-11,2));
signal_lt0_m32->SetBinContent(8,1+p[0][7]*(-3.2E-11)+p[1][7]*pow(-3.2E-11,2));
signal_lt0_m34->SetBinContent(8,1+p[0][7]*(-3.4E-11)+p[1][7]*pow(-3.4E-11,2));
signal_lt0_m36->SetBinContent(8,1+p[0][7]*(-3.6E-11)+p[1][7]*pow(-3.6E-11,2));
signal_lt0_m38->SetBinContent(8,1+p[0][7]*(-3.8E-11)+p[1][7]*pow(-3.8E-11,2));
signal_lt0_50->SetBinContent(8,1+p[0][7]*(5.E-11)+p[1][7]*pow(5.E-11,2));
signal_lt0_30->SetBinContent(8,1+p[0][7]*(3.E-11)+p[1][7]*pow(3.E-11,2));
signal_lt0_80->SetBinContent(8,1+p[0][7]*(8.E-11)+p[1][7]*pow(8.E-11,2));
signal_lt0_28->SetBinContent(8,1+p[0][7]*(2.8E-11)+p[1][7]*pow(2.8E-11,2));
signal_lt0_26->SetBinContent(8,1+p[0][7]*(2.6E-11)+p[1][7]*pow(2.6E-11,2));
signal_lt0_24->SetBinContent(8,1+p[0][7]*(2.4E-11)+p[1][7]*pow(2.4E-11,2));
signal_lt0_22->SetBinContent(8,1+p[0][7]*(2.2E-11)+p[1][7]*pow(2.2E-11,2));
signal_lt0_20->SetBinContent(8,1+p[0][7]*(2.E-11)+p[1][7]*pow(2.E-11,2));
signal_lt0_18->SetBinContent(8,1+p[0][7]*(1.8E-11)+p[1][7]*pow(1.8E-11,2));
signal_lt0_32->SetBinContent(8,1+p[0][7]*(3.2E-11)+p[1][7]*pow(3.2E-11,2));
signal_lt0_34->SetBinContent(8,1+p[0][7]*(3.4E-11)+p[1][7]*pow(3.4E-11,2));
signal_lt0_36->SetBinContent(8,1+p[0][7]*(3.6E-11)+p[1][7]*pow(3.6E-11,2));
signal_lt0_38->SetBinContent(8,1+p[0][7]*(3.8E-11)+p[1][7]*pow(3.8E-11,2));
*/
signal_lt0_m50->Multiply(th1wwa);
signal_lt0_m30->Multiply(th1wwa);
signal_lt0_m80->Multiply(th1wwa);
signal_lt0_m28->Multiply(th1wwa);
signal_lt0_m26->Multiply(th1wwa);
signal_lt0_m24->Multiply(th1wwa);
signal_lt0_m22->Multiply(th1wwa);
signal_lt0_m20->Multiply(th1wwa);
signal_lt0_m18->Multiply(th1wwa);
signal_lt0_m32->Multiply(th1wwa);
signal_lt0_m34->Multiply(th1wwa);
signal_lt0_m36->Multiply(th1wwa);
signal_lt0_m38->Multiply(th1wwa);
signal_lt0_50->Multiply(th1wwa);
signal_lt0_30->Multiply(th1wwa);
signal_lt0_80->Multiply(th1wwa);
signal_lt0_28->Multiply(th1wwa);
signal_lt0_26->Multiply(th1wwa);
signal_lt0_24->Multiply(th1wwa);
signal_lt0_22->Multiply(th1wwa);
signal_lt0_20->Multiply(th1wwa);
signal_lt0_18->Multiply(th1wwa);
signal_lt0_32->Multiply(th1wwa);
signal_lt0_34->Multiply(th1wwa);
signal_lt0_36->Multiply(th1wwa);
signal_lt0_38->Multiply(th1wwa);
signal_lt0_m50->Add(th1wwa,-1);
signal_lt0_m30->Add(th1wwa,-1);
signal_lt0_m80->Add(th1wwa,-1);
signal_lt0_m28->Add(th1wwa,-1);
signal_lt0_m26->Add(th1wwa,-1);
signal_lt0_m24->Add(th1wwa,-1);
signal_lt0_m22->Add(th1wwa,-1);
signal_lt0_m20->Add(th1wwa,-1);
signal_lt0_m18->Add(th1wwa,-1);
signal_lt0_m32->Add(th1wwa,-1);
signal_lt0_m34->Add(th1wwa,-1);
signal_lt0_m36->Add(th1wwa,-1);
signal_lt0_m38->Add(th1wwa,-1);
signal_lt0_50->Add(th1wwa,-1);
signal_lt0_30->Add(th1wwa,-1);
signal_lt0_80->Add(th1wwa,-1);
signal_lt0_28->Add(th1wwa,-1);
signal_lt0_26->Add(th1wwa,-1);
signal_lt0_24->Add(th1wwa,-1);
signal_lt0_22->Add(th1wwa,-1);
signal_lt0_20->Add(th1wwa,-1);
signal_lt0_18->Add(th1wwa,-1);
signal_lt0_32->Add(th1wwa,-1);
signal_lt0_34->Add(th1wwa,-1);
signal_lt0_36->Add(th1wwa,-1);
signal_lt0_38->Add(th1wwa,-1);
signal_lt0_m50->Scale(1.185/2.1);
signal_lt0_m30->Scale(1.185/2.1);
signal_lt0_m80->Scale(1.185/2.1);
signal_lt0_m28->Scale(1.185/2.1);
signal_lt0_m26->Scale(1.185/2.1);
signal_lt0_m24->Scale(1.185/2.1);
signal_lt0_m22->Scale(1.185/2.1);
signal_lt0_m20->Scale(1.185/2.1);
signal_lt0_m18->Scale(1.185/2.1);
signal_lt0_m32->Scale(1.185/2.1);
signal_lt0_m34->Scale(1.185/2.1);
signal_lt0_m36->Scale(1.185/2.1);
signal_lt0_m38->Scale(1.185/2.1);
signal_lt0_50->Scale(1.185/2.1);
signal_lt0_30->Scale(1.185/2.1);
signal_lt0_80->Scale(1.185/2.1);
signal_lt0_28->Scale(1.185/2.1);
signal_lt0_26->Scale(1.185/2.1);
signal_lt0_24->Scale(1.185/2.1);
signal_lt0_22->Scale(1.185/2.1);
signal_lt0_20->Scale(1.185/2.1);
signal_lt0_18->Scale(1.185/2.1);
signal_lt0_32->Scale(1.185/2.1);
signal_lt0_34->Scale(1.185/2.1);
signal_lt0_36->Scale(1.185/2.1);
signal_lt0_38->Scale(1.185/2.1);
/*
signal_lt0_18->Sumw2();
signal_lt0_20->Sumw2();
signal_lt0_22->Sumw2();
signal_lt0_24->Sumw2();
signal_lt0_26->Sumw2();
signal_lt0_28->Sumw2();
signal_lt0_30->Sumw2();
signal_lt0_32->Sumw2();
signal_lt0_34->Sumw2();
signal_lt0_36->Sumw2();
signal_lt0_38->Sumw2();
signal_lt0_50->Sumw2();
signal_lt0_80->Sumw2();
signal_lt0_m18->Sumw2();
signal_lt0_m20->Sumw2();
signal_lt0_m22->Sumw2();
signal_lt0_m24->Sumw2();
signal_lt0_m26->Sumw2();
signal_lt0_m28->Sumw2();
signal_lt0_m30->Sumw2();
signal_lt0_m32->Sumw2();
signal_lt0_m34->Sumw2();
signal_lt0_m36->Sumw2();
signal_lt0_m38->Sumw2();
signal_lt0_m50->Sumw2();
signal_lt0_m80->Sumw2();
*/
/* // Adding 35% Signal K-factor Systematic uncertainty
for(int hi=1;hi<=pv.NBINS;hi++){
fperr = pow(signal_lt0_m18->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m18->GetBinContent(hi),2);
signal_lt0_m18->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m20->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m20->GetBinContent(hi),2);
signal_lt0_m20->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m22->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m22->GetBinContent(hi),2);
signal_lt0_m22->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m24->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m24->GetBinContent(hi),2);
signal_lt0_m24->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m26->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m26->GetBinContent(hi),2);
signal_lt0_m26->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m28->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m28->GetBinContent(hi),2);
signal_lt0_m28->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m30->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m30->GetBinContent(hi),2);
signal_lt0_m30->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m32->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m32->GetBinContent(hi),2);
signal_lt0_m32->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m34->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m34->GetBinContent(hi),2);
signal_lt0_m34->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m36->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m36->GetBinContent(hi),2);
signal_lt0_m36->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m38->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m38->GetBinContent(hi),2);
signal_lt0_m38->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m50->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m50->GetBinContent(hi),2);
signal_lt0_m50->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_m80->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_m80->GetBinContent(hi),2);
signal_lt0_m80->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_18->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_18->GetBinContent(hi),2);
signal_lt0_18->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_20->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_20->GetBinContent(hi),2);
signal_lt0_20->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_22->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_22->GetBinContent(hi),2);
signal_lt0_22->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_24->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_24->GetBinContent(hi),2);
signal_lt0_24->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_26->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_26->GetBinContent(hi),2);
signal_lt0_26->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_28->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_28->GetBinContent(hi),2);
signal_lt0_28->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_30->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_30->GetBinContent(hi),2);
signal_lt0_30->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_32->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_32->GetBinContent(hi),2);
signal_lt0_32->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_34->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_34->GetBinContent(hi),2);
signal_lt0_34->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_36->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_36->GetBinContent(hi),2);
signal_lt0_36->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_38->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_38->GetBinContent(hi),2);
signal_lt0_38->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_50->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_50->GetBinContent(hi),2);
signal_lt0_50->SetBinError(hi,sqrt(fperr));
fperr = pow(signal_lt0_80->GetBinError(hi),2);
fperr += pow(0.28,2)*pow(signal_lt0_80->GetBinContent(hi),2);
signal_lt0_80->SetBinError(hi,sqrt(fperr));
}
*/
////////////////////////
// Set histogram labels:
const double BINWIDTH = ((pv.MAXRange-pv.MINRange)/pv.NBINS);
char tmpc[100]; sprintf(tmpc,"Events / %.1f GeV",BINWIDTH);
if (pv.slog==1) sprintf(tmpc,"Events / %.1f",BINWIDTH);
if (pv.slog==2) sprintf(tmpc,"Events / %.2f",BINWIDTH);
if (pv.slog==3) sprintf(tmpc,"Events / %.0f GeV",BINWIDTH);
if (pv.slog==6) sprintf(tmpc,"Events / %.2f rad",BINWIDTH);
signal_lt0_80->SetYTitle(tmpc);
signal_lt0_80->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_80->GetYaxis()->CenterTitle(true);
signal_lt0_50->SetYTitle(tmpc);
signal_lt0_50->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_50->GetYaxis()->CenterTitle(true);
signal_lt0_30->SetYTitle(tmpc);
signal_lt0_30->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_30->GetYaxis()->CenterTitle(true);
signal_lt0_m30->SetYTitle(tmpc);
signal_lt0_m30->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_m30->GetYaxis()->CenterTitle(true);
signal_lt0_m50->SetYTitle(tmpc);
signal_lt0_m50->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_m50->GetYaxis()->CenterTitle(true);
signal_lt0_m80->SetYTitle(tmpc);
signal_lt0_m80->GetXaxis()->SetTitle(pv.xlabel);
signal_lt0_m80->GetYaxis()->CenterTitle(true);
//////////////////////////////////////////////////////////
// Save Observed Data, Background (+ SM WWA), Background +
// Uncertainty, Background - Uncertainty, Anomalous Signal
// histograms to output ROOT file:
std::cout<<"Save Histograms..."<<std::endl;
f.cd();
signal_lt0_80->Write();
signal_lt0_50->Write();
signal_lt0_30->Write();
signal_lt0_m30->Write();
signal_lt0_m50->Write();
signal_lt0_m80->Write();
bin_1->Write();
bin_2->Write();
bin_3->Write();
bin_4->Write();
bin_5->Write();
bin_6->Write();
bin_7->Write();
bin_8->Write();
bin_9->Write();
bin_10->Write();
p0->Write();
p1->Write();
test->Write();
test2->Write();
test_r->Write();
test2_r->Write();
signal_lt0_m28->Write();
signal_lt0_m26->Write();
signal_lt0_m24->Write();
signal_lt0_m22->Write();
signal_lt0_m20->Write();
signal_lt0_m18->Write();
signal_lt0_m32->Write();
signal_lt0_m34->Write();
signal_lt0_m36->Write();
signal_lt0_m38->Write();
signal_lt0_28->Write();
signal_lt0_26->Write();
signal_lt0_24->Write();
signal_lt0_22->Write();
signal_lt0_20->Write();
signal_lt0_18->Write();
signal_lt0_32->Write();
signal_lt0_34->Write();
signal_lt0_36->Write();
signal_lt0_38->Write();
//For conveners
// th1wwa->Write();
//
}// End Main function
