Quick Links: ROOT Homepage Class Index Class Hierarchy

Source: header file inheritance tree (.pdf)

Sections: class description function members data members class charts

A++ » ROOSTATS » RooStats::HypoTestInverter

class RooStats::HypoTestInverter: public RooStats::IntervalCalculator

Function Members (Methods)

public:

virtual	~HypoTestInverter()
static TClass*	Class()
void	Clear()
virtual Double_t	ConfidenceLevel() const
RooStats::HypoTestCalculatorGeneric*	GetHypoTestCalculator() const
virtual RooStats::HypoTestInverterResult*	GetInterval() const
RooStats::SamplingDistribution*	GetLowerLimitDistribution(bool rebuild = false, int nToys = 100)
RooStats::TestStatistic*	GetTestStatistic() const
RooStats::SamplingDistribution*	GetUpperLimitDistribution(bool rebuild = false, int nToys = 100)
RooStats::HypoTestInverter	HypoTestInverter()
RooStats::HypoTestInverter	HypoTestInverter(RooStats::HypoTestCalculatorGeneric& hc, RooRealVar* scannedVariable = 0, double size = 0.050000000000000003)
RooStats::HypoTestInverter	HypoTestInverter(RooStats::HybridCalculator& hc, RooRealVar* scannedVariable = 0, double size = 0.050000000000000003)
RooStats::HypoTestInverter	HypoTestInverter(RooStats::FrequentistCalculator& hc, RooRealVar* scannedVariable, double size = 0.050000000000000003)
RooStats::HypoTestInverter	HypoTestInverter(RooStats::AsymptoticCalculator& hc, RooRealVar* scannedVariable, double size = 0.050000000000000003)
RooStats::HypoTestInverter	HypoTestInverter(RooAbsData& data, RooStats::ModelConfig& sb, RooStats::ModelConfig& b, RooRealVar* scannedVariable = 0, RooStats::HypoTestInverter::ECalculatorType type = kFrequentist, double size = 0.050000000000000003)
RooStats::IntervalCalculator	RooStats::IntervalCalculator::IntervalCalculator()
RooStats::IntervalCalculator	RooStats::IntervalCalculator::IntervalCalculator(const RooStats::IntervalCalculator&)
virtual TClass*	IsA() const
RooStats::SamplingDistribution*	RebuildDistributions(bool isUpper = true, int nToys = 100, TList* clsDist = 0, TList* clsbDist = 0, TList* clbDist = 0, const char* outputfile = "HypoTestInverterRebuiltDist.root")
bool	RunFixedScan(int nBins, double xMin, double xMax, bool scanLog = false) const
bool	RunLimit(double& limit, double& limitErr, double absTol = 0, double relTol = 0, const double* hint = 0) const
bool	RunOnePoint(double thisX, bool adaptive = false, double clTarget = -1) const
void	SetAutoScan()
static void	SetCloseProof(Bool_t flag)
virtual void	SetConfidenceLevel(Double_t cl)
virtual void	SetData(RooAbsData&)
void	SetFixedScan(int nBins, double xMin = 1, double xMax = -1, bool scanLog = false)
void	SetMaximumToys(int ntoys)
virtual void	SetModel(const RooStats::ModelConfig&)
void	SetNumErr(double err)
virtual void	SetTestSize(Double_t size)
bool	SetTestStatistic(RooStats::TestStatistic& stat)
void	SetVerbose(int level = 1)
virtual void	ShowMembers(TMemberInspector& insp) const
virtual Double_t	Size() const
virtual void	Streamer(TBuffer&)
void	StreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
void	UseCLs(bool on = true)

protected:

static void	CheckInputModels(const RooStats::HypoTestCalculatorGeneric& hc, const RooRealVar& scanVar)
void	CreateResults() const
RooStats::HypoTestResult*	Eval(RooStats::HypoTestCalculatorGeneric& hc, bool adaptive, double clsTarget) const
static RooRealVar*	GetVariableToScan(const RooStats::HypoTestCalculatorGeneric& hc)
RooStats::HypoTestInverter	HypoTestInverter(const RooStats::HypoTestInverter& rhs)
RooStats::HypoTestInverter&	operator=(const RooStats::HypoTestInverter& rhs)

Data Members

public:

static RooStats::HypoTestInverter::ECalculatorType	kAsymptotic
static RooStats::HypoTestInverter::ECalculatorType	kFrequentist
static RooStats::HypoTestInverter::ECalculatorType	kHybrid
static RooStats::HypoTestInverter::ECalculatorType	kUndefined

private:

RooStats::HypoTestInverter::ECalculatorType	fCalcType
RooStats::HypoTestCalculatorGeneric*	fCalculator0	pointer to the calculator passed in the constructor
unique_ptr<RooStats::HypoTestCalculatorGeneric>	fHC	! pointer to the generic hypotest calculator used
unique_ptr<TGraphErrors>	fLimitPlot	! plot of limits
int	fMaxToys	maximum number of toys to run
int	fNBins
double	fNumErr
RooStats::HypoTestInverterResult*	fResults	pointer to the result
bool	fScanLog
RooRealVar*	fScannedVariable	pointer to the constrained variable
double	fSize
int	fTotalToysRun
bool	fUseCLs
int	fVerbose
double	fXmax
double	fXmin
static double	fgAbsAccuracy
static string	fgAlgo
static double	fgCLAccuracy
static bool	fgCloseProof
static unsigned int	fgNToys
static double	fgRelAccuracy

Class Charts

Inheritance Chart:

RooStats::IntervalCalculator

←

RooStats::HypoTestInverter

Function documentation

HypoTestInverter()

 default constructor (used only for I/O)

HypoTestInverter( HypoTestCalculatorGeneric & hc, RooRealVar* scannedVariable =0, double size = 0.05)

 constructor from generic hypotest calculator

HypoTestInverter( FrequentistCalculator & hc, RooRealVar* scannedVariable, double size = 0.05)

 constructor from hybrid calculator
 constructor from frequentist calculator

HypoTestInverter(RooAbsData& data, RooStats::ModelConfig& sb, RooStats::ModelConfig& b, RooRealVar* scannedVariable = 0, RooStats::HypoTestInverter::ECalculatorType type = kFrequentist, double size = 0.050000000000000003)

 constructor from asymptotic calculator
 constructor from two ModelConfigs (first sb (the null model) then b (the alt model)
 creating a calculator inside

void Clear()

void SetFixedScan(int nBins, double xMin = 1, double xMax = -1, bool scanLog = false)

 set for a fixed scan in nbins

void SetAutoScan()

 set auto scan (default)

{ SetFixedScan(0); }

bool RunFixedScan(int nBins, double xMin, double xMax, bool scanLog = false) const

bool RunOnePoint(double thisX, bool adaptive = false, double clTarget = -1) const

bool RunLimit(double& limit, double& limitErr, double absTol = 0, double relTol = 0, const double* hint = 0) const

bool RunAutoScan( double xMin, double xMax, double target, double epsilon=0.005, unsigned int numAlgorithm=0 );

void UseCLs(bool on = true)

{ fUseCLs = on; if (fResults) fResults->UseCLs(on); }

void SetData(RooAbsData& )

void SetModel(const RooStats::ModelConfig& )

{ }

void SetTestSize(Double_t size)

 set the size of the test (rate of Type I error) ( Eg. 0.05 for a 95% Confidence Interval)

{fSize = size; if (fResults) fResults->SetTestSize(size); }

void SetConfidenceLevel(Double_t cl)

 set the confidence level for the interval (eg. 0.95 for a 95% Confidence Interval)

{fSize = 1.-cl; if (fResults) fResults->SetConfidenceLevel(cl); }

Double_t Size() const

 Get the size of the test (eg. rate of Type I error)

{return fSize;}

Double_t ConfidenceLevel() const

 Get the Confidence level for the test

{return 1.-fSize;}

virtual ~HypoTestInverter()

 destructor

HypoTestCalculatorGeneric * GetHypoTestCalculator() const

 retrieved a reference to the internally used HypoTestCalculator
 it might be invalid when the class is deleted

{ return fCalculator0; }

SamplingDistribution * GetLowerLimitDistribution(bool rebuild = false, int nToys = 100)

 get the upper/lower limit distribution

SamplingDistribution * GetUpperLimitDistribution(bool rebuild = false, int nToys = 100)

SamplingDistribution * RebuildDistributions(bool isUpper = true, int nToys = 100, TList* clsDist = 0, TList* clsbDist = 0, TList* clbDist = 0, const char* outputfile = "HypoTestInverterRebuiltDist.root")

 function to rebuild the distributions

bool SetTestStatistic(RooStats::TestStatistic& stat)

 get the test statistic
 set the test statistic

void SetVerbose(int level = 1)

 set verbose level (0,1,2)

{ fVerbose = level; }

void SetMaximumToys(int ntoys)

 set maximum number of toys

{ fMaxToys = ntoys;}

void SetNumErr(double err)

 set numerical error in test statistic evaluation (default is zero)

{ fNumErr = err; }

void SetCloseProof(Bool_t flag)

 set flag to close proof for every new run

HypoTestInverter(const RooStats::HypoTestInverter& rhs)

 copy c-tor

HypoTestInverter & operator=(const RooStats::HypoTestInverter& rhs)

 assignment

void CreateResults() const

HypoTestResult * Eval(RooStats::HypoTestCalculatorGeneric& hc, bool adaptive, double clsTarget) const

 run the hybrid at a single point

RooRealVar * GetVariableToScan(const RooStats::HypoTestCalculatorGeneric& hc)

 helper functions

void CheckInputModels(const RooStats::HypoTestCalculatorGeneric& hc, const RooRealVar& scanVar)