void central_interval_Bayesian(Model* model,double confidence){
cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl;
cout<<"Calculating central interval with the Bayesian method"<<endl;
cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl;
//configure the calculator
BayesianCalculator bcalc(*model->get_data(),*model->get_complete_likelihood(),*model->get_POI_set(),*model->get_POI_prior(),model->get_nuisance_set());
//get the interval
bcalc.SetConfidenceLevel(confidence);
SimpleInterval* interval = bcalc.GetInterval();
double ll=interval->LowerLimit();
double ul=interval->UpperLimit();
std::cout <<confidence <<"% CL confidence interval: " <<ll<<" , "<< ul<<endl;
}
void upper_limit_Bayesian(Model* model,double confidence){
cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl;
cout<<"Calculating upper limit with the Bayesian method"<<endl;
cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl;
RooWorkspace* wspace = new RooWorkspace("wspace");
ModelConfig* modelConfig = new ModelConfig("bayes");
modelConfig->SetWorkspace(*wspace);
modelConfig->SetPdf(*model->get_complete_likelihood());
modelConfig->SetPriorPdf(*model->get_POI_prior());
modelConfig->SetParametersOfInterest(*model->get_POI_set());
//modelConfig->SetNuisanceParameters(*model->get_nuisance_set());
//configure the calculator
//model->Print();
cout<<" POI size "<<model->get_POI_set()->getSize()<<endl;
BayesianCalculator bcalc(*model->get_data(), *modelConfig);
//BayesianCalculator bcalc(*model->get_data(),*model->get_complete_likelihood(),*model->get_POI_set(),*model->get_POI_prior(),model->get_nuisance_set());
//BayesianCalculator bcalc(*model->get_data(),*model->get_complete_likelihood(),*model->get_POI_set(),*model->get_POI_prior(),0);
bcalc.SetLeftSideTailFraction(0); //for upper limit
//get the interval
bcalc.SetConfidenceLevel(confidence);
cout<<"Calculating"<<endl;
SimpleInterval* interval = bcalc.GetInterval();
double ul=interval->UpperLimit();
std::cout <<confidence <<"% CL upper limit: "<< ul<<endl;
TCanvas *c1=new TCanvas;
bcalc.SetScanOfPosterior(100);
RooPlot * plot = bcalc.GetPosteriorPlot();
plot->Draw();
c1->SaveAs("bayesian_PosteriorPlot.png");
}
void StandardBayesianNumericalDemo(const char* infile = "",
const char* workspaceName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData") {
// option definitions
double confLevel = optBayes.confLevel;
TString integrationType = optBayes.integrationType;
int nToys = optBayes.nToys;
bool scanPosterior = optBayes.scanPosterior;
int nScanPoints = optBayes.nScanPoints;
int intervalType = optBayes.intervalType;
int maxPOI = optBayes.maxPOI;
double nSigmaNuisance = optBayes.nSigmaNuisance;
/////////////////////////////////////////////////////////////
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
////////////////////////////////////////////////////////////
const char* filename = "";
if (!strcmp(infile,"")) {
filename = "results/example_combined_GaussExample_model.root";
bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code
// if file does not exists generate with histfactory
if (!fileExist) {
#ifdef _WIN32
cout << "HistFactory file cannot be generated on Windows - exit" << endl;
return;
#endif
// Normally this would be run on the command line
cout <<"will run standard hist2workspace example"<<endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout <<"\n\n---------------------"<<endl;
cout <<"Done creating example input"<<endl;
cout <<"---------------------\n\n"<<endl;
}
}
else
filename = infile;
// Try to open the file
TFile *file = TFile::Open(filename);
// if input file was specified byt not found, quit
if(!file ){
cout <<"StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl;
return;
}
/////////////////////////////////////////////////////////////
// Tutorial starts here
////////////////////////////////////////////////////////////
// get the workspace out of the file
RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName);
if(!w){
cout <<"workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData* data = w->data(dataName);
// make sure ingredients are found
if(!data || !mc){
w->Print();
cout << "data or ModelConfig was not found" <<endl;
return;
}
/////////////////////////////////////////////
// create and use the BayesianCalculator
// to find and plot the 95% credible interval
// on the parameter of interest as specified
// in the model config
// before we do that, we must specify our prior
// it belongs in the model config, but it may not have
// been specified
RooUniform prior("prior","",*mc->GetParametersOfInterest());
w->import(prior);
mc->SetPriorPdf(*w->pdf("prior"));
// do without systematics
//mc->SetNuisanceParameters(RooArgSet() );
if (nSigmaNuisance > 0) {
RooAbsPdf * pdf = mc->GetPdf();
assert(pdf);
RooFitResult * res = pdf->fitTo(*data, Save(true), Minimizer(ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_str()), Hesse(true),
PrintLevel(ROOT::Math::MinimizerOptions::DefaultPrintLevel()-1) );
res->Print();
RooArgList nuisPar(*mc->GetNuisanceParameters());
for (int i = 0; i < nuisPar.getSize(); ++i) {
RooRealVar * v = dynamic_cast<RooRealVar*> (&nuisPar[i] );
assert( v);
v->setMin( TMath::Max( v->getMin(), v->getVal() - nSigmaNuisance * v->getError() ) );
v->setMax( TMath::Min( v->getMax(), v->getVal() + nSigmaNuisance * v->getError() ) );
std::cout << "setting interval for nuisance " << v->GetName() << " : [ " << v->getMin() << " , " << v->getMax() << " ]" << std::endl;
}
}
BayesianCalculator bayesianCalc(*data,*mc);
bayesianCalc.SetConfidenceLevel(confLevel); // 95% interval
// default of the calculator is central interval. here use shortest , central or upper limit depending on input
// doing a shortest interval might require a longer time since it requires a scan of the posterior function
if (intervalType == 0) bayesianCalc.SetShortestInterval(); // for shortest interval
if (intervalType == 1) bayesianCalc.SetLeftSideTailFraction(0.5); // for central interval
if (intervalType == 2) bayesianCalc.SetLeftSideTailFraction(0.); // for upper limit
if (!integrationType.IsNull() ) {
bayesianCalc.SetIntegrationType(integrationType); // set integrationType
bayesianCalc.SetNumIters(nToys); // set number of ietrations (i.e. number of toys for MC integrations)
}
// in case of toyMC make a nnuisance pdf
if (integrationType.Contains("TOYMC") ) {
RooAbsPdf * nuisPdf = RooStats::MakeNuisancePdf(*mc, "nuisance_pdf");
cout << "using TOYMC integration: make nuisance pdf from the model " << std::endl;
nuisPdf->Print();
bayesianCalc.ForceNuisancePdf(*nuisPdf);
scanPosterior = true; // for ToyMC the posterior is scanned anyway so used given points
}
// compute interval by scanning the posterior function
if (scanPosterior)
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooRealVar* poi = (RooRealVar*) mc->GetParametersOfInterest()->first();
if (maxPOI != -999 && maxPOI > poi->getMin())
poi->setMax(maxPOI);
SimpleInterval* interval = bayesianCalc.GetInterval();
// print out the iterval on the first Parameter of Interest
cout << "\n>>>> RESULT : " << confLevel*100 << "% interval on " << poi->GetName()<<" is : ["<<
interval->LowerLimit() << ", "<<
interval->UpperLimit() <<"] "<<endl;
// make a plot
// since plotting may take a long time (it requires evaluating
// the posterior in many points) this command will speed up
// by reducing the number of points to plot - do 50
// ignore errors of PDF if is zero
RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::Ignore) ;
cout << "\nDrawing plot of posterior function....." << endl;
// always plot using numer of scan points
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooPlot * plot = bayesianCalc.GetPosteriorPlot();
plot->Draw();
}
//
// calculation of the limit: assumes that wspace is set up and observations
// contained in data
//
MyLimit computeLimit (RooWorkspace* wspace, RooDataSet* data, StatMethod method, bool draw) {
// let's time this challenging example
TStopwatch t;
//
// get nominal signal
//
RooRealVar exp_sig(*wspace->var("s"));
double exp_sig_val = exp_sig.getVal();
std::cout << "exp_sig = " << exp_sig_val << std::endl;
/////////////////////////////////////////////////////
// Now the statistical tests
// model config
std::cout << wspace->pdf("model") << " "
<< wspace->pdf("prior") << " "
<< wspace->set("poi") << " "
<< wspace->set("nuis") << std::endl;
ModelConfig modelConfig("RA4abcd");
modelConfig.SetWorkspace(*wspace);
modelConfig.SetPdf(*wspace->pdf("model"));
modelConfig.SetPriorPdf(*wspace->pdf("prior"));
modelConfig.SetParametersOfInterest(*wspace->set("poi"));
modelConfig.SetNuisanceParameters(*wspace->set("nuis"));
//////////////////////////////////////////////////
// If you want to see the covariance matrix uncomment
// wspace->pdf("model")->fitTo(*data);
// use ProfileLikelihood
if ( method == ProfileLikelihoodMethod ) {
ProfileLikelihoodCalculator plc(*data, modelConfig);
plc.SetConfidenceLevel(0.95);
RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow();
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
LikelihoodInterval* plInt = plc.GetInterval();
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
plInt->LowerLimit( *wspace->var("s") ); // get ugly print out of the way. Fix.
// RooMsgService::instance().setGlobalKillBelow(RooFit::DEBUG);
if ( draw ) {
TCanvas* c = new TCanvas("ProfileLikelihood");
LikelihoodIntervalPlot* lrplot = new LikelihoodIntervalPlot(plInt);
lrplot->Draw();
}
// RooMsgService::instance().setGlobalKillBelow(msglevel);
double lowLim = plInt->LowerLimit(*wspace->var("s"));
double uppLim = plInt->UpperLimit(*wspace->var("s"));
// double exp_sig_val = wspace->var("s")->getVal();
// double exp_sig_val = exp_sig.getVal();
cout << "Profile Likelihood interval on s = [" <<
lowLim << ", " <<
uppLim << "]" << " " << exp_sig_val << endl;
// MyLimit result(plInt->IsInInterval(exp_sig),
MyLimit result(exp_sig_val>lowLim&&exp_sig_val<uppLim,lowLim,uppLim);
// std::cout << "isIn " << result << std::endl;
delete plInt;
// delete modelConfig;
return result;
}
// use FeldmaCousins (takes ~20 min)
if ( method == FeldmanCousinsMethod ) {
FeldmanCousins fc(*data, modelConfig);
fc.SetConfidenceLevel(0.95);
//number counting: dataset always has 1 entry with N events observed
fc.FluctuateNumDataEntries(false);
fc.UseAdaptiveSampling(true);
fc.SetNBins(100);
PointSetInterval* fcInt = NULL;
fcInt = (PointSetInterval*) fc.GetInterval(); // fix cast
double lowLim = fcInt->LowerLimit(*wspace->var("s"));
double uppLim = fcInt->UpperLimit(*wspace->var("s"));
// double exp_sig_val = wspace->var("s")->getVal();
cout << "Feldman Cousins interval on s = [" << lowLim << " " << uppLim << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(exp_sig_val>lowLim&&exp_sig_val<uppLim,
fcInt->LowerLimit(*wspace->var("s")),fcInt->UpperLimit(*wspace->var("s")));
delete fcInt;
return result;
}
// use BayesianCalculator (only 1-d parameter of interest, slow for this problem)
if ( method == BayesianMethod ) {
BayesianCalculator bc(*data, modelConfig);
bc.SetConfidenceLevel(0.95);
bc.SetLeftSideTailFraction(0.5);
SimpleInterval* bInt = NULL;
if( wspace->set("poi")->getSize() == 1) {
bInt = bc.GetInterval();
if ( draw ) {
TCanvas* c = new TCanvas("Bayesian");
// the plot takes a long time and print lots of error
// using a scan it is better
bc.SetScanOfPosterior(50);
RooPlot* bplot = bc.GetPosteriorPlot();
bplot->Draw();
}
cout << "Bayesian interval on s = [" <<
bInt->LowerLimit( ) << ", " <<
bInt->UpperLimit( ) << "]" << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(bInt->IsInInterval(exp_sig),
bInt->LowerLimit(),bInt->UpperLimit());
delete bInt;
return result;
} else {
cout << "Bayesian Calc. only supports on parameter of interest" << endl;
return MyLimit();
}
}
// use MCMCCalculator (takes about 1 min)
// Want an efficient proposal function, so derive it from covariance
// matrix of fit
if ( method == MCMCMethod ) {
RooFitResult* fit = wspace->pdf("model")->fitTo(*data,Save());
ProposalHelper ph;
ph.SetVariables((RooArgSet&)fit->floatParsFinal());
ph.SetCovMatrix(fit->covarianceMatrix());
ph.SetUpdateProposalParameters(kTRUE); // auto-create mean vars and add mappings
ph.SetCacheSize(100);
ProposalFunction* pf = ph.GetProposalFunction();
MCMCCalculator mc(*data, modelConfig);
mc.SetConfidenceLevel(0.95);
mc.SetProposalFunction(*pf);
mc.SetNumBurnInSteps(100); // first N steps to be ignored as burn-in
mc.SetNumIters(100000);
mc.SetLeftSideTailFraction(0.5); // make a central interval
MCMCInterval* mcInt = NULL;
mcInt = mc.GetInterval();
MCMCIntervalPlot mcPlot(*mcInt);
mcPlot.Draw();
cout << "MCMC interval on s = [" <<
mcInt->LowerLimit(*wspace->var("s") ) << ", " <<
mcInt->UpperLimit(*wspace->var("s") ) << "]" << endl;
// std::cout << "isIn " << result << std::endl;
MyLimit result(mcInt->IsInInterval(exp_sig),
mcInt->LowerLimit(*wspace->var("s")),mcInt->UpperLimit(*wspace->var("s")));
delete mcInt;
return result;
}
t.Print();
// delete modelConfig;
return MyLimit();
}
void rs701_BayesianCalculator(bool useBkg = true, double confLevel = 0.90)
{
RooWorkspace* w = new RooWorkspace("w",true);
w->factory("SUM::pdf(s[0.001,15]*Uniform(x[0,1]),b[1,0,2]*Uniform(x))");
w->factory("Gaussian::prior_b(b,1,1)");
w->factory("PROD::model(pdf,prior_b)");
RooAbsPdf* model = w->pdf("model"); // pdf*priorNuisance
RooArgSet nuisanceParameters(*(w->var("b")));
RooAbsRealLValue* POI = w->var("s");
RooAbsPdf* priorPOI = (RooAbsPdf *) w->factory("Uniform::priorPOI(s)");
RooAbsPdf* priorPOI2 = (RooAbsPdf *) w->factory("GenericPdf::priorPOI2('1/sqrt(@0)',s)");
w->factory("n[3]"); // observed number of events
// create a data set with n observed events
RooDataSet data("data","",RooArgSet(*(w->var("x")),*(w->var("n"))),"n");
data.add(RooArgSet(*(w->var("x"))),w->var("n")->getVal());
// to suppress messgaes when pdf goes to zero
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;
RooArgSet * nuisPar = 0;
if (useBkg) nuisPar = &nuisanceParameters;
//if (!useBkg) ((RooRealVar *)w->var("b"))->setVal(0);
double size = 1.-confLevel;
std::cout << "\nBayesian Result using a Flat prior " << std::endl;
BayesianCalculator bcalc(data,*model,RooArgSet(*POI),*priorPOI, nuisPar);
bcalc.SetTestSize(size);
SimpleInterval* interval = bcalc.GetInterval();
double cl = bcalc.ConfidenceLevel();
std::cout << cl <<"% CL central interval: [ " << interval->LowerLimit() << " - " << interval->UpperLimit()
<< " ] or "
<< cl+(1.-cl)/2 << "% CL limits\n";
RooPlot * plot = bcalc.GetPosteriorPlot();
TCanvas * c1 = new TCanvas("c1","Bayesian Calculator Result");
c1->Divide(1,2);
c1->cd(1);
plot->Draw();
c1->Update();
std::cout << "\nBayesian Result using a 1/sqrt(s) prior " << std::endl;
BayesianCalculator bcalc2(data,*model,RooArgSet(*POI),*priorPOI2,nuisPar);
bcalc2.SetTestSize(size);
SimpleInterval* interval2 = bcalc2.GetInterval();
cl = bcalc2.ConfidenceLevel();
std::cout << cl <<"% CL central interval: [ " << interval2->LowerLimit() << " - " << interval2->UpperLimit()
<< " ] or "
<< cl+(1.-cl)/2 << "% CL limits\n";
RooPlot * plot2 = bcalc2.GetPosteriorPlot();
c1->cd(2);
plot2->Draw();
gPad->SetLogy();
c1->Update();
// observe one event while expecting one background event -> the 95% CL upper limit on s is 4.10
// observe one event while expecting zero background event -> the 95% CL upper limit on s is 4.74
}
void IntervalExamples()
{
// Time this macro
TStopwatch t;
t.Start();
// set RooFit random seed for reproducible results
RooRandom::randomGenerator()->SetSeed(3001);
// make a simple model via the workspace factory
RooWorkspace* wspace = new RooWorkspace();
wspace->factory("Gaussian::normal(x[-10,10],mu[-1,1],sigma[1])");
wspace->defineSet("poi","mu");
wspace->defineSet("obs","x");
// specify components of model for statistical tools
ModelConfig* modelConfig = new ModelConfig("Example G(x|mu,1)");
modelConfig->SetWorkspace(*wspace);
modelConfig->SetPdf( *wspace->pdf("normal") );
modelConfig->SetParametersOfInterest( *wspace->set("poi") );
modelConfig->SetObservables( *wspace->set("obs") );
// create a toy dataset
RooDataSet* data = wspace->pdf("normal")->generate(*wspace->set("obs"),100);
data->Print();
// for convenience later on
RooRealVar* x = wspace->var("x");
RooRealVar* mu = wspace->var("mu");
// set confidence level
double confidenceLevel = 0.95;
// example use profile likelihood calculator
ProfileLikelihoodCalculator plc(*data, *modelConfig);
plc.SetConfidenceLevel( confidenceLevel);
LikelihoodInterval* plInt = plc.GetInterval();
// example use of Feldman-Cousins
FeldmanCousins fc(*data, *modelConfig);
fc.SetConfidenceLevel( confidenceLevel);
fc.SetNBins(100); // number of points to test per parameter
fc.UseAdaptiveSampling(true); // make it go faster
// Here, we consider only ensembles with 100 events
// The PDF could be extended and this could be removed
fc.FluctuateNumDataEntries(false);
// Proof
// ProofConfig pc(*wspace, 4, "workers=4", kFALSE); // proof-lite
//ProofConfig pc(w, 8, "localhost"); // proof cluster at "localhost"
// ToyMCSampler* toymcsampler = (ToyMCSampler*) fc.GetTestStatSampler();
// toymcsampler->SetProofConfig(&pc); // enable proof
PointSetInterval* interval = (PointSetInterval*) fc.GetInterval();
// example use of BayesianCalculator
// now we also need to specify a prior in the ModelConfig
wspace->factory("Uniform::prior(mu)");
modelConfig->SetPriorPdf(*wspace->pdf("prior"));
// example usage of BayesianCalculator
BayesianCalculator bc(*data, *modelConfig);
bc.SetConfidenceLevel( confidenceLevel);
SimpleInterval* bcInt = bc.GetInterval();
// example use of MCMCInterval
MCMCCalculator mc(*data, *modelConfig);
mc.SetConfidenceLevel( confidenceLevel);
// special options
mc.SetNumBins(200); // bins used internally for representing posterior
mc.SetNumBurnInSteps(500); // first N steps to be ignored as burn-in
mc.SetNumIters(100000); // how long to run chain
mc.SetLeftSideTailFraction(0.5); // for central interval
MCMCInterval* mcInt = mc.GetInterval();
// for this example we know the expected intervals
double expectedLL = data->mean(*x)
+ ROOT::Math::normal_quantile( (1-confidenceLevel)/2,1)
/ sqrt(data->numEntries());
double expectedUL = data->mean(*x)
+ ROOT::Math::normal_quantile_c((1-confidenceLevel)/2,1)
/ sqrt(data->numEntries()) ;
// Use the intervals
std::cout << "expected interval is [" <<
expectedLL << ", " <<
expectedUL << "]" << endl;
cout << "plc interval is [" <<
plInt->LowerLimit(*mu) << ", " <<
plInt->UpperLimit(*mu) << "]" << endl;
std::cout << "fc interval is ["<<
interval->LowerLimit(*mu) << " , " <<
interval->UpperLimit(*mu) << "]" << endl;
cout << "bc interval is [" <<
bcInt->LowerLimit() << ", " <<
bcInt->UpperLimit() << "]" << endl;
cout << "mc interval is [" <<
mcInt->LowerLimit(*mu) << ", " <<
mcInt->UpperLimit(*mu) << "]" << endl;
mu->setVal(0);
cout << "is mu=0 in the interval? " <<
plInt->IsInInterval(RooArgSet(*mu)) << endl;
// make a reasonable style
gStyle->SetCanvasColor(0);
gStyle->SetCanvasBorderMode(0);
gStyle->SetPadBorderMode(0);
gStyle->SetPadColor(0);
gStyle->SetCanvasColor(0);
gStyle->SetTitleFillColor(0);
gStyle->SetFillColor(0);
gStyle->SetFrameFillColor(0);
gStyle->SetStatColor(0);
// some plots
TCanvas* canvas = new TCanvas("canvas");
canvas->Divide(2,2);
// plot the data
canvas->cd(1);
RooPlot* frame = x->frame();
data->plotOn(frame);
data->statOn(frame);
frame->Draw();
// plot the profile likelihood
canvas->cd(2);
LikelihoodIntervalPlot plot(plInt);
plot.Draw();
// plot the MCMC interval
canvas->cd(3);
MCMCIntervalPlot* mcPlot = new MCMCIntervalPlot(*mcInt);
mcPlot->SetLineColor(kGreen);
mcPlot->SetLineWidth(2);
mcPlot->Draw();
canvas->cd(4);
RooPlot * bcPlot = bc.GetPosteriorPlot();
bcPlot->Draw();
canvas->Update();
t.Stop();
t.Print();
}
void StandardBayesianNumericalDemo(const char* infile = "",
const char* workspaceName = "combined",
const char* modelConfigName = "ModelConfig",
const char* dataName = "obsData"){
/////////////////////////////////////////////////////////////
// First part is just to access a user-defined file
// or create the standard example file if it doesn't exist
////////////////////////////////////////////////////////////
TString filename = infile;
if (filename.IsNull()) {
filename = "results/example_combined_GaussExample_model.root";
std::cout << "Use standard file generated with HistFactory : " << filename << std::endl;
}
// Check if example input file exists
TFile *file = TFile::Open(filename);
// if input file was specified but not found, quit
if(!file && !TString(infile).IsNull()){
cout <<"file " << filename << " not found" << endl;
return;
}
// if default file not found, try to create it
if(!file ){
// Normally this would be run on the command line
cout <<"will run standard hist2workspace example"<<endl;
gROOT->ProcessLine(".! prepareHistFactory .");
gROOT->ProcessLine(".! hist2workspace config/example.xml");
cout <<"\n\n---------------------"<<endl;
cout <<"Done creating example input"<<endl;
cout <<"---------------------\n\n"<<endl;
// now try to access the file again
file = TFile::Open(filename);
}
if(!file){
// if it is still not there, then we can't continue
cout << "Not able to run hist2workspace to create example input" <<endl;
return;
}
/////////////////////////////////////////////////////////////
// Tutorial starts here
////////////////////////////////////////////////////////////
// get the workspace out of the file
RooWorkspace* w = (RooWorkspace*) file->Get(workspaceName);
if(!w){
cout <<"workspace not found" << endl;
return;
}
// get the modelConfig out of the file
ModelConfig* mc = (ModelConfig*) w->obj(modelConfigName);
// get the modelConfig out of the file
RooAbsData* data = w->data(dataName);
// make sure ingredients are found
if(!data || !mc){
w->Print();
cout << "data or ModelConfig was not found" <<endl;
return;
}
/////////////////////////////////////////////
// create and use the BayesianCalculator
// to find and plot the 95% credible interval
// on the parameter of interest as specified
// in the model config
// before we do that, we must specify our prior
// it belongs in the model config, but it may not have
// been specified
RooUniform prior("prior","",*mc->GetParametersOfInterest());
w->import(prior);
mc->SetPriorPdf(*w->pdf("prior"));
// do without systematics
//mc->SetNuisanceParameters(RooArgSet() );
BayesianCalculator bayesianCalc(*data,*mc);
bayesianCalc.SetConfidenceLevel(0.95); // 95% interval
// default of the calculator is central interval. here use shortest , central or upper limit depending on input
// doing a shortest interval might require a longer time since it requires a scan of the posterior function
if (intervalType == 0) bayesianCalc.SetShortestInterval(); // for shortest interval
if (intervalType == 1) bayesianCalc.SetLeftSideTailFraction(0.5); // for central interval
if (intervalType == 2) bayesianCalc.SetLeftSideTailFraction(0.); // for upper limit
if (!integrationType.IsNull() ) {
bayesianCalc.SetIntegrationType(integrationType); // set integrationType
bayesianCalc.SetNumIters(nToys); // set number of ietrations (i.e. number of toys for MC integrations)
}
// compute interval by scanning the posterior function
if (scanPosterior)
bayesianCalc.SetScanOfPosterior(nScanPoints);
SimpleInterval* interval = bayesianCalc.GetInterval();
// print out the iterval on the first Parameter of Interest
RooRealVar* firstPOI = (RooRealVar*) mc->GetParametersOfInterest()->first();
cout << "\n95% interval on " <<firstPOI->GetName()<<" is : ["<<
interval->LowerLimit() << ", "<<
interval->UpperLimit() <<"] "<<endl;
// make a plot
// since plotting may take a long time (it requires evaluating
// the posterior in many points) this command will speed up
// by reducing the number of points to plot - do 50
cout << "\nDrawing plot of posterior function....." << endl;
bayesianCalc.SetScanOfPosterior(nScanPoints);
RooPlot * plot = bayesianCalc.GetPosteriorPlot();
plot->Draw();
}
void runBATCalculator()
{
// Definiton of a RooWorkspace containing the statistics model. Later the
// information for BATCalculator is retrieved from the workspace. This is
// certainly a bit of overhead but better from an educative point of view.
cout << "preparing the RooWorkspace object" << endl;
RooWorkspace* myWS = new RooWorkspace("myWS", true);
// combined prior for signal contribution
myWS->factory("Product::signal({sigma_s[0,20],L[5,15],epsilon[0,1]})");
myWS->factory("N_bkg[0,3]");
// define prior functions
// uniform prior for signal crosssection
myWS->factory("Uniform::prior_sigma_s(sigma_s)");
// (truncated) prior for efficiency
myWS->factory("Gaussian::prior_epsilon(epsilon,0.51,0.0765)");
// (truncated) Gaussian prior for luminosity
myWS->factory("Gaussian::prior_L(L,10,1)");
// (truncated) Gaussian prior for bkg crosssection
myWS->factory("Gaussian::prior_N_bkg(N_bkg,0.52,0.156)");
// Poisson distribution with mean signal+bkg
myWS->factory("Poisson::model(n[0,300],sum(signal,N_bkg))");
// define the global prior function
myWS->factory("PROD::prior(prior_sigma_s,prior_epsilon,prior_L,prior_N_bkg)");
// Definition of observables and parameters of interest
myWS->defineSet("obsSet", "n");
myWS->defineSet("poiSet", "sigma_s");
myWS->defineSet("nuisanceSet", "N_bkg,L,epsilon");
// ->model complete (Additional information can be found in the
// RooStats manual)
// feel free to vary the parameters, but don't forget to choose reasonable ranges for the
// variables. Currently the Bayesian methods will often not work well if the variable ranges
// are either too short (for obvious reasons) or too large (for technical reasons).
// A ModelConfig object is used to associate parts of your workspace with their statistical
// meaning (it is also possible to initialize BATCalculator directly with elements from the
// workspace but if you are sharing your workspace with others or if you want to use several
// different methods the use of ModelConfig will most often turn out to be the better choice.)
// setup the ModelConfig object
cout << "preparing the ModelConfig object" << endl;
ModelConfig modelconfig("modelconfig", "ModelConfig for this example");
modelconfig.SetWorkspace(*myWS);
modelconfig.SetPdf(*(myWS->pdf("model")));
modelconfig.SetParametersOfInterest(*(myWS->set("poiSet")));
modelconfig.SetPriorPdf(*(myWS->pdf("prior")));
modelconfig.SetNuisanceParameters(*(myWS->set("nuisanceSet")));
modelconfig.SetObservables(*(myWS->set("obsSet")));
// use BATCalculator to the derive credibility intervals as a function of the observed number of
// events in the hypothetical experiment
// define vector with tested numbers of events
TVectorD obsEvents;
// define vectors which will be filled with the lower and upper limits for each tested number
// of observed events
TVectorD BATul;
TVectorD BATll;
// fix upper limit of tested observed number of events
int obslimit = 10;
obsEvents.ResizeTo(obslimit);
BATul.ResizeTo(obslimit);
BATll.ResizeTo(obslimit);
cout << "starting the calculation of Bayesian credibility intervals with BATCalculator" << endl;
// loop over observed number of events in the hypothetical experiment
for (int obs = 1; obs <= obslimit; obs++) {
obsEvents[obs - 1] = (static_cast<double>(obs));
// prepare data input for the the observed number of events
// adjust number of observed events in the workspace. This is communicated to ModelConfig!
myWS->var("n")->setVal(obs);
// create data
RooDataSet data("data", "", *(modelconfig.GetObservables()));
data.add( *(modelconfig.GetObservables()));
// prepare BATCalulator
BATCalculator batcalc(data, modelconfig);
// give the BATCalculator a unique name (always a good idea in ROOT)
TString namestring = "mybatc_";
namestring += obs;
batcalc.SetName(namestring);
// fix amount of posterior probability in the calculated interval.
// the name confidence level is incorrect here
batcalc.SetConfidenceLevel(0.90);
// fix length of the Markov chain. (in general: the longer the Markov chain the more
// precise will be the results)
batcalc.SetnMCMC(20000);
// retrieve SimpleInterval object containing the information about the interval (this
// triggers the actual calculations)
SimpleInterval* interval = batcalc.GetInterval1D("sigma_s");
std::cout << "BATCalculator: 90% credibility interval: [ " << interval->LowerLimit() << " - " << interval->UpperLimit() << " ] or 95% credibility upper limit\n";
// add the interval borders for the current number of observed events to the vectors
// containing the lower and upper limits
BATll[obs - 1] = interval->LowerLimit();
BATul[obs - 1] = interval->UpperLimit();
// clean up for next loop element
batcalc.CleanCalculatorForNewData();
delete interval;
}
cout << "all limits calculated" << endl;
// summarize the results in a plot
TGraph* grBATll = new TGraph(obsEvents, BATll);
grBATll->SetLineColor(kGreen);
grBATll->SetLineWidth(200);
grBATll->SetFillStyle(3001);
grBATll->SetFillColor(kGreen);
TGraph* grBATul = new TGraph(obsEvents, BATul);
grBATul->SetLineColor(kGreen);
grBATul->SetLineWidth(-200);
grBATul->SetFillStyle(3001);
grBATul->SetFillColor(kGreen);
// create and draw multigraph
TMultiGraph* mg = new TMultiGraph("BayesianLimitsBATCalculator", "BayesianLimitsBATCalculator");
mg->SetTitle("example of Bayesian credibility intervals derived with BATCAlculator ");
mg->Add(grBATll);
mg->Add(grBATul);
mg->Draw("AC");
mg->GetXaxis()->SetTitle ("# observed events");
mg->GetYaxis()->SetTitle("limits on signal S (size of test: 0.1)");
mg->Draw("AC");
}
void exercise_3() {
//Open the rootfile and get the workspace from the exercise_0
TFile fIn("exercise_0.root");
fIn.cd();
RooWorkspace *w = (RooWorkspace*)fIn.Get("w");
//You can set constant parameters that are known
//If you leave them floating, the fit procedure will determine their uncertainty
w->var("mean")->setConstant(kFALSE); //don't fix the mean, it's what we want to know the interval for!
w->var("sigma")->setConstant(kTRUE);
w->var("tau")->setConstant(kTRUE);
w->var("Nsig")->setConstant(kTRUE);
w->var("Nbkg")->setConstant(kTRUE);
//Set the RooModelConfig and let it know what the content of the workspace is about
ModelConfig model;
model.SetWorkspace(*w);
model.SetPdf("PDFtot");
//Let the model know what is the parameter of interest
RooRealVar* mean = w->var("mean");
mean->setRange(120., 130.); //this is mostly for plotting reasons
RooArgSet poi(*mean);
// set confidence level
double confidenceLevel = 0.68;
//Build the profile likelihood calculator
ProfileLikelihoodCalculator plc;
plc.SetData(*(w->data("PDFtotData")));
plc.SetModel(model);
plc.SetParameters(poi);
plc.SetConfidenceLevel(confidenceLevel);
//Get the interval
LikelihoodInterval* plInt = plc.GetInterval();
//Now let's do the same for the Bayesian Calculator
//Now we also need to specify a prior in the ModelConfig
//To be quicker, we'll use the PDF factory facility of RooWorkspace
//NB!! For simplicity, we are using a flat prior, but this doesn't mean it's the best choice!
w->factory("Uniform::prior(mean)");
model.SetPriorPdf(*w->pdf("prior"));
//Construct the bayesian calculator
BayesianCalculator bc(*(w->data("PDFtotData")), model);
bc.SetConfidenceLevel(confidenceLevel);
bc.SetParameters(poi);
SimpleInterval* bcInt = bc.GetInterval();
// Let's make a plot
TCanvas dataCanvas("dataCanvas");
dataCanvas.Divide(2,1);
dataCanvas.cd(1);
LikelihoodIntervalPlot plotInt((LikelihoodInterval*)plInt);
plotInt.SetTitle("Profile Likelihood Ratio and Posterior for mH");
plotInt.SetMaximum(3.);
plotInt.Draw();
dataCanvas.cd(2);
RooPlot *bcPlot = bc.GetPosteriorPlot();
bcPlot->Draw();
dataCanvas.SaveAs("exercise_3.gif");
//Now print the interval for mH for the two methods
cout << "PLC interval is [" << plInt->LowerLimit(*mean) << ", " <<
plInt->UpperLimit(*mean) << "]" << endl;
cout << "Bayesian interval is [" << bcInt->LowerLimit() << ", " <<
bcInt->UpperLimit() << "]" << endl;
}
void counting( void ) {
//
// this function implements the interval calculation for a counting experiment
//
// make model
RooWorkspace * wspace = new RooWorkspace("myWS");
wspace -> factory("Uniform::model_pdf_1(x[0,1])");
wspace -> factory("Uniform::model_pdf_2(x)");
wspace -> factory("SUM::model_pdf(s[0,15]*model_pdf_1,b[1,0,2]*model_pdf_2)");
wspace -> factory("Lognormal::likelihood_b(b,1,3)");
wspace -> factory("PROD::model_likelihood(model_pdf, likelihood_b)");
wspace -> factory("Uniform::prior_pdf(s)");
// define observables
wspace -> defineSet("observables","x");
// define parameters of interest
wspace -> defineSet("poi","s");
// define nuisance parameters
wspace -> defineSet("nuisance_parameters","b");
// load data
RooArgList * observables = new RooArgList( *wspace->set("observables") );
RooDataSet * data = RooDataSet::read("counting_data_3.ascii", *observables);
data -> SetName("data");
wspace -> import(*data);
// model config
ModelConfig modelConfig("counting_model_config");
modelConfig . SetWorkspace(*wspace);
modelConfig . SetPdf(*wspace->pdf("model_likelihood"));
modelConfig . SetPriorPdf(*wspace->pdf("prior_pdf"));
modelConfig . SetParametersOfInterest(*wspace->set("poi"));
modelConfig . SetNuisanceParameters(*wspace->set("nuisance_parameters"));
wspace -> import(modelConfig, "counting_model_config");
// Bayesian Calculator
BayesianCalculator bc(*data, modelConfig);
bc.SetName("exostBayes");
wspace -> import(bc);
// inspect workspace
wspace -> Print();
// save workspace to file
wspace -> writeToFile("myWS.root");
// run Bayesian calculation
bc.SetConfidenceLevel(0.95);
SimpleInterval* bInt = 0;
bInt = bc.GetInterval();
// make plots
TCanvas * c1 = new TCanvas("c1");
RooPlot * bplot = bc.GetPosteriorPlot();
bplot -> Draw();
c1 -> SaveAs("posterior_pdf.png");
// query interval
std::cout << "Bayesian interval on s = [" <<
bInt->LowerLimit( ) << ", " <<
bInt->UpperLimit( ) << "]" << std::endl;
}
