void rf313_paramranges()
{
// C r e a t e 3 D p d f
// -------------------------
// Define observable (x,y,z)
RooRealVar x("x","x",0,10) ;
RooRealVar y("y","y",0,10) ;
RooRealVar z("z","z",0,10) ;
// Define 3 dimensional pdf
RooRealVar z0("z0","z0",-0.1,1) ;
RooPolynomial px("px","px",x,RooConst(0)) ;
RooPolynomial py("py","py",y,RooConst(0)) ;
RooPolynomial pz("pz","pz",z,z0) ;
RooProdPdf pxyz("pxyz","pxyz",RooArgSet(px,py,pz)) ;
// D e f i n e d n o n - r e c t a n g u l a r r e g i o n R i n ( x , y , z )
// -------------------------------------------------------------------------------------
//
// R = Z[0 - 0.1*Y^2] * Y[0.1*X - 0.9*X] * X[0 - 10]
//
// Construct range parameterized in "R" in y [ 0.1*x, 0.9*x ]
RooFormulaVar ylo("ylo","0.1*x",x) ;
RooFormulaVar yhi("yhi","0.9*x",x) ;
y.setRange("R",ylo,yhi) ;
// Construct parameterized ranged "R" in z [ 0, 0.1*y^2 ]
RooFormulaVar zlo("zlo","0.0*y",y) ;
RooFormulaVar zhi("zhi","0.1*y*y",y) ;
z.setRange("R",zlo,zhi) ;
// C a l c u l a t e i n t e g r a l o f n o r m a l i z e d p d f i n R
// ----------------------------------------------------------------------------------
// Create integral over normalized pdf model over x,y,z in "R" region
RooAbsReal* intPdf = pxyz.createIntegral(RooArgSet(x,y,z),RooArgSet(x,y,z),"R") ;
// Plot value of integral as function of pdf parameter z0
RooPlot* frame = z0.frame(Title("Integral of pxyz over x,y,z in region R")) ;
intPdf->plotOn(frame) ;
new TCanvas("rf313_paramranges","rf313_paramranges",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
return ;
}
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 rf105_funcbinding()
{
// B i n d T M a t h : : E r f C f u n c t i o n
// ---------------------------------------------------
// Bind one-dimensional TMath::Erf function as RooAbsReal function
RooRealVar x("x","x",-3,3) ;
RooAbsReal* errorFunc = bindFunction("erf",TMath::Erf,x) ;
// Print erf definition
errorFunc->Print() ;
// Plot erf on frame
RooPlot* frame1 = x.frame(Title("TMath::Erf bound as RooFit function")) ;
errorFunc->plotOn(frame1) ;
// B i n d R O O T : : M a t h : : b e t a _ p d f C f u n c t i o n
// -----------------------------------------------------------------------
// Bind pdf ROOT::Math::Beta with three variables as RooAbsPdf function
RooRealVar x2("x2","x2",0,0.999) ;
RooRealVar a("a","a",5,0,10) ;
RooRealVar b("b","b",2,0,10) ;
RooAbsPdf* beta = bindPdf("beta",ROOT::Math::beta_pdf,x2,a,b) ;
// Perf beta definition
beta->Print() ;
// Generate some events and fit
RooDataSet* data = beta->generate(x2,10000) ;
beta->fitTo(*data) ;
// Plot data and pdf on frame
RooPlot* frame2 = x2.frame(Title("ROOT::Math::Beta bound as RooFit pdf")) ;
data->plotOn(frame2) ;
beta->plotOn(frame2) ;
// B i n d R O O T T F 1 a s R o o F i t f u n c t i o n
// ---------------------------------------------------------------
// Create a ROOT TF1 function
TF1 *fa1 = new TF1("fa1","sin(x)/x",0,10);
// Create an observable
RooRealVar x3("x3","x3",0.01,20) ;
// Create binding of TF1 object to above observable
RooAbsReal* rfa1 = bindFunction(fa1,x3) ;
// Print rfa1 definition
rfa1->Print() ;
// Make plot frame in observable, plot TF1 binding function
RooPlot* frame3 = x3.frame(Title("TF1 bound as RooFit function")) ;
rfa1->plotOn(frame3) ;
TCanvas* c = new TCanvas("rf105_funcbinding","rf105_funcbinding",1200,400) ;
c->Divide(3) ;
c->cd(1) ; gPad->SetLeftMargin(0.15) ; frame1->GetYaxis()->SetTitleOffset(1.6) ; frame1->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; frame2->GetYaxis()->SetTitleOffset(1.6) ; frame2->Draw() ;
c->cd(3) ; gPad->SetLeftMargin(0.15) ; frame3->GetYaxis()->SetTitleOffset(1.6) ; frame3->Draw() ;
}
void LL(){
//y0 = 0.000135096401209 sigma_y0 = 0.000103896581837 x0 = 0.000446013873443 sigma_x0 =1.81384394011e-06
//0.014108652249 0.0168368471049 0.0219755396247 0.000120423865262 1.5575931164 1.55759310722 3.41637854038
//0.072569437325 0.084063541977 0.0376693978906 0.000284216132439 0.51908074913 0.519080758095 1.12037749267
// double d = 0.014108652249;
// double sd = 0.0168368471049;
// double mc = 0.0219755396247;
// double smc = 0.000120423865262;
// double r0 = d/mc;
double d = 0.072569437325;
double sd = 0.084063541977;
double mc = 0.0376693978906;
double smc = 0.00028421613243;
double r0 = d/mc;
RooRealVar x("x","x",mc*0.9,mc*1.1);
RooRealVar x0("x0","x0",mc);
RooRealVar sx("sx","sx",smc);
RooRealVar r("r","r",r0,0.,5.);
RooRealVar y0("y0","y0",d);
RooRealVar sy("sy","sy",sd);
RooProduct rx("rx","rx",RooArgList(r,x));
RooGaussian g1("g1","g1",x,x0,sx);
RooGaussian g2("g2","g2",rx,y0,sy);
RooProdPdf LL("LL","LL",g1,g2);
RooArgSet obs(x0,y0); //observables
RooArgSet poi(r); //parameters of interest
RooDataSet data("data", "data", obs);
data.add(obs); //actually add the data
RooFitResult* res = LL.fitTo(data,RooFit::Minos(poi),RooFit::Save(),RooFit::Hesse(false));
if(res->status()==0) {
r.Print();
x.Print();
cout << r.getErrorLo() << " " << r.getErrorHi() << endl;
} else {
cout << "Likelihood maximization failed" << endl;
}
RooAbsReal* nll = LL.createNLL(data);
RooPlot* frame = r.frame();
RooAbsReal* pll = nll->createProfile(poi);
pll->plotOn(frame);//,RooFit::LineColor(ROOT::kRed));
frame->Draw();
r.setVal(0.);
cout << pll->getVal() << endl;
return;
}
int DiagnosisMacro(int Nbins = 10, int Nsigma = 10, int CPUused = 1, TString Filename = "FIT_DATA_Psi2SJpsi_PPPrompt_Bkg_SecondOrderChebychev_pt65300_rap016_cent0200_262620_263757.root", TString Outputdir = "./")
//Nbins: Number of points for which to calculate profile likelihood. Time required is about (1/CPU) minutes per point per parameter. 0 means do plain likelihood only
//Nsigma: The range in which the scan is performed (value-Nsigma*sigma, value+Nsigma*sigma)
//CPUused: anything larger than 1 causes weird fit results on my laptop, runs fine on lxplus with more (16)
{
// R e a d w o r k s p a c e f r o m f i l e
// -----------------------------------------------
// Open input file with workspace
//Filename = "FIT_DATA_Psi2SJpsi_PP_Jpsi_DoubleCrystalBall_Psi2S_DoubleCrystalBall_Bkg_Chebychev2_pt6590_rap016_cent0200.root";
//Filename = "FIT_DATA_Psi2SJpsi_PbPb_Jpsi_DoubleCrystalBall_Psi2S_DoubleCrystalBall_Bkg_Chebychev1_pt6590_rap016_cent0200.root";
TFile *f = new TFile(Filename);
// Retrieve workspace from file
RooWorkspace* w = (RooWorkspace*)f->Get("workspace");
// Retrieve x,model and data from workspace
RooRealVar* x = w->var("invMass");
RooAbsPdf* model = w->pdf("simPdf_syst");
if (model == 0) {
model = w->pdf("simPdf");
}
if (model == 0) {
model = w->pdf("pdfMASS_Tot_PP");
}
if (model == 0) {
model = w->pdf("pdfMASS_Tot_PbPb");
}
if (model == 0) {
cout << "[ERROR] pdf failed to load from the workspace" << endl;
return false;
}
RooAbsData* data = w->data("dOS_DATA");
if (data == 0) {
data = w->data("dOS_DATA_PP");
}
if (data == 0) {
data = w->data("dOS_DATA_PbPb");
}
if (data == 0) {
cout << "[ERROR] data failed to load from the workspace" << endl;
return false;
}
// Print structure of composite p.d.f.
model->Print("t");
/*
// P l o t m o d e l
// ---------------------------------------------------------
// Plot data and PDF overlaid
RooPlot* xframe = x->frame(Title("J/psi Model and Data"));
data->plotOn(xframe);
model->plotOn(xframe);
// Draw the frame on the canvas
TCanvas* c2 = new TCanvas("PlotModel", "PlotModel", 1000, 1000);
gPad->SetLeftMargin(0.15);
xframe->GetYaxis()->SetTitleOffset(2.0);
xframe->Draw();//*/
///// Check parameters
RooArgSet* paramSet1 = model->getDependents(data);
paramSet1->Print("v"); // Just check
RooArgSet* paramSet2 = model->getParameters(data);
paramSet2->Print("v");
int Nparams = paramSet2->getSize();
cout << "Number of parameters: " << Nparams<<endl<<endl;
// C o n s t r u c t p l a i n l i k e l i h o o d
// ---------------------------------------------------
// Construct unbinned likelihood
RooAbsReal* nll = model->createNLL(*data, NumCPU(CPUused));
// Minimize likelihood w.r.t all parameters before making plots
RooMinuit(*nll).migrad();
//////////////////////////////////////////////////////
/////////////////// L O O P O V E R P A R A M E T E R S
/////////////////////////////////////////////////////
/// Set up loop over parameters
TString ParamName;
double ParamValue;
double ParamError;
double ParamLimitLow;
double ParamLimitHigh;
double FitRangeLow;
double FitRangeHigh;
RooRealVar* vParam;
int counter = 0;
// Loop start
TIterator* iter = paramSet2->createIterator();
TObject* var = iter->Next();
while (var != 0) {
counter++;
ParamName = var->GetName();
vParam = w->var(ParamName);
ParamValue = vParam->getVal();
ParamError = vParam->getError();
ParamLimitLow = vParam->getMin();
ParamLimitHigh = vParam->getMax();
cout << ParamName << " has value " << ParamValue << " with error: " << ParamError << " and limits: " << ParamLimitLow << " to " << ParamLimitHigh << endl << endl;
if (ParamError == 0) { //Skipping fixed parameters
cout << "Parameter was fixed, skipping its fitting" << endl;
cout << endl << "DONE WITH " << counter << " PARAMETER OUT OF " << Nparams << endl << endl;
var = iter->Next();
continue;
}
// determining fit range: Nsigma sigma on each side unless it would be outside of parameter limits
if ((ParamValue - Nsigma * ParamError) > ParamLimitLow) {
FitRangeLow = (ParamValue - Nsigma * ParamError);
}
else {
FitRangeLow = ParamLimitLow;
}
if ((ParamValue + Nsigma * ParamError) < ParamLimitHigh) {
FitRangeHigh = (ParamValue + Nsigma * ParamError);
}
else {
FitRangeHigh = ParamLimitHigh;
}
// P l o t p l a i n l i k e l i h o o d a n d C o n s t r u c t p r o f i l e l i k e l i h o o d
// ---------------------------------------------------
RooPlot* frame1;
RooAbsReal* pll=NULL;
if (Nbins != 0) {
frame1 = vParam->frame(Bins(Nbins), Range(FitRangeLow, FitRangeHigh), Title(TString::Format("LL and profileLL in %s", ParamName.Data())));
nll->plotOn(frame1, ShiftToZero());
pll = nll->createProfile(*vParam);
// Plot the profile likelihood
pll->plotOn(frame1, LineColor(kRed), RooFit::Precision(-1));
}
else { //Skip profile likelihood
frame1 = vParam->frame(Bins(10), Range(FitRangeLow, FitRangeHigh), Title(TString::Format("LL and profileLL in %s", ParamName.Data())));
nll->plotOn(frame1, ShiftToZero());
}
// D r a w a n d s a v e p l o t s
// -----------------------------------------------------------------------
// Adjust frame maximum for visual clarity
frame1->SetMinimum(0);
frame1->SetMaximum(20);
TCanvas* c = new TCanvas("CLikelihoodResult", "CLikelihoodResult", 800, 600);
c->cd(1);
gPad->SetLeftMargin(0.15);
frame1->GetYaxis()->SetTitleOffset(1.4);
frame1->Draw();
TLegend* leg = new TLegend(0.70, 0.70, 0.95, 0.88, "");
leg->SetFillColor(kWhite);
leg->SetBorderSize(0);
leg->SetTextSize(0.035);
TLegendEntry *le1 = leg->AddEntry(nll, "Plain likelihood", "l");
le1->SetLineColor(kBlue);
le1->SetLineWidth(3);
TLegendEntry *le2 = leg->AddEntry(pll, "Profile likelihood", "l");
le2->SetLineColor(kRed);
le2->SetLineWidth(3);
leg->Draw("same");
//Save plot
TString StrippedName = TString(Filename(Filename.Last('/')+1,Filename.Length()));
StrippedName = StrippedName.ReplaceAll(".root","");
cout << StrippedName << endl;
gSystem->mkdir(Form("%s/root/%s", Outputdir.Data(), StrippedName.Data()), kTRUE);
c->SaveAs(Form("%s/root/%s/Likelihood_scan_%s.root", Outputdir.Data(), StrippedName.Data(), ParamName.Data()));
gSystem->mkdir(Form("%s/pdf/%s", Outputdir.Data(), StrippedName.Data()), kTRUE);
c->SaveAs(Form("%s/pdf/%s/Likelihood_scan_%s.pdf", Outputdir.Data(), StrippedName.Data(), ParamName.Data()));
gSystem->mkdir(Form("%s/png/%s", Outputdir.Data(), StrippedName.Data()), kTRUE);
c->SaveAs(Form("%s/png/%s/Likelihood_scan_%s.png", Outputdir.Data(), StrippedName.Data(), ParamName.Data()));
delete c;
delete frame1;
if (pll) delete pll;
cout << endl << "DONE WITH " << counter << " PARAMETER OUT OF " << Nparams << endl << endl;
//if (counter == 2){ break; } //Exit - for testing
var = iter->Next();
} // End of the loop
return true;
}
RooWorkspace* makeInvertedANFit(TTree* tree, float forceSigma=-1, bool constrainMu=false, float forceMu=-1) {
RooWorkspace *ws = new RooWorkspace("ws","");
std::vector< TString (*)(TString, RooRealVar&, RooWorkspace&) > bkgPdfList;
bkgPdfList.push_back(makeSingleExp);
bkgPdfList.push_back(makeDoubleExp);
#if DEBUG==0
//bkgPdfList.push_back(makeTripleExp);
bkgPdfList.push_back(makeModExp);
bkgPdfList.push_back(makeSinglePow);
bkgPdfList.push_back(makeDoublePow);
bkgPdfList.push_back(makePoly2);
bkgPdfList.push_back(makePoly3);
#endif
RooRealVar mgg("mgg","m_{#gamma#gamma}",103,160,"GeV");
mgg.setBins(38);
mgg.setRange("sideband_low", 103,120);
mgg.setRange("sideband_high",131,160);
mgg.setRange("signal",120,131);
RooRealVar MR("MR","",0,3000,"GeV");
MR.setBins(60);
RooRealVar Rsq("t1Rsq","",0,1,"GeV");
Rsq.setBins(20);
RooRealVar hem1_M("hem1_M","",-1,2000,"GeV");
hem1_M.setBins(40);
RooRealVar hem2_M("hem2_M","",-1,2000,"GeV");
hem2_M.setBins(40);
RooRealVar ptgg("ptgg","p_{T}^{#gamma#gamma}",0,500,"GeV");
ptgg.setBins(50);
RooDataSet data("data","",tree,RooArgSet(mgg,MR,Rsq,hem1_M,hem2_M,ptgg));
RooDataSet* blind_data = (RooDataSet*)data.reduce("mgg<121 || mgg>130");
std::vector<TString> tags;
//fit many different background models
for(auto func = bkgPdfList.begin(); func != bkgPdfList.end(); func++) {
TString tag = (*func)("bonly",mgg,*ws);
tags.push_back(tag);
ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
RooFitResult* bres = ws->pdf("bonly_"+tag+"_ext")->fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
bres->SetName(tag+"_bonly_fitres");
ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame();
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
ws->pdf("bonly_"+tag+"_ext")->plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName(tag+"_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
//set all the parameters constant
RooArgSet* vars = ws->pdf("bonly_"+tag)->getVariables();
RooFIter iter = vars->fwdIterator();
RooAbsArg* a;
while( (a = iter.next()) ){
if(string(a->GetName()).compare("mgg")==0) continue;
static_cast<RooRealVar*>(a)->setConstant(kTRUE);
}
//make the background portion of the s+b fit
(*func)("b",mgg,*ws);
RooRealVar sigma(tag+"_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu(tag+"_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig(tag+"_sig_model","",mgg,mu,sigma);
RooRealVar Nsig(tag+"_sb_Ns","",5,0,100);
RooRealVar Nbkg(tag+"_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel(tag+"_sb_model","",RooArgList( *ws->pdf("b_"+tag), sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal* nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
sbres->SetName(tag+"_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_"+tag+"_ext")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName(tag+"_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName(tag+"_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName(tag+"_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
}
RooArgSet weights("weights");
RooArgSet pdfs_bonly("pdfs_bonly");
RooArgSet pdfs_b("pdfs_b");
RooRealVar minAIC("minAIC","",1E10);
//compute AIC stuff
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooAbsPdf *p_bonly = ws->pdf("bonly_"+*t);
RooAbsPdf *p_b = ws->pdf("b_"+*t);
RooFitResult *sb = (RooFitResult*)ws->obj(*t+"_bonly_fitres");
RooRealVar k(*t+"_b_k","",p_bonly->getParameters(RooArgSet(mgg))->getSize());
RooRealVar nll(*t+"_b_minNll","",sb->minNll());
RooRealVar Npts(*t+"_b_N","",blind_data->sumEntries());
RooFormulaVar AIC(*t+"_b_AIC","2*@0+2*@1+2*@1*(@1+1)/(@2-@1-1)",RooArgSet(nll,k,Npts));
ws->import(AIC);
if(AIC.getVal() < minAIC.getVal()) {
minAIC.setVal(AIC.getVal());
}
//aicExpSum+=TMath::Exp(-0.5*AIC.getVal()); //we will need this precomputed for the next step
pdfs_bonly.add(*p_bonly);
pdfs_b.add(*p_b);
}
ws->import(minAIC);
//compute the AIC weight
float aicExpSum=0;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
aicExpSum+=TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal())); //we will need this precomputed for the next step
}
std::cout << "aicExpSum: " << aicExpSum << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = new RooRealVar(*t+"_b_AICWeight","",TMath::Exp(-0.5*(AIC->getVal()-minAIC.getVal()))/aicExpSum);
if( TMath::IsNaN(AICw->getVal()) ) {AICw->setVal(0);}
ws->import(*AICw);
std::cout << *t << ": " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
weights.add(*AICw);
}
RooAddPdf bonly_AIC("bonly_AIC","",pdfs_bonly,weights);
RooAddPdf b_AIC("b_AIC","",pdfs_b,weights);
//b_AIC.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//RooFitResult* bres = b_AIC.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::Range("sideband_low,sideband_high"));
//bres->SetName("AIC_b_fitres");
//ws->import(*bres);
//make blinded fit
RooPlot *fmgg_b = mgg.frame(RooFit::Range("sideband_low,sideband_high"));
blind_data->plotOn(fmgg_b,RooFit::Range("sideband_low,sideband_high"));
TBox blindBox(121,fmgg_b->GetMinimum()-(fmgg_b->GetMaximum()-fmgg_b->GetMinimum())*0.015,130,fmgg_b->GetMaximum());
blindBox.SetFillColor(kGray);
fmgg_b->addObject(&blindBox);
bonly_AIC.plotOn(fmgg_b,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("sideband_low,sideband_high"));
fmgg_b->SetName("AIC_blinded_frame");
ws->import(*fmgg_b);
delete fmgg_b;
#if 1
RooRealVar sigma("AIC_s_sigma","",5,0,100);
if(forceSigma!=-1) {
sigma.setVal(forceSigma);
sigma.setConstant(true);
}
RooRealVar mu("AIC_s_mu","",126,120,132);
if(forceMu!=-1) {
mu.setVal(forceMu);
mu.setConstant(true);
}
RooGaussian sig("AIC_sig_model","",mgg,mu,sigma);
RooRealVar Nsig("AIC_sb_Ns","",5,0,100);
RooRealVar Nbkg("AIC_sb_Nb","",100,0,100000);
RooRealVar HiggsMass("HiggsMass","",125.1);
RooRealVar HiggsMassError("HiggsMassError","",0.24);
RooGaussian HiggsMassConstraint("HiggsMassConstraint","",mu,HiggsMass,HiggsMassError);
RooAddPdf fitModel("AIC_sb_model","",RooArgList( b_AIC, sig ),RooArgList(Nbkg,Nsig));
RooFitResult* sbres;
RooAbsReal *nll;
if(constrainMu) {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE),RooFit::ExternalConstraints(RooArgSet(HiggsMassConstraint)));
} else {
fitModel.fitTo(data,RooFit::Strategy(0),RooFit::Extended(kTRUE));
sbres = fitModel.fitTo(data,RooFit::Strategy(2),RooFit::Save(kTRUE),RooFit::Extended(kTRUE));
nll = fitModel.createNLL(data,RooFit::NumCPU(4),RooFit::Extended(kTRUE));
}
assert(nll!=0);
sbres->SetName("AIC_sb_fitres");
ws->import(*sbres);
ws->import(fitModel);
RooPlot *fmgg = mgg.frame();
data.plotOn(fmgg);
fitModel.plotOn(fmgg);
ws->pdf("b_AIC")->plotOn(fmgg,RooFit::LineColor(kRed),RooFit::Range("Full"),RooFit::NormRange("Full"));
fmgg->SetName("AIC_frame");
ws->import(*fmgg);
delete fmgg;
RooMinuit(*nll).migrad();
RooPlot *fNs = Nsig.frame(0,25);
fNs->SetName("AIC_Nsig_pll");
RooAbsReal *pll = nll->createProfile(Nsig);
//nll->plotOn(fNs,RooFit::ShiftToZero(),RooFit::LineColor(kRed));
pll->plotOn(fNs);
ws->import(*fNs);
delete fNs;
RooPlot *fmu = mu.frame(125,132);
fmu->SetName("AIC_mu_pll");
RooAbsReal *pll_mu = nll->createProfile(mu);
pll_mu->plotOn(fmu);
ws->import(*fmu);
delete fmu;
std::cout << "min AIC: " << minAIC.getVal() << std::endl;
for(auto t = tags.begin(); t!=tags.end(); t++) {
RooFormulaVar *AIC = (RooFormulaVar*)ws->obj(*t+"_b_AIC");
RooRealVar *AICw = ws->var(*t+"_b_AICWeight");
RooRealVar* k = ws->var(*t+"_b_k");
printf("%s & %0.0f & %0.2f & %0.2f \\\\\n",t->Data(),k->getVal(),AIC->getVal()-minAIC.getVal(),AICw->getVal());
//std::cout << k->getVal() << " " << AIC->getVal()-minAIC.getVal() << " " << AICw->getVal() << std::endl;
}
#endif
return ws;
}
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);
}
int main() {
const double PDGLbMass=5619.51;
const double RareUpperBlind=PDGLbMass+125.0;
const double RareLowerBlind=PDGLbMass-125.0;
const double Rare2UpperBlind=PDGLbMass+175.0;
const double Rare2LowerBlind=PDGLbMass-175.0;
bool blind=true;
bool remakecc=false;
bool remakerare=false;
bool remakerare2=false;
bool sweight=false;
TRandom3* MultiCandRand=new TRandom3(224); //dont change seed
TH1I* ControlChannelMultiCands= new TH1I("ControlChannelMultiCands","ControlChannelMultiCands",10,0,10);
TH1I* RareChannelMultiCands= new TH1I("RareChannelMultiCands","RareChannelMultiCands",10,0,10);
TH1I* Rare2ChannelMultiCands= new TH1I("RareChannel2MultiCands","RareChannel2MultiCands",10,0,10);
//_______________________________________ MAKE CONTROL CHANNEL ROODATASET______________________________________
if(remakecc) {
std::string ControlDataPath=std::getenv("BUKETAPDATABDTRESPROOT");
DataFile CC12A(ControlDataPath,Data,Twel,MagAll,buketap,"BDTApplied_SampleA");
DataFile CC12B(ControlDataPath,Data,Twel,MagAll,buketap,"BDTApplied_SampleB");
DataFile CC11A(ControlDataPath,Data,Elev,MagAll,buketap,"BDTApplied_SampleA");
DataFile CC11B(ControlDataPath,Data,Elev,MagAll,buketap,"BDTApplied_SampleB");
TreeReader* CC12Reader= new TreeReader("DecayTree");
CC12Reader->AddFile(CC12A);
CC12Reader->AddFile(CC12B);
CC12Reader->Initialize(ControlCuts::BranchesToKeep,"contains");
TFile* Minimal12File= new TFile("MinimalCC12.root","RECREATE");
TTree* Minimal12Tree=CC12Reader->CopyTree(ControlCuts::AllCuts12,-1,"DecayTree");
TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,ControlChannelMultiCands,NULL);
MinimalFlagged12Tree->Write();
Minimal12File->Close();
TreeReader* CC11Reader= new TreeReader("DecayTree");
CC11Reader->AddFile(CC11A);
CC11Reader->AddFile(CC11B);
CC11Reader->Initialize(ControlCuts::BranchesToKeep,"contains");
TFile* Minimal11File= new TFile("MinimalCC11.root","RECREATE");
TTree* Minimal11Tree=CC11Reader->CopyTree(ControlCuts::AllCuts11,-1,"DecayTree");
TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,ControlChannelMultiCands,NULL);
MinimalFlagged11Tree->Write();
Minimal11File->Close();
TreeReader* FlaggedReader= new TreeReader("DecayTree");
FlaggedReader->AddFile("MinimalCC12.root");
FlaggedReader->AddFile("MinimalCC11.root");
FlaggedReader->Initialize();
TFile* CCSingleFile= new TFile("CCSingleFile.root","RECREATE");
TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree");
SingleTree->Write();
CCSingleFile->Close();
}
//_____________________________________Make Rare Mode One Data__________________________________________________
if(remakerare) {
std::string RareDataPath=std::getenv("LBPKETAPPIPIGDATABDTRESPROOT");
DataFile Rare12A(RareDataPath,Data,Twel,MagAll,lbpketappipig,"BDTApplied_SampleA_NB");
DataFile Rare12B(RareDataPath,Data,Twel,MagAll,lbpketappipig,"BDTApplied_SampleB_NB");
DataFile Rare11A(RareDataPath,Data,Elev,MagAll,lbpketappipig,"BDTApplied_SampleA_NB");
DataFile Rare11B(RareDataPath,Data,Elev,MagAll,lbpketappipig,"BDTApplied_SampleB_NB");
TreeReader* Rare12Reader= new TreeReader("DecayTree");
Rare12Reader->AddFile(Rare12A);
Rare12Reader->AddFile(Rare12B);
Rare12Reader->Initialize(pipigCuts::BranchesToKeep,"contains");
TFile* Minimal12File= new TFile("MinimalRare12.root","RECREATE");
TTree* Minimal12Tree=Rare12Reader->CopyTree(pipigCuts::AllCuts12,-1,"DecayTree");
TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,RareChannelMultiCands,NULL);
MinimalFlagged12Tree->Write();
Minimal12File->Close();
TreeReader* Rare11Reader= new TreeReader("DecayTree");
Rare11Reader->AddFile(Rare11A);
Rare11Reader->AddFile(Rare11B);
Rare11Reader->Initialize(pipigCuts::BranchesToKeep,"contains");
TFile* Minimal11File= new TFile("MinimalRare11.root","RECREATE");
TTree* Minimal11Tree=Rare11Reader->CopyTree(pipigCuts::AllCuts11,-1,"DecayTree");
TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,RareChannelMultiCands,NULL);
MinimalFlagged11Tree->Write();
Minimal11File->Close();
TreeReader* FlaggedReader= new TreeReader("DecayTree");
FlaggedReader->AddFile("MinimalRare12.root");
FlaggedReader->AddFile("MinimalRare11.root");
FlaggedReader->Initialize();
TFile* RareSingleFile= new TFile("RareSingleFile.root","RECREATE");
TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree");
SingleTree->Write();
RareSingleFile->Close();
}
//___________________________________ Make Rare mode Two Data________________________________________________
if(remakerare2) {
std::string Rare2DataPath=std::getenv("LBPKETAPETADATABDTRESPROOT");
DataFile Rare212A(Rare2DataPath,Data,Twel,MagAll,lbpketapeta,"BDTApplied_SampleA_NB");
DataFile Rare212B(Rare2DataPath,Data,Twel,MagAll,lbpketapeta,"BDTApplied_SampleB_NB");
DataFile Rare211A(Rare2DataPath,Data,Elev,MagAll,lbpketapeta,"BDTApplied_SampleA_NB");
DataFile Rare211B(Rare2DataPath,Data,Elev,MagAll,lbpketapeta,"BDTApplied_SampleB_NB");
TreeReader* Rare212Reader= new TreeReader("DecayTree");
Rare212Reader->AddFile(Rare212A);
Rare212Reader->AddFile(Rare212B);
Rare212Reader->Initialize(etapetaCuts::BranchesToKeep,"contains");
TFile* Minimal12File= new TFile("MinimalRare212.root","RECREATE");
TTree* Minimal12Tree=Rare212Reader->CopyTree(etapetaCuts::AllCuts12,-1,"DecayTree");
TTree* MinimalFlagged12Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal12Tree,Rare2ChannelMultiCands,NULL);
MinimalFlagged12Tree->Write();
Minimal12File->Close();
TreeReader* Rare211Reader= new TreeReader("DecayTree");
Rare211Reader->AddFile(Rare211A);
Rare211Reader->AddFile(Rare211B);
Rare211Reader->Initialize(etapetaCuts::BranchesToKeep,"contains");
TFile* Minimal11File= new TFile("MinimalRare211.root","RECREATE");
TTree* Minimal11Tree=Rare211Reader->CopyTree(etapetaCuts::AllCuts11,-1,"DecayTree");
TTree* MinimalFlagged11Tree=HandyFunctions::GetSingleTree(MultiCandRand,Minimal11Tree,Rare2ChannelMultiCands,NULL);
MinimalFlagged11Tree->Write();
Minimal11File->Close();
TreeReader* FlaggedReader= new TreeReader("DecayTree");
FlaggedReader->AddFile("MinimalRare212.root");
FlaggedReader->AddFile("MinimalRare211.root");
FlaggedReader->Initialize();
TFile* Rare2SingleFile= new TFile("Rare2SingleFile.root","RECREATE");
TTree* SingleTree=FlaggedReader->CopyTree("isSingle==1",-1,"DecayTree");
SingleTree->Write();
Rare2SingleFile->Close();
}
//____________________________________ Shared Parameters_______________________________________________________
RooRealVar DataMCRatio("DataMCRatio","DataMCRatio",1.0,0.5,1.5);
RooRealVar CCMean("CCMean","CCMean",5279.0,5250.0,5310.0);
RooFormulaVar LambdabMean("LambdabMean","LambdabMean","@0+339.72",RooArgList(CCMean));
//RooRealVar LambdabMean("LambdabMean","LambdabMean",5619.0,5615.0,5630.0);
// RooFormulaVar CCMean("CCMean","CCMean","@0 - 339.72",RooArgList(LambdabMean));
std::vector<RooRealVar*> FreeParameters;
FreeParameters.push_back(&DataMCRatio);
// FreeParameters.push_back(&LambdabMean);
//____________________________________ Control Channel PDF______________________________________________________
TFile* CCInputFile = new TFile("CCSingleFile.root");
TTree* CCInputTree=(TTree*)CCInputFile->Get("DecayTree");
RooRealVar CCBMass("Bu_DTF_MF","Bu_DTF_MF",5000.0,5550.0);
RooRealVar CCEtaMass("eta_prime_MM","eta_prime_MM",880.0,1040.0);
RooArgSet CCArgs(CCBMass,CCEtaMass);
RooDataSet* CCData=new RooDataSet("CCData","CCData",CCArgs,Import(*CCInputTree));
//++++++++++++++++++++++++++++++Signal PDF+++++++++++++++++++++++++++++++++
TFile *CCMCFitResultFile = new TFile("CCFitResult.root");
RooFitResult* CCMCFitResult=NULL;
try {
CCMCFitResult=SafeGetFitResult(CCMCFitResultFile,"CCFitResult");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
CCMCFitResult->Print("v");
RooRealVar* CCMCSigma=NULL;
RooRealVar* CCMCLAlphaFix=NULL;
RooRealVar* CCMCRAlphaFix=NULL;
RooRealVar* CCMCLNFix=NULL;
RooRealVar* CCMCRNFix=NULL;
try {
CCMCSigma=SafeGetVar(CCMCFitResult,"CCSigma");
CCMCLAlphaFix=SafeGetVar(CCMCFitResult,"CCLAlpha");
CCMCRAlphaFix=SafeGetVar(CCMCFitResult,"CCRAlpha");
CCMCLNFix=SafeGetVar(CCMCFitResult,"CCLN");
CCMCRNFix=SafeGetVar(CCMCFitResult,"CCRN");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar CCMCSigmaFix("CCMCSigmaFix","CCMCSigmaFix",CCMCSigma->getVal());
CCMCSigmaFix.setConstant(kTRUE);
RooFormulaVar CCSigma("CCSigma","CCSigma","@0*@1",RooArgList(DataMCRatio,CCMCSigmaFix));
RooRealVar CCLAlpha("CCLAlpha","CCLAlpha",CCMCLAlphaFix->getVal());
RooRealVar CCRAlpha("CCRAlpha","CCRAlpha",CCMCRAlphaFix->getVal());
RooRealVar CCLN("CCLN","CCLN",CCMCLNFix->getVal());
RooRealVar CCRN("CCRN","CCRN",CCMCRNFix->getVal());
RooCBShape CCDCBLeft("CCDCBLeft","CCDCBLeft",CCBMass,CCMean,CCSigma,CCLAlpha,CCLN);
RooCBShape CCDCBRight("CCDCBRight","CCDCBRight",CCBMass,CCMean,CCSigma,CCRAlpha,CCRN);
RooRealVar CCFitFraction("CCFitFraction","CCFitFraction",0.5,0.0,1.0);
FreeParameters.push_back(&CCFitFraction);
RooAddPdf CCDCB("CCDCB","CCDCB",RooArgList(CCDCBRight,CCDCBLeft),CCFitFraction);
RooRealVar CCEtamean("CCEtamean","CCEtamean",958.0,955.0,960.0);
RooRealVar CCEtasigma("CCEtasigma","CCEtasigma",9.16,9.0,15.0);
RooRealVar* CCMCEtaLAlpha=NULL;
RooRealVar* CCMCEtaRAlpha=NULL;
RooRealVar* CCMCEtaLN=NULL;
RooRealVar* CCMCEtaRN=NULL;
try {
CCMCEtaLAlpha=SafeGetVar(CCMCFitResult,"CCEtaLAlpha");
CCMCEtaRAlpha=SafeGetVar(CCMCFitResult,"CCEtaRAlpha");
CCMCEtaLN=SafeGetVar(CCMCFitResult,"CCEtaLN");
CCMCEtaRN=SafeGetVar(CCMCFitResult,"CCEtaRN");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar CCEtaLAlpha("CCEtaLAlpha","CCEtaLAlpha",CCMCEtaLAlpha->getVal());
RooRealVar CCEtaRAlpha("CCEtaRAlpha","CCEtaRAlpha",CCMCEtaRAlpha->getVal());
RooRealVar CCEtaLN("CCEtaLN","CCEtaLN",CCMCEtaLN->getVal());
RooRealVar CCEtaRN("CCEtaRN","CCEtaRN",CCMCEtaRN->getVal());
RooCBShape CCEtaDCBLeft("CCEtaCBLeft","CCEtaCBLeft",CCEtaMass,CCEtamean,CCEtasigma,CCEtaLAlpha,CCEtaLN);
RooCBShape CCEtaDCBRight("CCEtaCBRight","CCEtaCBRight",CCEtaMass,CCEtamean,CCEtasigma,CCEtaRAlpha,CCEtaRN);
RooRealVar CCEtaFitFraction("CCEtaFitFraction","CCEtaFitFraction",0.22,0.1,1.0);
FreeParameters.push_back(&CCEtaFitFraction);
RooAddPdf CCEtaDCB("CCEteaDCB","CCEtaDCB",RooArgList(CCEtaDCBRight,CCEtaDCBLeft),CCEtaFitFraction);
RooProdPdf CCSignalPdf("CCSignalPdf","CCSignalPdf",RooArgSet(CCEtaDCB,CCDCB));
RooRealVar CCSignalYield("CCSignalYield","CCSignalYield",10000.0,1000.0,20000.0);
RooExtendPdf CCExtendedSignalPdf("CCExtendedSignalPdf","CCExtendedSignalPdf",CCSignalPdf,CCSignalYield);
//+++++++++++++++++++++++++++++++++ COMB NO ETAP PDF++++++++++++++++++++++++++++++++++++++++
RooRealVar CCNoEtaBSlope("CCNoEtaBSlope","CCNoEtaBSlope",-0.6,-0.8,-0.4);
FreeParameters.push_back(&CCNoEtaBSlope);
RooRealVar CCNoEtaBCurve("CCNoEtaBCurve","CCNoEtaBCurve",-0.1,-0.30,-0.05);
FreeParameters.push_back(&CCNoEtaBCurve);
RooChebychev CCNoEtaBLine("CCNoEtaBLine","CCNoEtaBLine",CCBMass,RooArgList(CCNoEtaBSlope,CCNoEtaBCurve));
RooRealVar CCNoEtaEtaP1("CCNoEtaEtaP1","CCNoEtaEtaP1",-0.1,-1.0,0.0);
FreeParameters.push_back(&CCNoEtaEtaP1);
RooRealVar CCNoEtaEtaP2("CCNoEtaEtaP2","CCNoEtaEtaP2",-0.1,-0.8,0.0);
FreeParameters.push_back(&CCNoEtaEtaP2);
RooChebychev CCNoEtaQuad("CCNoEtaQuad","CCNoEtaQuad",CCEtaMass,RooArgList(CCNoEtaEtaP1,CCNoEtaEtaP2));
RooProdPdf CCNoEtaBkgPdf("CCNoEtaBkgPdf","CCNoEtaBkgPdf",RooArgSet(CCNoEtaQuad,CCNoEtaBLine));
RooRealVar CCNoEtaBkgYield("CCNoEtaBkgYield","CCNoEtaBkgYield",2400.0,500.0,15000.0);
RooExtendPdf ExtCCNoEtaBkgPdf("ExtCCNoEtaBkgPdf","ExtCCNoEtaBkgPdf",CCNoEtaBkgPdf,CCNoEtaBkgYield);
//++++++++++++++++++++++++++++++++++ COMB TRUE ETAP PDF++++++++++++++++++++++++++++++++++
RooRealVar CCTrueEtaBSlope("CCTrueEtaBSlope","CCTrueEtaBSlope",-0.1,-1.0,0.0);
FreeParameters.push_back(&CCTrueEtaBSlope);
RooChebychev CCTrueEtaBLine("CCTrueEtaBLine","CCTrueEtaBLine",CCBMass,RooArgList(CCTrueEtaBSlope));
RooRealVar CCTrueEtaEtaLAlpha("CCTrueEtaEtaLAlpha","CCTrueEtaEtaLAlpha",CCMCEtaLAlpha->getVal());
RooRealVar CCTrueEtaEtaRAlpha("CCTrueEtaEtaRAlpha","CCTrueEtaEtaRAlpha",CCMCEtaRAlpha->getVal());
RooRealVar CCTrueEtaEtaLN("CCTrueEtaEtaLN","CCTrueEtaEtaLN",CCMCEtaLN->getVal());
RooRealVar CCTrueEtaEtaRN("CCTrueEtaEtaRN","CCTrueEtaEtaRN",CCMCEtaRN->getVal());
//RooCBShape CCTrueEtaEtaCBLeft("CCTrueEtaEtaCBLeft","CCTrueEtaEtaCBLeft",CCEtaMass,CCEtamean,CCEtasigma,CCTrueEtaEtaLAlpha,CCTrueEtaEtaLN);
RooCBShape CCTrueEtaEtaCBRight("CCTrueEtaEtaCBRight","CCTrueEtaEtaCBRight",CCEtaMass,CCEtamean,CCEtasigma,CCTrueEtaEtaRAlpha,CCTrueEtaEtaRN);
// RooRealVar CCTrueEtaEtaFitFraction("CCTrueEtaEtaFitFraction","CCTrueEtaEtaFitFraction",0.4,0.0,1.0);
//RooAddPdf CCTrueEtaEtaDCB("CCTrueEtaEtaDCB","CCTrueEtaEtaDCB",RooArgList(CCTrueEtaEtaCBRight,CCTrueEtaEtaCBLeft),CCTrueEtaEtaFitFraction);
RooProdPdf CCTrueEtaEtaBkgPdf("CCTrueEtaEtaBkgPdf","CCTrueEtaEtaBkgPdf",RooArgSet(CCTrueEtaEtaCBRight,CCTrueEtaBLine));
RooRealVar CCTrueEtaBkgYield("CCTrueEtaBkgYield","CCTrueEtaBkgYield",800.0,20.0,10000.0);
RooExtendPdf ExtCCTrueEtaBkgPdf("ExtCCTrueEtaBkgPdf","ExtCCTrueEtaBkgPdf",CCTrueEtaEtaBkgPdf,CCTrueEtaBkgYield);
RooAddPdf CCTotalPdf("CCTotalPdf","CCTotalPdf",RooArgList(ExtCCTrueEtaBkgPdf,ExtCCNoEtaBkgPdf,CCExtendedSignalPdf));
//_________________________________Rare1 Fit_____________________________
TFile * RareInputFile = new TFile("RareSingleFile.root");
TTree* RareInputTree=NULL;
try {
RareInputTree=SafeGetTree(RareInputFile,"DecayTree");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar LbMass("Lambda_b0_DTF_MF","Lambda_b0_DTF_MF",5200.0,6000.0);
RooRealVar RareLambda_b0_PE("Lambda_b0_PE","Lambda_b0_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareLambda_b0_PX("Lambda_b0_PX","Lambda_b0_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareLambda_b0_PY("Lambda_b0_PY","Lambda_b0_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareLambda_b0_PZ("Lambda_b0_PZ","Lambda_b0_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareProton_PE("Proton_PE","Proton_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareProton_PX("Proton_PX","Proton_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareProton_PY("Proton_PY","Proton_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareProton_PZ("Proton_PZ","Proton_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareKaon_PE("Kaon_PE","Kaon_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareKaon_PX("Kaon_PX","Kaon_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareKaon_PY("Kaon_PY","Kaon_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar RareKaon_PZ("Kaon_PZ","Kaon_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rareeta_prime_PE("eta_prime_PE","eta_prime_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rareeta_prime_PX("eta_prime_PX","eta_prime_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rareeta_prime_PY("eta_prime_PY","eta_prime_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rareeta_prime_PZ("eta_prime_PZ","eta_prime_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooArgSet RareArgs(LbMass,RareLambda_b0_PE,RareLambda_b0_PX,RareLambda_b0_PY,RareLambda_b0_PZ,RareProton_PE,RareProton_PX,RareProton_PY,RareProton_PZ);
RareArgs.add(RareKaon_PE);
RareArgs.add(RareKaon_PX);
RareArgs.add(RareKaon_PY);
RareArgs.add(RareKaon_PZ);
RareArgs.add(Rareeta_prime_PE);
RareArgs.add(Rareeta_prime_PX);
RareArgs.add(Rareeta_prime_PY);
RareArgs.add(Rareeta_prime_PZ);
RooDataSet* RareData= new RooDataSet("RareData","RareData",RareArgs,Import(*RareInputTree));
TFile * RareFitResultFile = new TFile("RareFitResult.root");
RooFitResult* RareMCFitResult=NULL;
try {
RareMCFitResult=SafeGetFitResult(RareFitResultFile,"RareFitResult");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RareMCFitResult->Print("v");
RooRealVar* RareMCRAlpha=NULL;
RooRealVar* RareMCFitFraction=NULL;
RooRealVar* RareMCLAlpha=NULL;
RooRealVar* RareMCLN=NULL;
RooRealVar* RareMCRN=NULL;
RooRealVar* RareMCSigma=NULL;
try {
RareMCRAlpha=SafeGetVar(RareMCFitResult,"RareAlpha");
RareMCFitFraction=SafeGetVar(RareMCFitResult,"RareFitFraction");
RareMCLAlpha=SafeGetVar(RareMCFitResult,"RareLAlpha");
RareMCLN=SafeGetVar(RareMCFitResult,"RareLN");
RareMCRN=SafeGetVar(RareMCFitResult,"RareRN");
RareMCSigma=SafeGetVar(RareMCFitResult,"RareSigma");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
//++++++++++++++++++++++++++++++Rare Signal PDF++++++++++++++++++++++++++++
RooRealVar RareMCSigmaFix("RareMCSigmaFix","RareMCSigmaFix",RareMCSigma->getVal());
RareMCSigmaFix.setConstant();
RooFormulaVar RareSigma("RareSigma","RareSigma","@0*@1",RooArgSet(RareMCSigmaFix,DataMCRatio));
RooRealVar RareLAlpha("RareLAlpha","RareLAlpha",RareMCLAlpha->getVal());
RooRealVar RareRAlpha("RareRAlpha","RareRAlpha",RareMCRAlpha->getVal());
RooRealVar RareRN("RareRN","RareRN",RareMCRN->getVal());
RooRealVar RareLN("RareLN","RareLN",RareMCLN->getVal());
RooRealVar RareFitFraction("RareFitFraction","RareFitFraction",RareMCFitFraction->getVal());
RooCBShape RareDCBLeft("DCBLeft","DCBLeft",LbMass,LambdabMean,RareSigma,RareLAlpha,RareLN);
RooCBShape RareDCBRight("DCBRight","DCBRight",LbMass,LambdabMean,RareSigma,RareRAlpha,RareRN);
RooAddPdf RareDCB("RareDCB","RareDCB",RooArgList(RareDCBLeft,RareDCBRight),RareFitFraction);
RooRealVar RareYield("RareYield","RareYield",40.0,-100.0,1000.0);
RooExtendPdf RareSignalPdf("RareSignalPdf","RareSignalPdf",RareDCB,RareYield);
//++++++++++++++++++++++++++++++Rare Combinatorial Bkg+++++++++++++++++++++++++++++++++++
RooRealVar Rarep1("Rarep1","Rarep1",-1.1,-5.0,-0.1);
FreeParameters.push_back(&Rarep1);
RooRealVar Rarep2("Rarep2","Rarep2",0.5,0.001,10.0);
FreeParameters.push_back(&Rarep2);
RooChebychev RarePoly("RarePoly","RarePoly",LbMass,RooArgList(Rarep1,Rarep2));
RooRealVar RareBkgYield("RareBkgYield","RareBkgYield",2000.0,0.0,10000.0);
RooExtendPdf RareBkgPdf("RareBkgPdf","RareBkgPdf",RarePoly,RareBkgYield);
//++++++++++++++++++++++++++++Rare PKPhi Bkg+++++++++++++++++++++++++++++++++
TFile* PKPhiMCFitresultFile= new TFile("PkPhiFitResultFile.root");
RooFitResult* PKPhiMCFitResult=NULL;
try {
PKPhiMCFitResult=SafeGetFitResult(PKPhiMCFitresultFile,"PkPhiFitResult");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
PKPhiMCFitResult->Print("v");
RooRealVar* PkPhiMean=NULL;
RooRealVar* PkPhiSigma=NULL;
RooRealVar* PkPhiLAlpha=NULL;
RooRealVar* PkPhiRAlpha=NULL;
RooRealVar* PkPhiLN=NULL;
RooRealVar* PkPhiRN=NULL;
try {
PkPhiMean=SafeGetVar(PKPhiMCFitResult,"PkPhiMean");
PkPhiSigma=SafeGetVar(PKPhiMCFitResult,"PkPhiSigma");
PkPhiLAlpha=SafeGetVar(PKPhiMCFitResult,"PkPhiLAlpha");
PkPhiLN=SafeGetVar(PKPhiMCFitResult,"PkPhiLN");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar RarePkPhiMean("RarePkPhiMean","RarePkPhiMean",PkPhiMean->getVal());
RooRealVar RarePkPhiSigma("RarePkPhiSigma","RarePkPhiSigma",PkPhiSigma->getVal());
RooRealVar RarePkPhiLN("RarePkPhiLN","RarePkPhiLN",PkPhiLN->getVal());
RooRealVar RarePkPhiLAlpha("RarePkPhiLAlpha","RarePkPhiLAlpha",PkPhiLAlpha->getVal());
RooCBShape RarePkPhiModel("RarePkPhiModel","RarePkPhiModel",LbMass,RarePkPhiMean,RarePkPhiSigma,RarePkPhiLAlpha,RarePkPhiLN);
RooRealVar RarePkPhiYield("RarePkPhiYield","RarePkPhiYield",50.0,1.0,150.0);
RooExtendPdf RarePkPhiPdf("RarePkPhiPdf","RarePkPhiPdf",RarePkPhiModel,RarePkPhiYield);
RooAddPdf RarePdf("RarePdf","RarePdf",RooArgList(RarePkPhiPdf,RareBkgPdf,RareSignalPdf));
/*RarePdf.fitTo(*RareData,Extended(kTRUE));
RooPlot* RareFrame=LbMass.frame(Bins(35),Range(5200.0,6100.0));
TCanvas RareCanvas;
RareData->plotOn(RareFrame);
RarePdf.plotOn(RareFrame);
RareFrame->Draw();
RareCanvas.SaveAs("RareCanvas.pdf");*/
//________________________________ Fit Rare 2_______________________________
TFile* Rare2InputFile = new TFile("Rare2SingleFile.root");
TTree* Rare2InputTree=NULL;
try {
Rare2InputTree=SafeGetTree(Rare2InputFile,"DecayTree");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar Rare2Lambda_b0_PE("Lambda_b0_PE","Lambda_b0_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Lambda_b0_PX("Lambda_b0_PX","Lambda_b0_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Lambda_b0_PY("Lambda_b0_PY","Lambda_b0_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Lambda_b0_PZ("Lambda_b0_PZ","Lambda_b0_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Proton_PE("Proton_PE","Proton_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Proton_PX("Proton_PX","Proton_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Proton_PY("Proton_PY","Proton_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Proton_PZ("Proton_PZ","Proton_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Kaon_PE("Kaon_PE","Kaon_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Kaon_PX("Kaon_PX","Kaon_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Kaon_PY("Kaon_PY","Kaon_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2Kaon_PZ("Kaon_PZ","Kaon_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2eta_prime_PE("eta_prime_PE","eta_prime_PE",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2eta_prime_PX("eta_prime_PX","eta_prime_PX",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2eta_prime_PY("eta_prime_PY","eta_prime_PY",-RooNumber::infinity(),RooNumber::infinity());
RooRealVar Rare2eta_prime_PZ("eta_prime_PZ","eta_prime_PZ",-RooNumber::infinity(),RooNumber::infinity());
RooArgSet Rare2Args(LbMass,Rare2Lambda_b0_PE,Rare2Lambda_b0_PX,Rare2Lambda_b0_PY,Rare2Lambda_b0_PZ,Rare2Proton_PE,Rare2Proton_PX,Rare2Proton_PY,Rare2Proton_PZ);
Rare2Args.add(Rare2Kaon_PE);
Rare2Args.add(Rare2Kaon_PX);
Rare2Args.add(Rare2Kaon_PY);
Rare2Args.add(Rare2Kaon_PZ);
Rare2Args.add(Rare2eta_prime_PE);
Rare2Args.add(Rare2eta_prime_PX);
Rare2Args.add(Rare2eta_prime_PY);
Rare2Args.add(Rare2eta_prime_PZ);
RooDataSet* Rare2Data=new RooDataSet("Rare2Data","Rare2Data",Rare2Args,Import(*Rare2InputTree));
TFile* Rare2MCFitResultFile= new TFile("RareTwoFitResult.root");
RooFitResult* Rare2MCFitResult=NULL;
try {
Rare2MCFitResult=SafeGetFitResult(Rare2MCFitResultFile,"RareTwoFitResult");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
//++++++++++++++++++++++++++++++Signal PDF++++++++++++++++++++++++++++++++
RooRealVar* Rare2MCFitFraction=NULL;
RooRealVar* Rare2MCLAlpha=NULL;
RooRealVar* Rare2MCLN=NULL;
RooRealVar* Rare2MCRN=NULL;
RooRealVar* Rare2MCRAlpha=NULL;
RooRealVar* Rare2MCSigma=NULL;
try {
Rare2MCFitFraction=SafeGetVar(Rare2MCFitResult,"Rare2FitFraction");
Rare2MCLAlpha=SafeGetVar(Rare2MCFitResult,"Rare2LAlpha");
Rare2MCLN=SafeGetVar(Rare2MCFitResult,"Rare2LN");
Rare2MCRN=SafeGetVar(Rare2MCFitResult,"Rare2RN");
Rare2MCRAlpha=SafeGetVar(Rare2MCFitResult,"Rare2RAlpha");
Rare2MCSigma=SafeGetVar(Rare2MCFitResult,"Rare2Sigma");
} catch(std::exception &e) {
std::cout<<e.what()<<std::endl;
return 1;
}
RooRealVar Rare2SigmaFix("Rare2SigmaFix","Rare2SigmaFix",Rare2MCSigma->getVal());
RooFormulaVar Rare2Sigma("Rare2Sigma","Rare2Sigma","@0*@1",RooArgList(Rare2SigmaFix,DataMCRatio));
RooRealVar Rare2LN("Rare2LN","Rare2LN",Rare2MCLN->getVal());
RooRealVar Rare2RN("Rare2RN","Rare2RN",Rare2MCRN->getVal());
RooRealVar Rare2RAlpha("Rare2RAlpha","Rare2RAlpha",Rare2MCRAlpha->getVal());
RooRealVar Rare2LAlpha("Rare2LAlpha","Rare2LAlpha",Rare2MCLAlpha->getVal());
RooRealVar Rare2FitFraction("Rare2FitFraction","Rare2FitFraction",Rare2MCFitFraction->getVal());
RooCBShape Rare2CBLeft("Rare2CBLeft","Rare2CBLeft",LbMass,LambdabMean,Rare2Sigma,Rare2LAlpha,Rare2LN);
RooCBShape Rare2CBRight("Rare2CBRight","Rare2CBRight",LbMass,LambdabMean,Rare2Sigma,Rare2RAlpha,Rare2RN);
RooAddPdf Rare2DCB("Rare2DCB","Rare2DCB",RooArgList(Rare2CBLeft,Rare2CBRight),Rare2FitFraction);
RooRealVar Rare2SignalYield("Rare2SignalYield","Rare2SignalYield",100.0,-100.0,1000.0);
RooExtendPdf Rare2SignalPdf("Rare2SignalPdf","Rare2SignalPdf",Rare2DCB,Rare2SignalYield);
//++++++++++++++++++++++++++++++Rare 2 Bkg pdf++++++++++++++++++++++++++++++
RooRealVar Rare2K("K","K",-0.003,-0.1,0.0);
RooExponential Rare2BkgExp("Rare2BkgExp","Rare2BkgExp",LbMass,Rare2K);
RooRealVar Rare2BkgYield("Rare2BkgYield","Rare2BkgYield",2000.0,0.0,100000.0);
RooExtendPdf Rare2BkgPdf("Rare2BkgPdf","Rare2BkgPdf",Rare2BkgExp,Rare2BkgYield);
RooAddPdf Rare2Pdf("Rare2Pdf","Rare2Pdf",RooArgList(Rare2SignalPdf,Rare2BkgPdf));
//___________________________________ SImultaneous Part ________________________________________________________
RooCategory Channel("Channel","Channel");
Channel.defineType("Rare");
Channel.defineType("Rare2");
Channel.defineType("Control");
RooDataSet* AllData = new RooDataSet("AllData","AllData",RooArgSet(LbMass,CCBMass,CCEtaMass),Index(Channel),Import("Rare",*RareData),Import("Rare2",*Rare2Data),Import("Control",*CCData));
RooSimultaneous SimPdf("SimPdf","SimPdf",Channel);
SimPdf.addPdf(Rare2Pdf,"Rare2");
SimPdf.addPdf(RarePdf,"Rare");
SimPdf.addPdf(CCTotalPdf,"Control");
RooDataSet* BlindedData=NULL;
RooFitResult* SimResult=NULL;
if(blind) {
LbMass.setRange("RLSB",5200.0,RareLowerBlind);
LbMass.setRange("RUSB",RareUpperBlind,6000.0);
LbMass.setRange("R2LSB",5200.0,Rare2LowerBlind);
LbMass.setRange("R2USB",Rare2UpperBlind,6000.0);
LbMass.setRange("RDLSB",5200.0,5493.33333);
LbMass.setRange("RDUSB",RareUpperBlind,6000.0);
std::string CutString="Lambda_b0_DTF_MF<"+std::to_string(RareLowerBlind)+"||Lambda_b0_DTF_MF>"+std::to_string(Rare2UpperBlind);
BlindedData=(RooDataSet*)AllData->reduce(CutString.data());
RooMsgService::instance().setSilentMode(kTRUE);
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;
}
RooArgSet MinosPars(Rare2SignalYield,RareYield,CCSignalYield);
SimResult = SimPdf.fitTo(*AllData,Save(kTRUE),Extended(kTRUE),Minos(MinosPars));
SimPdf.Print("v");
RooPlot* NominalLikelihoodRareYield=RareYield.frame(Title("Likelihood scan of RareYield"),Range(50,150));
RooAbsReal* nll = SimPdf.createNLL(*AllData,NumCPU(2),Extended(kTRUE));
TCanvas C;
nll->plotOn(NominalLikelihoodRareYield,ShiftToZero());
NominalLikelihoodRareYield->Draw();
C.SaveAs("NominalLikelihood.pdf");
// HandyFunctions::SetlhcbStyle();
//_______________________________ Plot B+ Canvas_____________________________________________________________
RooPlot* CCBFrame= CCBMass.frame(Bins(50),Range(5000.0,5500.0),Title("Control Channel B+ Mass Projection"));
AllData->plotOn(CCBFrame,Cut("Channel==Channel::Control"));
SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("ExtCCTrueEtaBkgPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("ExtCCNoEtaBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),Components("CCExtendedSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCBFrame,Slice(Channel,"Control"),ProjWData(Channel,*AllData));
TCanvas* CCBCanvas=HandyFunctions::DecoratePlot(CCBFrame);
/*(TCanvas* CCBCanvas= new TCanvas("CCBCanvas","CCBCanvas",1600,900);
CCBFrame->Draw();
CCBCanvas->SaveAs("CCBCanvas.eps");*/
//________________________________Plot Eta Canvas_____________________________________________________________
RooPlot* CCEtaFrame=CCEtaMass.frame(Bins(50),Range(880.0,1040.0),Title("Control Channel Eta' Projection"));
AllData->plotOn(CCEtaFrame,Cut("Channel==Channel::Control"));
SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("ExtCCTrueEtaBkgPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("ExtCCNoEtaBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),Components("CCExtendedSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(CCEtaFrame,Slice(Channel,"Control"),ProjWData(Channel,*AllData));
TCanvas* CCEtaCanvas=HandyFunctions::DecoratePlot(CCEtaFrame);
/*TCanvas* CCEtaCanvas=new TCanvas("CCEtaCanvas","CCEtaCanvas",1600,900);
CCEtaFrame->Draw();
CCEtaCanvas->Print("CCEtaCanvas.eps");*/
//________________________________Plot Rare Canvas_____________________________________________________________
RooPlot* RareFrame=LbMass.frame(Bins(30),Range(5200.0,6000.0),Title("#Lambda_{b} -> p K (#eta' -> #pi #pi #gamma) ;M(#Lambda_{b})"));
if(blind) {
double sidebandsN = RareData ->sumEntries("1","RLSB,RUSB");
double LowsidebandsN = RareData ->sumEntries("1","RLSB");
RareData->plotOn(RareFrame,CutRange("RDLSB,RDUSB"),Name("RareDataPlotted"));
RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Components("RarePkPhiPdf"),Name("RarePkPhiBkg"),LineColor(kMagenta),LineStyle(kDashed),Normalization(sidebandsN,RooAbsReal::NumEvent));
RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Components("RareBkgPdf"),Name("RareCombBkg"),LineColor(kGreen),LineStyle(kDashed),Normalization(sidebandsN,RooAbsReal::NumEvent));
RarePdf.plotOn(RareFrame,Range("RLSB,RUSB"),Normalization(sidebandsN,RooAbsReal::NumEvent));
} else {
AllData->plotOn(RareFrame,Cut("Channel==Channel::Rare"));
SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RarePkPhiPdf"),LineColor(kMagenta),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RareBkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),Components("RareSignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(RareFrame,Slice(Channel,"Rare"),ProjWData(Channel,*AllData));
}
int i=RareFrame->numItems();
std::cout<<"_________________________________________"<<std::endl;
for(int j=0; j<i; j++) {
std::cout<<RareFrame->nameOf(j)<<std::endl;
}
TLegend * RareLegend = new TLegend(0.66,0.7,0.9,0.9);
RareLegend->AddEntry(RareFrame->findObject("RarePkPhiBkg"),"#Lambda_{b} -> p K #phi bkg","l");
RareLegend->AddEntry(RareFrame->findObject("RareCombBkg"),"Combinatorial Background","l");
std::cout<<"++++++++++++++++++++++++++++++++++++++++++++"<<std::endl;
RooHist* Pulls=RareFrame->pullHist(0,"RarePdf_Norm[Lambda_b0_DTF_MF]");
TCanvas* RareCanvas=HandyFunctions::DecoratePlot(RareFrame,"DecoratedRareCanvas");
RareCanvas->Print("RareCanvas.pdf");
TCanvas * PullCanvas=new TCanvas("RarePullCanvas","RarePullCanvas",1200,1000);
Pulls->Draw("AP");
PullCanvas->SaveAs("RarePulls.pdf");
TCanvas *RareNoPullCanvas = new TCanvas("RareFitCanvas","RareFitCanvas",1600,900);
RareFrame->Draw();
RareLegend->Draw();
RareNoPullCanvas->Print("RareNoPullCanvasPrinted.eps");
//_______________________________Plot Rare2 Canvas_____________________________________________________________
RooPlot* Rare2Frame=LbMass.frame(Bins(25),Range(5200.0,6000.),Title("#Lambda_{b} -> p K (#eta' -> #pi #pi #eta);M(#Lambda_{b})"));
if(blind) {
double Rare2sidebandsN= Rare2Data->sumEntries("1","R2LSB,R2USB");
Rare2Data->plotOn(Rare2Frame,CutRange("R2LSB,R2USB"));
Rare2Pdf.plotOn(Rare2Frame,Range("R2LSB,R2USB"),Normalization(Rare2sidebandsN,RooAbsReal::NumEvent));
} else {
AllData->plotOn(Rare2Frame,Cut("Channel==Channel::Rare2"));
SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),Components("Rare2BkgPdf"),LineColor(kGreen),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),Components("Rare2SignalPdf"),LineColor(kRed),LineStyle(kDashed),ProjWData(Channel,*AllData));
SimPdf.plotOn(Rare2Frame,Slice(Channel,"Rare2"),ProjWData(Channel,*AllData));
}
TCanvas* NoPullRare2= new TCanvas("NoPullRare2","NoPullRare2",1800,1000);
Rare2Frame->Draw();
NoPullRare2->SaveAs("PiPiEtaFit.eps");
TCanvas* Rare2Canvas=HandyFunctions::DecoratePlot(Rare2Frame,"DecoratedRare2Canvas");
Rare2Canvas->SaveAs("Rare2Canvas.pdf");
if(blind) {
RooArgSet NotBlind(CCEtamean,CCSignalYield,DataMCRatio,CCNoEtaBkgYield,CCTrueEtaBkgYield,CCMean,RareBkgYield,Rare2BkgYield,RarePkPhiYield);
cout << "Fit complete" << endl;
cout << "covQual:" << SimResult->covQual() << endl;
cout << "EDM:" << SimResult->edm() << endl;
cout << "FCN at min:" << SimResult->minNll() << endl;
NotBlind.Print("s");
}
TFile* DataFitResults= new TFile("DataFitResults.root","RECREATE");
RareNoPullCanvas->Write();
CCBCanvas->Write();
CCEtaCanvas->Write();
RareCanvas->Write();
Rare2Canvas->Write();
SimResult->Write("DataFitResult");
DataFitResults->Close();
RooWorkspace* Wkspc= new RooWorkspace("w","workspace");
Wkspc->import(SimPdf);
// Wkspc->writeToFile("BigFitWorkspace.root");
Wkspc->writeToFile("TestBigFitWorkspace.root");
for(auto Var : FreeParameters) {
Var->setConstant();
}
RooStats::SPlot* sDataMass;
if(sweight) {
sDataMass = new RooStats::SPlot("sData","An SPlot",*RareData,&RarePdf,RooArgList(RarePkPhiYield,RareYield,RareBkgYield));
std::cout<<" Check SWeights: "<<std::endl;
std::cout<<" BkgYield= "<<RareBkgYield.getVal()<<std::endl;
std::cout<<" Bkg yield from sweights = "<<sDataMass->GetYieldFromSWeight("RareBkgYield")<<std::endl;
}
}
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();
*/
}
int main(){
/*Toy Model with following True parameters
Guess 20 events in Lb->pketa' (1)
and 15 events in Lb->pketa'->pipieta (2)
Lb Efficiencies=0.0002637
B+ Efficiency=0.000411 (3)
B(eta'->pi pi g)=0.291
B(eta'->pi pi eta)=0.16
fd/fL= 2.5
*/
int GenRare=40;
int GenRare2=30;
int GenControl=11000;
RooRealVar Mode2EfficiencyRatio("Mode2EfficiencyRatio","Mode2EfficiencyRatio",1.558589);
RooRealVar ModeEfficiencyRatio("ModeEfficiencyRatio","ModeEfficiencyRatio",1.558589);
RooRealVar SubBRRatio("SubBRRatio","SubBRRatio",0.645);
RooRealVar fdFl("fdFl","fdFl",2.5);
RooRealVar YieldRatio("YieldRatio","YieldRatio",0.1,0.000001,1.0);
RooRealVar YieldRatio2("YieldRatio2","YieldRatio2",0.1,0.000001,1.0);
//RooFormulaVar ObservableBFRatio("ObservableBFRatio","ObservableBFRatio","((@0*@1)+(@2*@3))*@4*@5",RooArgSet(YieldRatio,ModeEfficiencyRatio,YieldRatio2,Mode2EfficiencyRatio,SubBRRatio,fdFl));
RooRealVar ObservableBFRatio("ObservableBFRatio","ObservableBFRatio",0.5,0.00000001,10.0);
// RooRealVar ControlYield("ControlYield","ControlYield",10000.0,0.0,20000.0);
//RooRealVar RareYield("RareYield","RareYield",30.0,0.0,1100.0);
//RooFormulaVar RareArg("RareArg","RareArg","@1*@2",RooArgSet(ControlYield,YieldRatio));
RooRealVar ControlMean("ControlMean","ControlMean",5279.0,5200.0,5350.0);
RooRealVar SigmaCorrection("SigmaCorrection","SigmaCorrection",1.1,0.9,1.8);
RooRealVar LambdaMass("LambdaMass","LambdaMass",5000,6200.0);
// RooRealVar RareMean("RareMean","RareMean",5619.0,5600.0,5650.0);
RooFormulaVar RareMean("RareMean","RareMean","@0+339.72",RooArgSet(ControlMean));
RooRealVar MCRareSigma("MCRareSigma","MCRareSigma",25.0);
// RooRealVar RareSigma("RareSigma","RareSigma",29.0,20.0,40.0);
RooFormulaVar RareSigma("RareSigma","RareSigma","@0*@1",RooArgSet(MCRareSigma,SigmaCorrection));
RooGaussian RareMode("RareMode","RareMode",LambdaMass,RareMean,RareSigma);
RooRealVar K("K","K",-0.003,-0.010,-0.001);
RooExponential RareBkg("RareBkg","RareBkg",LambdaMass,K);
RooRealVar RareBkgYield("RareBkgYield","RareBkgYield",1000.0,0.0,2000.0);
RooExtendPdf ExtRareBkg("ExtRareBkg","ExtRareBkg",RareBkg,RareBkgYield);
// RooFormulaVar RareYield("RareYield","RareYield","@0*@1",RooArgSet(ControlYield,YieldRatio));
RooRealVar RareYield("RareYield","RareYield",1.0,0.0,600.0);
RooExtendPdf ExtRareSig("ExtRareSig","ExtRareSig",RareMode,RareYield);
RooAddPdf ExtRare("ExtRare","ExtRare",RooArgSet(ExtRareSig,ExtRareBkg));
RooDataSet* RareSigData=RareMode.generate(RooArgSet(LambdaMass),GenRare);
RooDataSet* RareBkgData=RareBkg.generate(RooArgSet(LambdaMass),500);
RooDataSet* RareData= new RooDataSet(*RareSigData,"RareData");
RareData->append(*RareBkgData);
RooRealVar MCRare2Sigma("MCRare2Sigma","MCRare2Sigma",17.0);
//RooRealVar Rare2Sigma("Rare2Sigma","Rare2Sigma",20.0,10.0,30.0);
RooFormulaVar Rare2Sigma("Rare2Sigma","Rare2Sigma","@0*@1",RooArgSet(MCRare2Sigma,SigmaCorrection));
RooGaussian RareMode2("RareMode2","RareMode2",LambdaMass,RareMean,Rare2Sigma);
RooDataSet* RareData2=RareMode2.generate(RooArgSet(LambdaMass),GenRare2);
//RooFormulaVar RareYield2("RareYield2","RareYield2","@0*@1",RooArgSet(ControlYield,YieldRatio2));
//RooFormulaVar RareYield2("RareYield2","RareYield2","(ControlYield*(1/Mode2EfficiencyRatio))*((ObservableBFRatio/(SubBRRatio*fdFl))-(YieldRatio*ModeEfficiencyRatio))",RooArgSet(ControlYield,Mode2EfficiencyRatio,ObservableBFRatio,SubBRRatio,fdFl,YieldRatio,ModeEfficiencyRatio));
RooRealVar RareYield2("RareYield2","RareYield2",1.0,0.0,100.0);
RooExtendPdf ExtRare2("ExtRare2","ExtRare2",RareMode2,RareYield2);
RooRealVar BMass("BMass","BMass",5000.0,5500.0);
// RooFormulaVar ControlMean("ControlMean","ControlMean","@0-339.72",RooArgSet(RareMean));
RooRealVar MCControlSigma("MCControlSigma","MCControlSigma",17.0);
RooFormulaVar ControlSigma("ControlSigma","ControlSigma","@0*@1",RooArgSet(MCControlSigma,SigmaCorrection));
//RooRealVar ControlSigma("ControlSigma","ControlSigma",20.0,10.0,40.0);
RooGaussian ControlMode("ControlMode","ControlMode",BMass,ControlMean,ControlSigma);
RooFormulaVar ControlYield("ControlYield","ControlYield","(1/ObservableBFRatio)*((ModeEfficiencyRatio*RareYield)+(Mode2EfficiencyRatio*RareYield2))*SubBRRatio*fdFl",RooArgSet(ObservableBFRatio,ModeEfficiencyRatio,RareYield,Mode2EfficiencyRatio,RareYield2,SubBRRatio,fdFl));
RooExtendPdf ExtControl("ExtControl","ExtControl",ControlMode,ControlYield);
RooDataSet* ControlData=ControlMode.generate(RooArgSet(BMass),GenControl);
RooCategory Mode("Mode","Mode");
Mode.defineType("Rare");
Mode.defineType("Rare2");
Mode.defineType("Control");
RooDataSet CombData("CombData","CombData",RooArgSet(BMass,LambdaMass),Index(Mode),Import("Rare2",*RareData2),Import("Rare",*RareData),Import("Control",*ControlData));
RooSimultaneous SimPdf("SimPdf","SimPdf",Mode);
SimPdf.addPdf(ExtRare,"Rare");
SimPdf.addPdf(ExtRare2,"Rare2");
SimPdf.addPdf(ExtControl,"Control");
RooFitResult* SimResult=SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));
/* double FreeYield=-1*SimResult->minNll();
std::cout<<"With free yield = "<<SimResult->minNll()<<std::endl;
RareYield.setVal(0);
RareYield.setConstant(kTRUE);
RooFitResult* Rare1Fixed=SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));
double NullYield=-1*Rare1Fixed->minNll();
std::cout<<"With not free yield = "<<Rare1Fixed->minNll()<<std::endl;
double DeltaLogLikelihood=NullYield-FreeYield;
std::cout<<"DeltaNll= "<<DeltaLogLikelihood<<std::endl;
double Significance=TMath::Sqrt(-2*DeltaLogLikelihood);
std::cout<<"Significance= "<<Significance<<std::endl;
SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));*/
RooPlot* BFrame= BMass.frame(Bins(50),Title("B Mass"),Range(5200.0,5400.0));
ControlData->plotOn(BFrame);
ControlMode.plotOn(BFrame);
RooPlot* LambdaFrame = LambdaMass.frame(Bins(50),Title("Lambda mass"),Range(5200.0,6100.0));
RareData->plotOn(LambdaFrame);
ExtRare.plotOn(LambdaFrame);
RooPlot* LambdaFrame2 = LambdaMass.frame(Bins(50),Title("Lambda mass"),Range(5200.0,6100.0));
RareData2->plotOn(LambdaFrame2);
RareMode2.plotOn(LambdaFrame2);
TCanvas BCanvas;
BFrame->Draw();
BCanvas.SaveAs("BCanvas.pdf");
TCanvas LambdaCanvas;
LambdaFrame->Draw();
LambdaCanvas.SaveAs("LambdaCanvas.pdf");
TCanvas LambdaCanvas2;
LambdaFrame2->Draw();
LambdaCanvas2.SaveAs("LambdaCanvas2.pdf");
SimResult->Print("v");
// S imPdf.graphVizTree("model.dot");
std::cout<<"Real Ratio = "<<GenRare/(double)GenControl<<std::endl;
ObservableBFRatio.Print("v");
std::cout<<"Lb BF = "<<ObservableBFRatio.getVal()*7.06E-5<<" + "<<ObservableBFRatio.getErrorHi()*7.06E-5<<" - "<<ObservableBFRatio.getErrorLo()*7.06E-5<<std::endl;
//________________________________________________ATTEMPT TO SWEIGHT____________________________________________
RooStats::SPlot* sDataMass = new RooStats::SPlot("sData","An SPlot",*RareData,&ExtRare,RooArgList(RareYield,RareBkgYield));
std::cout << std::endl << "Yield of signal is " << RareYield.getVal() << ". From sWeights it is " << sDataMass->GetYieldFromSWeight("RareYield") << std::endl;
std::cout << "Yield of background is " << RareBkgYield.getVal() << ". From sWeights it is " << sDataMass->GetYieldFromSWeight("RareBkgYield") << std::endl << std::endl;
RooAbsReal* nll = SimPdf.createNLL(CombData);
RooMinuit(*nll).migrad();
RooPlot* LLFrame=ObservableBFRatio.frame(Title("Some Title"),Range(0.005,0.03));
nll->plotOn(LLFrame,ShiftToZero());
LLFrame->GetYaxis()->SetRangeUser(0.0,1000.0);
TCanvas LLCanvas;
LLFrame->Draw();
LLCanvas.SaveAs("LLCanvas.pdf");
}
void rf605_profilell()
{
// C r e a t e m o d e l a n d d a t a s e t
// -----------------------------------------------
// Observable
RooRealVar x("x","x",-20,20) ;
// Model (intentional strong correlations)
RooRealVar mean("mean","mean of g1 and g2",0,-10,10) ;
RooRealVar sigma_g1("sigma_g1","width of g1",3) ;
RooGaussian g1("g1","g1",x,mean,sigma_g1) ;
RooRealVar sigma_g2("sigma_g2","width of g2",4,3.0,6.0) ;
RooGaussian g2("g2","g2",x,mean,sigma_g2) ;
RooRealVar frac("frac","frac",0.5,0.0,1.0) ;
RooAddPdf model("model","model",RooArgList(g1,g2),frac) ;
// Generate 1000 events
RooDataSet* data = model.generate(x,1000) ;
// C o n s t r u c t p l a i n l i k e l i h o o d
// ---------------------------------------------------
// Construct unbinned likelihood
RooAbsReal* nll = model.createNLL(*data,NumCPU(2)) ;
// Minimize likelihood w.r.t all parameters before making plots
RooMinuit(*nll).migrad() ;
// Plot likelihood scan frac
RooPlot* frame1 = frac.frame(Bins(10),Range(0.01,0.95),Title("LL and profileLL in frac")) ;
nll->plotOn(frame1,ShiftToZero()) ;
// Plot likelihood scan in sigma_g2
RooPlot* frame2 = sigma_g2.frame(Bins(10),Range(3.3,5.0),Title("LL and profileLL in sigma_g2")) ;
nll->plotOn(frame2,ShiftToZero()) ;
// C o n s t r u c t p r o f i l e l i k e l i h o o d i n f r a c
// -----------------------------------------------------------------------
// The profile likelihood estimator on nll for frac will minimize nll w.r.t
// all floating parameters except frac for each evaluation
RooAbsReal* pll_frac = nll->createProfile(frac) ;
// Plot the profile likelihood in frac
pll_frac->plotOn(frame1,LineColor(kRed)) ;
// Adjust frame maximum for visual clarity
frame1->SetMinimum(0) ;
frame1->SetMaximum(3) ;
// C o n s t r u c t p r o f i l e l i k e l i h o o d i n s i g m a _ g 2
// -------------------------------------------------------------------------------
// The profile likelihood estimator on nll for sigma_g2 will minimize nll
// w.r.t all floating parameters except sigma_g2 for each evaluation
RooAbsReal* pll_sigmag2 = nll->createProfile(sigma_g2) ;
// Plot the profile likelihood in sigma_g2
pll_sigmag2->plotOn(frame2,LineColor(kRed)) ;
// Adjust frame maximum for visual clarity
frame2->SetMinimum(0) ;
frame2->SetMaximum(3) ;
// Make canvas and draw RooPlots
TCanvas *c = new TCanvas("rf605_profilell","rf605_profilell",800, 400);
c->Divide(2);
c->cd(1) ; gPad->SetLeftMargin(0.15) ; frame1->GetYaxis()->SetTitleOffset(1.4) ; frame1->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; frame2->GetYaxis()->SetTitleOffset(1.4) ; frame2->Draw() ;
delete pll_frac ;
delete pll_sigmag2 ;
delete nll ;
}