A class for fitting histograms with functions. More...

#include <BCEfficiencyFitter.h>

Inheritance diagram for BCEfficiencyFitter:

Collaboration diagram for BCEfficiencyFitter:

Classes
class	ToyDataInterface

Public Member Functions
Constructors and destructors
	BCEfficiencyFitter ()

	BCEfficiencyFitter (const char *name)

	BCEfficiencyFitter (TH1D hist1, TH1D hist2, TF1 *func)

	BCEfficiencyFitter (const char name, TH1D hist1, TH1D hist2, TF1 func)

	~BCEfficiencyFitter ()

Member functions (get)
TH1D *	GetHistogram1 ()

TH1D *	GetHistogram2 ()

TGraphAsymmErrors *	GetHistogramRatio ()

TF1 *	GetFitFunction ()

TGraph *	GetErrorBand ()

TGraph *	GetGraphFitFunction ()

int	GetUncertainties (int n, int k, double p, double &xexp, double &xmin, double &xmax)

Member functions (set)
int	SetHistograms (TH1D hist1, TH1D hist2)

int	SetFitFunction (TF1 *func)

void	SetFlagIntegration (bool flag)

void	SetDataPointType (int type)

Member functions (miscellaneous methods)
virtual double	LogLikelihood (const std::vector< double > &parameters)

double	FitFunction (const std::vector< double > &x, const std::vector< double > &parameters)

int	Fit ()

int	Fit (TH1D hist1, TH1D hist2, TF1 *func)

void	DrawFit (const char *options="", bool flaglegend=false)

int	CalculatePValueFast (const std::vector< double > &par, BCEfficiencyFitter::ToyDataInterface *callback, double &pvalue, double &pvalueCorrected, unsigned nIterations=100000)

int	CalculatePValueFast (const std::vector< double > &par, double &pvalue, double &pvalueCorrected, unsigned nIterations=100000)

Public Member Functions inherited from BCFitter
	BCFitter ()

	BCFitter (const char *name)

	~BCFitter ()

TGraph *	GetErrorBand ()

TH2D *	GetErrorBandXY () const

TH2D *	GetErrorBandXY_yellow (double level=.68, int nsmooth=0) const

std::vector< double >	GetErrorBand (double level) const

TGraph *	GetErrorBandGraph (double level1, double level2) const

TGraph *	GetFitFunctionGraph (const std::vector< double > &parameters)

TGraph *	GetFitFunctionGraph ()

TGraph *	GetFitFunctionGraph (const std::vector< double > &parameters, double xmin, double xmax, int n=1000)

void	FixDataAxis (unsigned int index, bool fixed)

bool	GetFixedDataAxis (unsigned int index) const

void	SetFillErrorBand (bool flag=true)

void	SetErrorBandHisto (TH2D *h)

void	UnsetFillErrorBand ()

void	SetFitFunctionIndexX (int index)

void	SetFitFunctionIndexY (int index)

void	SetFitFunctionIndices (int indexx, int indexy)

void	SetErrorBandContinuous (bool flag)

int	ReadErrorBandFromFile (const char *file)

void	MCMCIterationInterface ()

void	MarginalizePreprocess ()

void	MarginalizePostprocess ()

void	FillErrorBand ()

Public Member Functions inherited from BCModel
	BCModel (const char *name="model")

	BCModel (const BCModel &bcmodel)

virtual	~BCModel ()

BCModel &	operator= (const BCModel &bcmodel)

const std::string &	GetName () const

double	GetModelAPrioriProbability () const

double	GetModelAPosterioriProbability () const

BCDataSet *	GetDataSet () const

BCDataPoint *	GetDataPointLowerBoundaries () const

BCDataPoint *	GetDataPointUpperBoundaries () const

double	GetDataPointLowerBoundary (unsigned int index) const

double	GetDataPointUpperBoundary (unsigned int index) const

bool	GetFlagBoundaries () const

unsigned	GetNDataPoints () const

BCDataPoint *	GetDataPoint (unsigned int index) const

void	SetName (const char *name)

void	SetModelAPrioriProbability (double probability)

void	SetModelAPosterioriProbability (double probability)

virtual int	AddParameter (BCParameter *parameter)

void	SetDataSet (BCDataSet *dataset)

void	SetSingleDataPoint (BCDataPoint *datapoint)

void	SetSingleDataPoint (BCDataSet *dataset, unsigned int index)

void	SetDataBoundaries (unsigned int index, double lowerboundary, double upperboundary, bool fixed=false)

void	SetDataPointLowerBoundaries (BCDataPoint *datasetlowerboundaries)

void	SetDataPointUpperBoundaries (BCDataPoint *datasetupperboundaries)

void	SetDataPointLowerBoundary (int index, double lowerboundary)

void	SetDataPointUpperBoundary (int index, double upperboundary)

int	SetPrior (int index, TF1 *f)

int	SetPrior (const char name, TF1 f)

int	SetPriorDelta (int index, double value)

int	SetPriorDelta (const char *name, double value)

int	SetPriorGauss (int index, double mean, double sigma)

int	SetPriorGauss (const char *name, double mean, double sigma)

int	SetPriorGauss (int index, double mean, double sigmadown, double sigmaup)

int	SetPriorGauss (const char *name, double mean, double sigmadown, double sigmaup)

int	SetPrior (int index, TH1 *h, bool flag=false)

int	SetPrior (const char name, TH1 h, bool flag=false)

int	SetPriorConstant (int index)

int	SetPriorConstant (const char *name)

int	SetPriorConstantAll ()

void	Copy (const BCModel &bcmodel)

double	APrioriProbability (const std::vector< double > &parameters)

virtual double	LogAPrioriProbability (const std::vector< double > &parameters)

virtual double	Likelihood (const std::vector< double > &params)

double	ProbabilityNN (const std::vector< double > &params)

double	LogProbabilityNN (const std::vector< double > &parameters)

double	Probability (const std::vector< double > &parameter)

double	LogProbability (const std::vector< double > &parameter)

virtual double	SamplingFunction (const std::vector< double > &parameters)

double	Eval (const std::vector< double > &parameters)

virtual double	LogEval (const std::vector< double > &parameters)

virtual void	CorrelateDataPointValues (std::vector< double > &x)

double	GetPvalueFromChi2 (const std::vector< double > &par, int sigma_index)

double	GetPvalueFromKolmogorov (const std::vector< double > &par, int index)

double	GetPvalueFromChi2NDoF (std::vector< double > par, int sigma_index)

BCH1D *	CalculatePValue (std::vector< double > par, bool flag_histogram=false)

double	GetPValue ()

double	GetPValueNDoF ()

double	GetChi2NDoF ()

std::vector< double >	GetChi2Runs (int dataIndex, int sigmaIndex)

void	SetGoFNIterationsMax (int n)

void	SetGoFNIterationsRun (int n)

void	SetGoFNChains (int n)

double	HessianMatrixElement (const BCParameter parameter1, const BCParameter parameter2, std::vector< double > point)

void	PrintSummary ()

void	PrintResults (const char *file)

void	PrintShortFitSummary (int chi2flag=0)

void	PrintHessianMatrix (std::vector< double > parameters)

virtual double	CDF (const std::vector< double > &, int, bool)

Public Member Functions inherited from BCIntegrate
	BCIntegrate ()

	BCIntegrate (const BCIntegrate &bcintegrate)

virtual	~BCIntegrate ()

BCIntegrate &	operator= (const BCIntegrate &bcintegrate)

int	ReadMarginalizedFromFile (const char *file)

BCH1D *	GetMarginalized (const BCParameter *parameter)

BCH1D *	GetMarginalized (const char *name)

BCH1D *	GetMarginalized (unsigned index)

BCH2D *	GetMarginalized (const BCParameter parameter1, const BCParameter parameter2)

BCH2D *	GetMarginalized (const char name1, const char name2)

BCH2D *	GetMarginalized (unsigned index1, unsigned index2)

int	PrintAllMarginalized1D (const char *filebase)

int	PrintAllMarginalized2D (const char *filebase)

int	PrintAllMarginalized (const char *file, std::string options1d="BTsiB3CS1D0pdf0Lmeanmode", std::string options2d="BTfB3CS1meangmode", unsigned int hdiv=1, unsigned int ndiv=1)

double	GetIntegral () const

BCIntegrate::BCOptimizationMethod	GetOptimizationMethod () const

BCIntegrate::BCIntegrationMethod	GetIntegrationMethod () const

BCIntegrate::BCMarginalizationMethod	GetMarginalizationMethod () const

BCIntegrate::BCSASchedule	GetSASchedule () const

void	GetRandomVectorUnitHypercube (std::vector< double > &x) const

void	GetRandomVectorInParameterSpace (std::vector< double > &x) const

double	GetRandomPoint (std::vector< double > &x)

int	GetNIterationsMin () const

int	GetNIterationsMax () const

int	GetNIterationsPrecisionCheck () const

int	GetNIterationsOutput () const

int	GetNIterations () const

double	GetRelativePrecision () const

double	GetAbsolutePrecision () const

BCCubaMethod	GetCubaIntegrationMethod () const

const BCCubaOptions::Vegas &	GetCubaVegasOptions () const

const BCCubaOptions::Suave &	GetCubaSuaveOptions () const

const BCCubaOptions::Divonne &	GetCubaDivonneOptions () const

const BCCubaOptions::Cuhre &	GetCubaCuhreOptions () const

BCH1D *	GetSlice (const BCParameter *parameter, const std::vector< double > parameters=std::vector< double >(0), int bins=0, bool flag_norm=true)

BCH1D *	GetSlice (const char *name, const std::vector< double > parameters=std::vector< double >(0), int nbins=0, bool flag_norm=true)

BCH2D *	GetSlice (const BCParameter parameter1, const BCParameter parameter2, const std::vector< double > parameters=std::vector< double >(0), int bins=0, bool flag_norm=true)

BCH2D *	GetSlice (const char name1, const char name2, const std::vector< double > parameters=std::vector< double >(0), int nbins=0, bool flag_norm=true)

BCH2D *	GetSlice (unsigned index1, unsigned index2, const std::vector< double > parameters=std::vector< double >(0), int nbins=0, bool flag_norm=true)

double	GetError () const

TMinuit *	GetMinuit ()

int	GetMinuitErrorFlag () const

double	GetSAT0 () const

double	GetSATmin () const

double	GetBestFitParameter (unsigned index) const

double	GetBestFitParameterError (unsigned index) const

double	GetLogMaximum ()

const std::vector< double > &	GetBestFitParameters () const

const std::vector< double > &	GetBestFitParameterErrors () const

void	SetMinuitArlist (double *arglist)

void	SetFlagIgnorePrevOptimization (bool flag)

void	SetOptimizationMethod (BCIntegrate::BCOptimizationMethod method)

void	SetIntegrationMethod (BCIntegrate::BCIntegrationMethod method)

void	SetMarginalizationMethod (BCIntegrate::BCMarginalizationMethod method)

void	SetSASchedule (BCIntegrate::BCSASchedule schedule)

void	SetNIterationsMin (int niterations)

void	SetNIterationsMax (int niterations)

void	SetNIterationsPrecisionCheck (int niterations)

void	SetNIterationsOutput (int niterations)

void	SetRelativePrecision (double relprecision)

void	SetAbsolutePrecision (double absprecision)

void	SetCubaIntegrationMethod (BCCubaMethod type)

void	SetCubaOptions (const BCCubaOptions::Vegas &options)

void	SetCubaOptions (const BCCubaOptions::Suave &options)

void	SetCubaOptions (const BCCubaOptions::Divonne &options)

void	SetCubaOptions (const BCCubaOptions::Cuhre &options)

void	SetSAT0 (double T0)

void	SetSATmin (double Tmin)

void	SetFlagWriteSAToFile (bool flag)

TTree *	GetSATree ()

void	InitializeSATree ()

double	Normalize ()

double	Integrate (BCIntegrationMethod intmethod)

double	Integrate ()

double	Integrate (BCIntegrationMethod type, tRandomizer randomizer, tEvaluator evaluator, tIntegralUpdater updater, std::vector< double > &sums)

double	EvaluatorMC (std::vector< double > &sums, const std::vector< double > &point, bool &accepted)

int	MarginalizeAll ()

int	MarginalizeAll (BCMarginalizationMethod margmethod)

void	SAInitialize ()

std::vector< double >	FindMode (std::vector< double > start=std::vector< double >())

std::vector< double >	FindMode (BCIntegrate::BCOptimizationMethod optmethod, std::vector< double > start=std::vector< double >())

double	SATemperature (double t)

double	SATemperatureBoltzmann (double t)

double	SATemperatureCauchy (double t)

virtual double	SATemperatureCustom (double t)

std::vector< double >	GetProposalPointSA (const std::vector< double > &x, int t)

std::vector< double >	GetProposalPointSABoltzmann (const std::vector< double > &x, int t)

std::vector< double >	GetProposalPointSACauchy (const std::vector< double > &x, int t)

virtual std::vector< double >	GetProposalPointSACustom (const std::vector< double > &x, int t)

std::vector< double >	SAHelperGetRandomPointOnHypersphere ()

double	SAHelperGetRadialCauchy ()

double	SAHelperSinusToNIntegral (int dim, double theta)

virtual void	ResetResults ()

std::string	DumpIntegrationMethod (BCIntegrationMethod type)

std::string	DumpCurrentIntegrationMethod ()

std::string	DumpUsedIntegrationMethod ()

std::string	DumpMarginalizationMethod (BCMarginalizationMethod type)

std::string	DumpCurrentMarginalizationMethod ()

std::string	DumpUsedMarginalizationMethod ()

std::string	DumpOptimizationMethod (BCOptimizationMethod type)

std::string	DumpCurrentOptimizationMethod ()

std::string	DumpUsedOptimizationMethod ()

std::string	DumpCubaIntegrationMethod (BCCubaMethod type)

std::string	DumpCubaIntegrationMethod ()

void	SetBestFitParameters (const std::vector< double > &x)

void	SetBestFitParameters (const std::vector< double > &x, const double &new_value, double &old_value)

unsigned	GetNIntegrationVariables ()

double	CalculateIntegrationVolume ()

bool	CheckMarginalizationAvailability (BCMarginalizationMethod type)

bool	CheckMarginalizationIndices (TH1 *hist, const std::vector< unsigned > &index)

Public Member Functions inherited from BCEngineMCMC
void	WriteMarkovChain (bool flag)

	BCEngineMCMC ()

	BCEngineMCMC (const BCEngineMCMC &enginemcmc)

virtual	~BCEngineMCMC ()

BCEngineMCMC &	operator= (const BCEngineMCMC &engineMCMC)

unsigned	MCMCGetNChains () const

unsigned	MCMCGetNLag () const

const std::vector< unsigned > &	MCMCGetNIterations () const

unsigned	MCMCGetCurrentIteration () const

unsigned	MCMCGetCurrentChain () const

unsigned	MCMCGetNIterationsConvergenceGlobal () const

bool	MCMCGetFlagConvergenceGlobal () const

unsigned	MCMCGetNIterationsMax () const

unsigned	MCMCGetNIterationsRun () const

unsigned	MCMCGetNIterationsPreRunMin () const

unsigned	MCMCGetNIterationsUpdate () const

unsigned	MCMCGetNIterationsUpdateMax () const

std::vector< int >	MCMCGetNTrialsTrue () const

int	MCMCGetNTrials () const

const std::vector< double > &	MCMCGetprobMean () const

const std::vector< double > &	MCMCGetVariance () const

const std::vector< double > &	MCMCGetTrialFunctionScaleFactor () const

std::vector< double >	MCMCGetTrialFunctionScaleFactor (unsigned ichain) const

double	MCMCGetTrialFunctionScaleFactor (unsigned ichain, unsigned ipar)

const std::vector< double > &	MCMCGetx () const

std::vector< double >	MCMCGetx (unsigned ichain)

double	MCMCGetx (unsigned ichain, unsigned ipar) const

const std::vector< double > &	MCMCGetLogProbx () const

double	MCMCGetLogProbx (unsigned ichain)

int	MCMCGetPhase () const

const std::vector< double > &	MCMCGetMaximumPoints () const

std::vector< double >	MCMCGetMaximumPoint (unsigned i) const

const std::vector< double > &	MCMCGetMaximumLogProb () const

int	MCMCGetFlagInitialPosition () const

double	MCMCGetRValueCriterion () const

double	MCMCGetRValueParametersCriterion () const

double	MCMCGetRValue () const

double	MCMCGetRValueParameters (unsigned i)

bool	MCMCGetRValueStrict () const

bool	MCMCGetFlagRun () const

TTree *	MCMCGetMarkovChainTree (unsigned i)

BCH1D *	MCMCGetH1Marginalized (unsigned i)

BCH2D *	MCMCGetH2Marginalized (unsigned i, unsigned j)

BCParameter *	GetParameter (int index) const

BCParameter *	GetParameter (const char *name) const

unsigned int	GetNParameters () const

unsigned int	GetNFixedParameters ()

unsigned int	GetNFreeParameters ()

const std::vector< double > &	GetBestFitParametersMarginalized () const

void	MCMCSetTrialFunctionScaleFactor (std::vector< double > scale)

void	MCMCSetNChains (unsigned n)

void	MCMCSetNLag (unsigned n)

void	MCMCSetNIterationsMax (unsigned n)

void	MCMCSetNIterationsRun (unsigned n)

void	MCMCSetNIterationsPreRunMin (unsigned n)

void	MCMCSetNIterationsUpdate (unsigned n)

void	MCMCSetNIterationsUpdateMax (unsigned n)

void	MCMCSetMinimumEfficiency (double efficiency)

void	MCMCSetMaximumEfficiency (double efficiency)

void	MCMCSetRandomSeed (unsigned seed)

void	MCMCSetWriteChainToFile (bool flag)

void	MCMCSetWritePreRunToFile (bool flag)

void	MCMCSetInitialPositions (const std::vector< double > &x0s)

void	MCMCSetInitialPositions (std::vector< std::vector< double > > x0s)

void	MCMCSetFlagInitialPosition (int flag)

void	MCMCSetFlagOrderParameters (bool flag)

void	MCMCSetFlagFillHistograms (bool flag)

void	MCMCSetFlagPreRun (bool flag)

void	MCMCSetRValueCriterion (double r)

void	MCMCSetRValueParametersCriterion (double r)

void	MCMCSetRValueStrict (bool strict=true)

void	MCMCSetMarkovChainTrees (const std::vector< TTree * > &trees)

void	MCMCInitializeMarkovChainTrees ()

int	SetMarginalized (unsigned index, TH1D *h)

int	SetMarginalized (unsigned index1, unsigned index2, TH2D *h)

void	MCMCSetValuesDefault ()

void	MCMCSetValuesQuick ()

void	MCMCSetValuesDetail ()

void	MCMCSetPrecision (BCEngineMCMC::Precision precision)

void	SetNbins (unsigned int nbins)

void	Copy (const BCEngineMCMC &enginemcmc)

virtual int	AddParameter (const char name, double min, double max, const char latexname="")

virtual void	MCMCTrialFunction (unsigned ichain, std::vector< double > &x)

virtual double	MCMCTrialFunctionSingle (unsigned ichain, unsigned ipar)

bool	MCMCGetProposalPointMetropolis (unsigned chain, std::vector< double > &x)

bool	MCMCGetProposalPointMetropolis (unsigned chain, unsigned parameter, std::vector< double > &x)

bool	MCMCGetNewPointMetropolis (unsigned chain=0)

bool	MCMCGetNewPointMetropolis (unsigned chain, unsigned parameter)

void	MCMCInChainCheckMaximum ()

void	MCMCInChainUpdateStatistics ()

void	MCMCInChainFillHistograms ()

void	MCMCInChainTestConvergenceAllChains ()

void	MCMCInChainWriteChains ()

int	MCMCMetropolis ()

int	MCMCMetropolisPreRun ()

void	MCMCResetRunStatistics ()

void	MCMCInitializeMarkovChains ()

int	MCMCInitialize ()

void	ClearParameters (bool hard=false)

virtual void	MCMCUserIterationInterface ()

virtual void	MCMCCurrentPointInterface (std::vector< double > &, int, bool)

Private Attributes
TH1D *	fHistogram1

TH1D *	fHistogram2

TGraphAsymmErrors *	fHistogramRatio

TF1 *	fFitFunction

bool	fFlagIntegration

TGraph *	fErrorBand

TGraph *	fGraphFitFunction

TH1D *	fHistogramBinomial

unsigned int	fDataPointType

Additional Inherited Members
Public Types inherited from BCIntegrate
enum	BCOptimizationMethod { kOptEmpty, kOptSimAnn, kOptMetropolis, kOptMinuit, kOptDefault, NOptMethods }

enum	BCIntegrationMethod { kIntEmpty, kIntMonteCarlo, kIntCuba, kIntGrid, kIntDefault, NIntMethods }

enum	BCMarginalizationMethod { kMargEmpty, kMargMetropolis, kMargMonteCarlo, kMargGrid, kMargDefault, NMargMethods }

enum	BCSASchedule { kSACauchy, kSABoltzmann, kSACustom, NSAMethods }

enum	BCCubaMethod { kCubaVegas, kCubaSuave, kCubaDivonne, kCubaCuhre, NCubaMethods }

typedef void(BCIntegrate::*	tRandomizer )(std::vector< double > &) const

typedef double(BCIntegrate::*	tEvaluator )(std::vector< double > &, const std::vector< double > &, bool &)

typedef void(*	tIntegralUpdater )(const std::vector< double > &, const int &, double &, double &)

Static Public Member Functions inherited from BCIntegrate
static void	IntegralUpdaterMC (const std::vector< double > &sums, const int &nIterations, double &integral, double &absprecision)

static int	CubaIntegrand (const int ndim, const double xx[], const int ncomp, double ff[], void *userdata)

static void	FCNLikelihood (int &npar, double grad, double &fval, double par, int flag)

Protected Member Functions inherited from BCIntegrate
unsigned	IntegrationOutputFrequency () const

void	LogOutputAtStartOfIntegration (BCIntegrationMethod type, BCCubaMethod cubatype)

void	LogOutputAtIntegrationStatusUpdate (BCIntegrationMethod type, double integral, double absprecision, int nIterations)

void	LogOutputAtEndOfIntegration (double integral, double absprecision, double relprecision, int nIterations)

void	Copy (const BCIntegrate &bcintegrate)

Protected Attributes inherited from BCFitter
TH2D *	fErrorBandXY

Detailed Description

A class for fitting histograms with functions.

Author: Daniel Kollar; Kevin Kröninger

Version: 1.0

Date: 11.2008 This class allows fitting of efficiencies defined as a ratio of two TH1D histograms using a TF1 function. It uses binomial probabilities calculated based on the number of entries in histograms. This is only applicable if the numerator is a subset of the denominator.

Definition at line 39 of file BCEfficiencyFitter.h.

Constructor & Destructor Documentation

BCEfficiencyFitter::BCEfficiencyFitter ( )

The default constructor.

Definition at line 32 of file BCEfficiencyFitter.cxx.

  : BCFitter()
  , fHistogram1(0)
  , fHistogram2(0)
  , fFitFunction(0)
  , fHistogramBinomial(0)
  , fDataPointType(1)
 {
    // set default options and values
    fFlagIntegration = false;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCEfficiencyFitter::BCEfficiencyFitter ( const char * name)

Constructor

Parameters

name	name fo the model

Definition at line 49 of file BCEfficiencyFitter.cxx.

  : BCFitter(name)
  , fHistogram1(0)
  , fHistogram2(0)
  , fFitFunction(0)
  , fHistogramBinomial(0)
  , fDataPointType(1)
 {
    // set default options and values
    fFlagIntegration = false;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCEfficiencyFitter::BCEfficiencyFitter	(	TH1D *	hist1,
		TH1D *	hist2,
		TF1 *	func
	)

A constructor.

Parameters

hist1	The histogram with the larger numbers
hist2	The histogram with the smaller numbers
func	The fit function.

Definition at line 66 of file BCEfficiencyFitter.cxx.

  : BCFitter()
  , fHistogram1(0)
  , fHistogram2(0)
  , fFitFunction(0)
  , fHistogramBinomial(0)
  , fDataPointType(1)
 {
    SetHistograms(hist1, hist2);
    SetFitFunction(func);
 
    fFlagIntegration = false;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCEfficiencyFitter::BCEfficiencyFitter	(	const char *	name,
		TH1D *	hist1,
		TH1D *	hist2,
		TF1 *	func
	)

Constructor.

Parameters

name	name fo the model
hist1	The histogram with the larger numbers
hist2	The histogram with the smaller numbers
func	The fit function.

Definition at line 85 of file BCEfficiencyFitter.cxx.

  : BCFitter(name)
  , fHistogram1(0)
  , fHistogram2(0)
  , fFitFunction(0)
  , fHistogramBinomial(0)
  , fDataPointType(1)
 {
    SetHistograms(hist1, hist2);
    SetFitFunction(func);
 
    MCMCSetRValueCriterion(0.01);
    fFlagIntegration = false;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCEfficiencyFitter::~BCEfficiencyFitter ( )

The default destructor.

Definition at line 211 of file BCEfficiencyFitter.cxx.

 {
    delete fHistogram1;
    delete fHistogram2;
    delete fHistogramBinomial;
 }

Member Function Documentation

int BCEfficiencyFitter::CalculatePValueFast	(	const std::vector< double > &	par,
		BCEfficiencyFitter::ToyDataInterface *	callback,
		double &	pvalue,
		double &	pvalueCorrected,
		unsigned	nIterations = `100000`
	)

Calculate the p-value using fast-MCMC. In every iteration, a new toy data set is created. By providing a suitable implementation of ToyDataInterface, the user can calculate the distribution of an arbitrary statistic. Each toy data set as well as the expected values for the parameter values are passed on to the interface.

Parameters

par	A set of parameter values
pvalue	The p-value for the default likelihood statistic
pvalueCorrected	The p-value for the default likelihood statistic with corrections for DoF to reduce fitting bias, in all nonpathological cases the correction lowers the p-value.
callback	requires class with operator(...) defined.
nIterations	number of toy data sets generated by the Markov chain

Returns: An error code

Definition at line 451 of file BCEfficiencyFitter.cxx.

 {
    // check size of parameter vector
    if (par.size() != GetNParameters()) {
       BCLog::OutError("BCEfficiencyFitter::CalculatePValueFast : Number of parameters is inconsistent.");
       return 0;
    }
 
    // check if histogram exists
    if (!fHistogram1 || !fHistogram2) {
       BCLog::OutError("BCEfficiencyFitter::CalculatePValueFast : Histogram not defined.");
       return 0;
    }
 
    // define temporary variables
    int nbins = fHistogram1->GetNbinsX();
 
    std::vector<unsigned> histogram(nbins, 0);
    std::vector<double> expectation(nbins, 0);
 
    double logp = 0;
    double logp_start = 0;
    int counter_pvalue = 0;
 
    // define starting distribution
    for (int ibin = 0; ibin < nbins; ++ibin) {
       // get bin boundaries
       double xmin = fHistogram1->GetBinLowEdge(ibin+1);
       double xmax = fHistogram1->GetBinLowEdge(ibin+2);
 
       // get the number of expected events
       double yexp = fFitFunction->Integral(xmin, xmax);
 
       // get n
       int n = int(fHistogram1->GetBinContent(ibin));
 
       // get k
       int k = int(fHistogram2->GetBinContent(ibin));
 
       histogram[ibin]   = k;
       expectation[ibin] = n * yexp;
 
       // calculate p;
       logp += BCMath::LogApproxBinomial(n, k, yexp);
    }
    logp_start = logp;
 
    // loop over iterations
    for (unsigned iiter = 0; iiter < nIterations; ++iiter)
    {
       // loop over bins
       for (int ibin = 0; ibin < nbins; ++ibin)
       {
          // get n
          int n = int(fHistogram1->GetBinContent(ibin));
 
          // get k
          int k = histogram.at(ibin);
 
          // get expectation
          double yexp = 0;
          if (n > 0)
             yexp = expectation.at(ibin)/n;
 
          // random step up or down in statistics for this bin
          double ptest = fRandom->Rndm() - 0.5;
 
          // continue, if efficiency is at limit
          if (!(yexp > 0. || yexp < 1.0))
             continue;
 
          // increase statistics by 1
          if (ptest > 0 && (k < n))
          {
             // calculate factor of probability
             double r = (double(n)-double(k))/(double(k)+1.) * yexp / (1. - yexp);
 
             // walk, or don't (this is the Metropolis part)
             if (fRandom->Rndm() < r)
             {
                histogram[ibin] = k + 1;
                logp += log(r);
             }
          }
 
          // decrease statistics by 1
          else if (ptest <= 0 && (k > 0))
          {
             // calculate factor of probability
             double r = double(k) / (double(n)-(double(k)-1)) * (1-yexp)/yexp;
 
             // walk, or don't (this is the Metropolis part)
             if (fRandom->Rndm() < r)
             {
                histogram[ibin] = k - 1;
                logp += log(r);
             }
          }
 
       } // end of looping over bins
 
       //one new toy data set is created
       //call user interface to calculate arbitrary statistic's distribution
       if (callback)
          (*callback)(expectation, histogram);
 
       // increase counter
       if (logp < logp_start)
          counter_pvalue++;
 
    } // end of looping over iterations
 
    // calculate p-value
    pvalue = double(counter_pvalue) / double(nIterations);
 
    // correct for fit bias
    pvalueCorrected = BCMath::CorrectPValue(pvalue, GetNParameters(), nbins);
 
    // no error
    return 1;
 }

int BCEfficiencyFitter::CalculatePValueFast	(	const std::vector< double > &	par,
		double &	pvalue,
		double &	pvalueCorrected,
		unsigned	nIterations = `100000`
	)

Calculate the p-value using fast-MCMC.

Parameters

par	A set of parameter values
pvalue	The pvalue
pvalueCorrected	The p-value for the default likelihood statistic with corrections for DoF to reduce fitting bias
nIterations	number of pseudo experiments generated by the Markov chain

Returns: An error code

Definition at line 443 of file BCEfficiencyFitter.cxx.

 {
    //use NULL pointer for no callback
    return CalculatePValueFast(par, NULL, pvalue, pvalueCorrected, nIterations);
 }

void BCEfficiencyFitter::DrawFit	(	const char *	options = `""`,
		bool	flaglegend = `false`
	)

virtual

Draw the fit in the current pad.

Implements BCFitter.

Definition at line 349 of file BCEfficiencyFitter.cxx.

 {
    if (!fHistogram1 || !fHistogram2) {
       BCLog::OutError("BCEfficiencyFitter::DrawFit : Histogram(s) not defined.");
       return;
    }
 
    if (!fFitFunction) {
       BCLog::OutError("BCEfficiencyFitter::DrawFit : Fit function not defined.");
       return;
    }
 
    // create efficiency graph
    TGraphAsymmErrors * histRatio = new TGraphAsymmErrors();
    histRatio->SetMarkerStyle(20);
    histRatio->SetMarkerSize(1.5);
 
    int npoints = 0;
 
    // set points
    for (int i = 1; i <= fHistogram1->GetNbinsX(); ++i)
    {
       if(int(fHistogram1->GetBinContent(i)) == 0) {
          ++npoints;
          continue;
       }
 
       // calculate central value and uncertainties
       double xexp, xmin, xmax;
       GetUncertainties( int(fHistogram1->GetBinContent(i)), int(fHistogram2->GetBinContent(i)), 0.68, xexp, xmin, xmax);
 
       histRatio->SetPoint( npoints, fHistogram1->GetBinCenter(i), xexp);
 
       // no X uncertainties
       histRatio->SetPointEXhigh(npoints, 0.);
       histRatio->SetPointEXlow(npoints, 0.);
 
       // set Y uncertainties
       histRatio->SetPointEYhigh(npoints, xmax - xexp);
       histRatio->SetPointEYlow(npoints, xexp - xmin);
 
       ++npoints;
    }
 
 
    // check wheather options contain "same"
    TString opt = options;
    opt.ToLower();
 
    // if not same, draw the histogram first to get the axes
    if(!opt.Contains("same"))
    {
       // create new histogram
       TH2D * hist_axes = new TH2D("hist_axes",
             Form(";%s;ratio", fHistogram1->GetXaxis()->GetTitle()),
             fHistogram1->GetNbinsX(),
             fHistogram1->GetXaxis()->GetBinLowEdge(1),
             fHistogram1->GetXaxis()->GetBinLowEdge(fHistogram1->GetNbinsX()+1),
             1, 0., 1.);
       hist_axes->SetStats(kFALSE);
       hist_axes->Draw();
 
       histRatio->Draw(TString::Format("%sp",opt.Data()));
    }
 
    // draw the error band as central 68% probability interval
    fErrorBand = GetErrorBandGraph(0.16, 0.84);
    fErrorBand->Draw("f same");
 
    // now draw the histogram again since it was covered by the band
    histRatio->SetMarkerSize(.7);
    histRatio->Draw(TString::Format("%ssamep",opt.Data()));
 
    // draw the fit function on top
    fGraphFitFunction = GetFitFunctionGraph( GetBestFitParameters() );
    fGraphFitFunction->SetLineColor(kRed);
    fGraphFitFunction->SetLineWidth(2);
    fGraphFitFunction->Draw("l same");
 
    // draw legend
    if (flaglegend)
    {
       TLegend * legend = new TLegend(0.25, 0.75, 0.55, 0.95);
       legend->SetBorderSize(0);
       legend->SetFillColor(kWhite);
       legend->AddEntry(histRatio, "Data", "L");
       legend->AddEntry(fGraphFitFunction, "Best fit", "L");
       legend->AddEntry(fErrorBand, "Error band", "F");
       legend->Draw();
    }
    gPad->RedrawAxis();
 }

int BCEfficiencyFitter::Fit ( )

virtual

Performs the fit.

Returns: An error code.

Implements BCFitter.

Definition at line 309 of file BCEfficiencyFitter.cxx.

 {
    // set histogram
    if (!fHistogram1 || !fHistogram2) {
       BCLog::OutError("BCEfficiencyFitter::Fit : Histogram(s) not defined.");
       return 0;
    }
 
    // set function
    if (!fFitFunction) {
       BCLog::OutError("BCEfficiencyFitter::Fit : Fit function not defined.");
       return 0;
    }
 
    // perform marginalization
    MarginalizeAll();
 
    // maximize posterior probability, using the best-fit values close
    // to the global maximum from the MCMC
    BCIntegrate::BCOptimizationMethod method_temp = GetOptimizationMethod();
    SetOptimizationMethod(BCIntegrate::kOptMinuit);
    FindMode( GetBestFitParameters());
    SetOptimizationMethod(method_temp);
 
    // calculate the p-value using the fast MCMC algorithm
    double pvalue, pvalueCorrected;
    if ( CalculatePValueFast(GetBestFitParameters(), pvalue, pvalueCorrected) )
       fPValue = pvalue;
    else
       BCLog::OutError("BCEfficiencyFitter::Fit : Could not use the fast p-value evaluation.");
 
    // print summary to screen
    PrintShortFitSummary();
 
    // no error
    return 1;
 }

int BCEfficiencyFitter::Fit	(	TH1D *	hist1,
		TH1D *	hist2,
		TF1 *	func
	)

Performs the fit.

Parameters

hist1	The histogram with the larger number.
hist2	The histogram with the smaller number.
func	The fit function.

Returns: An error code.

Definition at line 286 of file BCEfficiencyFitter.cxx.

 {
    // set histogram
    if (hist1 && hist2)
       SetHistograms(hist1, hist2);
    else {
       BCLog::OutError("BCEfficiencyFitter::Fit : Histogram(s) not defined.");
       return 0;
    }
 
    // set function
    if (func)
       SetFitFunction(func);
    else {
       BCLog::OutError("BCEfficiencyFitter::Fit : Fit function not defined.");
       return 0;
    }
 
    return Fit();
 }

double BCEfficiencyFitter::FitFunction	(	const std::vector< double > &	x,
		const std::vector< double > &	parameters
	)

virtual

Returns the y-value of the 1-dimensional fit function at an x and for a set of parameters.

Parameters

x	A vector with the x-value.
parameters	A set of parameters.

Reimplemented from BCFitter.

Definition at line 276 of file BCEfficiencyFitter.cxx.

 {
    // set the parameters of the function
    fFitFunction->SetParameters(&params[0]);
 
    return fFitFunction->Eval(x[0]);
 }

TGraph* BCEfficiencyFitter::GetErrorBand ( )

inline

Returns: pointer to the error band

Definition at line 120 of file BCEfficiencyFitter.h.

121 { return fErrorBand; };

TF1* BCEfficiencyFitter::GetFitFunction ( )

inline

Returns: The fit function

Definition at line 115 of file BCEfficiencyFitter.h.

116 { return fFitFunction; };

TGraph* BCEfficiencyFitter::GetGraphFitFunction ( )

inline

Returns: pointer to a graph for the fit function

Definition at line 125 of file BCEfficiencyFitter.h.

126 { return fGraphFitFunction; };

TH1D* BCEfficiencyFitter::GetHistogram1 ( )

inline

Returns: The histogram 1

Definition at line 100 of file BCEfficiencyFitter.h.

101 { return fHistogram1; };

TH1D* BCEfficiencyFitter::GetHistogram2 ( )

inline

Returns: The histogram 2

Definition at line 105 of file BCEfficiencyFitter.h.

106 { return fHistogram2; };

TGraphAsymmErrors* BCEfficiencyFitter::GetHistogramRatio ( )

inline

Returns: The histogram ratio

Definition at line 110 of file BCEfficiencyFitter.h.

111 { return fHistogramRatio; };

int BCEfficiencyFitter::GetUncertainties	(	int	n,
		int	k,
		double	p,
		double &	xexp,
		double &	xmin,
		double &	xmax
	)

Calculates the central value and the lower and upper limits for a given probability.

Parameters

n	n for the binomial.
k	k for the binomial.
p	The central probability defining the limits.
xmin	The central value.
xmin	The lower limit.
xmax	The upper limit.

Returns: A flag (=1 plot point, !=1 do not plot point).

Definition at line 576 of file BCEfficiencyFitter.cxx.

 {
    if (n == 0)
    {
       xexp = 0.;
       xmin = 0.;
       xmax = 0.;
       return 0;
    }
 
    BCLog::OutDebug(Form("Calculating efficiency data-point of type %d for (n,k) = (%d,%d)",fDataPointType,n,k));
 
    // create a histogram with binomial distribution
    if (fHistogramBinomial)
       fHistogramBinomial->Reset();
    else
       fHistogramBinomial = new TH1D("hist_binomial", "", 1000, 0., 1.);
 
    // loop over bins and fill histogram
    for (int i = 1; i <= 1000; ++i) {
       double x   = fHistogramBinomial->GetBinCenter(i);
       double val = BCMath::ApproxBinomial(n, k, x);
       fHistogramBinomial->SetBinContent(i, val);
    }
 
    // normalize
    fHistogramBinomial->Scale(1. / fHistogramBinomial->Integral());
 
    // calculate central value and uncertainties
    if (fDataPointType == 0) {
       xexp = fHistogramBinomial->GetMean();
       double rms = fHistogramBinomial->GetRMS();
       xmin = xexp-rms;
       xmax = xexp+rms;
       BCLog::OutDebug(Form(" - mean = %f , rms = %f)",xexp,rms));
    }
    else if (fDataPointType == 1) {
       xexp = (double)k/(double)n;
       BCH1D * fbh = new BCH1D((TH1D*)fHistogramBinomial->Clone("hcp"));
       std::vector<double> intervals = fbh->GetSmallestIntervals(p);
       int ninter = intervals.size();
       if ( ninter<2 ) {
          xmin = xmax = xexp = 0.;
       }
       else {
          xmin = intervals[0];
          xmax = intervals[1];
       }
       delete fbh;
    }
    else {
       // calculate quantiles
       int nprobSum = 3;
       double q[3];
       double probSum[3];
       probSum[0] = (1.-p)/2.;
       probSum[1] = 1.-(1.-p)/2.;
       probSum[2] = .5;
 
       fHistogramBinomial->GetQuantiles(nprobSum, q, probSum);
 
       xexp = q[2];
       xmin = q[0];
       xmax = q[1];
 
    }
 
    BCLog::OutDebug(Form(" - efficiency = %f , range (%f - %f)",xexp,xmin,xmax));
 
    return 1;
 }

double BCEfficiencyFitter::LogLikelihood ( const std::vector< double > & parameters)

virtual

The log of the prior probability. Overloaded from BCModel.

Parameters

parameters	A vector of doubles containing the parameter values. The log of the conditional probability. Overloaded from BCModel.
parameters	A vector of doubles containing the parameter values.

Implements BCModel.

Definition at line 230 of file BCEfficiencyFitter.cxx.

 {
 
    // initialize probability
    double loglikelihood = 0;
 
    // set the parameters of the function
    fFitFunction->SetParameters(&params[0]);
 
    // get the number of bins
    int nbins = fHistogram1->GetNbinsX();
 
    // get bin width
    double dx = fHistogram1->GetXaxis()->GetBinWidth(0);
 
    // loop over all bins
    for (int ibin = 1; ibin <= nbins; ++ibin)
    {
       // get n
       int n = int(fHistogram1->GetBinContent(ibin));
 
       // get k
       int k = int(fHistogram2->GetBinContent(ibin));
 
       // get x
       double x = fHistogram1->GetBinCenter(ibin);
 
       double eff = 0;
 
       // use ROOT's TH1D::Integral method
       if (fFlagIntegration)
          eff = fFitFunction->Integral(x - dx/2., x + dx/2.) / dx;
 
       // use linear interpolation
       else
          eff = (fFitFunction->Eval(x + dx/2.) + fFitFunction->Eval(x - dx/2.)) / 2.;
 
       // get the value of the Poisson distribution
       loglikelihood += BCMath::LogApproxBinomial(n, k, eff);
    }
 
    return loglikelihood;
 }

void BCEfficiencyFitter::SetDataPointType ( int type)

Set type of point to be used to plot the efficiency data 0 - mean + rms 1 - mode + smallest 68% 2 - median + central 68%

Definition at line 220 of file BCEfficiencyFitter.cxx.

 {
    if(type < 0 || type > 2)
       BCLog::OutError(Form("BCEfficiencyFitter::SetDataPointType : Unknown data point type %d (should be between 0 and 2).",type));
    else
       fDataPointType = type;
 }

int BCEfficiencyFitter::SetFitFunction ( TF1 * func)

Parameters

func	The fit function

Returns: An error code (1:pass, 0:fail).

Definition at line 171 of file BCEfficiencyFitter.cxx.

 {
    // check if function exists
    if(!func) {
       BCLog::OutError("BCEfficiencyFitter::SetFitFunction : TF1 not created.");
       return 0;
    }
 
    // set the function
    fFitFunction = func;
 
    // update the model name to contain the function name
    if(fName=="model")
       SetName(TString::Format("BCEfficiencyFitter with %s",fFitFunction->GetName()));
 
    // reset parameters
    ClearParameters(true);
 
    // get the new number of parameters
    int n = func->GetNpar();
 
    // add parameters
    for (int i = 0; i < n; ++i)
    {
       double xmin;
       double xmax;
 
       func->GetParLimits(i, xmin, xmax);
 
       AddParameter(func->GetParName(i), xmin, xmax);
    }
 
    // set flat prior for all parameters by default
    SetPriorConstantAll();
 
    return GetNParameters();
 }

void BCEfficiencyFitter::SetFlagIntegration ( bool flag)

inline

Sets the flag for integration.
true: use ROOT's TH1D::Integrate()
false: use linear interpolation

Definition at line 158 of file BCEfficiencyFitter.h.

159 { fFlagIntegration = flag; };

int BCEfficiencyFitter::SetHistograms	(	TH1D *	hist1,
		TH1D *	hist2
	)

Parameters

hist	The histogram 1
hist	The histogram 2

Returns: An error code (1:pass, 0:fail).

Definition at line 105 of file BCEfficiencyFitter.cxx.

 {
    // check if histogram exists
    if (!hist1 || !hist2) {
       BCLog::OutError("BCEfficiencyFitter::SetHistograms : TH1D not created.");
       return 0;
    }
 
    // check compatibility of both histograms : number of bins
    if (hist1->GetNbinsX() != hist2->GetNbinsX()) {
       BCLog::OutError("BCEfficiencyFitter::SetHistograms : Histograms do not have the same number of bins.");
       return 0;
    }
 
    // check compatibility of both histograms : bin content
    for (int i = 1; i <= hist1->GetNbinsX(); ++i)
       if (hist1->GetBinContent(i) < hist2->GetBinContent(i)) {
          BCLog::OutError("BCEfficiencyFitter::SetHistograms : Histogram 1 has fewer entries than histogram 2.");
          return 0;
       }
 
    // set pointer to histograms
    fHistogram1 = hist1;
    fHistogram2 = hist2;
 
    // create a data set. this is necessary in order to calculate the
    // error band. the data set contains as many data points as there
    // are bins. for now, the data points are empty.
    BCDataSet * ds = new BCDataSet();
 
    // create data points and add them to the data set.
    int nbins = fHistogram1->GetNbinsX();
    for (int i = 0; i < nbins; ++i) {
       BCDataPoint* dp = new BCDataPoint(2);
       ds->AddDataPoint(dp);
    }
 
    // set the new data set.
    SetDataSet(ds);
 
    // calculate the lower and upper edge in x.
    double xmin = hist1->GetBinLowEdge(1);
    double xmax = hist1->GetBinLowEdge(nbins+1);
 
 //   // calculate the minimum and maximum range in y.
 //   double histymin = hist2->GetMinimum();
 //   double histymax = hist1->GetMaximum();
 
 //   // calculate the minimum and maximum of the function value based on
 //   // the minimum and maximum value in y.
 //   double ymin = TMath::Max(0., histymin - 5.*sqrt(histymin));
 //   double ymax = histymax + 5.*sqrt(histymax);
 
    // set the data boundaries for x and y values.
    SetDataBoundaries(0, xmin, xmax);
    SetDataBoundaries(1, 0.0, 1.0);
 
    // set the indeces for fitting.
    SetFitFunctionIndices(0, 1);
 
    // no error
    return 1;
 }

Member Data Documentation

unsigned int BCEfficiencyFitter::fDataPointType

private

Type of point to plot for efficiency data 0 - mean + rms 1 - mode + smallest 68% 2 - median + central 68%

Definition at line 274 of file BCEfficiencyFitter.h.

TGraph* BCEfficiencyFitter::fErrorBand

private

Pointer to the error band (for legend)

Definition at line 260 of file BCEfficiencyFitter.h.

TF1* BCEfficiencyFitter::fFitFunction

private

The fit function

Definition at line 251 of file BCEfficiencyFitter.h.

bool BCEfficiencyFitter::fFlagIntegration

private

Flag for using the ROOT TH1D::Integral method (true), or linear interpolation (false)

Definition at line 256 of file BCEfficiencyFitter.h.

TGraph* BCEfficiencyFitter::fGraphFitFunction

private

Pointer to a graph for displaying the fit function

Definition at line 264 of file BCEfficiencyFitter.h.

TH1D* BCEfficiencyFitter::fHistogram1

private

The histogram containing the larger numbers.

Definition at line 239 of file BCEfficiencyFitter.h.

TH1D* BCEfficiencyFitter::fHistogram2

private

The histogram containing the smaller numbers.

Definition at line 243 of file BCEfficiencyFitter.h.

TH1D* BCEfficiencyFitter::fHistogramBinomial

private

Temporary histogram for calculating the binomial qunatiles

Definition at line 268 of file BCEfficiencyFitter.h.

TGraphAsymmErrors* BCEfficiencyFitter::fHistogramRatio

private

The efficiency histogram.

Definition at line 247 of file BCEfficiencyFitter.h.

The documentation for this class was generated from the following files:

Classes

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation