void ws_profile_interval1( const char* wsfile = "ws-test1.root", const char* parName = "mu_susy_sig", double alpha = 0.10, double mu_susy_sig_val = 0., double xmax = -1. ) {
TFile* wstf = new TFile( wsfile ) ;
RooWorkspace* ws = dynamic_cast<RooWorkspace*>( wstf->Get("ws") );
ws->Print() ;
//// ModelConfig* modelConfig = (ModelConfig*) ws->obj( "SbModel" ) ;
//// printf("\n\n\n ===== SbModel ====================\n\n") ;
//// modelConfig->Print() ;
RooDataSet* rds = (RooDataSet*) ws->obj( "ra2b_observed_rds" ) ;
printf("\n\n\n ===== RooDataSet ====================\n\n") ;
rds->Print() ;
rds->printMultiline(cout, 1, kTRUE, "") ;
printf("\n\n\n ===== Grabbing %s rrv ====================\n\n", parName ) ;
RooRealVar* rrv_par = ws->var( parName ) ;
if ( rrv_par == 0x0 ) {
printf("\n\n\n *** can't find %s in workspace. Quitting.\n\n\n", parName ) ; return ;
} else {
printf(" current value is : %8.3f\n", rrv_par->getVal() ) ; cout << flush ;
}
if ( xmax > 0 ) { rrv_par->setMax( xmax ) ; }
printf("\n\n\n ===== Grabbing mu_susy_sig rrv ====================\n\n") ;
RooRealVar* rrv_mu_susy_sig = ws->var("mu_susy_sig") ;
if ( rrv_mu_susy_sig == 0x0 ) {
printf("\n\n\n *** can't find mu_susy_sig in workspace. Quitting.\n\n\n") ; return ;
}
if ( strcmp( parName, "mu_susy_sig" ) != 0 ) {
if ( mu_susy_sig_val >= 0. ) {
printf(" current value is : %8.3f\n", rrv_mu_susy_sig->getVal() ) ; cout << flush ;
printf(" fixing to %8.2f.\n", mu_susy_sig_val ) ;
rrv_mu_susy_sig->setVal( mu_susy_sig_val ) ;
rrv_mu_susy_sig->setConstant(kTRUE) ;
} else {
printf(" current value is : %8.3f\n", rrv_mu_susy_sig->getVal() ) ; cout << flush ;
printf(" allowing mu_susy_sig to float.\n") ;
rrv_mu_susy_sig->setConstant(kFALSE) ;
}
} else {
printf("\n\n profile plot parameter is mu_susy_sig.\n") ;
rrv_mu_susy_sig->setConstant(kFALSE) ;
}
printf("\n\n\n ===== Grabbing likelihood pdf ====================\n\n") ;
RooAbsPdf* likelihood = ws->pdf("likelihood") ;
if ( likelihood == 0x0 ) {
printf("\n\n\n *** can't find likelihood pdf in workspace. Quitting.\n\n\n") ; return ;
} else {
printf("\n\n likelihood pdf: \n\n") ;
likelihood->Print() ;
}
printf("\n\n\n ===== Doing a fit ====================\n\n") ;
likelihood->fitTo( *rds ) ;
double mlValue = rrv_par->getVal() ;
printf(" Maximum likelihood value of %s : %8.3f +/- %8.3f\n",
parName, rrv_par->getVal(), rrv_par->getError() ) ;
printf("\n\n ========== Creating ProfileLikelihoodCalculator\n\n" ) ; cout << flush ;
// ProfileLikelihoodCalculator plc( *rds, *modelConfig ) ;
ProfileLikelihoodCalculator plc( *rds, *likelihood, RooArgSet( *rrv_par ) ) ;
plc.SetTestSize( alpha ) ;
ConfInterval* plinterval = plc.GetInterval() ;
double low = ((LikelihoodInterval*) plinterval)->LowerLimit(*rrv_par) ;
double high = ((LikelihoodInterval*) plinterval)->UpperLimit(*rrv_par) ;
printf("\n\n Limits: %8.3f, %8.3f\n\n", low, high ) ;
printf("\n\n ========= Making profile likelihood plot\n\n") ; cout << flush ;
LikelihoodIntervalPlot* profPlot = new LikelihoodIntervalPlot((LikelihoodInterval*)plinterval) ;
TCanvas* cplplot = new TCanvas("cplplot","cplplot", 500, 400) ;
profPlot->Draw() ;
gPad->SetGridy(1) ;
char plotname[10000] ;
sprintf( plotname, "plplot-%s.png", parName ) ;
cplplot->SaveAs( plotname ) ;
if ( alpha > 0.3 ) {
printf("\n\n\n 1 standard-deviation errors for %s : %8.2f + %8.2f - %8.2f\n\n\n",
parName, mlValue, high-mlValue, mlValue-low ) ;
}
}
//
// 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();
}
Int_t Tprime::RunPlr( std::string channel, // ejets, mujets, combined
std::string mode, // observed, expected
double peak, // resonance mass
std::string suffix, // suffix for output file names
Int_t ntoys, // number of pseudoexperiments for expected limit
std::string inputdir ) { // input dir name
//
// Profile likelihood ratio calculation
//
//RooStats::ProfileLikelihoodTestStat::setReuseNLL(kTRUE) ; // activate use of setData()
//RooStats::ToyMCSampler::setUseMultiGen(kTRUE) ;// activate use of prepareMultiGen()
std::string legend = "[tprime::RunPlr()]: ";
// print out inputs
std::cout << legend << std::endl;
std::cout << legend << "Input parameters specified. Some of them are not used and defaults are entered" << std::endl;
std::cout << legend << "------------------------------" << std::endl;
std::cout << legend << "channel: " << channel << std::endl;
std::cout << legend << "mode: " << mode << std::endl;
std::cout << legend << "input directory: " << inputdir << std::endl;
std::cout << legend << "resonance peak mass: " << peak << std::endl;
std::cout << legend << "suffix: ->" << suffix << "<-" << std::endl;
std::cout << legend << "number of pseudo-experiments: "<< ntoys << std::endl;
std::cout << legend << std::endl;
// compose the workspace file name
char buf[1024];
sprintf(buf, "%sresults_%04.0f/tprime_%s_tprimeCrossSection_model.root", inputdir.c_str(), peak, channel.c_str());
std::string _file = buf;
std::cout << legend << "guessed name of the file with the workspace: >" << _file << "<" << std::endl;
//load workspace
LoadWorkspace(_file, channel);
// fix POI range if needed
std::cout << std::endl << legend << "fixing POI range to [0-10]" << std::endl;
pWs->var("xsec")->setRange(0,10);
// timer
TStopwatch t;
t.Start();
int pe_counter = 0;
while (pe_counter < ntoys) {
// set data
if (mode.find("observed") != std::string::npos ) {
std::cout << legend << std::endl;
std::cout << legend << "calculating an observed limit..." << std::endl;
std::cout << legend << std::endl;
GetWorkspaceData("obsData");
ntoys = 1;
//RooStats::ModelConfig * _mc = GetModaelConfig();
//_mc->GetPdf()->fitTo(*data, Save());
}
else if (mode.find("expected") != std::string::npos ) { // expected interval
std::cout << legend << std::endl;
std::cout << legend << "this is pseudoexperiment " << pe_counter+1 << " of " << ntoys << std::endl;
std::cout << legend << "for the expected limit estimate" << std::endl;
std::cout << legend << std::endl;
GetPseudoData();
//GetWorkspaceData("obsData");
} // end of expected interval
GetPlrInterval(0.95);
// query intervals
RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelow();
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
RooStats::ModelConfig * _mc = GetModelConfig();
RooRealVar * _poi = (RooRealVar *)_mc->GetParametersOfInterest()->first();
Double_t upper_limit = pPlrInt->UpperLimit( *_poi );
RooMsgService::instance().setGlobalKillBelow(msglevel);
std::cout << legend << "Profile Likelihood upper limit = " << upper_limit << std::endl;
std::string _outfile = "tprime_limit_plr_" + channel + "_" + mode + "_" + suffix + ".ascii";
std::vector<Double_t> results;
results.push_back(peak);
results.push_back(upper_limit);
PrintToFile( _outfile, results, "# peak upper_limit" );
++pe_counter;
} // end of while toy loop
// stop timer and print time used
t.Stop();
t.Print();
// make plot
TCanvas c1("c1");
LikelihoodIntervalPlot * pPlrPlot = new LikelihoodIntervalPlot(pPlrInt);
pPlrPlot->Draw();
std::string plot_file_name = "tprime_limit_" + channel + "_" + mode + "_" + suffix + ".pdf";
c1.SaveAs(plot_file_name.c_str());
delete pPlrPlot;
return 0;
}