Logo ROOT  
Reference Guide
HypoTestInverter.h
Go to the documentation of this file.
1// @(#)root/roostats:$Id$
2// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
3/*************************************************************************
4 * Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
5 * All rights reserved. *
6 * *
7 * For the licensing terms see $ROOTSYS/LICENSE. *
8 * For the list of contributors see $ROOTSYS/README/CREDITS. *
9 *************************************************************************/
10
11#ifndef ROOSTATS_HypoTestInverter
12#define ROOSTATS_HypoTestInverter
13
14
16
17
19
20class RooRealVar;
21class TGraphErrors;
22
23#include <memory>
24
25
26namespace RooStats {
27
28 //class HypoTestCalculator;
29 class HybridCalculator;
30 class FrequentistCalculator;
31 class AsymptoticCalculator;
32 class HypoTestCalculatorGeneric;
33 class TestStatistic;
34
35
37
38public:
39
41
42 // default constructor (used only for I/O)
44
45 // constructor from generic hypotest calculator
47 RooRealVar* scannedVariable =0,
48 double size = 0.05) ;
49
50
51 // constructor from hybrid calculator
53 RooRealVar* scannedVariable = 0,
54 double size = 0.05) ;
55
56 // constructor from frequentist calculator
58 RooRealVar* scannedVariable,
59 double size = 0.05) ;
60
61 // constructor from asymptotic calculator
63 RooRealVar* scannedVariable,
64 double size = 0.05) ;
65
66 // constructor from two ModelConfigs (first sb (the null model) then b (the alt model)
67 // creating a calculator inside
69 RooRealVar * scannedVariable = 0, ECalculatorType type = kFrequentist,
70 double size = 0.05) ;
71
72
73 virtual HypoTestInverterResult* GetInterval() const;
74
75 void Clear();
76
77 /// Set up to perform a fixed scan.
78 /// \param[in] nBins Number of points to scan.
79 /// \param[in] xMin Lower limit of range to be scanned.
80 /// \param[in] xMax Upper limit of range to be scanned.
81 /// \param[in] scanLog Run in logarithmic steps along x.
82 void SetFixedScan(int nBins, double xMin = 1, double xMax = -1, bool scanLog = false ) {
83 fNBins = nBins;
84 fXmin = xMin; fXmax = xMax;
85 fScanLog = scanLog;
86 }
87
88 /// Use automatic scanning, i.e. adaptive
90
91 /// Run a fixed scan.
92 /// \param[in] nBins Number of points to scan.
93 /// \param[in] xMin Lower limit of range to be scanned.
94 /// \param[in] xMax Upper limit of range to be scanned.
95 /// \param[in] scanLog Run in logarithmic steps along x.
96 bool RunFixedScan( int nBins, double xMin, double xMax, bool scanLog = false ) const;
97
98 bool RunOnePoint( double thisX, bool adaptive = false, double clTarget = -1 ) const;
99
100 //bool RunAutoScan( double xMin, double xMax, double target, double epsilon=0.005, unsigned int numAlgorithm=0 );
101
102 bool RunLimit(double &limit, double &limitErr, double absTol = 0, double relTol = 0, const double *hint=0) const;
103
104 void UseCLs( bool on = true) { fUseCLs = on; if (fResults) fResults->UseCLs(on); }
105
106 virtual void SetData(RooAbsData &);
107
108 virtual void SetModel(const ModelConfig &) { } // not needed
109
110 // set the size of the test (rate of Type I error) ( Eg. 0.05 for a 95% Confidence Interval)
111 virtual void SetTestSize(Double_t size) {fSize = size; if (fResults) fResults->SetTestSize(size); }
112 // set the confidence level for the interval (eg. 0.95 for a 95% Confidence Interval)
113 virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl; if (fResults) fResults->SetConfidenceLevel(cl); }
114 // Get the size of the test (eg. rate of Type I error)
115 virtual Double_t Size() const {return fSize;}
116 // Get the Confidence level for the test
117 virtual Double_t ConfidenceLevel() const {return 1.-fSize;}
118
119 // destructor
120 virtual ~HypoTestInverter() ;
121
122 // retrieved a reference to the internally used HypoTestCalculator
123 // it might be invalid when the class is deleted
125
126 // get the upper/lower limit distribution
127 SamplingDistribution * GetLowerLimitDistribution(bool rebuild=false, int nToys = 100);
128 SamplingDistribution * GetUpperLimitDistribution(bool rebuild=false, int nToys = 100);
129
130 // function to rebuild the distributions
131 SamplingDistribution * RebuildDistributions(bool isUpper=true, int nToys = 100,
132 TList * clsDist = 0, TList *clsbDist= 0, TList * clbDist = 0, const char * outputfile = "HypoTestInverterRebuiltDist.root");
133
134 // get the test statistic
136
137 // set the test statistic
139
140 // set verbose level (0,1,2)
141 void SetVerbose(int level=1) { fVerbose = level; }
142
143 // set maximum number of toys
144 void SetMaximumToys(int ntoys) { fMaxToys = ntoys;}
145
146 // set numerical error in test statistic evaluation (default is zero)
147 void SetNumErr(double err) { fNumErr = err; }
148
149 // set flag to close proof for every new run
150 static void SetCloseProof(Bool_t flag);
151
152
153protected:
154
155 // copy c-tor
157
158 // assignment
160
161 void CreateResults() const;
162
163 // run the hybrid at a single point
164 HypoTestResult * Eval( HypoTestCalculatorGeneric &hc, bool adaptive , double clsTarget) const;
165
166 // helper functions
168 static void CheckInputModels(const HypoTestCalculatorGeneric &hc, const RooRealVar & scanVar);
169
170private:
171
172
173 static unsigned int fgNToys;
174 static double fgCLAccuracy;
175 static double fgAbsAccuracy;
176 static double fgRelAccuracy;
177 static bool fgCloseProof;
178 static std::string fgAlgo;
179
180 // graph, used to compute the limit, not just for plotting!
181 mutable std::unique_ptr<TGraphErrors> fLimitPlot; //! plot of limits
182
183
184 // performance counter: remember how many toys have been thrown
185 mutable int fTotalToysRun;
186 int fMaxToys; // maximum number of toys to run
187
188 HypoTestCalculatorGeneric* fCalculator0; // pointer to the calculator passed in the constructor
189 std::unique_ptr<HypoTestCalculatorGeneric> fHC; //! pointer to the generic hypotest calculator used
190 RooRealVar* fScannedVariable; // pointer to the constrained variable
191 mutable HypoTestInverterResult* fResults; // pointer to the result
192
195 double fSize;
199 double fXmin;
200 double fXmax;
201 double fNumErr;
202
203protected:
204
205 ClassDef(HypoTestInverter,4) // HypoTestInverter class
206
207};
208
209}
210
211#endif
#define b(i)
Definition: RSha256.hxx:100
bool Bool_t
Definition: RtypesCore.h:61
double Double_t
Definition: RtypesCore.h:57
#define ClassDef(name, id)
Definition: Rtypes.h:322
int type
Definition: TGX11.cxx:120
RooAbsData is the common abstract base class for binned and unbinned datasets.
Definition: RooAbsData.h:44
RooRealVar represents a variable that can be changed from the outside.
Definition: RooRealVar.h:35
Hypothesis Test Calculator based on the asymptotic formulae for the profile likelihood ratio.
Does a frequentist hypothesis test.
Same purpose as HybridCalculatorOriginal, but different implementation.
Common base class for the Hypothesis Test Calculators.
HypoTestInverterResult class holds the array of hypothesis test results and compute a confidence inte...
virtual void SetTestSize(Double_t size)
set the size of the test (rate of Type I error) (eg. 0.05 for a 95% Confidence Interval)
virtual void SetConfidenceLevel(Double_t cl)
set the confidence level for the interval (eg. 0.95 for a 95% Confidence Interval)
void UseCLs(bool on=true)
flag to switch between using CLsb (default) or CLs as confidence level
A class for performing a hypothesis test inversion by scanning the hypothesis test results of a HypoT...
virtual void SetData(RooAbsData &)
Set the DataSet ( add to the the workspace if not already there ?)
static void CheckInputModels(const HypoTestCalculatorGeneric &hc, const RooRealVar &scanVar)
check the model given the given hypotestcalculator
static void SetCloseProof(Bool_t flag)
set flag to close proof for every new run
void SetVerbose(int level=1)
RooRealVar * fScannedVariable
pointer to the generic hypotest calculator used
virtual ~HypoTestInverter()
destructor (delete the HypoTestInverterResult)
std::unique_ptr< HypoTestCalculatorGeneric > fHC
virtual void SetTestSize(Double_t size)
set the size of the test (rate of Type I error) ( e.g. 0.05 for a 95% Confidence Interval)
SamplingDistribution * RebuildDistributions(bool isUpper=true, int nToys=100, TList *clsDist=0, TList *clsbDist=0, TList *clbDist=0, const char *outputfile="HypoTestInverterRebuiltDist.root")
rebuild the sampling distributions by generating some toys and find for each of them a new upper limi...
HypoTestInverterResult * fResults
virtual Double_t Size() const
Get the size of the test (eg. rate of Type I error)
HypoTestInverter()
default constructor (doesn't do anything)
bool SetTestStatistic(TestStatistic &stat)
set the test statistic to use
virtual Double_t ConfidenceLevel() const
Get the Confidence level for the test.
SamplingDistribution * GetUpperLimitDistribution(bool rebuild=false, int nToys=100)
get the distribution of lower limit if rebuild = false (default) it will re-use the results of the sc...
virtual void SetConfidenceLevel(Double_t cl)
set the confidence level for the interval (e.g. 0.95 for a 95% Confidence Interval)
static unsigned int fgNToys
HypoTestCalculatorGeneric * GetHypoTestCalculator() const
void Clear()
delete contained result and graph
virtual void SetModel(const ModelConfig &)
Set the Model.
void SetAutoScan()
Use automatic scanning, i.e. adaptive.
TestStatistic * GetTestStatistic() const
return the test statistic which is or will be used by the class
virtual HypoTestInverterResult * GetInterval() const
Run a fixed scan or the automatic scan depending on the configuration.
bool RunLimit(double &limit, double &limitErr, double absTol=0, double relTol=0, const double *hint=0) const
Run an automatic scan until the desired accuracy is reached.
std::unique_ptr< TGraphErrors > fLimitPlot
bool RunFixedScan(int nBins, double xMin, double xMax, bool scanLog=false) const
Run a fixed scan.
bool RunOnePoint(double thisX, bool adaptive=false, double clTarget=-1) const
run only one point at the given POI value
SamplingDistribution * GetLowerLimitDistribution(bool rebuild=false, int nToys=100)
get the distribution of lower limit if rebuild = false (default) it will re-use the results of the sc...
HypoTestInverter & operator=(const HypoTestInverter &rhs)
assignment operator NOTE: this class does not copy the contained result and the HypoTestCalculator,...
void SetFixedScan(int nBins, double xMin=1, double xMax=-1, bool scanLog=false)
Set up to perform a fixed scan.
HypoTestCalculatorGeneric * fCalculator0
int fTotalToysRun
plot of limits
void CreateResults() const
create a new HypoTestInverterResult to hold all computed results
static RooRealVar * GetVariableToScan(const HypoTestCalculatorGeneric &hc)
get the variable to scan try first with null model if not go to alternate model
HypoTestResult * Eval(HypoTestCalculatorGeneric &hc, bool adaptive, double clsTarget) const
Run the Hypothesis test at a previous configured point (internal function called by RunOnePoint)
HypoTestResult is a base class for results from hypothesis tests.
IntervalCalculator is an interface class for a tools which produce RooStats ConfIntervals.
ModelConfig is a simple class that holds configuration information specifying how a model should be u...
Definition: ModelConfig.h:30
This class simply holds a sampling distribution of some test statistic.
TestStatistic is an interface class to provide a facility for construction test statistics distributi...
Definition: TestStatistic.h:31
A TGraphErrors is a TGraph with error bars.
Definition: TGraphErrors.h:26
A doubly linked list.
Definition: TList.h:44
Namespace for the RooStats classes.
Definition: Asimov.h:19