void plot(RooRealVar *mass, RooAbsPdf *pdf, RooDataSet *data, string name, int bins, int mhLow, int mhHigh){
RooPlot *plot = mass->frame();
mass->setRange("unblindReg_1",85,95);
mass->setRange("unblindReg_2",110,120);
if (BLIND) {
data->plotOn(plot,Binning(bins),CutRange("unblindReg_1"));
data->plotOn(plot,Binning(bins),CutRange("unblindReg_2"));
data->plotOn(plot,Binning(bins),Invisible());
}
else data->plotOn(plot,Binning(bins));
TCanvas *canv = new TCanvas();
pdf->plotOn(plot);//,RooFit::NormRange("fitdata_1,fitdata_2"));
//pdf->paramOn(plot,RooFit::Layout(0.35,0.89,0.89),RooFit::Format("NEA",AutoPrecision(1)));
//plot->getAttText()->SetTextSize(0.01);
plot->SetMaximum(plot->GetMaximum()*2);
if (BLIND) plot->SetMinimum(0.0001);
plot->SetTitle("");
plot->SetYTitle(Form("Events / %.2fGeV",float(mhHigh-mhLow)/float(bins)));
//plot->GetYaxis()->SetLabelSize(0.05);
plot->SetTitleSize(0.045, "Y");
plot->SetTitleOffset(1.,"Y");
//plot->GetXaxis()->SetLabelSize(0.15);
//plot->GetYaxis()->SetLabelSize(0.15);
plot->SetXTitle("m_{#gamma#gamma}(GeV)");
plot->SetTitleSize(0.15, "X");
plot->Draw();
TLatex *lat = new TLatex();
lat->SetNDC();
lat->SetTextFont(42);
lat->DrawLatex(0.68,0.93,"19.7fb^{-1}(8TeV)");
lat->DrawLatex(0.12,0.85,"CMS Preliminary");
string nameTemp = name;
int catNum = nameTemp.find("cat");
string catNameOLD = nameTemp.replace(0, catNum, "");
string catName = catNameOLD.replace(catNameOLD.length()-4, 4, "");
lat->DrawLatex(0.1,0.92, Form("%s", catName.c_str()));
TLegend *leg = new TLegend(0.12,0.7,0.32,0.8);
leg->SetFillColor(0);
leg->SetLineColor(1);
leg->AddEntry(data,"Data","lep");
leg->Draw("same");
canv->SaveAs(Form("%s.png",name.c_str()));
canv->SaveAs(Form("%s.pdf",name.c_str()));
delete canv;
delete lat;
}
void MakeSpinPlots::DrawSpinBackground(TString tag, TString mcName,bool signal){
bool drawSM = (smName!="" && smName!=mcName);
TCanvas cv;
double thisN = ws->data(mcName+"_Combined")->reduce(TString("evtcat==evtcat::")+tag)->sumEntries();
float norm = thisN; //607*lumi/12.*thisN/(totEB+totEE);
cout << norm <<endl;
if(signal) norm = ws->data(Form("Data_%s_%s_sigWeight",tag.Data(),mcName.Data()))->sumEntries();
RooPlot *frame = ws->var("cosT")->frame(0,1,5);
RooDataSet* bkgWeight = (RooDataSet*)ws->data(Form("Data_%s_%s_bkgWeight",tag.Data(),mcName.Data()));
RooDataSet* tmp = (RooDataSet*)ws->data("Data_Combined")->reduce(TString("((mass>115 && mass<120) || (mass>130 && mass<135)) && evtcat==evtcat::")+tag);
tmp->plotOn(frame,RooFit::Rescale(norm/tmp->sumEntries()));
cout << "b" <<endl;
ws->pdf(Form("%s_FIT_%s_cosTpdf",mcName.Data(),tag.Data()))->plotOn(frame,RooFit::LineColor(kGreen),RooFit::Normalization(norm/tmp->sumEntries()));
if(drawSM) ws->pdf(Form("%s_FIT_%s_cosTpdf",smName.Data(),tag.Data()))->plotOn(frame,RooFit::LineColor(kRed),RooFit::Normalization(norm/tmp->sumEntries()));
cout << "c " <<bkgWeight <<endl;
bkgWeight->plotOn(frame,RooFit::Rescale(norm/bkgWeight->sumEntries()),RooFit::MarkerColor(kBlue) );
if(signal){
cout << "d" <<endl;
ws->data(Form("Data_%s_%s_sigWeight",tag.Data(),mcName.Data()))->plotOn(frame,RooFit::MarkerStyle(4));
}
cout << "d" <<endl;
frame->SetMaximum(frame->GetMaximum()*(signal?0.8:0.4)*norm/tmp->sumEntries());
frame->SetMinimum(-1*frame->GetMaximum());
TLegend l(0.6,0.2,0.95,0.45);
l.SetFillColor(0);
l.SetBorderSize(0);
l.SetHeader(tag);
l.AddEntry(frame->getObject(0),"Data m#in [115,120]#cup[130,135]","p");
l.AddEntry(frame->getObject(1),mcName,"l");
if(drawSM) l.AddEntry(frame->getObject(2),"SM Higgs","l");
l.AddEntry(frame->getObject(2+drawSM),"background weighted Data","p");
if(signal) l.AddEntry(frame->getObject(3+drawSM),"signal weighted Data","p");
cout << "e" <<endl;
frame->Draw();
l.Draw("SAME");
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_%s%s_%s_%s.png",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data(),tag.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/C/CosThetaDist_%s%s_%s_%s.C",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data(),tag.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_%s%s_%s_%s.pdf",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data(),tag.Data()) );
}
void MakeSpinPlots::DrawSpinSubTotBackground(TString mcName,bool signal){
bool drawSM = (smName!="" && smName!=mcName);
TCanvas cv;
double thisN = ws->data(mcName+"_Combined")->sumEntries();
float norm = thisN;
if(signal) norm = ws->var(Form("Data_%s_FULLFIT_Nsig",mcName.Data()))->getVal();
RooPlot *frame = ws->var("cosT")->frame(0,1,10);
RooDataSet* tmp = (RooDataSet*)ws->data(Form("Data_Combined"))->reduce("(mass>115 && mass<120) || (mass>130 && mass<135)");
tmp->plotOn(frame,RooFit::Rescale(norm/tmp->sumEntries()));
ws->pdf(Form("%s_FIT_cosTpdf",mcName.Data()))->plotOn(frame,RooFit::LineColor(kGreen),RooFit::Normalization(norm/tmp->sumEntries()));
if(drawSM) ws->pdf(Form("%s_FIT_cosTpdf",smName.Data()))->plotOn(frame,RooFit::LineColor(kRed),RooFit::Normalization(norm/tmp->sumEntries()));
if(signal){
RooDataHist *h = (RooDataHist*)ws->data( Form("Data_%s_Combined_bkgSub_cosT",mcName.Data()) );
h->plotOn(frame,RooFit::MarkerStyle(4));
std::cout << "Nsig: " << h->sumEntries() << std::endl;
}
frame->SetMaximum(frame->GetMaximum()*(signal?2.:1.2)*norm/tmp->sumEntries());
frame->SetMinimum(-1*frame->GetMaximum());
TLegend l(0.6,0.2,0.95,0.45);
l.SetFillColor(0);
l.SetBorderSize(0);
l.SetHeader("Combined");
l.AddEntry(frame->getObject(0),"Data m#in [115,120]#cup[130,135]","p");
l.AddEntry(frame->getObject(1),mcName,"l");
if(drawSM) l.AddEntry(frame->getObject(2),"SM Higgs","l");
if(signal) l.AddEntry(frame->getObject(2+drawSM),"bkg-subtracted Data","p");
frame->Draw();
l.Draw("SAME");
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_SimpleSub_%s%s_%s.png",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/C/CosThetaDist_SimpleSub_%s%s_%s.C",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_SimpleSub_%s%s_%s.pdf",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
}
void Raa3S_Workspace(const char* name_pbpb="chad_ws_fits/centFits/ws_PbPbData_262548_263757_0cent10_0.0pt50.0_0.0y2.4.root", const char* name_pp="chad_ws_fits/centFits/ws_PPData_262157_262328_-1cent1_0.0pt50.0_0.0y2.4.root", const char* name_out="fitresult_combo.root"){
//TFile File(filename);
//RooWorkspace * ws = test_combine(name_pbpb, name_pp);
TFile *f = new TFile("fitresult_combo_333.root") ;
RooWorkspace * ws1 = (RooWorkspace*) f->Get("wcombo");
//File.GetObject("wcombo", ws);
ws1->Print();
RooAbsData * data = ws1->data("data"); //dataOS, dataSS
// RooDataSet * US_data = (RooDataSet*) data->reduce( "QQsign == QQsign::PlusMinus");
// US_data->SetName("US_data");
// ws->import(* US_data);
// RooDataSet * hi_data = (RooDataSet*) US_data->reduce("dataCat == dataCat::hi");
// hi_data->SetName("hi_data");
// ws->import(* hi_data);
// hi_data->Print();
RooRealVar* raa3 = new RooRealVar("raa3","R_{AA}(#Upsilon (3S))",0.5,-1,1);
RooRealVar* leftEdge = new RooRealVar("leftEdge","leftEdge",0);
RooRealVar* rightEdge = new RooRealVar("rightEdge","rightEdge",1);
RooGenericPdf step("step", "step", "(@0 >= @1) && (@0 < @2)", RooArgList(*raa3, *leftEdge, *rightEdge));
ws1->import(step);
ws1->factory( "Uniform::flat(raa3)" );
//pp Luminosities, Taa and efficiency ratios Systematics
ws1->factory( "Taa_hi[5.662e-9]" );
ws1->factory( "Taa_kappa[1.062]" ); // was 1.057
ws1->factory( "expr::alpha_Taa('pow(Taa_kappa,beta_Taa)',Taa_kappa,beta_Taa[0,-5,5])" );
ws1->factory( "prod::Taa_nom(Taa_hi,alpha_Taa)" );
ws1->factory( "Gaussian::constr_Taa(beta_Taa,glob_Taa[0,-5,5],1)" );
ws1->factory( "lumipp_hi[5.4]" );
ws1->factory( "lumipp_kappa[1.037]" ); // was 1.06
ws1->factory( "expr::alpha_lumipp('pow(lumipp_kappa,beta_lumipp)',lumipp_kappa,beta_lumipp[0,-5,5])" );
ws1->factory( "prod::lumipp_nom(lumipp_hi,alpha_lumipp)" );
ws1->factory( "Gaussian::constr_lumipp(beta_lumipp,glob_lumipp[0,-5,5],1)" );
// ws->factory( "effRat1[1]" );
// ws->factory( "effRat2[1]" );
ws1->factory( "effRat3_hi[0.95]" );
ws1->factory( "effRat_kappa[1.054]" );
ws1->factory( "expr::alpha_effRat('pow(effRat_kappa,beta_effRat)',effRat_kappa,beta_effRat[0,-5,5])" );
// ws->factory( "prod::effRat1_nom(effRat1_hi,alpha_effRat)" );
ws1->factory( "Gaussian::constr_effRat(beta_effRat,glob_effRat[0,-5,5],1)" );
// ws->factory( "prod::effRat2_nom(effRat2_hi,alpha_effRat)" );
ws1->factory( "prod::effRat3_nom(effRat3_hi,alpha_effRat)" );
//
ws1->factory("Nmb_hi[1.161e9]");
ws1->factory("prod::denominator(Taa_nom,Nmb_hi)");
ws1->factory( "expr::lumiOverTaaNmbmodified('lumipp_nom/denominator',lumipp_nom,denominator)");
RooAbsReal *lumiOverTaaNmbmodified = ws1->function("lumiOverTaaNmbmodified"); //RooFormulaVar *lumiOverTaaNmbmodified = ws->function("lumiOverTaaNmbmodified");
//
// RooRealVar *raa1 = ws->var("raa1");
// RooRealVar* nsig1_pp = ws->var("nsig1_pp");
// RooRealVar* effRat1 = ws->function("effRat1_nom");
// RooRealVar *raa2 = ws->var("raa2");
// RooRealVar* nsig2_pp = ws->var("nsig2_pp");
// RooRealVar* effRat2 = ws->function("effRat2_nom");
RooRealVar* nsig3_pp = ws1->var("R_{#frac{3S}{1S}}_pp"); //RooRealVar* nsig3_pp = ws->var("N_{#Upsilon(3S)}_pp");
cout << nsig3_pp << endl;
RooAbsReal* effRat3 = ws1->function("effRat3_nom"); //RooRealVar* effRat3 = ws->function("effRat3_nom");
//
// RooFormulaVar nsig1_hi_modified("nsig1_hi_modified", "@0*@1*@3/@2", RooArgList(*raa1, *nsig1_pp, *lumiOverTaaNmbmodified, *effRat1));
// ws->import(nsig1_hi_modified);
// RooFormulaVar nsig2_hi_modified("nsig2_hi_modified", "@0*@1*@3/@2", RooArgList(*raa2, *nsig2_pp, *lumiOverTaaNmbmodified, *effRat2));
// ws->import(nsig2_hi_modified);
RooFormulaVar nsig3_hi_modified("nsig3_hi_modified", "@0*@1*@3/@2", RooArgList(*raa3, *nsig3_pp, *lumiOverTaaNmbmodified, *effRat3));
ws1->import(nsig3_hi_modified);
// // background yield with systematics
ws1->factory( "nbkg_hi_kappa[1.10]" );
ws1->factory( "expr::alpha_nbkg_hi('pow(nbkg_hi_kappa,beta_nbkg_hi)',nbkg_hi_kappa,beta_nbkg_hi[0,-5,5])" );
ws1->factory( "SUM::nbkg_hi_nom(alpha_nbkg_hi*bkgPdf_hi)" );
ws1->factory( "Gaussian::constr_nbkg_hi(beta_nbkg_hi,glob_nbkg_hi[0,-5,5],1)" );
RooAbsPdf* sig1S_hi = ws1->pdf("sig1S_hi"); //RooAbsPdf* sig1S_hi = ws->pdf("cbcb_hi");
RooAbsPdf* sig2S_hi = ws1->pdf("sig2S_hi");
RooAbsPdf* sig3S_hi = ws1->pdf("sig3S_hi");
RooAbsPdf* LSBackground_hi = ws1->pdf("nbkg_hi_nom");
RooRealVar* nsig1_hi = ws1->var("N_{#Upsilon(1S)}_hi");
RooRealVar* nsig2_hi = ws1->var("R_{#frac{2S}{1S}}_hi");
RooAbsReal* nsig3_hi = ws1->function("nsig3_hi_modified"); //RooFormulaVar* nsig3_hi = ws->function("nsig3_hi_modified");
cout << nsig1_hi << " " << nsig2_hi << " " << nsig3_pp << endl;
RooRealVar* norm_nbkg_hi = ws1->var("n_{Bkgd}_hi");
RooArgList pdfs_hi( *sig1S_hi,*sig2S_hi,*sig3S_hi, *LSBackground_hi);
RooArgList norms_hi(*nsig1_hi,*nsig2_hi,*nsig3_hi, *norm_nbkg_hi);
////////////////////////////////////////////////////////////////////////////////
ws1->factory( "nbkg_pp_kappa[1.03]" );
ws1->factory( "expr::alpha_nbkg_pp('pow(nbkg_pp_kappa,beta_nbkg_pp)',nbkg_pp_kappa,beta_nbkg_pp[0,-5,5])" );
ws1->factory( "SUM::nbkg_pp_nom(alpha_nbkg_pp*bkgPdf_pp)" );
ws1->factory( "Gaussian::constr_nbkg_pp(beta_nbkg_pp,glob_nbkg_pp[0,-5,5],1)" );
RooAbsPdf* sig1S_pp = ws1->pdf("sig1S_pp"); //RooAbsPdf* sig1S_pp = ws1->pdf("cbcb_pp");
RooAbsPdf* sig2S_pp = ws1->pdf("sig2S_pp");
RooAbsPdf* sig3S_pp = ws1->pdf("sig3S_pp");
RooAbsPdf* LSBackground_pp = ws1->pdf("nbkg_pp_nom");
RooRealVar* nsig1_pp = ws1->var("N_{#Upsilon(1S)}_pp");
RooRealVar* nsig2_pp = ws1->var("R_{#frac{2S}{1S}}_pp"); //RooRealVar* nsig2_pp = ws1->var("N_{#Upsilon(2S)}_pp");
// RooRealVar* nsig3_pp = ws1->var("N_{#Upsilon(3S)}_pp");
RooRealVar* norm_nbkg_pp = ws1->var("n_{Bkgd}_pp");
RooArgList pdfs_pp( *sig1S_pp,*sig2S_pp,*sig3S_pp, *LSBackground_pp);
RooArgList norms_pp( *nsig1_pp,*nsig2_pp,*nsig3_pp,*norm_nbkg_pp);
RooAddPdf model_num("model_num", "model_num", pdfs_hi,norms_hi);
ws1->import(model_num);
ws1->factory("PROD::model_hi(model_num, constr_nbkg_hi,constr_lumipp,constr_Taa,constr_effRat)");
RooAddPdf model_den("model_den", "model_den", pdfs_pp,norms_pp);
ws1->import(model_den);
ws1->factory("PROD::model_pp(model_den, constr_nbkg_pp)");
ws1->factory("SIMUL::joint(dataCat,hi=model_hi,pp=model_pp)");
/////////////////////////////////////////////////////////////////////
RooRealVar * pObs = ws1->var("invariantMass"); // get the pointer to the observable
RooArgSet obs("observables");
obs.add(*pObs);
obs.add( *ws1->cat("dataCat"));
// /////////////////////////////////////////////////////////////////////
ws1->var("glob_lumipp")->setConstant(true);
ws1->var("glob_Taa")->setConstant(true);
ws1->var("glob_effRat")->setConstant(true);
ws1->var("glob_nbkg_pp")->setConstant(true);
ws1->var("glob_nbkg_hi")->setConstant(true);
RooArgSet globalObs("global_obs");
globalObs.add( *ws1->var("glob_lumipp") );
globalObs.add( *ws1->var("glob_Taa") );
globalObs.add( *ws1->var("glob_effRat") );
globalObs.add( *ws1->var("glob_nbkg_hi") );
globalObs.add( *ws1->var("glob_nbkg_pp") );
cout << "66666" << endl;
// ws1->Print();
RooArgSet poi("poi");
poi.add( *ws1->var("raa3") );
cout << "77777" << endl;
// create set of nuisance parameters
RooArgSet nuis("nuis");
nuis.add( *ws1->var("beta_lumipp") );
nuis.add( *ws1->var("beta_nbkg_hi") );
nuis.add( *ws1->var("beta_nbkg_pp") );
nuis.add( *ws1->var("beta_Taa") );
nuis.add( *ws1->var("beta_effRat") );
cout << "88888" << endl;
ws1->var("#alpha_{CB}_hi")->setConstant(true);
ws1->var("#alpha_{CB}_pp")->setConstant(true);
ws1->var("#sigma_{CB1}_hi")->setConstant(true);
ws1->var("#sigma_{CB1}_pp")->setConstant(true);
ws1->var("#sigma_{CB2}/#sigma_{CB1}_hi")->setConstant(true);
ws1->var("#sigma_{CB2}/#sigma_{CB1}_pp")->setConstant(true);
//ws1->var("Centrality")->setConstant(true); //delete
ws1->var("N_{#varUpsilon(1S)}_hi")->setConstant(true);
ws1->var("N_{#varUpsilon(1S)}_pp")->setConstant(true);
//ws1->var("N_{#Upsilon(2S)}_hi")->setConstant(true);
//ws1->var("N_{#Upsilon(2S)}_pp")->setConstant(true);
//ws1->var("N_{#Upsilon(3S)}_pp")->setConstant(true);
ws1->var("R_{#frac{2S}{1S}}_hi")->setConstant(true); //new
ws1->var("R_{#frac{2S}{1S}}_pp")->setConstant(true); //new
ws1->var("R_{#frac{3S}{1S}}_hi")->setConstant(true); //new
ws1->var("R_{#frac{3S}{1S}}_pp")->setConstant(true); //new
ws1->var("Nmb_hi")->setConstant(true);
// ws1->var("QQsign")->setConstant(true);
ws1->var("Taa_hi")->setConstant(true);
ws1->var("Taa_kappa")->setConstant(true);
// ws1->var("beta_Taa")->setConstant(true);
// ws1->var("beta_effRat")->setConstant(true);
// ws1->var("beta_lumipp")->setConstant(true);
// ws1->var("beta_nbkg_hi")->setConstant(true);
// ws1->var("beta_nbkg_pp")->setConstant(true);
// ws1->var("dataCat")->setConstant(true);
ws1->var("decay_hi")->setConstant(true);
ws1->var("decay_pp")->setConstant(true);
ws1->var("effRat3_hi")->setConstant(true);
ws1->var("effRat_kappa")->setConstant(true);
// ws1->var("glob_Taa")->setConstant(true);
// ws1->var("glob_effRat")->setConstant(true);
// ws1->var("glob_lumipp")->setConstant(true);
// ws1->var("glob_nbkg_hi")->setConstant(true);
// ws1->var("glob_nbkg_pp")->setConstant(true);
// ws1->var("invariantMass")->setConstant(true);
ws1->var("leftEdge")->setConstant(true);
ws1->var("lumipp_hi")->setConstant(true);
ws1->var("lumipp_kappa")->setConstant(true);
ws1->var("m_{ #varUpsilon(1S)}_hi")->setConstant(true); //ws1->var("mass1S_hi")->setConstant(true);
ws1->var("m_{ #varUpsilon(1S)}_pp")->setConstant(true); //ws1->var("mass1S_pp")->setConstant(true);
ws1->var("muMinusPt")->setConstant(true);
ws1->var("muPlusPt")->setConstant(true);
ws1->var("n_{Bkgd}_hi")->setConstant(true);
ws1->var("n_{Bkgd}_pp")->setConstant(true);
ws1->var("nbkg_hi_kappa")->setConstant(true);
ws1->var("nbkg_pp_kappa")->setConstant(true);
//ws1->var("n_{CB}")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true);
ws1->var("n_{CB}_hi")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true);
ws1->var("n_{CB}_pp")->setConstant(true); //ws1->var("n_{CB}")->setConstant(true); //ws1->var("npow")->setConstant(true);
// ws1->var("raa3")->setConstant(true);
ws1->var("rightEdge")->setConstant(true);
ws1->var("sigmaFraction_hi")->setConstant(true);
ws1->var("sigmaFraction_pp")->setConstant(true);
ws1->var("turnOn_hi")->setConstant(true);
ws1->var("turnOn_pp")->setConstant(true);
ws1->var("dimuPt")->setConstant(true); //ws1->var("upsPt")->setConstant(true);
ws1->var("dimuRapidity")->setConstant(true); //ws1->var("upsRapidity")->setConstant(true);
ws1->var("vProb")->setConstant(true);
ws1->var("width_hi")->setConstant(true);
ws1->var("width_pp")->setConstant(true);
// ws1->var("x3raw")->setConstant(true);
// RooArgSet fixed_again("fixed_again");
// fixed_again.add( *ws1->var("leftEdge") );
// fixed_again.add( *ws1->var("rightEdge") );
// fixed_again.add( *ws1->var("Taa_hi") );
// fixed_again.add( *ws1->var("Nmb_hi") );
// fixed_again.add( *ws1->var("lumipp_hi") );
// fixed_again.add( *ws1->var("effRat1_hi") );
// fixed_again.add( *ws1->var("effRat2_hi") );
// fixed_again.add( *ws1->var("effRat3_hi") );
// fixed_again.add( *ws1->var("nsig3_pp") );
// fixed_again.add( *ws1->var("nsig1_pp") );
// fixed_again.add( *ws1->var("nbkg_hi") );
// fixed_again.add( *ws1->var("alpha") );
// fixed_again.add( *ws1->var("nbkg_kappa") );
// fixed_again.add( *ws1->var("Taa_kappa") );
// fixed_again.add( *ws1->var("lumipp_kappa") );
// fixed_again.add( *ws1->var("mean_hi") );
// fixed_again.add( *ws1->var("mean_pp") );
// fixed_again.add( *ws1->var("width_hi") );
// fixed_again.add( *ws1->var("turnOn_hi") );
// fixed_again.add( *ws1->var("bkg_a1_pp") );
// fixed_again.add( *ws1->var("bkg_a2_pp") );
// fixed_again.add( *ws1->var("decay_hi") );
// fixed_again.add( *ws1->var("raa1") );
// fixed_again.add( *ws1->var("raa2") );
// fixed_again.add( *ws1->var("nsig2_pp") );
// fixed_again.add( *ws1->var("sigma1") );
// fixed_again.add( *ws1->var("nbkg_pp") );
// fixed_again.add( *ws1->var("npow") );
// fixed_again.add( *ws1->var("muPlusPt") );
// fixed_again.add( *ws1->var("muMinusPt") );
// fixed_again.add( *ws1->var("mscale_hi") );
// fixed_again.add( *ws1->var("mscale_pp") );
//
// ws1->Print();
cout << "99999" << endl;
// create signal+background Model Config
RooStats::ModelConfig sbHypo("SbHypo");
sbHypo.SetWorkspace( *ws1 );
sbHypo.SetPdf( *ws1->pdf("joint") );
sbHypo.SetObservables( obs );
sbHypo.SetGlobalObservables( globalObs );
sbHypo.SetParametersOfInterest( poi );
sbHypo.SetNuisanceParameters( nuis );
sbHypo.SetPriorPdf( *ws1->pdf("step") ); // this is optional
// ws1->Print();
/////////////////////////////////////////////////////////////////////
RooAbsReal * pNll = sbHypo.GetPdf()->createNLL( *data,NumCPU(10) );
cout << "111111" << endl;
RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots
cout << "444444" << endl;
RooPlot *framepoi = ((RooRealVar *)poi.first())->frame(Bins(10),Range(0.,0.2),Title("LL and profileLL in raa3"));
cout << "222222" << endl;
pNll->plotOn(framepoi,ShiftToZero());
cout << "333333" << endl;
RooAbsReal * pProfile = pNll->createProfile( globalObs ); // do not profile global observables
pProfile->getVal(); // this will do fit and set POI and nuisance parameters to fitted values
pProfile->plotOn(framepoi,LineColor(kRed));
framepoi->SetMinimum(0);
framepoi->SetMaximum(3);
TCanvas *cpoi = new TCanvas();
cpoi->cd(); framepoi->Draw();
cpoi->SaveAs("cpoi.pdf");
((RooRealVar *)poi.first())->setMin(0.);
RooArgSet * pPoiAndNuisance = new RooArgSet("poiAndNuisance");
// pPoiAndNuisance->add(*sbHypo.GetNuisanceParameters());
// pPoiAndNuisance->add(*sbHypo.GetParametersOfInterest());
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
sbHypo.SetSnapshot(*pPoiAndNuisance);
RooPlot* xframeSB = pObs->frame(Title("SBhypo"));
data->plotOn(xframeSB,Cut("dataCat==dataCat::hi"));
RooAbsPdf *pdfSB = sbHypo.GetPdf();
RooCategory *dataCat = ws1->cat("dataCat");
pdfSB->plotOn(xframeSB,Slice(*dataCat,"hi"),ProjWData(*dataCat,*data));
TCanvas *c1 = new TCanvas();
c1->cd(); xframeSB->Draw();
c1->SaveAs("c1.pdf");
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
ws1->import( sbHypo );
/////////////////////////////////////////////////////////////////////
RooStats::ModelConfig bHypo = sbHypo;
bHypo.SetName("BHypo");
bHypo.SetWorkspace(*ws1);
pNll = bHypo.GetPdf()->createNLL( *data,NumCPU(2) );
RooArgSet poiAndGlobalObs("poiAndGlobalObs");
poiAndGlobalObs.add( poi );
poiAndGlobalObs.add( globalObs );
pProfile = pNll->createProfile( poiAndGlobalObs ); // do not profile POI and global observables
((RooRealVar *)poi.first())->setVal( 0 ); // set raa3=0 here
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet( "poiAndNuisance" );
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
bHypo.SetSnapshot(*pPoiAndNuisance);
RooPlot* xframeB = pObs->frame(Title("Bhypo"));
data->plotOn(xframeB,Cut("dataCat==dataCat::hi"));
RooAbsPdf *pdfB = bHypo.GetPdf();
pdfB->plotOn(xframeB,Slice(*dataCat,"hi"),ProjWData(*dataCat,*data));
TCanvas *c2 = new TCanvas();
c2->cd(); xframeB->Draw();
c2->SaveAs("c2.pdf");
delete pProfile;
delete pNll;
delete pPoiAndNuisance;
// import model config into workspace
bHypo.SetWorkspace(*ws1);
ws1->import( bHypo );
/////////////////////////////////////////////////////////////////////
ws1->Print();
bHypo.Print();
sbHypo.Print();
// save workspace to file
ws1 -> SaveAs(name_out);
return;
}
void fit_mass(TString fileN="") {//suffix added before file extension, e.g., '.pdf'
TString placeholder;//to add strings before using them, e.g., for saving text files
gROOT->SetBatch(kTRUE);
gROOT->ProcessLine(".x /afs/cern.ch/user/m/mwilkins/cmtuser/src/lhcbStyle.C");
// gStyle->SetPadTickX(1);
// gStyle->SetPadTickY(1);
// gStyle->SetPadLeftMargin(0.15);
// gStyle->SetTextSize(0.3);
// //open file and get histogram
// TFile *inHistos = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/histos_data.root", "READ");
// TH1F * h100 = (TH1F*)inHistos->Get("h70");
// cout<<"data histogram gotten"<<endl;
//unbinned
TFile *hastree = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/cutfile_Optimized.root", "READ");
TTree * h100 = (TTree*)hastree->Get("mytree");
cout<<"tree gotten"<<endl;
TFile *SMChistos= new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/MC/withKScut/histos_SMCfile_fullMC.root", "READ");
cout<<"SMC file opened"<<endl;
TH1F *SMCh = (TH1F*)SMChistos->Get("h00");
cout<<"SMC hist gotten"<<endl;
RooRealVar *mass = new RooRealVar("Bs_LOKI_MASS_JpsiConstr","m(J/#psi #Lambda)",4100,6100,"MeV");
mass->setRange("bkg1",4300,4800);
mass->setRange("bkg2",5700,5950);
mass->setRange("bkg3",4300,5500);
mass->setRange("bkg4",5100,5500);
mass->setRange("L",5350,5950);
mass->setRange("tot",4300,5950);
cout<<"mass declared"<<endl;
// RooDataHist *data = new RooDataHist("data","1D",RooArgList(*mass),h100);
//unbinned
RooDataSet *data = new RooDataSet("data","1D",h100,*mass);
cout<<"data declared"<<endl;
RooDataHist *SMC = new RooDataHist("SMC","1D",RooArgList(*mass),SMCh);
cout<<"SMC hist assigned to RooDataHist"<<endl;
// Construct Pdf Model
// /\0
//gaussian
RooRealVar mean1L("mean1L","/\\ gaus 1: mean",5621.103095,5525,5700);
RooRealVar sig1L("sig1L","/\\ gaus 1: sigma",6.898126,0,100);
RooGaussian gau1L("gau1L","#Lambda signal: gaussian 1",*mass,mean1L,sig1L);
RooFormulaVar mean2L("mean2L","@0",mean1L);
RooRealVar sig2L("sig2L","/\\ gaus 2: sigma",14.693117,0,100);
RooGaussian gau2L("gau2L","#Lambda signal: gaussian 2",*mass,mean2L,sig2L);
RooRealVar f1L("f1L","/\\ signal: fraction gaussian 1",0.748776,0,1);
RooAddPdf sigL("sigL","#Lambda signal",RooArgList(gau1L,gau2L),RooArgList(f1L));
// //CB
// RooRealVar mean3L("mean3L","/\\ CB: mean",5621.001,5525,5700);
// RooRealVar sig3L("sig3L","/\\ CB: sigma",5.161,0,100);
// RooRealVar alphaL3("alphaL3","/\\ CB: alpha",2.077,0,1000);
// RooRealVar nL3("nL1","/\\ CB: n",0.286,0,1000);
// RooCBShape CBL("CBL","#Lambda signal: CB",*mass,mean3L,sig3L,alphaL3,nL3);
// RooRealVar mean4L("mean4L","/\\ gaus: mean",5621.804,5525,5700);
// RooRealVar sig4L("sig4L","/\\ gaus: sigma",10.819,0,100);
// RooGaussian gauL("gauL","#Lambda signal: gaussian",*mass,mean4L,sig4L);
// RooRealVar f1L("f1L","/\\ signal: fraction CB",0.578,0,1);
// RooAddPdf sigL("sigL","#Lambda signal",RooArgList(CBL,gauL),RooArgList(f1L));
// sigma0
//using RooHistPdf from MC--no need to build pdf here
RooHistPdf sigS = makeroohistpdf(SMC,mass,"sigS","#Sigma^{0} signal (RooHistPdf)");
// /\*
cout<<"Lst stuff"<<endl;
RooRealVar meanLst1("meanLst1","/\\*(misc.): mean1",5011.031237,4900,5100);
RooRealVar sigLst1("sigLst1","/\\*(misc.): sigma1",70.522092,0,100);
RooRealVar meanLst2("mean5Lst2","/\\*(1405): mean2",5245.261703,5100,5350);
RooRealVar sigLst2("sigLst2","/\\*(1405): sigma2",64.564763,0,100);
RooRealVar alphaLst2("alphaLst2","/\\*(1405): alpha2",29.150301);
RooRealVar nLst2("nLst2","/\\*(1405): n2",4.615817,0,50);
RooGaussian gauLst1("gauLst1","#Lambda*(misc.), gaus",*mass,meanLst1,sigLst1);
RooCBShape gauLst2("gauLst2","#Lambda*(1405), CB",*mass,meanLst2,sigLst2,alphaLst2,nLst2);
// RooRealVar fLst1("fLst1","/\\* bkg: fraction gaus 1",0.743,0,1);
// RooAddPdf bkgLst("bkgLst","#Lambda* signal",RooArgList(gauLst1,gauLst2),RooArgList(fLst1));
//Poly func BKG mass
// RooRealVar b0("b0","Background: Chebychev b0",-1.071,-10000,10000);
RooRealVar b1("b1","Background: Chebychev b1",-1.323004,-10,-0.00000000000000000000001);
RooRealVar b2("b2","Background: Chebychev b2",0.145494,0,10);
RooRealVar b3("b3","Background: Chebychev b3",-0.316,-10000,10000);
RooRealVar b4("b4","Background: Chebychev b4",0.102,-10000,10000);
RooRealVar b5("b5","Background: Chebychev b5",0.014,-10000,10000);
RooRealVar b6("b6","Background: Chebychev b6",-0.015,-10000,10000);
RooRealVar b7("b7","Background: Chebychev b7",0.012,-10000,10000);
RooArgList bList(b1,b2);
RooChebychev bkg("bkg","Background", *mass, bList);
// TF1 *ep = new TF1("ep","[2]*exp([0]*x+[1]*x*x)",4300,5950);
// ep->SetParameter(0,1);
// ep->SetParameter(1,-1);
// ep->SetParameter(2,2000);
// ep->SetParName(0,"a");
// ep->SetParName(1,"b");
// ep->SetParName(2,"c");
// RooRealVar a("a","Background: Coefficent of x",1,-10000,10000);
// RooRealVar b("b","Background: Coefficent of x*x",-1,-10000,10000);
// RooRealVar c("c","Background: Coefficent of exp()",2000,-10000,10000);
// RooTFnPdfBinding bkg("ep","ep",ep,RooArgList(*mass,a,b));
//number of each shape
RooRealVar nbkg("nbkg","N bkg",2165.490249,0,100000000);
RooRealVar nsigL("nsigL","N /\\",1689.637290,0,1000000000);
RooRealVar nsigS("nsigS","N sigma",0.000002,0,10000000000);
RooRealVar ngauLst1("ngauLst1","N /\\*(misc.)",439.812103,0,10000000000);
RooRealVar ngauLst2("ngauLst2","N /\\*(1405)",152.061617,0,10000000000);
RooRealVar nbkgLst("nbkgLst","N /\\*",591.828,0,1000000000);
//add shapes and their number to a totalPdf
RooArgList shapes;
RooArgList yields;
shapes.add(sigL); yields.add(nsigL);
shapes.add(sigS); yields.add(nsigS);
// shapes.add(bkgLst); yields.add(nbkgLst);
shapes.add(gauLst1); yields.add(ngauLst1);
shapes.add(gauLst2); yields.add(ngauLst2);
shapes.add(bkg); yields.add(nbkg);
RooAddPdf totalPdf("totalPdf","totalPdf",shapes,yields);
//fit the totalPdf
RooAbsReal * nll = totalPdf.createNLL(*data,Extended(kTRUE),Range("tot"));
RooMinuit m(*nll);
m.setVerbose(kFALSE);
m.migrad();
m.minos();
m.minos();
//display and save information
ofstream textfile;//create text file to hold data
placeholder = "plots/fit"+fileN+".txt";
textfile.open(placeholder);
TString outputtext;//for useful text
//plot things
RooPlot *framex = mass->frame();
framex->GetYaxis()->SetTitle("Events/(5 MeV)");
data->plotOn(framex,Name("Hist"),MarkerColor(kBlack),LineColor(kBlack),DataError(RooAbsData::SumW2));
totalPdf.plotOn(framex,Name("curvetot"),LineColor(kBlue));
RooArgSet* totalPdfComponents = totalPdf.getComponents();
TIterator* itertPC = totalPdfComponents->createIterator();
RooAddPdf* vartPC = (RooAddPdf*) itertPC->Next();
vartPC = (RooAddPdf*) itertPC->Next();//skip totalPdf
int i=0;//color index
TLegend *leg = new TLegend(0.2, 0.02, .4, .42);
leg->SetTextSize(0.06);
leg->AddEntry(framex->findObject("curvetot"),"Total PDF","l");
while(vartPC){//loop over compotents of totalPdf
TString vartPCtitle = vartPC->GetTitle();
TIterator* itercompPars;//forward declare so it persists outside the if statement
RooRealVar* varcompPars;
if(!(vartPCtitle.Contains(":")||vartPCtitle.Contains("@"))){//only for non-sub-shapes
while(i==0||i==10||i==4||i==1||i==5||(i>=10&&i<=27))i++;//avoid white and blue and black and yellow and horribleness
RooArgSet* compPars = vartPC->getParameters(data);//set of the parameters of the component the loop is on
itercompPars = compPars->createIterator();
varcompPars = (RooRealVar*) itercompPars->Next();
while(varcompPars){//write and print mean, sig, etc. of sub-shapes
TString vartitle = varcompPars->GetTitle();
double varval = varcompPars->getVal();
TString varvalstring = Form("%f",varval);
double hi = varcompPars->getErrorHi();
TString varerrorstring = "[exact]";
if(hi!=-1){
double lo = varcompPars->getErrorLo();
double varerror = TMath::Max(fabs(lo),hi);
varerrorstring = Form("%E",varerror);
}
outputtext = vartitle+" = "+varvalstring+" +/- "+varerrorstring;
textfile<<outputtext<<endl;
cout<<outputtext<<endl;
varcompPars = (RooRealVar*) itercompPars->Next();
}
totalPdf.plotOn(framex,Name(vartPC->GetName()),LineStyle(kDashed),LineColor(i),Components(vartPC->GetName()));
leg->AddEntry(framex->findObject(vartPC->GetName()),vartPCtitle,"l");
i++;
}
vartPC = (RooAddPdf*) itertPC->Next();
itercompPars->Reset();//make sure it's ready for the next vartPC
}
// Calculate chi2/ndf
RooArgSet *floatpar = totalPdf.getParameters(data);
int floatpars = (floatpar->selectByAttrib("Constant",kFALSE))->getSize();
Double_t chi2 = framex->chiSquare("curvetot","Hist",floatpars);
TString chi2string = Form("%f",chi2);
//create text box to list important parameters on the plot
// TPaveText* txt = new TPaveText(0.1,0.5,0.7,0.9,"NBNDC");
// txt->SetTextSize(0.06);
// txt->SetTextColor(kBlack);
// txt->SetBorderSize(0);
// txt->SetFillColor(0);
// txt->SetFillStyle(0);
outputtext = "#chi^{2}/N_{DoF} = "+chi2string;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
// txt->AddText(outputtext);
// Print stuff
TIterator* iteryields = yields.createIterator();
RooRealVar* varyields = (RooRealVar*) iteryields->Next();//only inherits things from TObject unless class specified
vector<double> Y, E;//holds yields and associated errors
vector<TString> YS, ES;//holds strings of the corresponding yields
int j=0;//count vector position
int jS=0, jL=0;//these hold the position of the S and L results;initialized in case there is no nsigS or nsigL
while(varyields){//loop over yields
TString varname = varyields->GetName();
TString vartitle = varyields->GetTitle();
double varval = varyields->getVal();
Y.push_back(varval);
double lo = varyields->getErrorLo();
double hi = varyields->getErrorHi();
E.push_back(TMath::Max(fabs(lo),hi));
YS.push_back(Form("%f",Y[j]));
ES.push_back(Form("%f",E[j]));
if(varname=="nsigS") jS=j;
if(varname=="nsigL") jL=j;
outputtext = vartitle+" = "+YS[j]+" +/- "+ES[j];
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
varyields = (RooRealVar*) iteryields->Next();
j++;
}
//S/L
double result = Y[jS]/Y[jL];
cout<<"result declared"<<endl;
double E_result = TMath::Abs(result)*sqrt(pow(E[jS]/Y[jS],2)+pow(E[jL]/Y[jL],2));
cout<<"E_result declared"<<endl;
TString resultstring = Form("%E",result);
TString E_resultstring = Form("%E",E_result);
outputtext = "Y_{#Sigma^{0}}/Y_{#Lambda} = "+resultstring+" +/- "+E_resultstring;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
double resultlimit = (Y[jS]+E[jS])/(Y[jL]-E[jL]);
outputtext = Form("%E",resultlimit);
outputtext = "limit = "+outputtext;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
// Create canvas and pads, set style
TCanvas *c1 = new TCanvas("c1","data fits",1200,800);
TPad *pad1 = new TPad("pad1","pad1",0.0,0.3,1.0,1.0);
TPad *pad2 = new TPad("pad2","pad2",0.0,0.0,1.0,0.3);
pad1->SetBottomMargin(0);
pad2->SetTopMargin(0);
pad2->SetBottomMargin(0.5);
pad2->SetBorderMode(0);
pad1->SetBorderMode(0);
c1->SetBorderMode(0);
pad2->Draw();
pad1->Draw();
pad1->cd();
framex->SetMinimum(1);
framex->SetMaximum(3000);
framex->addObject(leg);//add legend to frame
//framex->addObject(txt);//add text to frame
gPad->SetTopMargin(0.06);
pad1->SetLogy();
// pad1->Range(4100,0,6100,0.0005);
pad1->Update();
framex->Draw();
// Pull distribution
RooPlot *framex2 = mass->frame();
RooHist* hpull = framex->pullHist("Hist","curvetot");
framex2->addPlotable(hpull,"P");
hpull->SetLineColor(kBlack);
hpull->SetMarkerColor(kBlack);
framex2->SetTitle(0);
framex2->GetYaxis()->SetTitle("Pull");
framex2->GetYaxis()->SetTitleSize(0.15);
framex2->GetYaxis()->SetLabelSize(0.15);
framex2->GetXaxis()->SetTitleSize(0.2);
framex2->GetXaxis()->SetLabelSize(0.15);
framex2->GetYaxis()->CenterTitle();
framex2->GetYaxis()->SetTitleOffset(0.45);
framex2->GetXaxis()->SetTitleOffset(1.1);
framex2->GetYaxis()->SetNdivisions(505);
framex2->GetYaxis()->SetRangeUser(-8.8,8.8);
pad2->cd();
framex2->Draw();
c1->cd();
placeholder = "plots/fit"+fileN+".eps";
c1->Print(placeholder);
placeholder = "plots/fit"+fileN+".C";
c1->SaveAs(placeholder);
textfile.close();
}
void combinedWorkspace_4WS(const char* name_pbpb_pass="******", const char* name_pbpb_fail="fitresult_pbpb_fail.root", const char* name_pp_pass="******", const char* name_pp_fail="fitresult_pp_fail.root", const char* name_out="fitresult_combo.root", const float systval = 0., const char* subDirName ="wsTest", int nCPU=2){
// subdir: Directory to save workspaces under currentPATH/CombinedWorkspaces/subDir/
// set things silent
gErrorIgnoreLevel=kError;
RooMsgService::instance().setGlobalKillBelow(RooFit::ERROR);
bool dosyst = (systval > 0.);
TString nameOut(name_out);
RooWorkspace * ws = test_combine_4WS(name_pbpb_pass, name_pp_pass, name_pbpb_fail, name_pp_fail, false, nCPU);
RooAbsData * data = ws->data("dOS_DATA");
RooRealVar* RFrac2Svs1S_PbPbvsPP_P = ws->var("RFrac2Svs1S_PbPbvsPP_P");
RooRealVar* leftEdge = new RooRealVar("leftEdge","leftEdge",-10);
RooRealVar* rightEdge = new RooRealVar("rightEdge","rightEdge",10);
RooGenericPdf step("step", "step", "(@0 >= @1) && (@0 < @2)", RooArgList(*RFrac2Svs1S_PbPbvsPP_P, *leftEdge, *rightEdge));
ws->import(step);
ws->factory( "Uniform::flat(RFrac2Svs1S_PbPbvsPP_P)" );
// systematics
if (dosyst) {
ws->factory( Form("kappa_syst[%f]",systval) );
ws->factory( "expr::alpha_syst('kappa_syst*beta_syst',kappa_syst,beta_syst[0,-5,5])" );
ws->factory( "Gaussian::constr_syst(beta_syst,glob_syst[0,-5,5],1)" );
// add systematics into the double ratio
ws->factory( "expr::RFrac2Svs1S_PbPbvsPP_P_syst('@0+@1',RFrac2Svs1S_PbPbvsPP_P,alpha_syst)" );
// build the pbpb pdf
RooRealVar* effjpsi_pp_P = (RooRealVar*)ws->var("effjpsi_pp_P");
RooRealVar* effpsip_pp_P = (RooRealVar*)ws->var("effpsip_pp_P");
RooRealVar* effjpsi_pp_NP = (RooRealVar*)ws->var("effjpsi_pp_NP");
Double_t Npsi2SPbPbPass = npsip_pbpb_pass_from_doubleratio_prompt(ws, RooArgList(*effjpsi_pp_P,*effpsip_pp_P,*effjpsi_pp_NP),true); // Create and import N_Psi2S_PbPb_pass_syst
ws->factory( "SUM::pdfMASS_Tot_PbPb_pass_syst(N_Jpsi_PbPb_pass * pdfMASS_Jpsi_PbPb_pass, N_Psi2S_PbPb_pass_syst * pdfMASS_Psi2S_PbPb_pass, N_Bkg_PbPb_pass * pdfMASS_Bkg_PbPb_pass)" );
ws->factory( "PROD::pdfMASS_Tot_PbPb_pass_constr(pdfMASS_Tot_PbPb_pass_syst,constr_syst)" );
// build the combined pdf
ws->factory("SIMUL::simPdf_syst_noconstr(sample,PbPb_pass=pdfMASS_Tot_PbPb_pass_syst,PbPb_fail=pdfMASS_Tot_PbPb_fail,PP_pass=pdfMASS_Tot_PP_pass,PP_fail=pdfMASS_Tot_PP_fail)");
RooSimultaneous *simPdf = (RooSimultaneous*) ws->pdf("simPdf_syst_noconstr");
RooGaussian *constr_syst = (RooGaussian*) ws->pdf("constr_syst");
RooProdPdf *simPdf_constr = new RooProdPdf("simPdf_syst","simPdf_syst",RooArgSet(*simPdf,*constr_syst));
ws->import(*simPdf_constr);
} else {
ws->factory("SIMUL::simPdf_syst(sample,PbPb_pass=pdfMASS_Tot_PbPb_pass,PbPb_fail=pdfMASS_Tot_PbPb_fail,PP_pass=pdfMASS_Tot_PP_pass,PP_fail=pdfMASS_Tot_PP_fail)");
}
ws->Print();
if (dosyst) ws->var("beta_syst")->setConstant(kFALSE);
/////////////////////////////////////////////////////////////////////
RooRealVar * pObs = ws->var("invMass"); // get the pointer to the observable
RooArgSet obs("observables");
obs.add(*pObs);
obs.add( *ws->cat("sample"));
// /////////////////////////////////////////////////////////////////////
if (dosyst) ws->var("glob_syst")->setConstant(true);
RooArgSet globalObs("global_obs");
if (dosyst) globalObs.add( *ws->var("glob_syst") );
// ws->Print();
RooArgSet poi("poi");
poi.add( *ws->var("RFrac2Svs1S_PbPbvsPP_P") );
// create set of nuisance parameters
RooArgSet nuis("nuis");
if (dosyst) nuis.add( *ws->var("beta_syst") );
// set parameters constant
RooArgSet allVars = ws->allVars();
TIterator* it = allVars.createIterator();
RooRealVar *theVar = (RooRealVar*) it->Next();
while (theVar) {
TString varname(theVar->GetName());
// if (varname != "RFrac2Svs1S_PbPbvsPP"
// && varname != "invMass"
// && varname != "sample"
// )
// theVar->setConstant();
if ( varname.Contains("f_Jpsi_PP") || varname.Contains("f_Jpsi_PbPb") ||
varname.Contains("rSigma21_Jpsi_PP") ||
varname.Contains("m_Jpsi_PP") || varname.Contains("m_Jpsi_PbPb") ||
varname.Contains("sigma1_Jpsi_PP") || varname.Contains("sigma1_Jpsi_PbPb") ||
(varname.Contains("lambda")) ||
(varname.Contains("_fail") && !varname.Contains("RFrac2Svs1S")))
{
theVar->setConstant();
}
if (varname=="glob_syst"
|| varname=="beta_syst"
) {
cout << varname << endl;
theVar->setConstant(!dosyst);
}
theVar = (RooRealVar*) it->Next();
}
// create signal+background Model Config
RooStats::ModelConfig sbHypo("SbHypo");
sbHypo.SetWorkspace( *ws );
sbHypo.SetPdf( *ws->pdf("simPdf_syst") );
sbHypo.SetObservables( obs );
sbHypo.SetGlobalObservables( globalObs );
sbHypo.SetParametersOfInterest( poi );
sbHypo.SetNuisanceParameters( nuis );
sbHypo.SetPriorPdf( *ws->pdf("step") ); // this is optional
/////////////////////////////////////////////////////////////////////
RooAbsReal * pNll = sbHypo.GetPdf()->createNLL( *data,NumCPU(nCPU) );
RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots
if (controlPlots)
{
RooPlot *framepoi = ((RooRealVar *)poi.first())->frame(Bins(10),Range(0.,1),Title("LL and profileLL in RFrac2Svs1S_PbPbvsPP_P"));
pNll->plotOn(framepoi,ShiftToZero());
framepoi->SetMinimum(0);
framepoi->SetMaximum(10);
TCanvas *cpoi = new TCanvas();
cpoi->cd(); framepoi->Draw();
cpoi->SaveAs("cpoi.pdf");
}
((RooRealVar *)poi.first())->setMin(0.);
RooArgSet * pPoiAndNuisance = new RooArgSet("poiAndNuisance");
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
sbHypo.SetSnapshot(*pPoiAndNuisance);
if (controlPlots)
{
RooPlot* xframeSB_PP_pass = pObs->frame(Title("SBhypo_PP_pass"));
data->plotOn(xframeSB_PP_pass,Cut("sample==sample::PP_pass"));
RooAbsPdf *pdfSB_PP_pass = sbHypo.GetPdf();
RooCategory *sample = ws->cat("sample");
pdfSB_PP_pass->plotOn(xframeSB_PP_pass,Slice(*sample,"PP_pass"),ProjWData(*sample,*data));
TCanvas *c1 = new TCanvas();
c1->cd(); xframeSB_PP_pass->Draw();
c1->SaveAs("c1.pdf");
RooPlot* xframeSB_PP_fail = pObs->frame(Title("SBhypo_PP_fail"));
data->plotOn(xframeSB_PP_fail,Cut("sample==sample::PP_fail"));
RooAbsPdf *pdfSB_PP_fail = sbHypo.GetPdf();
pdfSB_PP_fail->plotOn(xframeSB_PP_fail,Slice(*sample,"PP_fail"),ProjWData(*sample,*data));
TCanvas *c2 = new TCanvas();
c2->cd(); xframeSB_PP_fail->Draw();
c2->SaveAs("c1.pdf");
RooPlot* xframeB_PbPb_pass = pObs->frame(Title("SBhypo_PbPb_pass"));
data->plotOn(xframeB_PbPb_pass,Cut("sample==sample::PbPb_pass"));
RooAbsPdf *pdfB_PbPb_pass = sbHypo.GetPdf();
pdfB_PbPb_pass->plotOn(xframeB_PbPb_pass,Slice(*sample,"PbPb_pass"),ProjWData(*sample,*data));
TCanvas *c3 = new TCanvas();
c3->cd(); xframeB_PbPb_pass->Draw();
c3->SetLogy();
c3->SaveAs("c2.pdf");
RooPlot* xframeB_PbPb_fail = pObs->frame(Title("SBhypo_PbPb_fail"));
data->plotOn(xframeB_PbPb_fail,Cut("sample==sample::PbPb_fail"));
RooAbsPdf *pdfB_PbPb_fail = sbHypo.GetPdf();
pdfB_PbPb_fail->plotOn(xframeB_PbPb_fail,Slice(*sample,"PbPb_fail"),ProjWData(*sample,*data));
TCanvas *c4 = new TCanvas();
c4->cd(); xframeB_PbPb_fail->Draw();
c4->SetLogy();
c4->SaveAs("c2.pdf");
}
delete pNll;
delete pPoiAndNuisance;
ws->import( sbHypo );
/////////////////////////////////////////////////////////////////////
RooStats::ModelConfig bHypo = sbHypo;
bHypo.SetName("BHypo");
bHypo.SetWorkspace(*ws);
pNll = bHypo.GetPdf()->createNLL( *data,NumCPU(nCPU) );
// RooMinuit(*pNll).migrad(); // minimize likelihood wrt all parameters before making plots
RooArgSet poiAndGlobalObs("poiAndGlobalObs");
poiAndGlobalObs.add( poi );
poiAndGlobalObs.add( globalObs );
RooAbsReal * pProfile = pNll->createProfile( poiAndGlobalObs ); // do not profile POI and global observables
((RooRealVar *)poi.first())->setVal( 0 ); // set RFrac2Svs1S_PbPbvsPP=0 here
pProfile->getVal(); // this will do fit and set nuisance parameters to profiled values
pPoiAndNuisance = new RooArgSet( "poiAndNuisance" );
pPoiAndNuisance->add( nuis );
pPoiAndNuisance->add( poi );
bHypo.SetSnapshot(*pPoiAndNuisance);
delete pNll;
delete pPoiAndNuisance;
// import model config into workspace
bHypo.SetWorkspace(*ws);
ws->import( bHypo );
/////////////////////////////////////////////////////////////////////
ws->Print();
bHypo.Print();
sbHypo.Print();
// save workspace to file
string mainDIR = gSystem->ExpandPathName(gSystem->pwd());
string wsDIR = mainDIR + "/CombinedWorkspaces/";
string ssubDirName="";
if (subDirName) ssubDirName.append(subDirName);
string subDIR = wsDIR + ssubDirName;
void * dirp = gSystem->OpenDirectory(wsDIR.c_str());
if (dirp) gSystem->FreeDirectory(dirp);
else gSystem->mkdir(wsDIR.c_str(), kTRUE);
void * dirq = gSystem->OpenDirectory(subDIR.c_str());
if (dirq) gSystem->FreeDirectory(dirq);
else gSystem->mkdir(subDIR.c_str(), kTRUE);
const char* saveName = Form("%s/%s",subDIR.c_str(),nameOut.Data());
ws->writeToFile(saveName);
}
void plot_pll(TString fname="monoh_withsm_SRCR_bg11.7_bgslop-0.0_nsig0.0.root")
{
SetAtlasStyle();
TFile* file = TFile::Open(fname);
RooWorkspace* wspace = (RooWorkspace*) file->Get("wspace");
cout << "\n\ncheck that eff and reco terms included in BSM component to make fiducial cross-section" <<endl;
wspace->function("nsig")->Print();
RooRealVar* reco = wspace->var("reco");
if( wspace->function("nsig")->dependsOn(*reco) ) {
cout << "all good." <<endl;
} else {
cout << "need to rerun fit_withsm using DO_FIDUCIAL_LIMIT true" <<endl;
return;
}
/*
// DANGER
// TEST WITH EXAGGERATED UNCERTAINTY
wspace->var("unc_theory")->setMax(1);
wspace->var("unc_theory")->setVal(1);
wspace->var("unc_theory")->Print();
*/
// this was for making plot about decoupling/recoupling approach
TCanvas* tc = new TCanvas("tc","",400,400);
RooPlot *frame = wspace->var("xsec_bsm")->frame();
RooAbsPdf* pdfc = wspace->pdf("jointModeld");
RooAbsData* data = wspace->data("data");
RooAbsReal *nllJoint = pdfc->createNLL(*data, RooFit::Constrained()); // slice with fixed xsec_bsm
RooAbsReal *profileJoint = nllJoint->createProfile(*wspace->var("xsec_bsm"));
wspace->allVars().Print("v");
pdfc->fitTo(*data);
wspace->allVars().Print("v");
wspace->var("xsec_bsm")->Print();
double nllmin = 2*nllJoint->getVal();
wspace->var("xsec_bsm")->setVal(0);
double nll0 = 2*nllJoint->getVal();
cout << Form("nllmin = %f, nll0 = %f, Z=%f", nllmin, nll0, sqrt(nll0-nllmin)) << endl;
nllJoint->plotOn(frame, RooFit::LineColor(kGreen), RooFit::LineStyle(kDotted), RooFit::ShiftToZero(), RooFit::Name("nll_statonly")); // no error
profileJoint->plotOn(frame,RooFit::Name("pll") );
wspace->var("xsec_sm")->Print();
wspace->var("theory")->Print();
wspace->var("theory")->setConstant();
profileJoint->plotOn(frame, RooFit::LineColor(kRed), RooFit::LineStyle(kDashed), RooFit::Name("pll_smfixed") );
frame->GetXaxis()->SetTitle("#sigma_{BSM, fid} [fb]");
frame->GetYaxis()->SetTitle("-log #lambda ( #sigma_{BSM, fid} )");
double temp = frame->GetYaxis()->GetTitleOffset();
frame->GetYaxis()->SetTitleOffset( 1.1* temp );
frame->SetMinimum(1e-7);
frame->SetMaximum(4);
// Legend
double x1,y1,x2,y2;
GetX1Y1X2Y2(tc,x1,y1,x2,y2);
TLegend *legend_sr=FastLegend(x2-0.75,y2-0.3,x2-0.25,y2-0.5,0.045);
legend_sr->AddEntry(frame->findObject("pll"),"with #sigma_{SM} uncertainty","L");
legend_sr->AddEntry(frame->findObject("pll_smfixed"),"with #sigma_{SM} constant","L");
legend_sr->AddEntry(frame->findObject("nll_statonly"),"no systematics","L");
frame->Draw();
legend_sr->Draw("SAME");
// descriptive text
vector<TString> pavetext11;
pavetext11.push_back("#bf{#it{ATLAS Internal}}");
pavetext11.push_back("#sqrt{#it{s}} = 8 TeV #scale[0.6]{#int}Ldt = 20.3 fb^{-1}");
pavetext11.push_back("#it{H}+#it{E}_{T}^{miss} , #it{H #rightarrow #gamma#gamma}, #it{m}_{#it{H}} = 125.4 GeV");
TPaveText* text11=CreatePaveText(x2-0.75,y2-0.25,x2-0.25,y2-0.05,pavetext11,0.045);
text11->Draw();
tc->SaveAs("pll.pdf");
/*
wspace->var("xsec_bsm")->setConstant(true);
wspace->var("eff" )->setConstant(true);
wspace->var("mh" )->setConstant(true);
wspace->var("sigma_h" )->setConstant(true);
wspace->var("lumi" )->setConstant(true);
wspace->var("xsec_sm" )->setVal(v_xsec_sm);
wspace->var("eff" )->setVal(1.0);
wspace->var("lumi" )->setVal(v_lumi);
TH1* nllHist = profileJoint->createHistogram("xsec_bsm",100);
TFile* out = new TFile("nllHist.root","REPLACE");
nllHist->Write()
out->Write();
out->Close();
*/
}
void paper_fit_plot()
{
SetAtlasStyle();
// get the stuff from the file
char fname_postfit[200] = "monoh_withsm_SRCR_bg11.7_bgslop-0.0_nsig0.0.root";
TFile *tf = new TFile(fname_postfit);
RooWorkspace *ws_post = (RooWorkspace*)tf->Get("wspace");
// data and pdf
RooAbsData *data = ws_post->data("data");
RooAbsPdf *pdfc = ws_post->pdf("jointModeld");
// variables to be constrained
RooRealVar *mh = ws_post->var("mh");
RooRealVar *sigma_h = ws_post->var("sigma_h");
RooRealVar *eff = ws_post->var("eff");
RooRealVar *theory = ws_post->var("theory");
RooRealVar *lumi = ws_post->var("lumi");
RooRealVar *x_mgg = ws_post->var("mgg");
RooArgSet cas(*mh,*sigma_h,*eff,*theory,*lumi);
// redo the fit
RooFitResult *r = pdfc->fitTo(*data,RooFit::Constrain(cas),RooFit::Save(true));
// make the frame
RooPlot *frame = x_mgg->frame();
TCanvas *tc = new TCanvas("tc","",700,500);
frame->GetXaxis()->SetTitle("m_{#gamma#gamma} [GeV]");
frame->GetYaxis()->SetTitle("Events / 1 GeV");
// add the data
data->plotOn(frame,RooFit::Binning(55),RooFit::Name("xdata"),RooFit::DataError(RooAbsData::Poisson));
//data->plotOn(frame,RooFit::Binning(11),RooFit::Name("xdata"),RooFit::DataError(RooAbsData::Poisson));
/// PDFs
pdfc->plotOn(frame, RooFit::Components("E"), RooFit::LineColor(kRed), RooFit::Name("xbackground"));
pdfc->plotOn(frame, RooFit::Components("S"), RooFit::LineColor(kBlue),RooFit::LineStyle(kDotted), RooFit::Name("xsm"));
pdfc->plotOn(frame, RooFit::Components("G"), RooFit::LineColor(kGreen),RooFit::LineStyle(kDotted), RooFit::Name("xbsm"));
pdfc->plotOn(frame, RooFit::LineColor(kRed), RooFit::LineStyle(kDashed),RooFit::Name("xtotal"));
frame->SetMinimum(1e-7);
frame->SetMaximum(9);
// Legend
double x1,y1,x2,y2;
GetX1Y1X2Y2(tc,x1,y1,x2,y2);
TLegend *legend_sr=FastLegend(x1+0.02,y2-0.3,x1+0.35,y2-0.02,0.045);
legend_sr->AddEntry(frame->findObject("xdata"),"Data","LEP");
legend_sr->AddEntry(frame->findObject("xbackground"),"Background fit","L");
legend_sr->AddEntry(frame->findObject("xsm"),"SM H","L");
legend_sr->AddEntry(frame->findObject("xbsm"),"Best-fit BSM H","L");
legend_sr->AddEntry(frame->findObject("xtotal"),"Total","L");
frame->Draw();
legend_sr->Draw("SAME");
// descriptive text
vector<TString> pavetext11;
pavetext11.push_back("#bf{#it{ATLAS Internal}}");
pavetext11.push_back("#sqrt{#it{s}} = 8 TeV #scale[0.6]{#int}#it{L} dt = 20.3 fb^{-1}");
pavetext11.push_back("#it{H + E}_{T}^{miss} , #it{H #rightarrow #gamma#gamma}, #it{m}_{#it{H}} = 125.4 GeV");
TPaveText* text11=CreatePaveText(x2-0.47,y2-0.25,x2-0.05,y2-0.05,pavetext11,0.045);
text11->Draw();
tc->Print("paper_fit_plot.pdf");
}
void fitPtOverMCJLST(int mass = 125, int LHCsqrts = 7, int whichtype = 1,
bool correctErrors = false, /* string changeParName = "", */
bool showErrorPDFs = false, string systString = "Default")
// whichtype
// 0 - gg Signal
// 1 - VBF Signal
// 2 - ZZ
// 3 - ZX
// 4 - ggZZ
// 5 - WH
// 6 - ZH
// 7 - ttH
{
string changeParName = "";
if (systString == "Default") changeParName = "up";
string nameSample[8] = {"gg","vbf","zz","zx","ggzz","wh","zh","tth"};
float maxType[8] = {2.4,3.2,1.6,1.6,1.6,3.2,3.2,3.2};
float rebinType[8] = {1,2,1,1,4,10,10,40};
for (int t = 0; t < 8; t++) {
if (mass > 150) maxType[t] = int(117.90*maxType[t]/sqrt(mass-10.91))/10.;
}
char fileToOpen[200];
sprintf(fileToOpen,"selRootFiles/PToverM_%s%d_SEL_%dTeV.root",nameSample[whichtype].c_str(),mass,LHCsqrts);
// if (whichtype == 3) sprintf(fileToOpen,"PTOVERM_%s_SEL_allTeV.root",nameSample[whichtype].c_str());
RooRealVar* ptoverm = new RooRealVar("ptoverm","p_{T}/M^{4l}",0.,maxType[whichtype],"GeV/c");
TFile input(fileToOpen);
// if (systString == "Mass" || systString == "Mela") {
// sprintf(fileToOpen,"ptovermH_%sUp",systString.c_str());
// } else {
sprintf(fileToOpen,"ptovermH_%s",systString.c_str());
//}
TH1F* ptovermH = (TH1F*)input.Get(fileToOpen);
if (rebinType[whichtype] > 1) ptovermH->Rebin(rebinType[whichtype]);
if (maxType[whichtype] < ptovermH->GetBinLowEdge(ptovermH->GetNbinsX() + 1) - ptovermH->GetBinWidth(1)) {
int theBin = ptovermH->FindBin(maxType[whichtype]);
ptovermH->GetXaxis()->SetRange(1,theBin-1);
}
gROOT->ProcessLine(".L mytdrstyle.C");
gROOT->ProcessLine("setTDRStyle()");
// cout << endl << "Signal " << endl;
ptoverm->setBins(ptovermH->GetNbinsX());
RooDataHist* rdh = new RooDataHist("rdh","Some dataset",RooArgList(*ptoverm),Import(*ptovermH,kFALSE));
// fit definitions
// RooWorkspace *ws = new RooWorkspace("ws");
RooRealVar m("m","emme", 1.,0.01, 40.);
RooRealVar n("n","enne", 0.93, 0.05, 15.);
RooRealVar n2("n2","enne2", 0.75, 0.5, 15.);
RooRealVar bb("bb","bibi",0.02, 0.000005, 20.0);
RooRealVar T("T","tti",0.2,0.00000005,1.);
RooRealVar bb2("bb2","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexp("fexp","f_exp",0.02, 0.0, 1.0);
if (whichtype == 0) {
if (LHCsqrts == 8) {
m.setVal(3.319); // m.setConstant(kTRUE);
n.setVal(0.7606); if (systString != "Default" || mass != 125) n.setConstant(kTRUE);
n2.setVal(0.8061); n2.setConstant(kTRUE);
bb.setVal(3.728); // bb.setConstant(kTRUE);
T.setVal(0.00333); // T.setConstant(kTRUE);
bb2.setVal(1.7172); // bb2.setConstant(kTRUE);
fexp.setVal(0.002144); if (systString != "Default" || mass != 125) fexp.setConstant(kTRUE);
} else {
m.setVal(0.061); // m.setConstant(kTRUE);
n.setVal(1.6141); if (systString == "Resummation" || systString == "TopMass") n.setConstant(kTRUE);
n2.setVal(1.3294); n2.setConstant(kTRUE);
bb.setVal(4.2761); // bb.setConstant(kTRUE);
T.setVal(0.0361); // T.setConstant(kTRUE);
bb2.setVal(1.6643); bb2.setConstant(kTRUE);
fexp.setVal(0.0004); // fexp.setConstant(kTRUE);
}
} else if (whichtype == 1) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.02048); bb.setConstant(kTRUE);
T.setVal(0.16115); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE); // T.setConstant(kTRUE);
bb2.setVal(1.0024); bb2.setConstant(kTRUE);
fexp.setVal(0.005); fexp.setConstant(kTRUE);
if (mass > 300) {
fexp.setVal(0.0); fexp.setConstant(kFALSE);
}
if (mass > 500) {
bb2.setVal(5.0); // bb2.setConstant(kFALSE);
}
if (mass > 500) {
bb.setVal(15.0); // bb.setConstant(kFALSE);
}
} else if (whichtype == 2) {
if (LHCsqrts == 8) {
m.setVal(1.0476); // m.setConstant(kTRUE);
bb.setVal(3.3088); // if (mass != 140) bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.0021889); if (systString.find("Mela") != string::npos || mass != 140) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else {
m.setVal(1.028); // m.setConstant(kTRUE);
bb.setVal(2.91); // bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.002248); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
}
} else if (whichtype == 3) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(3.4523); n.setConstant(kTRUE);
n2.setVal(0.6910); n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 4) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(5.756); // n.setConstant(kTRUE);
n2.setVal(0.8738); // n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 5 && LHCsqrts == 8) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(3.897); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
} else {
// cout << "Entro qui" << endl;
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.0129); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
}
RooModifTsallis* rt3 = new RooModifTsallis("rt3","rt3",*ptoverm,m,n,n2,bb,bb2,T,fexp);
// ws->import(*rt3);
// fit
RooFitResult* fit = rt3->fitTo(*rdh,Minos(0),Save(1),SumW2Error(kTRUE),NumCPU(1));
float mVal = m.getVal();
float nVal = n.getVal();
float n2Val = n2.getVal();
float bbVal = bb.getVal();
float bb2Val = bb2.getVal();
float fexpVal = fexp.getVal();
float TVal = T.getVal();
if (correctErrors) {
// Tsallis errors not reliable, use toy MC
TH1F* mHist = new TH1F("mHist","m",21,-0.5*mVal,0.5*mVal);
TH1F* nHist = new TH1F("nHist","n",21,-0.2*nVal,0.2*nVal);
TH1F* n2Hist = new TH1F("n2Hist","n2",21,-0.2*n2Val,0.2*n2Val);
TH1F* bbHist = new TH1F("bbHist","bb",21,-0.2*bbVal,0.2*bbVal);
TH1F* bb2Hist = new TH1F("bb2Hist","bb2",21,-0.2*bb2Val,0.2*bb2Val);
TH1F* fexpHist = new TH1F("fexpHist","fexp",21,-0.2*fexpVal-0.000001,0.2*fexpVal+0.000001);
TH1F* THist = new TH1F("THist","T",21,-0.5*TVal,0.5*TVal);
mHist->GetXaxis()->SetTitle("m-m_{gen}");
nHist->GetXaxis()->SetTitle("n-n_{gen}");
n2Hist->GetXaxis()->SetTitle("n2-n2_{gen}");
bbHist->GetXaxis()->SetTitle("bb-bb_{gen}");
bb2Hist->GetXaxis()->SetTitle("bb2-bb2_{gen}");
THist->GetXaxis()->SetTitle("T-T_{gen}");
fexpHist->GetXaxis()->SetTitle("fexp-fexp_{gen}");
for (unsigned int iToy = 0; iToy < 200; iToy++) {
cout << endl << "####" << endl;
cout << "Generating toy experiment n. " << iToy+1 << endl;
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
TDatime *now = new TDatime();
Int_t seed = now->GetDate() + now->GetTime();
cout << "RooFit Generation Seed = " << seed+iToy << endl;
RooRandom::randomGenerator()->SetSeed(seed+iToy);
cout << "####" << endl << endl;
RooDataSet *dataToy = rt3->generate(RooArgSet(*ptoverm),ptovermH->GetEntries());
RooDataHist *dataToyH = new RooDataHist("dataToyH","toy",RooArgSet(*ptoverm),*dataToy);
rt3->fitTo(*dataToyH,Minos(0),SumW2Error(kTRUE),NumCPU(1));
if (fit->floatParsFinal().find("m")) mHist->Fill(m.getVal()-mVal);
if (fit->floatParsFinal().find("n")) nHist->Fill(n.getVal()-nVal);
if (fit->floatParsFinal().find("n2")) n2Hist->Fill(n2.getVal()-n2Val);
if (fit->floatParsFinal().find("bb")) bbHist->Fill(bb.getVal()-bbVal);
if (fit->floatParsFinal().find("bb2")) bb2Hist->Fill(bb2.getVal()-bb2Val);
if (fit->floatParsFinal().find("fexp")) fexpHist->Fill(fexp.getVal()-fexpVal);
if (fit->floatParsFinal().find("T")) THist->Fill(T.getVal()-TVal);
}
TCanvas cant("cant","Test canvas",5.,5.,900.,500.);
cant.Divide(4,2);
cant.cd(1); mHist->Draw();
cant.cd(2); nHist->Draw();
cant.cd(3); n2Hist->Draw();
cant.cd(4); bbHist->Draw();
cant.cd(5); bb2Hist->Draw();
cant.cd(6); fexpHist->Draw();
cant.cd(7); THist->Draw();
// cant.SaveAs("figs/testToys.pdf");
cant.SaveAs("newfigs/testToys.pdf");
if (fit->floatParsFinal().find("m")) m.setError(mHist->GetRMS());
if (fit->floatParsFinal().find("n")) n.setError(nHist->GetRMS());
if (fit->floatParsFinal().find("n2")) n2.setError(n2Hist->GetRMS());
if (fit->floatParsFinal().find("bb")) bb.setError(bbHist->GetRMS());
if (fit->floatParsFinal().find("bb2")) bb2.setError(bb2Hist->GetRMS());
if (fit->floatParsFinal().find("fexp")) fexp.setError(fexpHist->GetRMS());
if (fit->floatParsFinal().find("T")) T.setError(THist->GetRMS());
}
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
char fileToSave[200];
// if (changeParName != "")
// sprintf(fileToSave,"text/paramsPTOverMCJLST_%s_%dTeV_%s_%s.txt",nameSample[whichtype].c_str(),LHCsqrts,systString.c_str(),changeParName.c_str());
// else
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_%s.txt",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
ofstream os1(fileToSave);
if (changeParName != "") {
sprintf(fileToSave,"m%s",changeParName.c_str()); m.SetName(fileToSave);
sprintf(fileToSave,"n%s",changeParName.c_str()); n.SetName(fileToSave);
sprintf(fileToSave,"n2%s",changeParName.c_str()); n2.SetName(fileToSave);
sprintf(fileToSave,"bb%s",changeParName.c_str()); bb.SetName(fileToSave);
sprintf(fileToSave,"bb2%s",changeParName.c_str()); bb2.SetName(fileToSave);
sprintf(fileToSave,"fexp%s",changeParName.c_str()); fexp.SetName(fileToSave);
sprintf(fileToSave,"T%s",changeParName.c_str()); T.SetName(fileToSave);
}
(RooArgSet(m,n,n2,bb,bb2,fexp,T)).writeToStream(os1,false);
os1.close();
RooRealVar mup("mup","emme", 1.,0.01, 30.);
RooRealVar nup("nup","enne", 0.93, 0.5, 15.);
RooRealVar n2up("n2up","enne2", 0.75, 0.5, 15.);
RooRealVar bbup("bbup","bibi",0.02, 0.00005, 20.0);
RooRealVar Tup("Tup","tti",0.2,0.00000005,1.);
RooRealVar bb2up("bb2up","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpup("fexpup","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3up = new RooModifTsallis("rt3up","rt3up",*ptoverm,mup,nup,n2up,bbup,bb2up,Tup,fexpup);
// ws->import(*rt3up);
RooRealVar mdown("mdown","emme", 1.,0.01, 30.);
RooRealVar ndown("ndown","enne", 0.93, 0.5, 15.);
RooRealVar n2down("n2down","enne2", 0.75, 0.5, 15.);
RooRealVar bbdown("bbdown","bibi",0.02, 0.00005, 20.0);
RooRealVar Tdown("Tdown","tti",0.2,0.00000005,1.);
RooRealVar bb2down("bb2down","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpdown("fexpdown","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3down = new RooModifTsallis("rt3down","rt3down",*ptoverm,mdown,ndown,n2down,bbdown,bb2down,Tdown,fexpdown);
// ws->import(*rt3down);
RooPlot *frame = ptoverm->frame();
char reducestr[300];
sprintf(reducestr,"ptoverm > %f && ptoverm < %f",ptoverm->getMin(),ptoverm->getMax());
rdh->plotOn(frame,DataError(RooAbsData::SumW2),Cut(reducestr));
static RooHist *hpull;
float chi2 = 0.;
if (changeParName == "") {
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_Default.txt",nameSample[whichtype].c_str(),mass,LHCsqrts);
ifstream is1(fileToSave);
(RooArgSet(mup,nup,n2up,bbup,bb2up,fexpup,Tup)).readFromStream(is1,false);
mdown.setVal(fabs(3*mup.getVal() - 2*m.getVal()));
ndown.setVal(fabs(3*nup.getVal() - 2*n.getVal()));
n2down.setVal(fabs(3*n2up.getVal() - 2*n2.getVal()));
bbdown.setVal(fabs(3*bbup.getVal() - 2*bb.getVal()));
Tdown.setVal(fabs(3*Tup.getVal() - 2*T.getVal()));
bb2down.setVal(fabs(3*bb2up.getVal() - 2*bb2.getVal()));
fexpdown.setVal(fabs(3*fexpup.getVal() - 2*fexp.getVal()));
if (showErrorPDFs) {
rt3->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
rt3up->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
if (systString.find("Mela") == string::npos) rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
} else {
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
}
} else {
mup.setVal(m.getVal() + m.getError()); cout << "mup = " << mup.getVal() << endl;
nup.setVal(n.getVal() + n.getError());
n2up.setVal(n2.getVal() + n2.getError());
bbup.setVal(bb.getVal() + bb.getError());
Tup.setVal(T.getVal() + T.getError());
bb2up.setVal(bb2.getVal() + bb2.getError());
fexpup.setVal(fexp.getVal() + fexp.getError());
mdown.setVal(m.getVal() - m.getError()); cout << "mdown = " << mdown.getVal() << endl;
ndown.setVal(n.getVal() - n.getError());
n2down.setVal(n2.getVal() - n2.getError());
bbdown.setVal(bb.getVal() - bb.getError());
Tdown.setVal(T.getVal() - T.getError());
bb2down.setVal(bb2.getVal() - bb2.getError());
fexpdown.setVal(fexp.getVal() - fexp.getError());
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
if (showErrorPDFs) {
rt3up->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
}
}
double *ypulls = hpull->GetY();
unsigned int nBins = rdh->numEntries();
unsigned int nFullBins = 0;
for (unsigned int i = 0; i < nBins; i++) {
cout << "Pull of bin " << i << " = " << ypulls[i] << endl;
if (fabs(ypulls[i]) < 5.0) chi2 += ypulls[i]*ypulls[i];
cout << "Partial chi2 = " << chi2 << endl;
if (fabs(ypulls[i]) > 0.0001 && fabs(ypulls[i]) < 5.0) nFullBins++;
}
for (unsigned int i = 0; i < nBins; i++) {
if (fabs(ypulls[i]) < 0.0001) ypulls[i] = 999.;
hpull->SetPointError(i,0.,0.,0.,0.);
}
int nFitPar = fit->floatParsFinal().getSize() - 1;
TCanvas can("can","The canvas",5.,5.,500.,900.);
can.Divide(1,3);
TLatex *t = new TLatex();
t->SetNDC();
t->SetTextAlign(22);
t->SetTextSize(0.06);
can.cd(1);
gPad->SetBottomMargin(0.0);
frame->Draw();
// gPad->SetLogy();
// Htest->Draw();
sprintf(fileToSave,"%s %d GeV at %d TeV",nameSample[whichtype].c_str(),mass,LHCsqrts);
t->DrawLatex(0.6,0.8,fileToSave);
can.cd(2);
gPad->SetLogy();
gPad->SetTopMargin(0.0);
frame->Draw();
RooPlot* pull = ptoverm->frame(Title("Pull Distribution")) ;
pull->GetYaxis()->SetTitle("Pull");
/* pull->SetLabelSize(0.08,"XYZ");
pull->SetTitleSize(0.08,"XYZ");
pull->SetTitleOffset(0.6,"Y");
pull->SetTitleOffset(1.0,"X"); */
pull->addPlotable(hpull,"P") ;
pull->SetMinimum(-6.);
pull->SetMaximum(6.);
can.cd(3);
gPad->SetGridy();
pull->Draw();
sprintf(fileToSave,"#chi^{2}/n_{DoF} = %4.1f/%d",chi2,nFullBins - nFitPar);
if (chi2 < 1000.) t->DrawLatex(0.80,0.86,fileToSave);
// sprintf(fileToSave,"figs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
sprintf(fileToSave,"newfigs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
can.SaveAs(fileToSave);
}
void plotLHCPPZHproj(variables var=km) {
RooRealVar* costheta1 = new RooRealVar("costheta1","cos#theta_{1}",-1.,1.);
RooRealVar* costheta2 = new RooRealVar("costheta2","cos#theta_{2}",-1.,1.);
RooRealVar* phi = new RooRealVar("phi","#Phi",-TMath::Pi(),TMath::Pi());
RooRealVar* m= new RooRealVar("m","m_{VH} [GeV]", 200, 1000);
RooRealVar* Y= new RooRealVar("Y","Rapidity (VH)", -4, 4);
// additional variables
// event weight
RooRealVar* wt = new RooRealVar("wt", "wt", 0.0, 50);
vector<RooRealVar*> meas;
meas.push_back(costheta1);
meas.push_back(costheta2);
meas.push_back(phi);
meas.push_back(m);
meas.push_back(Y);
meas.push_back(wt);
int parameterization = 1;
RooRealVar* mH = new RooRealVar("mH","m_{H}",125.);
ScalarPdfFactoryPPZH SMHiggs(costheta1,costheta2,phi,m,Y,mH,parameterization,false);
ScalarPdfFactoryPPZH psScalar(costheta1,costheta2,phi,m,Y,mH,parameterization,false);
psScalar.g1Val->setVal(0.0);
psScalar.g4Val->setVal(1.0);
ScalarPdfFactoryPPZH f3p5Scalar(costheta1,costheta2,phi,m,Y,mH,parameterization,false);
f3p5Scalar.g1Val->setVal(1.0);
f3p5Scalar.g4Val->setVal(0.144708);
ScalarPdfFactoryPPZH f3p5_90_Scalar(costheta1,costheta2,phi,m,Y,mH,parameterization,false);
f3p5_90_Scalar.g1Val->setVal(1.0);
f3p5_90_Scalar.g4ValIm->setVal(0.144708);
//
// Read datasets
//
TChain* SMHtree = new TChain("SelectedTree");
SMHtree->Add("samples/pp_ZH/pp_ZH_llbb_g1_1M_false.root");
RooDataSet dataTMPSMH("dataTMPSMH","dataTMPSMH", SMHtree, RooArgSet(*costheta1,*costheta2,*phi,*m,*Y, *wt));
RooDataSet SMHdata = RooDataSet("SMHData","SMHData",RooArgList(*costheta1,*costheta2,*phi,*m, *Y, *wt), WeightVar("wt"), Import(dataTMPSMH));
TChain* PStree = new TChain("SelectedTree");
PStree->Add("samples/pp_ZH/pp_ZH_llbb_g4_1M_false.root");
RooDataSet dataTMPPS("dataTMPPS","dataTMPPS", PStree, RooArgSet(*costheta1,*costheta2,*phi,*m,*Y, *wt));
RooDataSet PSdata = RooDataSet("PSData","PSData",RooArgList(*costheta1,*costheta2,*phi,*m, *Y, *wt), WeightVar("wt"), Import(dataTMPPS));
TChain* f3p5tree = new TChain("SelectedTree");
f3p5tree->Add("samples/pp_ZH/pp_ZH_llbb_g1_p_g4_1M_false.root");
RooDataSet dataTMPf3p5("dataTMPf3p5","dataTMPf3p5", f3p5tree, RooArgSet(*costheta1,*costheta2,*phi,*m,*Y, *wt));
RooDataSet f3p5data = RooDataSet("f3p5Data","f3p5Data",RooArgList(*costheta1,*costheta2,*phi,*m, *Y, *wt), WeightVar("wt"), Import(dataTMPf3p5));
TChain* f3p5_90_tree = new TChain("SelectedTree");
f3p5_90_tree->Add("samples/pp_ZH/pp_ZH_llbb_g1_p_ig4_1M_false.root");
RooDataSet dataTMPf3p5_90("dataTMPf3p5_90","dataTMPf3p5_90", f3p5_90_tree, RooArgSet(*costheta1,*costheta2,*phi,*m,*Y, *wt));
RooDataSet f3p5_90_data = RooDataSet("f3p5_90Data","f3p5_90Data",RooArgList(*costheta1,*costheta2,*phi,*m, *Y, *wt), WeightVar("wt"), Import(dataTMPf3p5_90));
TString varName = "costheta1";
const int nbins = 20;
double xMin = -1;
double xMax = 1.;
if ( var == kcostheta2 ) {
varName = "costheta2";
} else if( var == kphi) {
varName = "phi";
xMin = -TMath::Pi();
xMax = TMath::Pi();
} else if ( var == km) {
varName = "m";
xMin = 200;
xMax = 1000.;
} else if ( var == kY) {
varName = "Y";
xMin = -4;
xMax = 4;
}
//
// Do some gymnastics about the plots
// normalize to 1
//
TH1F *h_0p = new TH1F("h_0p", "h_0p", nbins, xMin, xMax);
SMHtree->Project("h_0p", varName,"wt");
double rescale_0p = 1./h_0p->Integral();
h_0p->Scale(rescale_0p);
// std::cout << "rescale_0p = " << rescale_0p << "\n";
double ymax = h_0p->GetMaximum();
TH1F *h_0m = new TH1F("h_0m", "h_0m", nbins, xMin, xMax);
PStree->Project("h_0m", varName,"wt");
double rescale_0m = 1./h_0m->Integral();
// std::cout << "rescale_0m = " << rescale_0m << "\n";
h_0m->Scale(rescale_0m);
ymax = h_0m->GetMaximum() > ymax ? h_0m->GetMaximum() : ymax;
TH1F *h_0mix = new TH1F("h_0mix", "h_0mix", nbins, xMin, xMax);
f3p5tree->Project("h_0mix", varName,"wt");
double rescale_0mix = 1./h_0mix->Integral();
// std::cout << "rescale_0mix = " << rescale_0mix << "\n";
h_0mix->Scale(rescale_0mix);
ymax = h_0mix->GetMaximum() > ymax ? h_0mix->GetMaximum() : ymax;
TH1F *h_0mixphase = new TH1F("h_0mixphase", "h_0mixphase", nbins, xMin, xMax);
f3p5_90_tree->Project("h_0mixphase", varName,"wt");
double rescale_0mixphase = 1./h_0mixphase->Integral();
// std::cout << "rescale_0mixphase = " << rescale_0mixphase << "\n";
h_0mixphase->Scale(rescale_0mixphase);
ymax = h_0mixphase->GetMaximum() > ymax ? h_0mixphase->GetMaximum() : ymax;
// create rooplot and plot data/pdfs
RooPlot* plot = (meas[var])->frame(nbins);
SMHdata.plotOn(plot,MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),XErrorSize(0),DataError(RooAbsData::None), Rescale(rescale_0p));
SMHiggs.PDF->plotOn(plot,LineColor(kRed),LineWidth(2), Normalization(rescale_0p));
PSdata.plotOn(plot,MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0),DataError(RooAbsData::None), Rescale(rescale_0m));
psScalar.PDF->plotOn(plot,LineColor(kBlue),LineWidth(2), Normalization(rescale_0m));
f3p5data.plotOn(plot,MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0),DataError(RooAbsData::None), Rescale(rescale_0mix));
f3p5Scalar.PDF->plotOn(plot,LineColor(kGreen+3),LineWidth(2), Normalization(rescale_0mix));
f3p5_90_data.plotOn(plot,MarkerColor(kMagenta+1),MarkerStyle(20), MarkerSize(1.5),XErrorSize(0),DataError(RooAbsData::None), Rescale(rescale_0mixphase));
f3p5_90_Scalar.PDF->plotOn(plot,LineColor(kMagenta+1),LineWidth(2), Normalization(rescale_0mixphase));
//TGaxis::SetMaxDigits(3);
plot->SetMaximum(ymax*1.1);
if ( var == km )
plot->SetMaximum(ymax*1.3);
TCanvas* can = new TCanvas("can","can",600,600);
// plot styles
// gStyle->SetPadLeftMargin(0.05);
plot->GetXaxis()->CenterTitle();
plot->GetYaxis()->CenterTitle();
plot->GetYaxis()->SetTitle(" ");
plot->GetXaxis()->SetNdivisions(505);
plot->Draw();
TString plotName = "h1";
if ( var == kcostheta2) plotName = "h2";
if ( var == kphi) plotName = "phi";
if ( var == km) plotName = "mvh";
if ( var == kY) plotName = "Yvh";
can->SaveAs(Form("paperplots/%s_ppzh_pp_ZH_llbb_accfalse.eps", plotName.Data()));
can->SaveAs(Form("paperplots/%s_ppzh_pp_ZH_llbb_accfalse.png", plotName.Data()));
delete h_0p;
delete h_0m;
delete h_0mix;
delete h_0mixphase;
delete plot;
delete can;
delete SMHtree;
delete PStree;
delete f3p5tree;
delete f3p5_90_tree;
}
void checkFitCBBW(float mass,float width,string channel, string modelName,double Ymax,bool testGeneratedKinematics=0,bool testKinematicsWithoutSelection =0)
{
float gamma = width*mass;
std::ostringstream s;
s<< mass;
std::string Mass(s.str());
std::ostringstream ss; int temp_width = width*10;
ss<<temp_width;
std::string swidth(ss.str());
string sMCname = "MC sample, m_{VV}="+Mass+", width=0."+swidth;
string suffix ="#"+channel;
if(channel.find("mu")==string::npos)
{
suffix = "e";
}
string name= modelName+" #rightarrow "+suffix+", m_{WW} = "+Mass;
string soutput_pdf_name = "/usr/users/dschaefer/root/results/testFit/M"+Mass+"/"+modelName+"_M"+Mass+"_"+"width0p"+swidth+"_"+channel+"_matchedJet.pdf";
if(testGeneratedKinematics)
{
soutput_pdf_name = "/usr/users/dschaefer/root/results/testFit/M"+Mass+"/"+modelName+"_M"+Mass+"_"+"width0p"+swidth+"_"+channel+"_matchedJet_gen.pdf";
}
if(testKinematicsWithoutSelection)
{
soutput_pdf_name = "/usr/users/dschaefer/root/results/testFit/M"+Mass+"/"+modelName+"_M"+Mass+"_"+"width0p"+swidth+"_"+channel+"_withoutSelections.pdf";
}
string sfile_narrow;
if(mass == 800 or mass ==1600)
{
sfile_narrow ="/usr/users/dschaefer/root/results/BulkGrav/BulkGrav_M"+Mass+"_width0p0_mWW_"+channel+".root";
if(testKinematicsWithoutSelection)
{
sfile_narrow ="/usr/users/dschaefer/root/results/BulkGrav/BulkGrav_M"+Mass+"_width0p0_mWW_"+channel+"_withoutSelection.root";
}
}
else
{
sfile_narrow ="/usr/users/dschaefer/root/results/Wprime/Wprime_M"+Mass+"_width0p0_mWW_"+channel+".root";
}
string sfile_width ="/usr/users/dschaefer/root/results/"+modelName+"/"+modelName+"_M"+Mass+"_width0p"+swidth+"_mWW_"+channel+".root";
if(testGeneratedKinematics)
{
sfile_width ="/usr/users/dschaefer/root/results/"+modelName+"/"+modelName+"_M"+Mass+"_width0p"+swidth+"_mWW_"+channel+"_gen.root";
}
if(testKinematicsWithoutSelection)
{
sfile_width ="/usr/users/dschaefer/root/results/"+modelName+"/"+modelName+"_M"+Mass+"_width0p"+swidth+"_mWW_"+channel+"_withoutSelection.root";
}
const char* file_width = sfile_width.c_str();
const char* file_narrow = sfile_narrow.c_str();
const char* MCname= sMCname.c_str();
const char* title = name.c_str();
const char* output_pdf_name = soutput_pdf_name.c_str();
TFile *f = new TFile(file_width,"READ");
TFile *f_narrow = new TFile(file_narrow,"READ");
TH1F* h = (TH1F*) f->Get("hmWW");
TH1F* h_narrow = (TH1F*) f_narrow->Get("hmWW");
int tmp = h_narrow->GetSize()-2;
double massMax_narrow = h_narrow->GetBinLowEdge(h_narrow->GetBin(tmp));
double massMin_narrow = h_narrow->GetBinLowEdge(0);
tmp = h->GetSize()-2;
double massMax_width = h->GetBinLowEdge(h->GetBin(tmp));
double massMin_width = h->GetBinLowEdge(0);
RooRealVar m_narrow("m","m",massMin_narrow, massMax_narrow);
RooRealVar m_width("m_w","m_w",massMin_width,massMax_width);
float mCBMin;
float mCBMax;
float sCB;
float sCBMin;
float sCBMax;
float n1;
float n1Max;
float n1Min;
float n2Max;
float n2Min;
float n2;
float alpha1;
float alpha11Min;
float alpha1Max;
float alpha1Min;
float alpha2Max;
float alpha2Min;
float alpha2;
if(mass == 800)
{
sCB =50; sCBMin =40; sCBMax=70;
n1 = 15.; n1Min=5.;n1Max =25.;
n2 = 15.; n2Min=5.;n2Max =25.;
alpha1 =1.5;alpha1Min=1.;alpha1Max=1.9;
alpha2 =1.64;alpha2Min=1.;alpha2Max=1.9;
}
if(mass == 1200)
{
sCB =50; sCBMin =40; sCBMax=70;
n1 = 15.; n1Min=5.;n1Max =25.;
n2 = 15.; n2Min=5.;n2Max =25.;
alpha1 =1.5;alpha1Min=1.;alpha1Max=1.9;
alpha2 =1.64;alpha2Min=1.;alpha2Max=1.9;
}
if(mass == 2000)
{
sCB =150; sCBMin =110; sCBMax=175;
n1 = 10.; n1Min=0.01;n1Max =35.;
n2 = 20; n2Min=0.01;n2Max =35.;
alpha1 =1.5;alpha1Min=0.5;alpha1Max=3.;
alpha2 =1.5;alpha2Min=0.5;alpha2Max=3.0;
}
if(mass == 3000)
{
sCB =150; sCBMin =110; sCBMax=175;
n1 = 10.; n1Min=0.01;n1Max =35.;
n2 = 20; n2Min=0.01;n2Max =35.;
alpha1 =1.5;alpha1Min=0.5;alpha1Max=3.;
alpha2 =1.5;alpha2Min=0.5;alpha2Max=3.0;
}
if(mass==4000)
{
sCB =200; sCBMin =140; sCBMax=230;
n1 = 10.; n1Min=0.01;n1Max =35.;
n2 = 20; n2Min=0.01;n2Max =35.;
alpha1 =1.5;alpha1Min=0.5;alpha1Max=3.;
alpha2 =1.5;alpha2Min=0.5;alpha2Max=3.0;
}
RooRealVar m_new = m_width;
m_new.setBins(1000,"cache");
RooRealVar mean_CB("mean_CB","mean_CB",mass+90,mass-20,mass+100);
RooRealVar sigma_CB("sigma_CB","sigma_CB",sCB,sCBMin,sCBMax);
RooRealVar n1_CB("n1_CB","n1_CB",n1,n1Min,n1Max);
RooRealVar alpha2_CB("alpha2_CB","alpha2_CB",alpha2,alpha2Min,alpha2Max);
RooRealVar n2_CB("n2_CB","n2_CB",n2,n2Min,n2Max);
RooRealVar alpha1_CB("alpha1_CB","alpha1_CB",alpha1,alpha1Min,alpha1Max);
RooRealVar mean_conv("mean_conv","mean_conv",0);
RooRealVar width_BW("width_BW","width_BW",gamma);
RooDoubleCrystalBall CB("CB","CB",m_narrow,mean_CB,sigma_CB,alpha1_CB,n1_CB,alpha2_CB,n2_CB);
RooDataHist dh_narrow("dh_narrow","dh_narrow",m_narrow,Import(*h_narrow));
CB.fitTo(dh_narrow);
mean_CB.getVal();
sigma_CB.getVal();
n1_CB.getVal();
n2_CB.getVal();
alpha1_CB.getVal();
alpha2_CB.getVal();
RooBWRunPdf BW("BW","BW",m_new,mean_CB,width_BW);
RooDoubleCrystalBall CB_fitted("CB_fitted","CB_fitted",m_new,mean_conv,sigma_CB,alpha1_CB,n1_CB,alpha2_CB,n2_CB);
RooDataHist dh("dh","dh",m_width,Import(*h));
RooPlot* frame = m_width.frame();
frame->GetXaxis()->SetTitle("m_{VV} [GeV]");
frame->SetTitle(title);
frame->GetYaxis()->SetTitleOffset(1.4);
frame->setPadFactor(1);
dh.plotOn(frame,"name_dh");
if(testKinematicsWithoutSelection)
{
RooBWRunPdf BW_withoutSelection("BW_wS","BW_wS",m_width,mean_CB,width_BW);
BW_withoutSelection.plotOn(frame,"name_model_pdf");
}
else
{
RooFFTConvPdf model_pdf("conv","conv",m_new,BW,CB_fitted);
model_pdf.setBufferFraction(5.0);
model_pdf.plotOn(frame,"name_model_pdf");
}
//BW.plotOn(frame,MarkerColor(kRed),LineColor(kRed));
//CB.plotOn(frame,MarkerColor(kGreen),LineColor(kGreen));
//model_pdf.fitTo(dh);
RooPlot* frame_narrow_fit = m_narrow.frame();
frame_narrow_fit->GetXaxis()->SetTitle("m_{VV} [GeV]");
frame_narrow_fit->SetTitle("Double Crystall Ball");
dh_narrow.plotOn(frame_narrow_fit);
CB.plotOn(frame_narrow_fit);
TCanvas* canvas1 = new TCanvas("canvas1","canvas1",400,600);
gPad->SetLeftMargin(0.15);
TPad* pad1 = new TPad("pad1","pad1",0.,0.2,1.,1.0);
TPad* pad2 = new TPad("pad2","pad2",0.,0.,1.0,0.2);
pad1->SetLeftMargin(0.15);
pad2->SetLeftMargin(0.15);
pad1->Draw();
pad2->Draw();
pad1->cd();
frame->GetYaxis()->SetTitleOffset(2.0);
//double Ymax = 400;
frame->SetMaximum(Ymax);
frame->Draw();
TString dh_name = frame->nameOf(0);
TString model_pdf_name = frame->nameOf(1);
TLegend* leg = new TLegend(0.48,0.89,0.89,0.8);//0.48,0.89,0.9,0.8)
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->AddEntry(frame->findObject(dh_name),MCname,"lep");
if(testKinematicsWithoutSelection)
{
leg->AddEntry(frame->findObject(model_pdf_name),"Breit-Wigner ","L");
}
else
{
leg->AddEntry(frame->findObject(model_pdf_name),"(CB*BW)(m) ","L");
}
leg->Draw();
double chi2 = frame->chiSquare();
string schi2 = "X^{2} ="+std::to_string(chi2);
const char* textChi2 = schi2.c_str();
TLatex text;
text.SetTextFont(43);
text.SetTextSize(16);
text.DrawLatex(massMin_width+(massMax_width-massMin_width)/10.,Ymax-Ymax/10.,textChi2);
RooPlot* frame2 = m_width.frame();
frame2->addObject(frame->pullHist());
frame2->SetMinimum(-25);
frame2->SetMaximum(15);
frame2->SetTitle("pulls");
pad2->cd();
frame2->Draw();
canvas1->SaveAs(output_pdf_name);
TCanvas* canvas2 = new TCanvas("canvas2","canvas2",400,400);
canvas2->cd();
frame_narrow_fit->Draw();
}
void mKKfit(string filename, string branchname, string cuts, string weight, string xtitle, string unit, string plotname, double xlow, double xup, double yup, int nbins, bool convolve, bool phsp, bool fitnonres, bool fitfzero, bool fitftwop)
{
/*Physics parameters**********************************************************/
// Define in MeV
double mBs = 5366.77; // TODO: turn this into a map (or one map per dimension: energy, inverse energy and unitless) and do the MeV to GeV conversion at the top
double mfzero = 990;//939.9;
double gpipi = 199;
double gKK = gpipi*3;
double mftwop = 1522.2;
double Gftwop = 84;
double mphi = 1019.461;
double Gphi = 4.266;
double mpi = 139.57018;
double mK = 493.677;
double BWBFradius = 0.0031;
double mKKresolution_lo = 0.2;
double mKKresolution_hi = 0.6;
double mKKresolution_MC = 0.4;
/*Input***********************************************************************/
TFile* file = TFile::Open(filename.c_str());
TTree* tree = GetTree(file,cuts);
/*Fit the resolution**********************************************************/
using namespace RooFit;
/*Do convolved fit************************************************************/
RooRealVar* m = new RooRealVar(branchname.c_str(),xtitle.c_str(),xlow,xup);
cout << "Importing tree" << endl;
RooDataSet* data;
MassFitter* massfitter = new MassFitter(m);
if(weight == "")
data = new RooDataSet("data","",RooArgSet(*m),Import(*tree));
else
{
RooRealVar* w = new RooRealVar(weight.c_str(),"weighting variable",-100,100);
data = new RooDataSet("data","",RooArgSet(*m,*w),Import(*tree),WeightVar(*w));
massfitter->SetWeighted();
}
RooRealVar* Nnonres = new RooRealVar("N","Number of non-resonant candidates",200,0,1e6);
RooRealVar* Nfzero = new RooRealVar("N","Number of f0(980) candidates",150,0,1e6);
RooRealVar* Nphi = new RooRealVar("N","Number of phi candidates",3000,0,1e6);
RooRealVar* Nftwop = new RooRealVar("N","Number of f2'(1525) candidates",200,0,1e6);
/*Phase space function********************************************************/
if(phsp)
{
Component* phasespace = massfitter->SetWeightFunction("Three Body Phase Space");
if(unit.find("GeV")!=string::npos)
{
phasespace->SetRange("M",mBs*1e-3,mBs*1e-3);
phasespace->FixValue("M",mBs*1e-3);
phasespace->SetRange("m1",mK*1e-3,mK*1e-3);
phasespace->FixValue("m1",mK*1e-3);
phasespace->SetRange("m2",mK*1e-3,mK*1e-3);
phasespace->FixValue("m2",mK*1e-3);
phasespace->SetRange("m3",mphi*1e-3,mphi*1e-3);
phasespace->FixValue("m3",mphi*1e-3);
}
else
{
phasespace->SetRange("M",mBs,mBs);
phasespace->FixValue("M",mBs);
phasespace->SetRange("m1",mK,mK);
phasespace->FixValue("m1",mK);
phasespace->SetRange("m2",mK,mK);
phasespace->FixValue("m2",mK);
phasespace->SetRange("m3",mphi,mphi);
phasespace->FixValue("m3",mphi);
}
}
/*Non-resonant kaon pairs*****************************************************/
Component* nonres;
if(fitnonres)
{
if(!phsp)
{
nonres = massfitter->AddComponent("nonres","Three Body Phase Space",Nnonres);
if(unit.find("GeV")!=string::npos)
{
nonres->SetRange("M",mBs*1e-3,mBs*1e-3);
nonres->FixValue("M",mBs*1e-3);
nonres->SetRange("m1",mK*1e-3,mK*1e-3);
nonres->FixValue("m1",mK*1e-3);
nonres->SetRange("m2",mK*1e-3,mK*1e-3);
nonres->FixValue("m2",mK*1e-3);
nonres->SetRange("m3",mphi*1e-3,mphi*1e-3);
nonres->FixValue("m3",mphi*1e-3);
}
else
{
nonres->SetRange("M",mBs,mBs);
nonres->FixValue("M",mBs);
nonres->SetRange("m1",mK,mK);
nonres->FixValue("m1",mK);
nonres->SetRange("m2",mK,mK);
nonres->FixValue("m2",mK);
nonres->SetRange("m3",mphi,mphi);
nonres->FixValue("m3",mphi);
}
}
else
{
nonres = massfitter->AddComponent("nonres","Flat",Nnonres);
}
nonres->SetColour(kCyan+1);
nonres->SetStyle(kDotted);
}
/*f0(980)*********************************************************************/
Component* fzero;
if(fitfzero)
{
fzero = massfitter->AddComponent("fzero","Flatte",Nfzero);
fzero->SetColour(kGreen+1);
fzero->SetStyle(9);
// fzero->FixValue("spin",0);
if(unit.find("GeV")!=string::npos)
{
fzero->SetRange("mean",mfzero*1e-3,mfzero*1e-3);
fzero->FixValue("mean",mfzero*1e-3);
fzero->SetRange("gpipi",gpipi*1e-3,gpipi*1e-3);
fzero->FixValue("gpipi",gpipi*1e-3);
fzero->SetRange("mpi",mpi*1e-3,mpi*1e-3);
fzero->FixValue("mpi",mpi*1e-3);
fzero->SetRange("gKK",gKK*1e-3,gKK*1e-3);
fzero->FixValue("gKK",gKK*1e-3);
fzero->SetRange("mK",mK*1e-3,mK*1e-3);
fzero->FixValue("mK",mK*1e-3);
}
else
{
fzero->SetRange("mean",mfzero,mfzero);
fzero->FixValue("mean",mfzero);
fzero->SetRange("gpipi",gpipi,gpipi);
fzero->FixValue("gpipi",gpipi);
fzero->SetRange("mpi",mpi,mpi);
fzero->FixValue("mpi",mpi);
fzero->SetRange("gKK",gKK,gKK);
fzero->FixValue("gKK",gKK);
fzero->SetRange("mK",mK,mK);
fzero->FixValue("mK",mK);
}
}
/*phi(1020)*******************************************************************/
Component* phi;
if(convolve)
{
phi = massfitter->AddComponent("phi","RBW(X)Gauss",Nphi);
}
else
{
phi = massfitter->AddComponent("phi","Rel Breit-Wigner",Nphi);
}
phi->SetColour(kMagenta+1);
phi->SetStyle(9);
phi->FixValue("spin",1);
if(unit.find("GeV")!=string::npos)
{
phi->SetRange("mean",mphi*1e-3,mphi*1e-3);
phi->FixValue("mean",mphi*1e-3);
phi->SetRange("width",Gphi*1e-3,Gphi*1e-3);
phi->FixValue("width",Gphi*1e-3);
phi->SetRange("radius",BWBFradius*1e3,BWBFradius*1e3);
phi->FixValue("radius",BWBFradius*1e3);
phi->SetRange("mK",mK*1e-3,mK*1e-3);
phi->FixValue("mK",mK*1e-3);
if(convolve)
{
phi->SetRange("sigma1",mKKresolution_lo*1e-3,mKKresolution_hi*1e-3);
phi->FixValue("sigma1",mKKresolution_MC*1e-3);
}
}
else
{
phi->SetRange("mean",mphi,mphi);
phi->FixValue("mean",mphi);
phi->SetRange("width",Gphi,Gphi);
phi->FixValue("width",Gphi);
phi->SetRange("radius",BWBFradius,BWBFradius);
phi->FixValue("radius",BWBFradius);
phi->SetRange("mK",mK,mK);
phi->FixValue("mK",mK);
if(convolve)
{
phi->SetRange("sigma1",mKKresolution_lo,mKKresolution_hi);
phi->FixValue("sigma1",mKKresolution_MC);
}
}
/*f2'(1525)*******************************************************************/
Component* ftwop;
if(fitftwop)
{
ftwop = massfitter->AddComponent("ftwop","Rel Breit-Wigner",Nftwop);
ftwop->FixValue("spin",2);
ftwop->SetColour(kOrange+2);
ftwop->SetStyle(9);
if(unit.find("GeV")!=string::npos)
{
ftwop->SetRange("mean",mftwop*1e-3,mftwop*1e-3);
ftwop->FixValue("mean",mftwop*1e-3);
ftwop->SetRange("width",Gftwop*1e-3,Gftwop*1e-3);
ftwop->FixValue("width",Gftwop*1e-3);
ftwop->SetRange("radius",BWBFradius*1e3,BWBFradius*1e3);
ftwop->FixValue("radius",BWBFradius*1e3);
ftwop->SetRange("mK",mK*1e-3,mK*1e-3);
ftwop->FixValue("mK",mK*1e-3);
}
else
{
ftwop->SetRange("mean",mftwop,mftwop);
ftwop->FixValue("mean",mftwop);
ftwop->SetRange("width",Gftwop,Gftwop);
ftwop->FixValue("width",Gftwop);
ftwop->SetRange("radius",BWBFradius,BWBFradius);
ftwop->FixValue("radius",BWBFradius);
ftwop->SetRange("mK",mK,mK);
ftwop->FixValue("mK",mK);
}
}
/*Do the fit******************************************************************/
massfitter->Fit(data);
RooPlot* frame = m->frame();
cout << "Plotting" << endl;
data->plotOn(frame,(Binning(nbins)));
massfitter->Plot(frame);
plotmaker fullplot(frame);
RooHist* pullhist = frame->pullHist();
RooPlot* pullframe = m->frame(Title("Pull"));
pullframe->addPlotable(pullhist,"B");
fullplot.SetPullPlot(pullframe);
fullplot.SetTitle(xtitle, unit);
if(yup>0)
frame->SetMaximum(yup);
frame->SetMinimum(0);
TCanvas* can = fullplot.Draw();
stringstream ytitle;
ytitle << "#font[132]{}Candidates / (" << (xup-xlow)/nbins << " " << unit << ")";
frame->GetYaxis()->SetTitle(ytitle.str().c_str());
can->SaveAs((plotname+".pdf").c_str());
double xsplit = 1060;
double lowbinwidth = 1;
if(unit.find("GeV")!=string::npos)
{
xsplit*=1e-3;
lowbinwidth*=1e-3;
}
if((xup-xlow) > 2*(xsplit-xlow))
{
// Make low range bins a certain width
int nbins_lo = (xsplit-xlow)/lowbinwidth;
// Get the same bin width for the high range
int nbins_hi = nbins * (xup-xsplit)/(xup-xlow);
// Make the frames
RooPlot* frame_lo = m->frame(Range(xlow,xsplit),Bins(nbins_lo));
RooPlot* frame_hi = m->frame(Range(xsplit,xup),Bins(nbins_hi));
// Plot the data
data->plotOn(frame_lo);
data->plotOn(frame_hi);
// Plot the PDFs
massfitter->Plot(frame_lo);
massfitter->Plot(frame_hi);
// Set the y-axis ranges
frame_lo->SetMaximum(yup);
frame_lo->SetMinimum(0);
frame_hi->SetMinimum(0);
// Make the pull plots
RooHist* pullhist_lo = frame_lo->pullHist();
RooHist* pullhist_hi = frame_hi->pullHist();
RooPlot* pullframe_lo = m->frame(Title("Pull"),Range(xlow,xsplit));
RooPlot* pullframe_hi = m->frame(Title("Pull"),Range(xsplit,xup));
pullframe_lo->addPlotable(pullhist_lo,"B");
pullframe_hi->addPlotable(pullhist_hi,"B");
// Draw the low-mass plot
plotmaker lowplot(frame_lo);
lowplot.SetPullPlot(pullframe_lo);
lowplot.SetTitle(xtitle, unit);
can = lowplot.Draw();
stringstream ytitle_lo;
ytitle_lo << "#font[132]{}Candidates / (" << lowbinwidth << " " << unit << ")";
frame_lo->GetYaxis()->SetTitle(ytitle_lo.str().c_str());
can->SaveAs((plotname+"_low_range.pdf").c_str());
// Draw the high-mass plot
plotmaker highplot(frame_hi);
highplot.SetPullPlot(pullframe_hi);
highplot.SetTitle(xtitle, unit);
can = highplot.Draw();
frame_hi->GetYaxis()->SetTitle(ytitle.str().c_str());
can->SaveAs((plotname+"_high_range.pdf").c_str());
}
}
