Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
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 
15 #include "RooStats/IntervalCalculator.h"
16 
17 
18 #include "RooStats/HypoTestInverterResult.h"
19 
20 class RooRealVar;
21 class TGraphErrors;
22 
23 #include <memory>
24 
25 
26 namespace RooStats {
27 
28  //class HypoTestCalculator;
29  class HybridCalculator;
30  class FrequentistCalculator;
31  class AsymptoticCalculator;
32  class HypoTestCalculatorGeneric;
33  class TestStatistic;
34 
35 
36 class HypoTestInverter : public IntervalCalculator {
37 
38 public:
39 
40  enum ECalculatorType { kUndefined = 0, kHybrid = 1, kFrequentist = 2, kAsymptotic = 3};
41 
42  // default constructor (used only for I/O)
43  HypoTestInverter();
44 
45  // constructor from generic hypotest calculator
46  HypoTestInverter( HypoTestCalculatorGeneric & hc,
47  RooRealVar* scannedVariable =0,
48  double size = 0.05) ;
49 
50 
51  // constructor from hybrid calculator
52  HypoTestInverter( HybridCalculator & hc,
53  RooRealVar* scannedVariable = 0,
54  double size = 0.05) ;
55 
56  // constructor from frequentist calculator
57  HypoTestInverter( FrequentistCalculator & hc,
58  RooRealVar* scannedVariable,
59  double size = 0.05) ;
60 
61  // constructor from asymptotic calculator
62  HypoTestInverter( AsymptoticCalculator & hc,
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
68  HypoTestInverter( RooAbsData& data, ModelConfig &sb, ModelConfig &b,
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
89  void SetAutoScan() { SetFixedScan(0); }
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
124  HypoTestCalculatorGeneric * GetHypoTestCalculator() const { return fCalculator0; }
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
135  TestStatistic * GetTestStatistic() const;
136 
137  // set the test statistic
138  bool SetTestStatistic(TestStatistic& stat);
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 
153 protected:
154 
155  // copy c-tor
156  HypoTestInverter(const HypoTestInverter & rhs);
157 
158  // assignment
159  HypoTestInverter & operator=(const HypoTestInverter & rhs);
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
167  static RooRealVar * GetVariableToScan(const HypoTestCalculatorGeneric &hc);
168  static void CheckInputModels(const HypoTestCalculatorGeneric &hc, const RooRealVar & scanVar);
169 
170 private:
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 
193  bool fUseCLs;
194  bool fScanLog;
195  double fSize;
196  int fVerbose;
197  ECalculatorType fCalcType;
198  int fNBins;
199  double fXmin;
200  double fXmax;
201  double fNumErr;
202 
203 protected:
204 
205  ClassDef(HypoTestInverter,4) // HypoTestInverter class
206 
207 };
208 
209 }
210 
211 #endif