#ifndef ROOSTATS_HypoTestInverter
#define ROOSTATS_HypoTestInverter
#ifndef ROOSTATS_IntervalCalculator
#include "RooStats/IntervalCalculator.h"
#endif
#ifndef ROOSTATS_HypoTestInverterResult
#include "RooStats/HypoTestInverterResult.h"
#endif
class RooRealVar;
class TGraphErrors;
#include <memory>
namespace RooStats {
class HybridCalculator;
class FrequentistCalculator;
class AsymptoticCalculator;
class HypoTestCalculatorGeneric;
class TestStatistic;
class HypoTestInverter : public IntervalCalculator {
public:
enum ECalculatorType { kUndefined = 0, kHybrid = 1, kFrequentist = 2, kAsymptotic = 3};
HypoTestInverter();
HypoTestInverter( HypoTestCalculatorGeneric & hc,
RooRealVar* scannedVariable =0,
double size = 0.05) ;
HypoTestInverter( HybridCalculator & hc,
RooRealVar* scannedVariable = 0,
double size = 0.05) ;
HypoTestInverter( FrequentistCalculator & hc,
RooRealVar* scannedVariable,
double size = 0.05) ;
HypoTestInverter( AsymptoticCalculator & hc,
RooRealVar* scannedVariable,
double size = 0.05) ;
HypoTestInverter( RooAbsData& data, ModelConfig &sb, ModelConfig &b,
RooRealVar * scannedVariable = 0, ECalculatorType type = kFrequentist,
double size = 0.05) ;
virtual HypoTestInverterResult* GetInterval() const;
void Clear();
void SetFixedScan(int nBins, double xMin = 1, double xMax = -1, bool scanLog = false ) {
fNBins = nBins;
fXmin = xMin; fXmax = xMax;
fScanLog = scanLog;
}
void SetAutoScan() { 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;
void UseCLs( bool on = true) { fUseCLs = on; if (fResults) fResults->UseCLs(on); }
virtual void SetData(RooAbsData &);
virtual void SetModel(const ModelConfig &) { }
virtual void SetTestSize(Double_t size) {fSize = size; if (fResults) fResults->SetTestSize(size); }
virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl; if (fResults) fResults->SetConfidenceLevel(cl); }
virtual Double_t Size() const {return fSize;}
virtual Double_t ConfidenceLevel() const {return 1.-fSize;}
virtual ~HypoTestInverter() ;
HypoTestCalculatorGeneric * GetHypoTestCalculator() const { return fCalculator0; }
SamplingDistribution * GetLowerLimitDistribution(bool rebuild=false, int nToys = 100);
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");
TestStatistic * GetTestStatistic() const;
bool SetTestStatistic(TestStatistic& stat);
void SetVerbose(int level=1) { fVerbose = level; }
void SetMaximumToys(int ntoys) { fMaxToys = ntoys;}
void SetNumErr(double err) { fNumErr = err; }
static void SetCloseProof(Bool_t flag);
protected:
HypoTestInverter(const HypoTestInverter & rhs);
HypoTestInverter & operator=(const HypoTestInverter & rhs);
void CreateResults() const;
HypoTestResult * Eval( HypoTestCalculatorGeneric &hc, bool adaptive , double clsTarget) const;
static RooRealVar * GetVariableToScan(const HypoTestCalculatorGeneric &hc);
static void CheckInputModels(const HypoTestCalculatorGeneric &hc, const RooRealVar & scanVar);
private:
static unsigned int fgNToys;
static double fgCLAccuracy;
static double fgAbsAccuracy;
static double fgRelAccuracy;
static bool fgCloseProof;
static std::string fgAlgo;
mutable std::unique_ptr<TGraphErrors> fLimitPlot;
mutable int fTotalToysRun;
int fMaxToys;
HypoTestCalculatorGeneric* fCalculator0;
std::unique_ptr<HypoTestCalculatorGeneric> fHC;
RooRealVar* fScannedVariable;
mutable HypoTestInverterResult* fResults;
bool fUseCLs;
bool fScanLog;
double fSize;
int fVerbose;
ECalculatorType fCalcType;
int fNBins;
double fXmin;
double fXmax;
double fNumErr;
protected:
ClassDef(HypoTestInverter,4)
};
}
#endif