readExclusion() { TFile * file = new TFile("theExclusion_M115_EGMLOOSE006.root"); HypoTestInverterResult * r = dynamic_cast<HypoTestInverterResult*>( file->Get("result_r") ); double upperLimit = r->UpperLimit(); double ulError = r->UpperLimitEstimatedError(); std::cout << "The computed upper limit is: " << upperLimit << " +/- " << ulError << std::endl; const int nEntries = r->ArraySize(); TCanvas *c0 = new TCanvas("c0","coucou",600,600); c0->SetFillColor(0); TString plotTitle = "CL Scan for workspace"; HypoTestInverterPlot *plot = new HypoTestInverterPlot("HTI_Result_Plot",plotTitle,r); plot->Draw("CLb 2CL"); // plot all and Clb c0->Print("limit_plot.gif"); const int nEntries = r->ArraySize(); cout << "N entries = " << nEntries << endl; TCanvas * c2 = new TCanvas(); c2->Divide( 2, TMath::Ceil(nEntries/2)); for (int i=0; i<nEntries; i++) { c2->cd(i+1); SamplingDistPlot * pl = plot->MakeTestStatPlot(i); pl->SetLogYaxis(true); pl->Draw(); } }
void central_interval_Hybrid_fixed_scan(Model* model,double confidence,int n_toys_per_point,double lower_scan_bound, double upper_scan_bound,int n_steps,int random_seed=0,bool useCLS=true){ cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl; cout<<"Calculating central interval with the Hybrid method"<<endl; cout<<"///////////////////////////////////////////////////////////////////////////////////////////"<<endl; //set the random seed RooRandom::randomGenerator()->SetSeed(random_seed); //get the calculator HybridCalculatorOriginal myhc(*model->get_data(),*model->get_sb_likelihood(),*model->get_b_likelihood()); //for numbercounting experiments myhc.PatchSetExtended(false); //set likelihood ratio as the test statistics myhc.SetTestStatistic(1); //define the systematics to be used if (model->get_nuisance_set()) { myhc.UseNuisance(true); myhc.SetNuisancePdf(*model->get_nuisance_prior_pdf()); myhc.SetNuisanceParameters(*model->get_nuisance_set()); } else { myhc.UseNuisance(false); } //define the number of toys to be done myhc.SetNumberOfToys(n_toys_per_point); //get the interval calculator HypoTestInverter myInverter(myhc,*model->get_POI()); //use the CLS method myInverter.UseCLs(useCLS); //set the confidence myInverter.SetTestSize(1-confidence); //run the auto fixed in range lower_scan_bound - upper_scan_bound with n_steps steps myInverter.RunFixedScan(n_steps,lower_scan_bound,upper_scan_bound); //get the result HypoTestInverterResult* results = myInverter.GetInterval(); double upperLimit = results->UpperLimit(); double lowerLimit = results->LowerLimit(); std::cout <<confidence<<"% interval is: " << lowerLimit<<" , "<< upperLimit << std::endl; }
void rs801_HypoTestInverterOriginal() { // prepare the model RooRealVar lumi("lumi","luminosity",1); RooRealVar r("r","cross-section ratio",3.74,0,50); RooFormulaVar ns("ns","1*r*lumi",RooArgList(lumi,r)); RooRealVar nb("nb","background yield",1); RooRealVar x("x","dummy observable",0,1); RooConstVar p0(RooFit::RooConst(0)); RooPolynomial flatPdf("flatPdf","flat PDF",x,p0); RooAddPdf totPdf("totPdf","S+B model",RooArgList(flatPdf,flatPdf),RooArgList(ns,nb)); RooExtendPdf bkgPdf("bkgPdf","B-only model",flatPdf,nb); RooDataSet* data = totPdf.generate(x,1); // prepare the calculator HybridCalculatorOriginal myhc(*data, totPdf, bkgPdf,0,0); myhc.SetTestStatistic(2); myhc.SetNumberOfToys(1000); myhc.UseNuisance(false); // run the hypothesis-test invertion HypoTestInverterOriginal myInverter(myhc,r); myInverter.SetTestSize(0.10); myInverter.UseCLs(true); // myInverter.RunFixedScan(5,1,6); // scan for a 95% UL myInverter.RunAutoScan(3.,5,myInverter.Size()/2,0.005); // run an alternative autoscan algorithm // myInverter.RunAutoScan(1,6,myInverter.Size()/2,0.005,1); //myInverter.RunOnePoint(3.9); HypoTestInverterResult* results = myInverter.GetInterval(); HypoTestInverterPlot myInverterPlot("myInverterPlot","",results); TGraphErrors* gr1 = myInverterPlot.MakePlot(); gr1->Draw("ALP"); double ulError = results->UpperLimitEstimatedError(); double upperLimit = results->UpperLimit(); std::cout << "The computed upper limit is: " << upperLimit << std::endl; std::cout << "an estimated error on this upper limit is: " << ulError << std::endl; // expected result: 4.10 }
double countingExperiment95CLUpperLimit (int nObserved, double bkgMean, double bkgSigma, int nToys=500) { // expect nothing beyond 5 sigma double bkgMaxExpected = bkgMean+5*bkgSigma; // 5 sigma double signalMaxExpected = nObserved+5*sqrt(double(nObserved))-bkgMean+5*bkgSigma; // variables RooRealVar signal ("signal", "signal", 0, 0, signalMaxExpected); RooRealVar bkg ("bkg", "bkg", bkgMean, 0, bkgMaxExpected); RooRealVar flatUnit ("flatUnit","flatUnit",0.,1.); // sets RooArgSet nuisPar (bkg); RooArgSet poi (signal); // constants RooRealVar bkgMeanVar ("bkgMean", "bkgMean", bkgMean); RooRealVar bkgSigmaVar ("bkgSigma", "bkgSigma", bkgSigma); // PDFs RooUniform signalPdf ("signalPdf","signalPdf",flatUnit); RooUniform backgroundPdf ("backgroundPdf","backgroundPdf",flatUnit); RooAddPdf modelPdf ("model","model",RooArgList(signalPdf,backgroundPdf),RooArgList(signal,bkg)); RooExtendPdf modelBkgPdf ("modelBkg","modelBkg",backgroundPdf,bkg); RooGaussian priorBkgPdf ("priorBkg","priorBkg",bkg,bkgMeanVar,bkgSigmaVar); RooDataSet* data = modelPdf.generate(flatUnit, nObserved); HybridCalculator hc(*data, modelPdf, modelBkgPdf, &nuisPar, &priorBkgPdf); hc.SetTestStatistic(2); // # of events hc.SetNumberOfToys(nToys); hc.UseNuisance(true); HypoTestInverter myInverter(hc,signal); double targetP = 0.05; // 95% C.L. myInverter.RunAutoScan(0, signalMaxExpected, targetP, 0.1*targetP); HypoTestInverterResult* results = myInverter.GetInterval(); results->SetConfidenceLevel (1-2.*targetP); double upperLimit = results->UpperLimit(); delete data; // delete results; return upperLimit; }
readExclusion_M130(){ TString massPointString = IntToString(massPoint); TFile * file = new TFile("theExclusion_M"+massPointString+"_"+nomPlot+".root"); HypoTestInverterResult * r = dynamic_cast<HypoTestInverterResult*>( file->Get("result_r") ); double upperLimit = r->UpperLimit(); double ulError = r->UpperLimitEstimatedError(); std::cout << "The computed upper limit is: " << upperLimit << " +/- " << ulError << std::endl; const int nEntries = r->ArraySize(); TCanvas *c0 = new TCanvas("c0","coucou",600,600); c0->SetFillColor(0); TString plotTitle = "CL Scan for workspace"; HypoTestInverterPlot *plot = new HypoTestInverterPlot("HTI_Result_Plot",plotTitle,r); plot->Draw("CLb 2CL");//("CLb 2CL"); // plot all and Clb c0->Print("limit_plot_M"+massPointString+".gif"); const int nEntries = r->ArraySize(); cout << "N entries = " << nEntries << endl; TCanvas * c2 = new TCanvas(); c2->Divide( 2, TMath::Ceil(nEntries/2)); for (int i=0; i<nEntries; i++) { c2->cd(i+1); SamplingDistPlot * pl = plot->MakeTestStatPlot(i); pl->SetLogYaxis(true); pl->Draw(); } std::cout << "The computed upper limit is: " << upperLimit << " +/- " << ulError << std::endl; std::cout << "The expected limi is : " << r->GetExpectedUpperLimit(0) << endl; float expected = r->GetExpectedUpperLimit(0); float observed = r->UpperLimit(); float observedError = r->UpperLimitEstimatedError(); float expected1sP = r->GetExpectedUpperLimit(1); float expected2sP = r->GetExpectedUpperLimit(2); float expected1sM = r->GetExpectedUpperLimit(-1); float expected2sM = r->GetExpectedUpperLimit(-2); cout << "ZZZZ graph->SetPoint(" <<number << "," << massPoint<< "," << expected << ");" << endl; cout << "ZZZZ grae->SetPoint(" <<number << "," << massPoint<< "," << expected << ");" << endl; cout << "ZZZZ grae->SetPointError(" << number << ",0,0," << (expected-expected1sM) << "," << (expected1sP-expected) << ");" << endl; cout << "ZZZZ grae2->SetPoint(" <<number << "," << massPoint<< "," << expected << ");" << endl; cout << "ZZZZ grae2->SetPointError(" << number << ",0,0," << (expected-expected2sM) << "," << (expected2sP-expected) << ");" << endl; cout << "ZZZZ gre->SetPoint(" <<number << "," << massPoint<< "," << observed << ");" << endl; cout << "ZZZZ gre->SetPointError(" <<number << ",0," << observedError <<");" << endl; }
void RA2bHypoTestInvDemo(const char * fileName =0, const char * wsName = "combined", const char * modelSBName = "ModelConfig", const char * modelBName = "", const char * dataName = "obsData", int calculatorType = 0, int testStatType = 3, bool useCls = true , int npoints = 5, double poimin = 0, double poimax = 5, int ntoys=1000, int mgl = -1, int mlsp = -1, const char * outFileName = "test") { /* Other Parameter to pass in tutorial apart from standard for filename, ws, modelconfig and data type = 0 Freq calculator type = 1 Hybrid testStatType = 0 LEP = 1 Tevatron = 2 Profile Likelihood = 3 Profile Likelihood one sided (i.e. = 0 if mu < mu_hat) useCLs scan for CLs (otherwise for CLs+b) npoints: number of points to scan , for autoscan set npoints = -1 poimin,poimax: min/max value to scan in case of fixed scans (if min >= max, try to find automatically) ntoys: number of toys to use extra options are available as global paramters of the macro. They are: plotHypoTestResult plot result of tests at each point (TS distributions) useProof = true; writeResult = true; nworkers = 4; */ if (fileName==0) { fileName = "results/example_combined_GaussExample_model.root"; std::cout << "Use standard file generated with HistFactory :" << fileName << std::endl; } TFile * file = new TFile(fileName); RooWorkspace * w = dynamic_cast<RooWorkspace*>( file->Get(wsName) ); HypoTestInverterResult * r = 0; std::cout << w << "\t" << fileName << std::endl; if (w != NULL) { r = RunInverter(w, modelSBName, modelBName, dataName, calculatorType, testStatType, npoints, poimin, poimax, ntoys, useCls ); if (!r) { std::cerr << "Error running the HypoTestInverter - Exit " << std::endl; return; } } else { // case workspace is not present look for the inverter result std::cout << "Reading an HypoTestInverterResult with name " << wsName << " from file " << fileName << std::endl; r = dynamic_cast<HypoTestInverterResult*>( file->Get(wsName) ); // if (!r) { std::cerr << "File " << fileName << " does not contain a workspace or an HypoTestInverterResult - Exit " << std::endl; file->ls(); return; } } printf("\n\n") ; HypoTestResult* htr = r->GetResult(0) ; printf(" Data value for test stat : %7.3f\n", htr->GetTestStatisticData() ) ; printf(" CLsplusb : %9.4f\n", r->CLsplusb(0) ) ; printf(" CLb : %9.4f\n", r->CLb(0) ) ; printf(" CLs : %9.4f\n", r->CLs(0) ) ; printf("\n\n") ; cout << flush ; double upperLimit = r->UpperLimit(); double ulError = r->UpperLimitEstimatedError(); std::cout << "The computed upper limit is: " << upperLimit << " +/- " << ulError << std::endl; const int nEntries = r->ArraySize(); const char * typeName = (calculatorType == 0) ? "Frequentist" : "Hybrid"; const char * resultName = (w) ? w->GetName() : r->GetName(); TString plotTitle = TString::Format("%s CL Scan for workspace %s",typeName,resultName); HypoTestInverterPlot *plot = new HypoTestInverterPlot("HTI_Result_Plot",plotTitle,r); TCanvas* c1 = new TCanvas() ; plot->Draw("CLb 2CL"); // plot all and Clb c1->Update() ; c1->SaveAs("cls-canv1.png") ; c1->SaveAs("cls-canv1.pdf") ; if (plotHypoTestResult) { TCanvas * c2 = new TCanvas(); c2->Divide( 2, TMath::Ceil(nEntries/2)); for (int i=0; i<nEntries; i++) { c2->cd(i+1); SamplingDistPlot * pl = plot->MakeTestStatPlot(i); pl->SetLogYaxis(true); pl->Draw(); } c2->Update() ; c2->SaveAs("cls-canv2.png") ; c2->SaveAs("cls-canv2.pdf") ; } std::cout << " expected limit (median) " << r->GetExpectedUpperLimit(0) << std::endl; std::cout << " expected limit (-1 sig) " << r->GetExpectedUpperLimit(-1) << std::endl; std::cout << " expected limit (+1 sig) " << r->GetExpectedUpperLimit(1) << std::endl; // save 2d histograms bin to file TH2F *result = new TH2F("result","result",22,100,1200,23,50,1200); TH2F *exp_res = new TH2F("exp_res","exp_res",22,100,1200,23,50,1200); TH2F *exp_res_minus = new TH2F("exp_res_minus","exp_res_minus",22,100,1200,23,50,1200); TH2F *exp_res_plus = new TH2F("exp_res_plus","exp_res_plus",22,100,1200,23,50,1200); result->Fill(mgl,mlsp,upperLimit); exp_res->Fill(mgl,mlsp,r->GetExpectedUpperLimit(0)); exp_res_minus->Fill(mgl,mlsp,r->GetExpectedUpperLimit(-1)); exp_res_plus->Fill(mgl,mlsp,r->GetExpectedUpperLimit(1)); TFile *f = new TFile(outFileName,"RECREATE"); f->cd(); result->Write(); exp_res->Write(); exp_res_minus->Write(); exp_res_plus->Write(); f->Close(); if (w != NULL && writeResult) { // write to a file the results const char * calcType = (calculatorType == 0) ? "Freq" : "Hybr"; const char * limitType = (useCls) ? "CLs" : "Cls+b"; const char * scanType = (npoints < 0) ? "auto" : "grid"; TString resultFileName = TString::Format("%s_%s_%s_ts%d_",calcType,limitType,scanType,testStatType); resultFileName += fileName; TFile * fileOut = new TFile(resultFileName,"RECREATE"); r->Write(); fileOut->Close(); } }
void test_counting_experiment() { ////////////////////// MODEL BUILDING ///////////////////////////////// /////////////////////////////////////////////////////////////////////////// /* N_s = N_tot_theory(Mass,Xsec) * Acceptance_SR * Eff_AmBe_bin_i * mu N_b = N_Co_SR_bin_i * Norm_factor Xesec: considered 10^-40 cm^2 Norm_factor = N_Data_CR / N_Co_CR --> assuming no difference between Co and Data in CR and SR. N_tot_theory(Mass,Xsec): for 225 livedays, 45kg and considering Xsec. It is a constant, no uncertainty at the moment. ---Costraint Signal nuissance parameter = Acceptance_SR, Eff_AmBe_bin_i Gauss(Acceptance_SR_obs | Acceptance_SR, err.) Poisson(S0_i | S_tot_SR * Eff_AmBe_bin_i) ---Costraint Bkg nuissance parameter = N_Co_SR_bin_i, Norm_factor Gauss(Norm_factor_obs | Norm_factor, err) Poisson(B0_i | N_Co_SR_bin_i) ---- WARNING:: convergence problems: mu_hat should always be >> 1, too small values have problem in finding minimum because mu is set >0. ---> Try to fix Xsec in order to have mu_hat ~ 10 */ RooWorkspace w("w"); //gROOT->ProcessLine(".L retrieve_input_from_histo_NoSys.C+"); gROOT->ProcessLine(".L retrieve_input_from_histo.C+"); retrieve_input_from_histo(w); // Building the model ModelConfig mc("ModelConfig",&w); mc.SetPdf(*w.pdf("model")); mc.SetParametersOfInterest(*w.var("mu")); // Setting nuissance parameter mc.SetNuisanceParameters(*w.set("nuissance_parameter")); // need now to set the global observable mc.SetGlobalObservables(*w.set("g_observables")); mc.SetObservables(*w.set("observables")); // this is needed for the hypothesis tests mc.SetSnapshot(*w.var("mu")); // make data set with the number of observed events RooDataSet data("data","", *w.set("observables")); data.add(*w.set("observables")); // import data set in workspace and save it in a file w.import(data); // import model in the workspace w.import(mc); w.writeToFile("CountingModel.root", true); w.Print(); data.Print(); /* cout << w.var("S_i")->getValV() << endl;//<< " " << w.var("S_i_exp")->getValV() << endl; /////////////////////////////////////////////////////////////////////// ProfileLikelihoodCalculator pl(data,mc); pl.SetConfidenceLevel(0.95); LikelihoodInterval* interval = pl.GetInterval(); // find the iterval on the first Parameter of Interest RooRealVar* firstPOI = (RooRealVar*) mc.GetParametersOfInterest()->first(); double lowerLimit = interval->LowerLimit(*firstPOI); double upperLimit = interval->UpperLimit(*firstPOI); cout << "\n95% interval on " <<firstPOI->GetName()<<" is : ["<< lowerLimit << ", "<< upperLimit <<"] "<<endl; LikelihoodIntervalPlot * plot = new LikelihoodIntervalPlot(interval); // plot->SetRange(0,50); // possible eventually to change ranges //plot->SetNPoints(50); // do not use too many points, it could become very slow for some models plot->Draw(""); // use option TF1 if too slow (plot.Draw("tf1") */ ////////////////////////// hypo test // get the modelConfig (S+B) out of the file // and create the B model from the S+B model ModelConfig * sbModel = (ModelConfig*) mc.Clone(); sbModel->SetName("S+B Model"); RooRealVar* poi = (RooRealVar*) sbModel->GetParametersOfInterest()->first(); poi->setVal(1); // set POI snapshot in S+B model for expected significance sbModel->SetSnapshot(*poi); ModelConfig * bModel = (ModelConfig*) mc.Clone(); bModel->SetName("B Model"); RooRealVar* poi2 = (RooRealVar*) bModel->GetParametersOfInterest()->first(); poi2->setVal(0); bModel->SetSnapshot( *poi2 ); //------------------Limit calculation for N_th event expected = 10 AsymptoticCalculator ac(data, *bModel, *sbModel); //ac.SetOneSidedDiscovery(true); // for one-side discovery test // ac.SetOneSided(true); // for one-side tests (limits) ac.SetQTilde(true); ac.SetPrintLevel(2); // to suppress print level // create hypotest inverter // passing the desired calculator HypoTestInverter *calc = new HypoTestInverter(ac); // for asymptotic //HypoTestInverter calc(fc); // for frequentist calc->SetConfidenceLevel(0.90); //calc->UseCLs(false); calc->UseCLs(true); int npoints = 500; // number of points to scan //int npoints = 1000; // number of points to scan default 1000 // min and max (better to choose smaller intervals) double poimin = poi->getMin(); double poimax = poi->getMax(); //poimin = 0; poimax=10; std::cout << "Doing a fixed scan in interval : " << poimin << " , " << poimax << std::endl; calc->SetFixedScan(npoints,poimin,poimax); calc->SetVerbose(2); HypoTestInverterResult * r = calc->GetInterval(); double upperLimit = r->UpperLimit(); std::cout << "The computed Expected upper limit is: " << r->GetExpectedUpperLimit(0) << std::endl; //------------ Getting the interval as function of m --------------// /* ifstream in; in.open("integral_mass.dat"); vector <double> masses_v; vector <double> observed_v; vector <double> expected_v; vector <double> expected_gaud_v; vector <double> expected_S1_up_v; vector <double> expected_S1_dw_v; vector <double> expected_S2_up_v; vector <double> expected_S2_dw_v; double mass_itr =0.; double Nev_exp_th_itr =0.; double xsec_modifier = 10.; double N_tot_theory = w.var("N_tot_theory")->getValV(); while(mass_itr <1000.){ in >> mass_itr; in >> Nev_exp_th_itr; xsec_modifier = Nev_exp_th_itr * 225.009 * 34.; //225.009 livedays and 34 kg and 10^-40 cm2 Xsec. masses_v.push_back(mass_itr); observed_v.push_back( 1.e-40 * N_tot_theory / xsec_modifier * upperLimit ); expected_v.push_back( 1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(0) ); expected_gaud_v.push_back(7e-38 * 1.37590955945e-05 / Nev_exp_th_itr ); expected_S1_up_v.push_back(1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(1)); expected_S2_up_v.push_back(1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(2)); expected_S2_dw_v.push_back(1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(-2)); expected_S1_dw_v.push_back(1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(-1)); cout << "Expected median limit for mass " << mass_itr << " GeV = " << 1.e-40 * N_tot_theory / xsec_modifier * r->GetExpectedUpperLimit(0) << " cm^2 " << endl; // observed_v.push_back( w.var("Xsec")->getValV() * w.var("K_m")->getValV()* upperLimit ); // expected_v.push_back( w.var("Xsec")->getValV() * w.var("K_m")->getValV()* r->GetExpectedUpperLimit(0) ); // expected_S1_up_v.push_back(w.var("Xsec")->getValV() * w.var("K_m")->getValV()* r->GetExpectedUpperLimit(1)); // expected_S2_up_v.push_back(w.var("Xsec")->getValV() * w.var("K_m")->getValV()* r->GetExpectedUpperLimit(2)); // expected_S2_dw_v.push_back(w.var("Xsec")->getValV() * w.var("K_m")->getValV()* r->GetExpectedUpperLimit(-2)); // expected_S1_dw_v.push_back(w.var("Xsec")->getValV() * w.var("K_m")->getValV()* r->GetExpectedUpperLimit(-1)); } in.close(); const int n = masses_v.size(); double xe[n]; double mA[n]; double observed[n]; double expected[n]; double expected_gaudenz[n]; double exSigma1_l[n]; double exSigma1_u[n]; double exSigma2_l[n]; double exSigma2_u[n]; for(int k=0; k< n; k++){ mA[k] = masses_v[k]; observed[k] = observed_v[k]; expected[k] = expected_v[k]; expected_gaudenz[k] = expected_gaud_v[k]; exSigma1_l[k] =expected_v[k] - expected_S1_dw_v[k] ; exSigma1_u[k] = expected_S1_up_v[k] - expected_v[k]; exSigma2_l[k] = expected_v[k] - expected_S2_dw_v[k]; exSigma2_u[k] = expected_S2_up_v[k] - expected_v[k] ; } TGraphErrors *obs_limits = new TGraphErrors(n, mA, observed); TGraphErrors *Exp_limits = new TGraphErrors(n, mA, expected ); TGraphAsymmErrors *Exp_limitsS1 = new TGraphAsymmErrors(n, mA, expected ,xe, xe, exSigma1_l, exSigma1_u ); TGraphAsymmErrors *Exp_limitsS2 = new TGraphAsymmErrors(n, mA, expected ,xe, xe, exSigma2_l, exSigma2_u); TGraphErrors *Exp_limits_gaudenz = new TGraphErrors( n, mA, expected_gaudenz); //double expected_xmass[15] = {8e-36,7e-37, 2e-37, 1e-37, 8e-38, 6e-38, 5.5e-38, 5e-38, 4.3e-38, 5e-38, 6e-38, 7e-38, 9e-38, 1.2e-37, 1.5e-37}; //double m_xmass[15] = { 20, 30., 40., 50., 60., 70., 80., 90., 100., 200., 300., 400, 500.,700., 1000.}; TGraphErrors *Exp_limits_xmass = new TGraphErrors(16); Exp_limits_xmass->SetPoint(0,20,8e-36); Exp_limits_xmass->SetPointError(0,0,0); Exp_limits_xmass->SetPoint(1,29.8071,7.162923e-37); Exp_limits_xmass->SetPointError(1,0,0); Exp_limits_xmass->SetPoint(2,39.90202,2.027528e-37); Exp_limits_xmass->SetPointError(2,0,0); Exp_limits_xmass->SetPoint(3,53.41583,9.91722e-38); Exp_limits_xmass->SetPointError(3,0,0); Exp_limits_xmass->SetPoint(4,62.16429,7.461589e-38); Exp_limits_xmass->SetPointError(4,0,0); Exp_limits_xmass->SetPoint(5,69.85718,6.3506e-38); Exp_limits_xmass->SetPointError(5,0,0); Exp_limits_xmass->SetPoint(6,83.21777,5.354015e-38); Exp_limits_xmass->SetPointError(6,0,0); Exp_limits_xmass->SetPoint(7,90,5e-38); Exp_limits_xmass->SetPointError(7,0,0); Exp_limits_xmass->SetPoint(8,105.0887,4.600252e-38); Exp_limits_xmass->SetPointError(8,0,0); Exp_limits_xmass->SetPoint(9,200,5e-38); Exp_limits_xmass->SetPointError(9,0,0); Exp_limits_xmass->SetPoint(10,300,6e-38); Exp_limits_xmass->SetPointError(10,0,0); Exp_limits_xmass->SetPoint(11,388.2045,7.252295e-38); Exp_limits_xmass->SetPointError(11,0,0); Exp_limits_xmass->SetPoint(12,590.8438,9.823615e-38); Exp_limits_xmass->SetPointError(12,0,0); Exp_limits_xmass->SetPoint(13,746.1269,1.210266e-37); Exp_limits_xmass->SetPointError(13,0,0); Exp_limits_xmass->SetPoint(14,1000,1.5e-37); Exp_limits_xmass->SetPointError(14,0,0); Exp_limits_xmass->SetPoint(15,4244.204,4.354065e-37); Exp_limits_xmass->SetPointError(15,0,0); TCanvas *c1 = new TCanvas("limits", "limit", 600, 600); Exp_limitsS1->SetFillColor(3); Exp_limitsS1->SetLineColor(3); Exp_limitsS1->SetMarkerColor(3); Exp_limitsS1->SetMarkerSize(0); Exp_limitsS2->SetFillColor(5); Exp_limitsS2->SetLineColor(5); Exp_limitsS2->SetMarkerColor(5); Exp_limitsS2->SetMarkerSize(0); obs_limits->SetFillColor(0); obs_limits->SetLineWidth(3); obs_limits->SetMarkerSize(0); Exp_limits->SetFillColor(0); Exp_limits->SetMarkerSize(0); Exp_limits->SetLineStyle(7); Exp_limits->SetLineWidth(3); Exp_limits_gaudenz->SetFillColor(0); Exp_limits_gaudenz->SetMarkerSize(0); Exp_limits_gaudenz->SetLineWidth(3); Exp_limits_gaudenz->SetLineColor(4); Exp_limits_xmass->SetFillColor(0); Exp_limits_xmass->SetMarkerSize(0); Exp_limits_xmass->SetLineWidth(3); Exp_limits_xmass->SetLineColor(2); //Exp_limitsS2->GetYaxis()->SetTitle("#sigma#timesBR( #phi #rightarrow #tau#tau ) [pb]"); Exp_limitsS2->GetYaxis()->SetTitle("#sigma"); Exp_limitsS2->GetXaxis()->SetTitle("M [GeV]"); Exp_limitsS2->GetXaxis()->SetLimits(9.,1000.); Exp_limitsS2->GetYaxis()->SetRangeUser(1E-38,1E-30); Exp_limits->GetXaxis()->SetLimits(9.,1000.); Exp_limits->GetYaxis()->SetRangeUser(1E-38,1E-30); Exp_limitsS2->Draw("Al3"); Exp_limitsS1->Draw("sameL3"); Exp_limits->Draw("PL"); Exp_limits_gaudenz->Draw("PC"); Exp_limits_xmass->Draw("PC"); //obs_limits->Draw("PL"); TLegend* lego = new TLegend(0.2,0.9,0.5,0.7); lego->SetTextSize(0.033); lego->SetFillColor(0); lego->SetBorderSize(0); lego->AddEntry(obs_limits,"Observed 90\% CLs limit"); lego->AddEntry(Exp_limits_gaudenz, "Expected 90\% Gaudenz"); lego->AddEntry(Exp_limits_xmass, "Expected 90\% XMASS"); lego->AddEntry(Exp_limits, "Expected 90\% CLs limit"); lego->AddEntry(Exp_limitsS1,"1 #sigma","f"); lego->AddEntry(Exp_limitsS2,"2 #sigma","f"); lego->Draw(); gPad->SetLogy(); gPad->SetLogx(); gPad->RedrawAxis("g"); myText(0.4,0.86,2,"Test"); */ // now use the profile inspector ProfileInspector p; TList* list = p.GetListOfProfilePlots(data,&mc); // now make plots TCanvas* c1 = new TCanvas("c1","ProfileInspectorDemo",800,200); if(list->GetSize()>4){ double n = list->GetSize(); int nx = (int)sqrt(n) ; int ny = TMath::CeilNint(n/nx); nx = TMath::CeilNint( sqrt(n) ); c1->Divide(ny,nx); } else c1->Divide(list->GetSize()); for(int i=0; i<list->GetSize(); ++i){ c1->cd(i+1); list->At(i)->Draw("al"); } cout << endl; /* // plot now the result of the scan HypoTestInverterPlot *plot = new HypoTestInverterPlot("HTI_Result_Plot","HypoTest Scan Result",r); // plot in a new canvas with style TCanvas * c1 = new TCanvas("HypoTestInverter Scan"); c1->SetLogy(false); plot->Draw("2CL"); // plot also CLb and CLs+b //plot->Draw("OBS"); // plot only observed p-value */ // plot also in a new canvas the test statistics distributions // plot test statistics distributions for the two hypothesis /* // when distribution is generated (case of FrequentistCalculators) const int n = r->ArraySize(); if (n> 0 && r->GetResult(0)->GetNullDistribution() ) { TCanvas * c2 = new TCanvas("Test Statistic Distributions","",2); if (n > 1) { int ny = TMath::CeilNint( sqrt(n) ); int nx = TMath::CeilNint(double(n)/ny); c2->Divide( nx,ny); } for (int i=0; i<n; i++) { if (n > 1) c2->cd(i+1); SamplingDistPlot * pl = plot->MakeTestStatPlot(i); pl->SetLogYaxis(true); pl->Draw(); } } */ }
void HypoTestInvDemo(const char * fileName ="GausModel_b.root", const char * wsName = "w", const char * modelSBName = "model_sb", const char * modelBName = "model_b", const char * dataName = "data_obs", int type = 0, // calculator type int testStatType = 0, // test stat type int npoints = 10, int ntoys=1000, bool useCls = true ) { /* type = 0 Freq calculator type = 1 Hybrid testStatType = 0 LEP = 1 Tevatron = 2 PL */ if (fileName==0) { std::cout << "give input filename " << std::endl; return; } TFile * file = new TFile(fileName); RooWorkspace * w = dynamic_cast<RooWorkspace*>( file->Get(wsName) ); if (!w) { return; } w->Print(); RooAbsData * data = w->data(dataName); if (!data) { Error("HypoTestDemo","Not existing data %s",dataName); } // get models from WS // get the modelConfig out of the file ModelConfig* bModel = (ModelConfig*) w->obj(modelBName); ModelConfig* sbModel = (ModelConfig*) w->obj(modelSBName); SimpleLikelihoodRatioTestStat slrts(*bModel->GetPdf(),*sbModel->GetPdf()); slrts.SetNullParameters(*bModel->GetSnapshot()); slrts.SetAltParameters(*sbModel->GetSnapshot()); RatioOfProfiledLikelihoodsTestStat ropl(*bModel->GetPdf(), *sbModel->GetPdf(), sbModel->GetSnapshot()); ropl.SetSubtractMLE(false); ProfileLikelihoodTestStat profll(*sbModel->GetPdf()); profll.SetOneSided(0); TestStatistic * testStat = &slrts; if (testStatType == 1) testStat = &ropl; if (testStatType == 2) testStat = &profll; HypoTestCalculatorGeneric * hc = 0; if (type == 0) hc = new FrequentistCalculator(*data, *sbModel, *bModel); else new HybridCalculator(*data, *sbModel, *bModel); ToyMCSampler *toymcs = (ToyMCSampler*)hc->GetTestStatSampler(); //toymcs->SetNEventsPerToy(1); toymcs->SetTestStatistic(testStat); if (type == 1) { HybridCalculator *hhc = (HybridCalculator*) hc; hhc->SetToys(ntoys,ntoys); // hhc->ForcePriorNuisanceAlt(*pdfNuis); // hhc->ForcePriorNuisanceNull(*pdfNuis); } else ((FrequentistCalculator*) hc)->SetToys(ntoys,ntoys); // Get the result RooMsgService::instance().getStream(1).removeTopic(RooFit::NumIntegration); TStopwatch tw; tw.Start(); const RooArgSet * poiSet = sbModel->GetParametersOfInterest(); RooRealVar *poi = (RooRealVar*)poiSet->first(); // fit the data first sbModel->GetPdf()->fitTo(*data); double poihat = poi->getVal(); //poi->setVal(30); //poi->setError(10); HypoTestInverter calc(*hc); // GENA: for two-sided interval //calc.SetConfidenceLevel(0.95); // GENA: for 95% upper limit calc.SetConfidenceLevel(0.90); calc.UseCLs(useCls); calc.SetVerbose(true); // can spped up using proof ProofConfig pc(*w, 2, "workers=2", kFALSE); //ProofConfig pc(*w, 30, "localhost", kFALSE); //ToyMCSampler * toymcs = dynamic_cast<ToyMCSampler *> (calc.GetHypoTestCalculator()->GetTestStatSampler() ); // GENA: disable proof for now //toymcs->SetProofConfig(&pc); // enable proof if (npoints > 0) { // GENA double poimin = TMath::Max(poihat - 4 * poi->getError(), 0.0); //poimin = poihat; double poimax = poihat + 4 * poi->getError(); poimin = 0; poimax = 20; //double poimin = poi->getMin(); //double poimax = poi->getMax(); std::cout << "Doing a fixed scan in interval : " << poimin << " , " << poimax << std::endl; calc.SetFixedScan(npoints,poimin,poimax); } HypoTestInverterResult * r = calc.GetInterval(); // write to a file the results TString resultFileName = (useCls) ? "CLs_" : "Cls+b_"; resultFileName += fileName; // GENA //TFile * file = new TFile(resultFileName,"RECREATE"); file = new TFile(resultFileName,"RECREATE"); r->Write(); file->Close(); double ulError = r->UpperLimitEstimatedError(); double upperLimit = r->UpperLimit(); std::cout << "The computed upper limit is: " << upperLimit << std::endl; std::cout << "an estimated error on this upper limit is: " << ulError << std::endl; // check using interpolation // double interpLimit = r->FindInterpolatedLimit(1.-r->ConfidenceLevel() ); // cout << "The computer interpolated limits is " << interpLimit << endl; const int nEntries = r->ArraySize(); std::vector<Double_t> xArray(nEntries); std::vector<Double_t> yArray(nEntries); std::vector<Double_t> yErrArray(nEntries); for (int i=0; i<nEntries; i++) { xArray[i] = r->GetXValue(i); yArray[i] = r->GetYValue(i); yErrArray[i] = r->GetYError(i); std::cout << xArray[i] << " , " << yArray[i] << " err = " << yErrArray[i] << std::endl; } // see expected result (bands) TGraph * g0 = new TGraph(nEntries); TGraphAsymmErrors * g1 = new TGraphAsymmErrors(nEntries); TGraphAsymmErrors * g2l = new TGraphAsymmErrors(nEntries); TGraphAsymmErrors * g2u = new TGraphAsymmErrors(nEntries); double p[7]; double q[7]; p[0] = ROOT::Math::normal_cdf(-2); p[1] = ROOT::Math::normal_cdf(-1.5); p[2] = ROOT::Math::normal_cdf(-1); p[3] = 0.5; p[4] = ROOT::Math::normal_cdf(1); p[5] = ROOT::Math::normal_cdf(1.5); p[6] = ROOT::Math::normal_cdf(2); for (int i=0; i<nEntries; i++) { SamplingDistribution * s = r->GetExpectedDistribution(i); // GENA //const std::vector<double> & values = s->GetSamplingDistribution(); const std::vector<Double_t> & cValues = s->GetSamplingDistribution(); std::vector<Double_t> values; for (std::vector<Double_t>::const_iterator val = cValues.begin(); val != cValues.end(); ++val) values.push_back(*val); TMath::Quantiles(values.size(), 7, &values[0],q,p,false); double p0 = q[3]; double p2l = q[1]; double p2u = q[5]; g0->SetPoint(i, r->GetXValue(i), p0 ) ; g1->SetPoint(i, r->GetXValue(i), p0); g2l->SetPoint(i, r->GetXValue(i), p2l); g2u->SetPoint(i, r->GetXValue(i), p2u); //g2->SetPoint(i, r->GetXValue(i), s->InverseCDF(0.50)); g1->SetPointEYlow(i, q[3] - q[2]); // -1 sigma errorr g1->SetPointEYhigh(i, q[4] - q[3]);//+1 sigma error g2l->SetPointEYlow(i, q[1]-q[0]); // -2 -- -1 sigma error g2l->SetPointEYhigh(i, q[2]-q[1]); g2u->SetPointEYlow(i, q[5]-q[4]); g2u->SetPointEYhigh(i, q[6]-q[5]); if (plotHypoTestResult) { HypoTestResult * hr = new HypoTestResult(); hr->SetNullDistribution( r->GetBackgroundDistribution() ); hr->SetAltDistribution( r->GetSignalAndBackgroundDistribution(i) ); new TCanvas(); HypoTestPlot * pl = new HypoTestPlot(*hr); pl->Draw(); } } HypoTestInverterPlot *plot = new HypoTestInverterPlot("result","",r); TGraphErrors * g = plot->MakePlot(); g->Draw("APL"); g2l->SetFillColor(kYellow); g2l->Draw("3"); g2u->SetFillColor(kYellow); g2u->Draw("3"); g1->SetFillColor(kGreen); g1->Draw("3"); g0->SetLineColor(kBlue); g0->SetLineStyle(2); g0->SetLineWidth(2); g0->Draw("L"); //g1->Draw("P"); //g2->Draw("P"); g->SetLineWidth(2); g->Draw("PL"); // GENA: two-sided interval //double alpha = 1.-r->ConfidenceLevel(); // GENA: upper limit double alpha = (1.-r->ConfidenceLevel())/2.0; double x1 = g->GetXaxis()->GetXmin(); double x2 = g->GetXaxis()->GetXmax(); TLine * line = new TLine(x1, alpha, x2,alpha); line->SetLineColor(kRed); line->Draw(); // see the expected limit and -1 +1 sigma bands // SamplingDistribution * limits = r->GetUpperLimitDistribution(); // std::cout << " expected limit (median) " << limits->InverseCDF(0.50) << std::endl; // std::cout << " expected limit (-1 sig) " << limits->InverseCDF((ROOT::Math::normal_cdf(-1))) << std::endl; // std::cout << " expected limit (+1 sig) " << limits->InverseCDF((ROOT::Math::normal_cdf(+1))) << std::endl; tw.Print(); }