// // single measurement (LM0 or LM1) // void RA4Single (StatMethod method, double* sig, double* bkg) { // RooWorkspace* wspace = createWorkspace(); RA4WorkSpace ra4WSpace("wspace",true,true,true); ra4WSpace.addChannel(RA4WorkSpace::MuChannel); ra4WSpace.finalize(); double lm0_mc[4] = { 1.09, 7.68, 3.78, 21.13 }; double lm1_mc[4] = { 0.05 , 0.34 , 1.12 , 3.43 }; double* lm_mc = sig ? sig : lm0_mc; double bkg_mc[4] = { 14.73, 18.20, 8.48, 10.98 }; ra4WSpace.setBackground(RA4WorkSpace::MuChannel,bkg_mc[0],bkg_mc[1],bkg_mc[2],bkg_mc[3]); ra4WSpace.setSignal(RA4WorkSpace::MuChannel,lm_mc[0],lm_mc[1],lm_mc[2],lm_mc[3],1.,1.,1.,1.); // setBackgrounds(wspace,bkg); // setSignal(wspace,lm_mc); RooWorkspace* wspace = ra4WSpace.workspace(); // wspace->Print("v"); // RooArgSet allVars = wspace->allVars(); // // allVars.printLatex(std::cout,1); // TIterator* it = allVars.createIterator(); // RooRealVar* var; // while ( var=(RooRealVar*)it->Next() ) { // var->Print("v"); // var->printValue(std::cout); // } //////////////////////////////////////////////////////////// // Generate toy data // generate toy data assuming current value of the parameters // import into workspace. // add Verbose() to see how it's being generated // wspace->var("s")->setVal(0.); // RooDataSet* data = wspace->pdf("model")->generate(*wspace->set("obs"),1); // data->Print("v"); // // wspace->import(*data); // wspace->var("s")->setVal(lm_mc[3]); RooDataSet* data = new RooDataSet("data","data",*wspace->set("obs")); data->add(*wspace->set("obs")); data->Print("v"); MyLimit limit = computeLimit(wspace,data,method,true); std::cout << "Limit [ " << limit.lowerLimit << " , " << limit.upperLimit << " ] ; isIn = " << limit.isInInterval << std::endl; }
void rf510_wsnamedsets() { // C r e a t e m o d e l a n d d a t a s e t // ----------------------------------------------- RooWorkspace* w = new RooWorkspace("w") ; fillWorkspace(*w) ; // Exploit convention encoded in named set "parameters" and "observables" // to use workspace contents w/o need for introspected RooAbsPdf* model = w->pdf("model") ; // Generate data from p.d.f. in given observables RooDataSet* data = model->generate(*w->set("observables"),1000) ; // Fit model to data model->fitTo(*data) ; // Plot fitted model and data on frame of first (only) observable RooPlot* frame = ((RooRealVar*)w->set("observables")->first())->frame() ; data->plotOn(frame) ; model->plotOn(frame) ; // Overlay plot with model with reference parameters as stored in snapshots w->loadSnapshot("reference_fit") ; model->plotOn(frame,LineColor(kRed)) ; w->loadSnapshot("reference_fit_bkgonly") ; model->plotOn(frame,LineColor(kRed),LineStyle(kDashed)) ; // Draw the frame on the canvas new TCanvas("rf510_wsnamedsets","rf503_wsnamedsets",600,600) ; gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ; // Print workspace contents w->Print() ; // Workspace will remain in memory after macro finishes gDirectory->Add(w) ; }
// // scan over parameter space // void RA4Mult (const RA4WorkingPoint& muChannel, const RA4WorkingPoint& eleChannel, StatMethod method) { // // Prepare workspace // no syst. parameters: efficiency / sig.cont. / kappa // bool noEffSyst(false); bool noSContSyst(false); bool noKappaSyst(false); RA4WorkSpace ra4WSpace("wspace",noEffSyst,noSContSyst,noKappaSyst); TFile* fYield[2]; TFile* fKFactor[2]; // // Muon channel // unsigned int nf(0); RA4WorkSpace::ChannelType channelTypes[2]; const RA4WorkingPoint* workingPoints[2]; addChannel(muChannel,RA4WorkSpace::MuChannel,ra4WSpace,fYield,fKFactor, nf,channelTypes,workingPoints); addChannel(eleChannel,RA4WorkSpace::EleChannel,ra4WSpace,fYield,fKFactor, nf,channelTypes,workingPoints); if ( nf==0 ) { std::cout << "No input file" << std::endl; return; } // // finish definition of model // ra4WSpace.finalize(); RooWorkspace* wspace = ra4WSpace.workspace(); // wspace->Print("v"); // RooArgSet allVars = wspace->allVars(); // // allVars.printLatex(std::cout,1); // TIterator* it = allVars.createIterator(); // RooRealVar* var; // while ( var=(RooRealVar*)it->Next() ) { // var->Print("v"); // var->printValue(std::cout); // } // // preparation of histograms with yields and k-factors // const char* cRegion = { "ABCD" }; TH2* hYields[4][2]; TH2* hYields05[4][2]; TH2* hYields20[4][2]; TH2* hYEntries[4][2]; TH2* hYESmooth[4][2]; for ( unsigned int j=0; j<nf; ++j ) { for ( unsigned int i=0; i<4; ++i ) { hYields[i][j] = 0; hYields05[i][j] = 0; hYields20[i][j] = 0; hYEntries[i][j] = 0; hYESmooth[i][j] = 0; } } TH2* hKF05[2]; TH2* hKF10[2]; TH2* hKF20[2]; for ( unsigned int j=0; j<nf; ++j ) { hKF05[j] = 0; hKF10[j] = 0; hKF20[j] = 0; } // // Retrieval of histograms with k-factors // for ( unsigned int j=0; j<nf; ++j ) { hKF05[j] = (TH2*)fKFactor[j]->Get("hKF05D"); hKF10[j] = (TH2*)fKFactor[j]->Get("hKF10D"); hKF20[j] = (TH2*)fKFactor[j]->Get("hKF20D"); if ( hKF05[j]==0 || hKF10==0 || hKF20==0 ) { std::cout << "Missing histogram for kfactor for channel " << j << std::endl; return; } } // // Retrieval of histograms with yields // std::string hName; for ( unsigned int j=0; j<nf; ++j ) { for ( unsigned int i=0; i<4; ++i ) { hName = "Events"; hName += cRegion[i]; hYields[i][j] = (TH2*)fYield[j]->Get(hName.c_str())->Clone(); hYields05[i][j] = (TH2*)fYield[j]->Get(hName.c_str())->Clone(); hYields20[i][j] = (TH2*)fYield[j]->Get(hName.c_str())->Clone(); if ( hYields[i][j]==0 ) { std::cout << "Missing histogram for region " << cRegion[i] << std::endl; return; } hYields[i][j]->Multiply(hYields[i][j],hKF10[j]); hYields05[i][j]->Multiply(hYields05[i][j],hKF05[j]); hYields20[i][j]->Multiply(hYields20[i][j],hKF20[j]); hName = "Entries"; hName += cRegion[i]; hYEntries[i][j] = (TH2*)fYield[j]->Get(hName.c_str()); if ( hYEntries[i][j]==0 ) { std::cout << "Missing histogram for region " << cRegion[i] << std::endl; return; } hName = "SmoothEntries"; hName += cRegion[i]; hYESmooth[i][j] = (TH2*)fYield[j]->Get(hName.c_str()); if ( hYESmooth[i][j]==0 ) { std::cout << "Missing histogram for region " << cRegion[i] << std::endl; return; } // convert to efficiency (assume 10000 MC events/bin) hYEntries[i][j]->Scale(1/10000.); hYESmooth[i][j]->Scale(1/10000.); // convert yield to cross section hYields[i][j]->Divide(hYields[i][j],hYEntries[i][j]); hYields05[i][j]->Divide(hYields05[i][j],hYEntries[i][j]); hYields20[i][j]->Divide(hYields20[i][j],hYEntries[i][j]); } } // // histograms with exclusion and limits // gROOT->cd(); TH2* hExclusion = (TH2*)hYields[0][0]->Clone("Exclusion"); hExclusion->Reset(); hExclusion->SetTitle("Exclusion"); TH2* hLowerLimit = (TH2*)hYields[0][0]->Clone("LowerLimit"); hLowerLimit->Reset(); hLowerLimit->SetTitle("LowerLimit"); TH2* hUpperLimit = (TH2*)hYields[0][0]->Clone("UpperLimit"); hUpperLimit->Reset(); hUpperLimit->SetTitle("UpperLimit"); double yields[4][2]; double yields05[4][2]; double yields20[4][2]; double entries[4][2]; // double bkgs[4][2]; // double kappa = (bkgs[0]*bkgs[3])/(bkgs[1]*bkgs[2]); // double sigma_kappa_base = 0.10; // double delta_kappa_abs = kappa - 1.; // double sigma_kappa = sqrt(sigma_kappa_base*sigma_kappa_base+delta_kappa_abs*delta_kappa_abs); // sigma_kappa = sqrt(0.129*0.129+0.1*0.1); #ifndef DEBUG int nbx = hYields[0][0]->GetNbinsX(); int nby = hYields[0][0]->GetNbinsY(); for ( int ix=1; ix<=nbx; ++ix ) { for ( int iy=1; iy<=nby; ++iy ) { #else { int ix=40; { int iy=11; #endif bool process(false); for ( unsigned int j=0; j<nf; ++j ) { ra4WSpace.setBackground(channelTypes[j], workingPoints[j]->bkg_[0],workingPoints[j]->bkg_[1], workingPoints[j]->bkg_[2],workingPoints[j]->bkg_[3]); ra4WSpace.setObserved(channelTypes[j], workingPoints[j]->obs_[0],workingPoints[j]->obs_[1], workingPoints[j]->obs_[2],workingPoints[j]->obs_[3]); for ( unsigned int i=0; i<4; ++i ) { yields[i][j] = hYields[i][j]->GetBinContent(ix,iy); yields05[i][j] = hYields05[i][j]->GetBinContent(ix,iy); yields20[i][j] = hYields20[i][j]->GetBinContent(ix,iy); entries[i][j] = hYESmooth[i][j]->GetBinContent(ix,iy); } if ( yields[3][j]>0.01 && yields[3][j]<10000 && entries[3][j]>0.0001 ) process = true; ra4WSpace.setSignal(channelTypes[j], yields[0][j],yields[1][j], yields[2][j],yields[3][j], entries[0][j],entries[1][j], entries[2][j],entries[3][j]); #ifdef DEBUG std::cout << "yields for channel " << j << " ="; for ( unsigned int i=0; i<4; ++i ) std::cout << " " << yields[i][j]; std::cout << endl; std::cout << "effs for channel " << j << " ="; for ( unsigned int i=0; i<4; ++i ) std::cout << " " << entries[i][j]; std::cout << endl; std::cout << "backgrounds for channel " << j << " ="; for ( unsigned int i=0; i<4; ++i ) std::cout << " " << workingPoints[j]->bkg_[i]; std::cout << endl; #endif } MyLimit limit(true,0.,999999999.); double sumD(0.); for ( unsigned int j=0; j<nf; ++j ) { sumD += (yields[3][j]*entries[3][j]); } if ( !process || sumD<0.01 ) { hExclusion->SetBinContent(ix,iy,limit.isInInterval); hLowerLimit->SetBinContent(ix,iy,limit.lowerLimit); hUpperLimit->SetBinContent(ix,iy,limit.upperLimit); #ifndef DEBUG continue; #endif } double sigK(0.); for ( unsigned int j=0; j<nf; ++j ) { if ( workingPoints[j]->sigKappa_>sigK ) sigK = workingPoints[j]->sigKappa_; // sigK += workingPoints[j]->sigKappa_; } // sigK /= nf; double sigEffBase(0.15); double sigEffLept(0.05); double sigEffNLO(0.); for ( unsigned int j=0; j<nf; ++j ) { double sige = max(fabs(yields05[3][j]-yields[3][j]), fabs(yields20[3][j]-yields[3][j])); sige /= yields[3][j]; if ( sige>sigEffNLO ) sigEffNLO = sige; } double sigEff = sqrt(sigEffBase*sigEffBase+sigEffLept*sigEffLept+sigEffNLO*sigEffNLO); std::cout << "Systematics are " << sigK << " " << sigEff << std::endl; sigEff = 0.20; if ( !noKappaSyst ) wspace->var("sigmaKappa")->setVal(sigK); if ( !noSContSyst ) wspace->var("sigmaScont")->setVal(sigEff); if ( !noEffSyst ) wspace->var("sigmaEff")->setVal(sigEff); // wspace->var("sigmaKappa")->setVal(sqrt(0.129*0.129+0.1*0.1)*0.967); // for the time being: work with yields // if ( muChannel.valid_ ) { // wspace->var("effM")->setVal(1.); // wspace->var("sadM")->setVal(0.); // wspace->var("sbdM")->setVal(0.); // wspace->var("scdM")->setVal(0.); // } // if ( eleChannel.valid_ ) { // wspace->var("effE")->setVal(1.); // wspace->var("sadE")->setVal(0.); // wspace->var("sbdE")->setVal(0.); // wspace->var("scdE")->setVal(0.); // } #ifdef DEBUG wspace->Print("v"); RooArgSet allVars = wspace->allVars(); // allVars.printLatex(std::cout,1); TIterator* it = allVars.createIterator(); RooRealVar* var; while ( var=(RooRealVar*)it->Next() ) { var->Print("v"); var->printValue(std::cout); std::cout << std::endl; } #endif std::cout << "Checked ( " << hExclusion->GetXaxis()->GetBinCenter(ix) << " , " << hExclusion->GetYaxis()->GetBinCenter(iy) << " ) with signal " << yields[3][nf-1] << std::endl; RooDataSet data("data","data",*wspace->set("obs")); data.add(*wspace->set("obs")); data.Print("v"); limit = computeLimit(wspace,&data,method); std::cout << " Limit [ " << limit.lowerLimit << " , " << limit.upperLimit << " ] ; isIn = " << limit.isInInterval << std::endl; double excl = limit.isInInterval; if ( limit.upperLimit<limit.lowerLimit ) excl = -1; hExclusion->SetBinContent(ix,iy,excl); hLowerLimit->SetBinContent(ix,iy,limit.lowerLimit); hUpperLimit->SetBinContent(ix,iy,limit.upperLimit); // return; } } TFile* out = new TFile("RA4abcd.root","RECREATE"); hExclusion->SetDirectory(out); hExclusion->SetMinimum(); hExclusion->SetMaximum(); hExclusion->SetContour(1); hExclusion->SetContourLevel(0,0.5); hLowerLimit->SetDirectory(out); hLowerLimit->SetMinimum(); hLowerLimit->SetMaximum(); hUpperLimit->SetDirectory(out); hUpperLimit->SetMinimum(); hUpperLimit->SetMaximum(); for ( unsigned int j=0; j<nf; ++j ) { hYields[3][j]->SetDirectory(out); hYields[3][j]->SetMinimum(); hYields[3][j]->SetMaximum(); } out->Write(); delete out; }
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 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 fillDatasets( TString fname, TString tname, TString outfname ) { TFile *inFile = TFile::Open( fname ); TTree *tree = (TTree*)inFile->Get( tname ); ULong64_t eventNumber; TString *year = 0; double B_s0_DTF_B_s0_M; int itype; bool pass_bdt; bool pass_pid; bool pass_rhokst; bool pass_massveto; bool pass_multcand; bool B_s0_L0HadronDecision_TOS; bool B_s0_L0Global_TIS; double B_s0_DTF_KST1_M; double B_s0_DTF_KST2_M; tree->SetBranchAddress( "eventNumber" , &eventNumber ); tree->SetBranchAddress( "year" , &year ); tree->SetBranchAddress( "B_s0_DTF_B_s0_M" , &B_s0_DTF_B_s0_M ); tree->SetBranchAddress( "itype" , &itype ); tree->SetBranchAddress( "pass_bdt" , &pass_bdt ); tree->SetBranchAddress( "pass_pid" , &pass_pid ); tree->SetBranchAddress( "pass_rhokst" , &pass_rhokst ); tree->SetBranchAddress( "pass_massveto" , &pass_massveto ); tree->SetBranchAddress( "pass_multcand" , &pass_multcand ); tree->SetBranchAddress( "B_s0_L0HadronDecision_TOS" , &B_s0_L0HadronDecision_TOS ); tree->SetBranchAddress( "B_s0_L0Global_TIS" , &B_s0_L0Global_TIS ); tree->SetBranchAddress( "B_s0_DTF_KST1_M" , &B_s0_DTF_KST1_M ); tree->SetBranchAddress( "B_s0_DTF_KST2_M" , &B_s0_DTF_KST2_M ); RooWorkspace *w = new RooWorkspace("w","w"); defineDatasets( w ); for (int ev=0; ev<tree->GetEntries(); ev++) { tree->GetEntry(ev); if ( ev%10000==0 ) cout << ev << " / " << tree->GetEntries() << endl; // cut events outside the mass window if ( B_s0_DTF_B_s0_M < 5000 || B_s0_DTF_B_s0_M > 5800 ) continue; if ( B_s0_DTF_KST1_M < 750 || B_s0_DTF_KST1_M > 1600 ) continue; if ( B_s0_DTF_KST2_M < 750 || B_s0_DTF_KST2_M > 1600 ) continue; // set workspace values w->var("B_s0_DTF_B_s0_M")->setVal( B_s0_DTF_B_s0_M ); w->var("eventNumber")->setVal( eventNumber ); if ( *year==TString("2011") ) { if ( B_s0_L0HadronDecision_TOS ) w->cat("DataCat")->setLabel("HadronTOS2011"); else if ( B_s0_L0Global_TIS && !B_s0_L0HadronDecision_TOS ) w->cat("DataCat")->setLabel("GlobalTIS2011"); else continue; } else if ( *year==TString("2012") ) { if ( B_s0_L0HadronDecision_TOS ) w->cat("DataCat")->setLabel("HadronTOS2012"); else if ( B_s0_L0Global_TIS && !B_s0_L0HadronDecision_TOS ) w->cat("DataCat")->setLabel("GlobalTIS2012"); else continue; } else continue; // for the most case we put the bdt and pid requirement in // for low stats MC samples we don't use it // // NO REQUIREMENT: // Lb2pKpipi MC if ( itype == -78 || itype == -88 ) { w->data("Lb2pKpipi")->add( *w->set("observables") ); } // Lb2ppipipi MC else if ( itype == -79 || itype == -89 ) { w->data("Lb2ppipipi")->add( *w->set("observables") ); } // Bd2PhiKst MC else if ( itype == -75 || itype == -85 ) { w->data("Bd2PhiKst")->add( *w->set("observables") ); } // Bs2PhiKst MC else if ( itype == -76 || itype == -86 ) { w->data("Bs2PhiKst")->add( *w->set("observables") ); } // Bd2RhoKst MC else if ( itype == -77 || itype == -87 ) { w->data("Bd2RhoKst")->add( *w->set("observables") ); } // FROM HERE BDT, PID AND MASS VETO REQUIREMENTS //if ( pass_bdt && pass_pid && pass_multcand && !pass_rhokst && !pass_massveto) { if ( pass_bdt && pass_pid && pass_multcand && !pass_massveto) { // Data 2011 if ( itype == 71 ) { w->data("Data")->add( *w->set("observables") ); w->data("Data2011")->add( *w->set("observables") ); if ( B_s0_L0HadronDecision_TOS ) { w->data("Data2011HadronTOS")->add( *w->set("observables") ); } if ( B_s0_L0Global_TIS && !B_s0_L0HadronDecision_TOS ) { w->data("Data2011GlobalTIS")->add( *w->set("observables") ); } } // Data 2012 else if ( itype == 81 ) { w->data("Data")->add( *w->set("observables") ); w->data("Data2012")->add( *w->set("observables") ); if ( B_s0_L0HadronDecision_TOS ) { w->data("Data2012HadronTOS")->add( *w->set("observables") ); } if ( B_s0_L0Global_TIS && !B_s0_L0HadronDecision_TOS ) { w->data("Data2012GlobalTIS")->add( *w->set("observables") ); } } // Bs2KstKst MC else if ( itype == -70 || itype == -80 ) { w->data("Bs2KstKst")->add( *w->set("observables") ); } // Bs2KstKst1430 MC else if ( itype == -71 || itype == -81 ) { w->data("Bs2KstKst1430")->add( *w->set("observables") ); } // Bs2Kst1430Kst1430 MC else if ( itype == -72 || itype == -82 ) { w->data("Bs2Kst1430Kst1430")->add( *w->set("observables") ); } // Bs2KPiKPi PhaseSpace else if ( itype == -73 || itype == -83 ) { w->data("Bs2KpiKpiPhaseSpace")->add( *w->set("observables") ); } // Bd2KstKst MC else if ( itype == -74 || itype == -84 ) { w->data("Bd2KstKst")->add( *w->set("observables") ); } } } // combined data map<string,RooDataSet*> dsetMap; dsetMap[ "HadronTOS2011" ] = (RooDataSet*)w->data("Data2011HadronTOS") ; dsetMap[ "GlobalTIS2011" ] = (RooDataSet*)w->data("Data2011GlobalTIS") ; dsetMap[ "HadronTOS2012" ] = (RooDataSet*)w->data("Data2012HadronTOS") ; dsetMap[ "GlobalTIS2012" ] = (RooDataSet*)w->data("Data2012GlobalTIS") ; RooDataSet *DataComb = new RooDataSet( "DataCombined", "DataCombined", *w->set("observables"), Index(*w->cat("DataCat")), Import(dsetMap) ); w->import(*DataComb); delete DataComb; inFile->Close(); delete inFile; delete year; w->writeToFile( outfname ); }
void makeModel(RooWorkspace& w) { TFile *_file0 = TFile::Open("plots/htotal_root_ZprimeRecomass.root"); TH1F *Histo = (TH1F*)_file0->Get("htotaldata"); RooRealVar invm("invm","invm",200.,4000.); RooDataHist* data = new RooDataHist("data","data",invm,Import(*Histo)) ; // TTree* tree = new TTree("simple","data from ascii file"); // Long64_t nlines = tree->ReadFile("list_mll_200_2016.txt","x1:x2:x3:invm:x5:x6"); // Long64_t nlines = tree->ReadFile("a.txt","x1:x2:x3:invm:x5:x6"); // printf(" found %lld pointsn",nlines); // tree->Write(); // tree->GetEntries(); RooRealVar mass("mass","mass", 300., 200., 1600.); RooRealVar nsig("nsig","Number of signal events", 0., 5000.); RooRealVar nbkg("nbkg","Number of background events", 0., 300000.); w.import(mass); w.import(nsig); w.import(nbkg); // RooRealVar invm("invm","Invariant mass", 200., 4000.); // RooDataSet* data = new RooDataSet("data", "Data", invm, RooFit::Import(*tree)); data->Print("v"); w.import(invm); w.import(*data); w.factory("expr::sigma('invm*(0.01292 + 0.00001835 * invm - 0.0000000002733 * invm*invm)',invm)"); w.factory("expr::width('0.03*invm',invm)"); w.factory("CEXPR::bkgpdf('exp(24.9327 - 2.39287e-03*invm + 3.19926e-07*invm*invm - 3.38799e-11*invm*invm*invm)*pow(invm,-3.3634)',invm)"); w.factory("Voigtian::sigpdf(invm,mass,width,sigma)"); w.factory("SUM::model(nbkg*bkgpdf, nsig*sigpdf)"); RooAbsPdf* sigpdf = w.pdf("sigpdf"); RooAbsPdf* bkgpdf = w.pdf("bkgpdf"); RooAbsPdf* model = w.pdf("model"); RooStats::ModelConfig* mc = new ModelConfig("mc",&w); mc->SetPdf(*w.pdf("model")); mc->SetParametersOfInterest(*w.var("nsig")); mc->SetObservables(*w.var("invm")); w.defineSet("nuisParams","nbkg"); mc->SetNuisanceParameters(*w.set("nuisParams")); w.var("mass")->setConstant(true); w.import(*mc); w.Print("tree"); w.writeToFile("MyModel_workspace.root"); TCanvas* c1 = new TCanvas("c1","Control Plots", 900, 700); RooPlot* plot = w.var("invm")->frame(); w.data("data")->plotOn(plot); w.pdf("model")->plotOn(plot); w.pdf("model")->plotOn(plot, Components("bkgpdf"),LineStyle(kDashed)); w.pdf("model")->plotOn(plot, Components("sigpdf"),LineColor(kRed)); plot->Draw(); return; }
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; }