Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
OneSidedFrequentistUpperLimitWithBands.C
Go to the documentation of this file.
1/// \file
2/// \ingroup tutorial_roostats
3/// \notebook
4/// OneSidedFrequentistUpperLimitWithBands
5///
6/// This is a standard demo that can be used with any ROOT file
7/// prepared in the standard way. You specify:
8/// - name for input ROOT file
9/// - name of workspace inside ROOT file that holds model and data
10/// - name of ModelConfig that specifies details for calculator tools
11/// - name of dataset
12///
13/// With default parameters the macro will attempt to run the
14/// standard hist2workspace example and read the ROOT file
15/// that it produces.
16///
17/// The first ~100 lines define a new test statistic, then the main macro starts.
18/// You may want to control:
19/// ~~~{.cpp}
20/// double confidenceLevel=0.95;
21/// int nPointsToScan = 12;
22/// int nToyMC = 150;
23/// ~~~
24/// This uses a modified version of the profile likelihood ratio as
25/// a test statistic for upper limits (eg. test stat = 0 if muhat>mu).
26///
27/// Based on the observed data, one defines a set of parameter points
28/// to be tested based on the value of the parameter of interest
29/// and the conditional MLE (eg. profiled) values of the nuisance parameters.
30///
31/// At each parameter point, pseudo-experiments are generated using this
32/// fixed reference model and then the test statistic is evaluated.
33/// Note, the nuisance parameters are floating in the fits. For each point,
34/// the threshold that defines the 95% acceptance region is found. This
35/// forms a "Confidence Belt".
36///
37/// After constructing the confidence belt, one can find the confidence
38/// interval for any particular dataset by finding the intersection
39/// of the observed test statistic and the confidence belt. First
40/// this is done on the observed data to get an observed 1-sided upper limt.
41///
42/// Finally, there expected limit and bands (from background-only) are
43/// formed by generating background-only data and finding the upper limit.
44/// This is done by hand for now, will later be part of the RooStats tools.
45///
46/// On a technical note, this technique is NOT the Feldman-Cousins technique,
47/// because that is a 2-sided interval BY DEFINITION. However, like the
48/// Feldman-Cousins technique this is a Neyman-Construction. For technical
49/// reasons the easiest way to implement this right now is to use the
50/// FeldmanCousins tool and then change the test statistic that it is using.
51///
52/// Building the confidence belt can be computationally expensive. Once it is built,
53/// one could save it to a file and use it in a separate step.
54///
55/// Note, if you have a boundary on the parameter of interest (eg. cross-section)
56/// the threshold on the one-sided test statistic starts off very small because we
57/// are only including downward fluctuations. You can see the threshold in these printouts:
58/// ~~~{.cpp}
59/// [#0] PROGRESS:Generation -- generated toys: 500 / 999
60/// NeymanConstruction: Prog: 12/50 total MC = 39 this test stat = 0
61/// SigXsecOverSM=0.69 alpha_syst1=0.136515 alpha_syst3=0.425415 beta_syst2=1.08496 [-1e+30, 0.011215] in interval = 1
62/// ~~~
63/// this tells you the values of the parameters being used to generate the pseudo-experiments
64/// and the threshold in this case is 0.011215. One would expect for 95% that the threshold
65/// would be ~1.35 once the cross-section is far enough away from 0 that it is essentially
66/// unaffected by the boundary. As one reaches the last points in the scan, the
67/// threshold starts to get artificially high. This is because the range of the parameter in
68/// the fit is the same as the range in the scan. In the future, these should be independently
69/// controlled, but they are not now. As a result the ~50% of pseudo-experiments that have an
70/// upward fluctuation end up with muhat = muMax. Because of this, the upper range of the
71/// parameter should be well above the expected upper limit... but not too high or one will
72/// need a very large value of nPointsToScan to resolve the relevant region. This can be
73/// improved, but this is the first version of this script.
74///
75/// Important note: when the model includes external constraint terms, like a Gaussian
76/// constraint to a nuisance parameter centered around some nominal value there is
77/// a subtlety. The asymptotic results are all based on the assumption that all the
78/// measurements fluctuate... including the nominal values from auxiliary measurements.
79/// If these do not fluctuate, this corresponds to an "conditional ensemble". The
80/// result is that the distribution of the test statistic can become very non-chi^2.
81/// This results in thresholds that become very large. This can be seen in the following
82/// thought experiment. Say the model is
83/// \f$ Pois(N | s + b)G(b0|b,sigma) \f$
84/// where \f$ G(b0|b,sigma) \f$ is the external constraint and b0 is 100. If N is also 100
85/// then the profiled value of b given s is going to be some trade off between 100-s and b0.
86/// If sigma is \f$ \sqrt(N) \f$, then the profiled value of b is probably 100 - s/2 So for
87/// s=60 we are going to have a profiled value of b~70. Now when we generate pseudo-experiments
88/// for s=60, b=70 we will have N~130 and the average shat will be 30, not 60. In practice,
89/// this is only an issue for values of s that are very excluded. For values of s near the 95%
90/// limit this should not be a big effect. This can be avoided if the nominal values of the constraints also fluctuate,
91/// but that requires that those parameters are RooRealVars in the model.
92/// This version does not deal with this issue, but it will be addressed in a future version.
93///
94/// \macro_image
95/// \macro_output
96/// \macro_code
97///
98/// \authors Kyle Cranmer, Haichen Wang, Daniel Whiteson
99
100#include "TFile.h"
101#include "TROOT.h"
102#include "TH1F.h"
103#include "TCanvas.h"
104#include "TSystem.h"
105
106#include "RooWorkspace.h"
107#include "RooSimultaneous.h"
108#include "RooAbsData.h"
109
110#include "RooStats/ModelConfig.h"
115
118
119using namespace RooFit;
120using namespace RooStats;
121
122// -------------------------------------------------------
123// The actual macro
124
125void OneSidedFrequentistUpperLimitWithBands(const char *infile = "", const char *workspaceName = "combined",
126 const char *modelConfigName = "ModelConfig",
127 const char *dataName = "obsData")
128{
129
130 double confidenceLevel = 0.95;
131 int nPointsToScan = 12;
132 int nToyMC = 150;
133
134 // -------------------------------------------------------
135 // First part is just to access a user-defined file
136 // or create the standard example file if it doesn't exist
137 const char *filename = "";
138 if (!strcmp(infile, "")) {
139 filename = "results/example_combined_GaussExample_model.root";
140 bool fileExist = !gSystem->AccessPathName(filename); // note opposite return code
141 // if file does not exists generate with histfactory
142 if (!fileExist) {
143 // Normally this would be run on the command line
144 cout << "will run standard hist2workspace example" << endl;
145 gROOT->ProcessLine(".! prepareHistFactory .");
146 gROOT->ProcessLine(".! hist2workspace config/example.xml");
147 cout << "\n\n---------------------" << endl;
148 cout << "Done creating example input" << endl;
149 cout << "---------------------\n\n" << endl;
150 }
151
152 } else
154
155 // Try to open the file
156 TFile *file = TFile::Open(filename);
157
158 // if input file was specified but not found, quit
159 if (!file) {
160 cout << "StandardRooStatsDemoMacro: Input file " << filename << " is not found" << endl;
161 return;
162 }
163
164 // -------------------------------------------------------
165 // Now get the data and workspace
166
167 // get the workspace out of the file
169 if (!w) {
170 cout << "workspace not found" << endl;
171 return;
172 }
173
174 // get the modelConfig out of the file
176
177 // get the modelConfig out of the file
178 RooAbsData *data = w->data(dataName);
179
180 // make sure ingredients are found
181 if (!data || !mc) {
182 w->Print();
183 cout << "data or ModelConfig was not found" << endl;
184 return;
185 }
186
187 // -------------------------------------------------------
188 // Now get the POI for convenience
189 // you may want to adjust the range of your POI
190
191 RooRealVar *firstPOI = (RooRealVar *)mc->GetParametersOfInterest()->first();
192 /* firstPOI->setMin(0);*/
193 /* firstPOI->setMax(10);*/
194
195 // --------------------------------------------
196 // Create and use the FeldmanCousins tool
197 // to find and plot the 95% confidence interval
198 // on the parameter of interest as specified
199 // in the model config
200 // REMEMBER, we will change the test statistic
201 // so this is NOT a Feldman-Cousins interval
203 fc.SetConfidenceLevel(confidenceLevel);
204 fc.AdditionalNToysFactor(
205 0.5); // degrade/improve sampling that defines confidence belt: in this case makes the example faster
206 /* fc.UseAdaptiveSampling(true); // speed it up a bit, don't use for expected limits*/
207 fc.SetNBins(nPointsToScan); // set how many points per parameter of interest to scan
208 fc.CreateConfBelt(true); // save the information in the belt for plotting
209
210 // -------------------------------------------------------
211 // Feldman-Cousins is a unified limit by definition
212 // but the tool takes care of a few things for us like which values
213 // of the nuisance parameters should be used to generate toys.
214 // so let's just change the test statistic and realize this is
215 // no longer "Feldman-Cousins" but is a fully frequentist Neyman-Construction.
216 /* ProfileLikelihoodTestStatModified onesided(*mc->GetPdf());*/
217 /* fc.GetTestStatSampler()->SetTestStatistic(&onesided);*/
218 /* ((ToyMCSampler*) fc.GetTestStatSampler())->SetGenerateBinned(true); */
219 ToyMCSampler *toymcsampler = (ToyMCSampler *)fc.GetTestStatSampler();
220 ProfileLikelihoodTestStat *testStat = dynamic_cast<ProfileLikelihoodTestStat *>(toymcsampler->GetTestStatistic());
221 testStat->SetOneSided(true);
222
223 // Since this tool needs to throw toy MC the PDF needs to be
224 // extended or the tool needs to know how many entries in a dataset
225 // per pseudo experiment.
226 // In the 'number counting form' where the entries in the dataset
227 // are counts, and not values of discriminating variables, the
228 // datasets typically only have one entry and the PDF is not
229 // extended.
230 if (!mc->GetPdf()->canBeExtended()) {
231 if (data->numEntries() == 1)
232 fc.FluctuateNumDataEntries(false);
233 else
234 cout << "Not sure what to do about this model" << endl;
235 }
236
237 if (mc->GetGlobalObservables()) {
238 cout << "will use global observables for unconditional ensemble" << endl;
239 mc->GetGlobalObservables()->Print();
240 toymcsampler->SetGlobalObservables(*mc->GetGlobalObservables());
241 }
242
243 // Now get the interval
244 PointSetInterval *interval = fc.GetInterval();
245 ConfidenceBelt *belt = fc.GetConfidenceBelt();
246
247 // print out the interval on the first Parameter of Interest
248 cout << "\n95% interval on " << firstPOI->GetName() << " is : [" << interval->LowerLimit(*firstPOI) << ", "
249 << interval->UpperLimit(*firstPOI) << "] " << endl;
250
251 // get observed UL and value of test statistic evaluated there
253 double observedUL = interval->UpperLimit(*firstPOI);
254 firstPOI->setVal(observedUL);
255 double obsTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*data, tmpPOI);
256
257 // Ask the calculator which points were scanned
258 RooDataSet *parameterScan = (RooDataSet *)fc.GetPointsToScan();
260
261 // make a histogram of parameter vs. threshold
263 new TH1F("histOfThresholds", "", parameterScan->numEntries(), firstPOI->getMin(), firstPOI->getMax());
264 histOfThresholds->GetXaxis()->SetTitle(firstPOI->GetName());
265 histOfThresholds->GetYaxis()->SetTitle("Threshold");
266
267 // loop through the points that were tested and ask confidence belt
268 // what the upper/lower thresholds were.
269 // For FeldmanCousins, the lower cut off is always 0
270 for (Int_t i = 0; i < parameterScan->numEntries(); ++i) {
271 tmpPoint = (RooArgSet *)parameterScan->get(i)->clone("temp");
272 // cout <<"get threshold"<<endl;
273 double arMax = belt->GetAcceptanceRegionMax(*tmpPoint);
274 double poiVal = tmpPoint->getRealValue(firstPOI->GetName());
276 }
277 TCanvas *c1 = new TCanvas();
278 c1->Divide(2);
279 c1->cd(1);
280 histOfThresholds->SetMinimum(0);
281 histOfThresholds->Draw();
282 c1->cd(2);
283
284 // -------------------------------------------------------
285 // Now we generate the expected bands and power-constraint
286
287 // First: find parameter point for mu=0, with conditional MLEs for nuisance parameters
288 std::unique_ptr<RooAbsReal> nll{mc->GetPdf()->createNLL(*data)};
289 std::unique_ptr<RooAbsReal> profile{nll->createProfile(*mc->GetParametersOfInterest())};
290 firstPOI->setVal(0.);
291 profile->getVal(); // this will do fit and set nuisance parameters to profiled values
293 if (mc->GetNuisanceParameters())
294 poiAndNuisance->add(*mc->GetNuisanceParameters());
295 poiAndNuisance->add(*mc->GetParametersOfInterest());
296 w->saveSnapshot("paramsToGenerateData", *poiAndNuisance);
298 cout << "\nWill use these parameter points to generate pseudo data for bkg only" << endl;
299 paramsToGenerateData->Print("v");
300
302 unconditionalObs.add(*mc->GetObservables());
303 unconditionalObs.add(*mc->GetGlobalObservables()); // comment this out for the original conditional ensemble
304
305 double CLb = 0;
306 double CLbinclusive = 0;
307
308 // Now we generate background only and find distribution of upper limits
309 TH1F *histOfUL = new TH1F("histOfUL", "", 100, 0, firstPOI->getMax());
310 histOfUL->GetXaxis()->SetTitle("Upper Limit (background only)");
311 histOfUL->GetYaxis()->SetTitle("Entries");
312 for (int imc = 0; imc < nToyMC; ++imc) {
313
314 // set parameters back to values for generating pseudo data
315 // cout << "\n get current nuis, set vals, print again" << endl;
316 w->loadSnapshot("paramsToGenerateData");
317 // poiAndNuisance->Print("v");
318
319 std::unique_ptr<RooDataSet> toyData;
320 // now generate a toy dataset
321 if (!mc->GetPdf()->canBeExtended()) {
322 if (data->numEntries() == 1)
323 toyData = std::unique_ptr<RooDataSet>{mc->GetPdf()->generate(*mc->GetObservables(), 1)};
324 else
325 cout << "Not sure what to do about this model" << endl;
326 } else {
327 // cout << "generating extended dataset"<<endl;
328 toyData = std::unique_ptr<RooDataSet>{mc->GetPdf()->generate(*mc->GetObservables(), Extended())};
329 }
330
331 // generate global observables
332 // need to be careful for simpdf
333 // RooDataSet* globalData = mc->GetPdf()->generate(*mc->GetGlobalObservables(),1);
334
335 RooSimultaneous *simPdf = dynamic_cast<RooSimultaneous *>(mc->GetPdf());
336 if (!simPdf) {
337 std::unique_ptr<RooDataSet> one{mc->GetPdf()->generate(*mc->GetGlobalObservables(), 1)};
338 const RooArgSet *values = one->get();
339 std::unique_ptr<RooArgSet> allVars{mc->GetPdf()->getVariables()};
340 allVars->assign(*values);
341 } else {
342
343 // try fix for sim pdf
344 for (auto const& tt : simPdf->indexCat()) {
345 auto const& catName = tt.first;
346
347 // Get pdf associated with state from simpdf
348 RooAbsPdf *pdftmp = simPdf->getPdf(catName.c_str());
349
350 // Generate only global variables defined by the pdf associated with this state
351 std::unique_ptr<RooArgSet> globtmp{pdftmp->getObservables(*mc->GetGlobalObservables())};
352 std::unique_ptr<RooDataSet> tmp{pdftmp->generate(*globtmp, 1)};
353
354 // Transfer values to output placeholder
355 globtmp->assign(*tmp->get(0));
356 }
357 }
358
359 // globalData->Print("v");
360 // unconditionalObs = *globalData->get();
361 // mc->GetGlobalObservables()->Print("v");
362 // delete globalData;
363 // cout << "toy data = " << endl;
364 // toyData->get()->Print("v");
365
366 // get test stat at observed UL in observed data
367 firstPOI->setVal(observedUL);
368 double toyTSatObsUL = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData, tmpPOI);
369 // toyData->get()->Print("v");
370 // cout <<"obsTSatObsUL " <<obsTSatObsUL << "toyTS " << toyTSatObsUL << endl;
371 if (obsTSatObsUL < toyTSatObsUL) // not sure about <= part yet
372 CLb += (1.) / nToyMC;
373 if (obsTSatObsUL <= toyTSatObsUL) // not sure about <= part yet
374 CLbinclusive += (1.) / nToyMC;
375
376 // loop over points in belt to find upper limit for this toy data
377 double thisUL = 0;
378 for (Int_t i = 0; i < parameterScan->numEntries(); ++i) {
379 tmpPoint = (RooArgSet *)parameterScan->get(i)->clone("temp");
380 double arMax = belt->GetAcceptanceRegionMax(*tmpPoint);
381 firstPOI->setVal(tmpPoint->getRealValue(firstPOI->GetName()));
382 // double thisTS = profile->getVal();
383 double thisTS = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData, tmpPOI);
384
385 // cout << "poi = " << firstPOI->getVal()
386 // << " max is " << arMax << " this profile = " << thisTS << endl;
387 // cout << "thisTS = " << thisTS<<endl;
388 if (thisTS <= arMax) {
389 thisUL = firstPOI->getVal();
390 } else {
391 break;
392 }
393 }
394
395 /*
396 // loop over points in belt to find upper limit for this toy data
397 double thisUL = 0;
398 for(Int_t i=0; i<histOfThresholds->GetNbinsX(); ++i){
399 tmpPoint = (RooArgSet*) parameterScan->get(i)->clone("temp");
400 cout <<"---------------- "<<i<<endl;
401 tmpPoint->Print("v");
402 cout << "from hist " << histOfThresholds->GetBinCenter(i+1) <<endl;
403 double arMax = histOfThresholds->GetBinContent(i+1);
404 // cout << " threshold from Hist = aMax " << arMax<<endl;
405 // double arMax2 = belt->GetAcceptanceRegionMax(*tmpPoint);
406 // cout << "from scan arMax2 = "<< arMax2 << endl; // not the same due to TH1F not TH1D
407 // cout << "scan - hist" << arMax2-arMax << endl;
408 firstPOI->setVal( histOfThresholds->GetBinCenter(i+1));
409 // double thisTS = profile->getVal();
410 double thisTS = fc.GetTestStatSampler()->EvaluateTestStatistic(*toyData,tmpPOI);
411
412 // cout << "poi = " << firstPOI->getVal()
413 // << " max is " << arMax << " this profile = " << thisTS << endl;
414 // cout << "thisTS = " << thisTS<<endl;
415
416 // NOTE: need to add a small epsilon term for single precision vs. double precision
417 if(thisTS<=arMax + 1e-7){
418 thisUL = firstPOI->getVal();
419 } else{
420 break;
421 }
422 }
423 */
424
425 histOfUL->Fill(thisUL);
426
427 // for few events, data is often the same, and UL is often the same
428 // cout << "thisUL = " << thisUL<<endl;
429 }
430 histOfUL->Draw();
431 c1->SaveAs("one-sided_upper_limit_output.pdf");
432
433 // if you want to see a plot of the sampling distribution for a particular scan point:
434 /*
435 SamplingDistPlot sampPlot;
436 int indexInScan = 0;
437 tmpPoint = (RooArgSet*) parameterScan->get(indexInScan)->clone("temp");
438 firstPOI->setVal( tmpPoint->getRealValue(firstPOI->GetName()) );
439 toymcsampler->SetParametersForTestStat(tmpPOI);
440 SamplingDistribution* samp = toymcsampler->GetSamplingDistribution(*tmpPoint);
441 sampPlot.AddSamplingDistribution(samp);
442 sampPlot.Draw();
443 */
444
445 // Now find bands and power constraint
446 Double_t *bins = histOfUL->GetIntegral();
447 TH1F *cumulative = (TH1F *)histOfUL->Clone("cumulative");
448 cumulative->SetContent(bins);
450 for (int i = 1; i <= cumulative->GetNbinsX(); ++i) {
451 if (bins[i] < RooStats::SignificanceToPValue(2))
452 band2sigDown = cumulative->GetBinCenter(i);
453 if (bins[i] < RooStats::SignificanceToPValue(1))
454 band1sigDown = cumulative->GetBinCenter(i);
455 if (bins[i] < 0.5)
456 bandMedian = cumulative->GetBinCenter(i);
457 if (bins[i] < RooStats::SignificanceToPValue(-1))
458 band1sigUp = cumulative->GetBinCenter(i);
459 if (bins[i] < RooStats::SignificanceToPValue(-2))
460 band2sigUp = cumulative->GetBinCenter(i);
461 }
462 cout << "-2 sigma band " << band2sigDown << endl;
463 cout << "-1 sigma band " << band1sigDown << " [Power Constraint)]" << endl;
464 cout << "median of band " << bandMedian << endl;
465 cout << "+1 sigma band " << band1sigUp << endl;
466 cout << "+2 sigma band " << band2sigUp << endl;
467
468 // print out the interval on the first Parameter of Interest
469 cout << "\nobserved 95% upper-limit " << interval->UpperLimit(*firstPOI) << endl;
470 cout << "CLb strict [P(toy>obs|0)] for observed 95% upper-limit " << CLb << endl;
471 cout << "CLb inclusive [P(toy>=obs|0)] for observed 95% upper-limit " << CLbinclusive << endl;
472}
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char filename
#define gROOT
Definition TROOT.h:411
R__EXTERN TSystem * gSystem
Definition TSystem.h:572
Abstract base class for binned and unbinned datasets.
Definition RooAbsData.h:57
Abstract interface for all probability density functions.
Definition RooAbsPdf.h:32
RooArgSet is a container object that can hold multiple RooAbsArg objects.
Definition RooArgSet.h:24
Container class to hold unbinned data.
Definition RooDataSet.h:32
Variable that can be changed from the outside.
Definition RooRealVar.h:37
Facilitates simultaneous fitting of multiple PDFs to subsets of a given dataset.
ConfidenceBelt is a concrete implementation of the ConfInterval interface.
The FeldmanCousins class (like the Feldman-Cousins technique) is essentially a specific configuration...
< A class that holds configuration information for a model using a workspace as a store
Definition ModelConfig.h:34
PointSetInterval is a concrete implementation of the ConfInterval interface.
ProfileLikelihoodTestStat is an implementation of the TestStatistic interface that calculates the pro...
ToyMCSampler is an implementation of the TestStatSampler interface.
Persistable container for RooFit projects.
The Canvas class.
Definition TCanvas.h:23
TObject * Get(const char *namecycle) override
Return pointer to object identified by namecycle.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
Definition TFile.h:131
static TFile * Open(const char *name, Option_t *option="", const char *ftitle="", Int_t compress=ROOT::RCompressionSetting::EDefaults::kUseCompiledDefault, Int_t netopt=0)
Create / open a file.
Definition TFile.cxx:3765
1-D histogram with a float per channel (see TH1 documentation)
Definition TH1.h:879
virtual Bool_t AccessPathName(const char *path, EAccessMode mode=kFileExists)
Returns FALSE if one can access a file using the specified access mode.
Definition TSystem.cxx:1309
return c1
Definition legend1.C:41
double nll(double pdf, double weight, int binnedL, int doBinOffset)
Definition MathFuncs.h:388
The namespace RooFit contains mostly switches that change the behaviour of functions of PDFs (or othe...
Definition CodegenImpl.h:67
Namespace for the RooStats classes.
Definition CodegenImpl.h:61
double SignificanceToPValue(double Z)
returns p-value corresponding to a 1-sided significance
auto * tt
Definition textangle.C:16