Logo ROOT   6.30.04
Reference Guide
 All Namespaces Files Pages
HypoTestInverterResult.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_HypoTestInverterResult
12 #define ROOSTATS_HypoTestInverterResult
13 
14 
15 
16 #include "RooStats/SimpleInterval.h"
17 
18 #include "RooStats/HypoTestResult.h"
19 
20 class RooRealVar;
21 
22 namespace RooStats {
23 
24 class SamplingDistribution;
25 
26 class HypoTestInverterResult : public SimpleInterval {
27 
28 public:
29 
30  /// default constructor
31  explicit HypoTestInverterResult(const char* name = 0);
32 
33  /// constructor
34  HypoTestInverterResult( const char* name,
35  const RooRealVar& scannedVariable,
36  double cl ) ;
37 
38  HypoTestInverterResult( const HypoTestInverterResult& other, const char* name );
39 
40  /// destructor
41  virtual ~HypoTestInverterResult();
42 
43  /// operator =
44  HypoTestInverterResult& operator = (const HypoTestInverterResult& other);
45 
46  /// remove points that appear to have failed.
47  int ExclusionCleanup();
48 
49  /// merge with the content of another HypoTestInverterResult object
50  bool Add( const HypoTestInverterResult& otherResult );
51 
52  ///add the result of a single point (an HypoTestRsult)
53  bool Add( Double_t x, const HypoTestResult & result );
54 
55  /// function to return the value of the parameter of interest for the i^th entry in the results
56  double GetXValue( int index ) const ;
57 
58  /// function to return the value of the confidence level for the i^th entry in the results
59  double GetYValue( int index ) const ;
60 
61  /// function to return the estimated error on the value of the confidence level for the i^th entry in the results
62  double GetYError( int index ) const ;
63 
64  /// return the observed CLsplusb value for the i-th entry
65  double CLsplusb( int index) const;
66 
67  /// return the observed CLb value for the i-th entry
68  double CLb( int index) const;
69 
70  /// return the observed CLb value for the i-th entry
71  double CLs( int index) const;
72 
73  /// return the observed CLsplusb value for the i-th entry
74  double CLsplusbError( int index) const;
75 
76  /// return the observed CLb value for the i-th entry
77  double CLbError( int index) const;
78 
79  /// return the observed CLb value for the i-th entry
80  double CLsError( int index) const;
81 
82  /// return a pointer to the i^th result object
83  HypoTestResult* GetResult( int index ) const ;
84 
85  double GetLastYValue( ) const { return GetYValue( fXValues.size()-1); }
86 
87  double GetLastXValue( ) const { return GetXValue( fXValues.size()-1); }
88 
89  double GetLastYError( ) const { return GetYError( fXValues.size()-1); }
90 
91  HypoTestResult * GetLastResult( ) const { return GetResult( fXValues.size()-1); }
92 
93  /// number of entries in the results array
94  int ArraySize() const { return fXValues.size(); };
95 
96  int FindIndex(double xvalue) const;
97 
98  /// set the size of the test (rate of Type I error) (eg. 0.05 for a 95% Confidence Interval)
99  virtual void SetTestSize( Double_t size ) { fConfidenceLevel = 1.-size; }
100 
101  /// set the confidence level for the interval (eg. 0.95 for a 95% Confidence Interval)
102  virtual void SetConfidenceLevel( Double_t cl ) { fConfidenceLevel = cl; }
103 
104  /// set CLs threshold for exclusion cleanup function
105  inline void SetCLsCleanupThreshold( Double_t th ) { fCLsCleanupThreshold = th; }
106 
107  /// flag to switch between using CLsb (default) or CLs as confidence level
108  void UseCLs( bool on = true ) { fUseCLs = on; }
109 
110  /// query if one sided result
111  bool IsOneSided() const { return !fIsTwoSided; }
112  /// query if two sided result
113  bool IsTwoSided() const { return fIsTwoSided; }
114 
115  /// lower and upper bound of the confidence interval (to get upper/lower limits, multiply the size( = 1-confidence level ) by 2
116  Double_t LowerLimit();
117  Double_t UpperLimit();
118 
119  /// rough estimation of the error on the computed bound of the confidence interval
120  /// Estimate of lower limit error
121  ///function evaluates only a rough error on the lower limit. Be careful when using this estimation
122  Double_t LowerLimitEstimatedError();
123 
124  /// Estimate of lower limit error
125  ///function evaluates only a rough error on the lower limit. Be careful when using this estimation
126  Double_t UpperLimitEstimatedError();
127 
128  /// return expected distribution of p-values (Cls or Clsplusb)
129 
130  SamplingDistribution * GetExpectedPValueDist(int index) const;
131 
132  SamplingDistribution * GetBackgroundTestStatDist(int index ) const;
133 
134  SamplingDistribution * GetSignalAndBackgroundTestStatDist(int index) const;
135 
136  /// same in terms of alt and null
137  SamplingDistribution * GetNullTestStatDist(int index) const {
138  return GetSignalAndBackgroundTestStatDist(index);
139  }
140  SamplingDistribution * GetAltTestStatDist(int index) const {
141  return GetBackgroundTestStatDist(index);
142  }
143 
144  /// get expected lower limit distributions
145  /// implemented using interpolation
146  /// The size for the sampling distribution is given (by default is given by the average number of toy/point)
147  SamplingDistribution* GetLowerLimitDistribution() const { return GetLimitDistribution(true); }
148 
149  /// get expected upper limit distributions
150  /// implemented using interpolation
151  SamplingDistribution* GetUpperLimitDistribution() const { return GetLimitDistribution(false); }
152 
153  /// get Limit value corresponding at the desired nsigma level (0) is median -1 sigma is 1 sigma
154  double GetExpectedLowerLimit(double nsig = 0, const char * opt = "" ) const ;
155 
156  /// get Limit value corresponding at the desired nsigma level (0) is median -1 sigma is 1 sigma
157  double GetExpectedUpperLimit(double nsig = 0, const char * opt = "") const ;
158 
159 
160  double FindInterpolatedLimit(double target, bool lowSearch = false, double xmin=1, double xmax=0);
161 
162  enum InterpolOption_t { kLinear, kSpline };
163 
164  /// set the interpolation option, linear (kLinear ) or spline (kSpline)
165  void SetInterpolationOption( InterpolOption_t opt) { fInterpolOption = opt; }
166 
167  InterpolOption_t GetInterpolationOption() const { return fInterpolOption; }
168 
169 private:
170 
171 
172  double CalculateEstimatedError(double target, bool lower = true, double xmin = 1, double xmax = 0);
173 
174  int FindClosestPointIndex(double target, int mode = 0, double xtarget = 0);
175 
176  SamplingDistribution* GetLimitDistribution(bool lower ) const;
177 
178  double GetExpectedLimit(double nsig, bool lower, const char * opt = "" ) const ;
179 
180  double GetGraphX(const TGraph & g, double y0, bool lowSearch, double &xmin, double &xmax) const;
181  double GetGraphX(const TGraph & g, double y0, bool lowSearch = true) const {
182  double xmin=1; double xmax = 0;
183  return GetGraphX(g,y0,lowSearch,xmin,xmax);
184  }
185 
186 
187 protected:
188 
189  bool fUseCLs;
190  bool fIsTwoSided; /// two sided scan (look for lower/upper limit)
191  bool fInterpolateLowerLimit;
192  bool fInterpolateUpperLimit;
193  bool fFittedLowerLimit;
194  bool fFittedUpperLimit;
195  InterpolOption_t fInterpolOption; /// interpolation option (linear or spline)
196 
197  double fLowerLimitError;
198  double fUpperLimitError;
199 
200  double fCLsCleanupThreshold;
201 
202  static double fgAsymptoticMaxSigma; /// max sigma value used to scan asymptotic expected p values
203  static int fgAsymptoticNumPoints; /// number of points used to build expected p-values
204 
205  std::vector<double> fXValues;
206 
207  TList fYObjects; /// list of HypoTestResult for each point
208  TList fExpPValues; /// list of expected sampling distribution for each point
209 
210  friend class HypoTestInverter;
211  friend class HypoTestInverterPlot;
212  friend class HypoTestInverterOriginal;
213 
214  ClassDef(HypoTestInverterResult,5) /// HypoTestInverterResult class
215 };
216 }
217 
218 #endif