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

#include <BCHistogramFitter.h>

Inheritance diagram for BCHistogramFitter:

Collaboration diagram for BCHistogramFitter:

Public Member Functions
Constructors and destructors
	BCHistogramFitter ()

	BCHistogramFitter (const char *name)

	BCHistogramFitter (TH1D hist, TF1 func)

	BCHistogramFitter (const char name, TH1D hist, TF1 *func)

	~BCHistogramFitter ()

Member functions (get)
TH1D *	GetHistogram ()

TH1D *	GetHistogramExpected ()

TF1 *	GetFitFunction ()

TGraph *	GetErrorBand ()

TGraph *	GetGraphFitFunction ()

Member functions (set)
int	SetHistogram (TH1D *hist)

int	SetHistogramExpected (const std::vector< double > &parameters)

int	SetFitFunction (TF1 *func)

void	SetFlagIntegration (bool flag)

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 hist, TF1 func)

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

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

int	CalculatePValueLikelihood (const std::vector< double > &par)

int	CalculatePValueLeastSquares (const std::vector< double > &par, bool weightExpect=true)

int	CalculatePValueKolmogorov (const std::vector< double > &par)

double	CDF (const std::vector< double > &parameters, int index, bool lower=false)

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)

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 *	fHistogram

TF1 *	fFitFunction

bool	fFlagIntegration

TGraph *	fErrorBand

TGraph *	fGraphFitFunction

TH1D *	fHistogramExpected

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 a TH1D histogram using a TF1 function.

Definition at line 35 of file BCHistogramFitter.h.

Constructor & Destructor Documentation

BCHistogramFitter::BCHistogramFitter ( )

The default constructor.

Definition at line 30 of file BCHistogramFitter.cxx.

  : BCFitter()
  , fHistogram(0)
  , fFitFunction(0)
  , fHistogramExpected(0)
 {
    // set default options and values
    MCMCSetNIterationsRun(2000);
    SetFillErrorBand();
    fFlagIntegration = true;
    flag_discrete = true;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCHistogramFitter::BCHistogramFitter ( const char * name)

Constructor

Parameters

name	name of the model

Definition at line 48 of file BCHistogramFitter.cxx.

  : BCFitter(name)
  , fHistogram(0)
  , fFitFunction(0)
  , fHistogramExpected(0)
 {
    // set default options and values
    MCMCSetNIterationsRun(2000);
    SetFillErrorBand();
    fFlagIntegration = true;
    flag_discrete = true;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCHistogramFitter::BCHistogramFitter	(	TH1D *	hist,
		TF1 *	func
	)

Constructor.

Parameters

hist	histogram to fit
func	fit function

Definition at line 66 of file BCHistogramFitter.cxx.

  : BCFitter()
  , fHistogram(0)
  , fFitFunction(0)
  , fHistogramExpected(0)
 {
    SetHistogram(hist);
    SetFitFunction(func);
 
    MCMCSetNIterationsRun(2000);
    SetFillErrorBand();
    fFlagIntegration = true;
    flag_discrete = true;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCHistogramFitter::BCHistogramFitter	(	const char *	name,
		TH1D *	hist,
		TF1 *	func
	)

Constructor

Parameters

name	name of the model
hist	histogram to fit
func	fit function

Definition at line 86 of file BCHistogramFitter.cxx.

  : BCFitter(name)
  , fHistogram(0)
  , fFitFunction(0)
  , fHistogramExpected(0)
 {
    SetHistogram(hist);
    SetFitFunction(func);
 
    MCMCSetNIterationsRun(2000);
    SetFillErrorBand();
    fFlagIntegration = true;
    flag_discrete = true;
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCHistogramFitter::~BCHistogramFitter ( )

The default destructor.

Definition at line 259 of file BCHistogramFitter.cxx.

 {
    // todo memory leak, many members not removed
    delete fHistogramExpected;
 }

Member Function Documentation

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

Calculate the p-value using fast-MCMC and the likelihood as test statistic. The method is explained in the appendix of http://arxiv.org/abs/1011.1674

Note: Obtain the results with

See Also: BCModel::GetPValue and the value corrected for degrees of freedom with; BCModel::GetPValueNDoF

Parameters

par	The parameter values for which expectations are computed
nIterations	number of pseudo experiments generated by the Markov chain

Returns: An error code

Definition at line 442 of file BCHistogramFitter.cxx.

 {
    // check size of parameter vector
    if (par.size() != GetNParameters()) {
       BCLog::OutError(
        "BCHistogramFitter::CalculatePValueFast : Number of parameters is inconsistent.");
       return 0;
    }
 
    // check if histogram exists
    if (!fHistogram) {
       BCLog::OutError(
        "BCHistogramFitter::CalculatePValueFast : Histogram not defined.");
       return 0;
    }
 
    //update the expected number of events for all bins
    SetHistogramExpected(par);
 
    // copy observed and expected values
    std::vector<unsigned> observed(fHistogram->GetNbinsX());
    std::vector<double> expected(fHistogramExpected->GetNbinsX());
 
    for (int ibin = 0 ; ibin < fHistogram->GetNbinsX(); ++ibin){
       observed[ibin] = (unsigned int) fHistogram->GetBinContent(ibin + 1);
       expected[ibin] = fHistogramExpected->GetBinContent(ibin + 1);
    }
 
    // create pseudo experiments
    fPValue = BCMath::FastPValue(observed, expected, nIterations, fRandom->GetSeed());
 
    // correct for fitting bias
    fPValueNDoF = BCMath::CorrectPValue(fPValue, GetNParameters(), fHistogram->GetNbinsX());
 
    // no error
    return 1;
 }

int BCHistogramFitter::CalculatePValueKolmogorov ( const std::vector< double > & par)

Calculate the p-value using Kolmogorov-Smirnov test. Note that the reference distribution is known only asymptotically. Some explanation is given in http://root.cern.ch/root/htmldoc/TMath.html

Parameters

par	The set of parameter values used in the model, usually the best fit parameters
pvalue	The pvalue

Returns: An error code

Definition at line 554 of file BCHistogramFitter.cxx.

 {
    if (!fHistogramExpected || !fHistogram) {
       BCLog::OutError("BCHistogramFitter::CalculatePValueKolmogorov: "
             "Please define the reference distribution by calling \n"
             "BCHistogramFitter::SetHistogramExpected() first!");
       return 0;
    }
 
    //update expected counts with current parameters
    SetHistogramExpected(par);
 
    //perform the test
    fPValue = fHistogramExpected->KolmogorovTest(fHistogram);
    fPValue = BCMath::CorrectPValue(fPValue, GetNParameters(), GetNDataPoints());
 
    // no error
    return 1;
 }

int BCHistogramFitter::CalculatePValueLeastSquares	(	const std::vector< double > &	par,
		bool	weightExpect = `true`
	)

Calculate the p-value using approximate chi^2 distribution of squared difference for conventional weights. Approximation is valid for bin contents >5 and not as as good for little data as CalculatePValueLikelihood, see eq. (32.13), PDG: Statistics, Monte Carlo, Group Theory. Physics Letters B 667, 316-339(2008).

Parameters

par	The set of parameter values used in the model, usually the best fit parameters
pvalue	The pvalue
weight	use the variance from the expected #counts (true) or the measured counts (false)

Returns: An error code

Definition at line 517 of file BCHistogramFitter.cxx.

 {
    // initialize test statistic chi^2
    double chi2 = 0.0;
 
    //Calculate expected counts to compare with
    SetHistogramExpected(par);
 
    for (int ibin = 1; ibin <= fHistogram->GetNbinsX(); ++ibin) {
 
       // get the number of observed events
       double y = fHistogram->GetBinContent(ibin);
 
       // get the number of expected events
       double yexp = fHistogramExpected->GetBinContent(ibin);
 
       //convert 1/0.0 into 1 for weighted sum
       double weight;
       if (weightExpect)
          weight = (yexp > 0) ? yexp : 1.0;
       else
          weight = (y > 0) ? y : 1.0;
 
       // get the contribution from this datapoint
       chi2 += (y - yexp) * (y - yexp) / weight;
    }
 
    // p value from chi^2 distribution
    fPValue = TMath::Prob(chi2, GetNDataPoints());
    fPValueNDoF = TMath::Prob(chi2, GetNDataPoints() - GetNParameters());
 
    // no error
    return 1;
 }

int BCHistogramFitter::CalculatePValueLikelihood ( const std::vector< double > & par)

Calculate the p-value using approximate chi^2 distribution of scaled likelihood. Approximation is valid for bin contents >5, see eq. (32.12), PDG: Statistics, Monte Carlo, Group Theory. Physics Letters B 667, 316-339(2008).

Parameters

par	The set of parameter values used in the model, usually the best fit parameters
pvalue	The pvalue

Returns: An error code

Definition at line 481 of file BCHistogramFitter.cxx.

 {
    // initialize test statistic -2*lambda
    double logLambda = 0.0;
 
    //Calculate expected counts to compare with
    SetHistogramExpected(par);
 
    for (int ibin = 1; ibin <= fHistogram->GetNbinsX(); ++ibin) {
 
       // get the number of observed events
       double y = fHistogram->GetBinContent(ibin);
 
       // get the number of expected events
       double yexp = fHistogramExpected->GetBinContent(ibin);
 
       // get the contribution from this datapoint
       if (y == 0)
          logLambda += yexp;
       else
          logLambda += yexp - y + y * log(y / yexp);
    }
 
    // rescale
    logLambda *= 2.0;
 
    //p value from chi^2 distribution, returns zero if logLambda < 0
    fPValue = TMath::Prob(logLambda, GetNDataPoints());
    fPValueNDoF = TMath::Prob(logLambda, GetNDataPoints() - GetNParameters());
 
    // no error
    return 1;
 }

double BCHistogramFitter::CDF	(	const std::vector< double > &	,
		int	,
		bool	= `false`
	)

virtual

1dim cumulative distribution function of the probability to get the data f(x_i|param) for a single measurement, assumed to be of identical functional form for all measurements

Parameters

parameters	The parameter values at which point to compute the cdf
index	The data point index starting at 0,1...N-1
lower	only needed for discrete distributions! Return the CDF for the count one less than actually observed, e.g. in Poisson process, if 3 actually observed, then CDF(2) is returned

Reimplemented from BCModel.

Definition at line 576 of file BCHistogramFitter.cxx.

 {
 
    if (parameters.empty())
       BCLog::OutWarning("BCHistogramFitter::CDF: parameter vector empty!");
    //histogram stores underflow in bin 0, so datapoint 0 is in bin 1
    index++;
 
    // get the number of observed events (should be integer)
    double yObs = fHistogram->GetBinContent(index);
 
    // get function value of lower bin edge
    double edgeLow = fHistogram->GetBinLowEdge(index);
    double edgeHigh = edgeLow + fHistogram->GetBinWidth(index);
 
    // expectation value of this bin
    double yExp = 0.0;
 
    // use ROOT's TH1D::Integral method
    if (fFlagIntegration)
       yExp = fFitFunction->Integral(edgeLow, edgeHigh, &parameters[0]);
 
    // use linear interpolation
    else {
       double dx = fHistogram->GetBinWidth(index);
       double fEdgeLow = fFitFunction->Eval(edgeLow);
       double fEdgeHigh = fFitFunction->Eval(edgeHigh);
       yExp = fEdgeLow * dx + (fEdgeHigh - fEdgeLow) * dx / 2.;
    }
 
    // usually Poisson bins do not agree with fixed probability bins
    // so choose where it should belong
 
    if (lower) {
       if ((int) yObs >= 1)
     return ROOT::Math::poisson_cdf((unsigned int) (yObs - 1), yExp);
       else
     return 0.0;
    }
    // what if yObs as double doesn't reprepsent a whole number? exception?
    if ((double) (unsigned int) yObs != yObs) {
       BCLog::OutWarning(Form(
        "BCHistogramFitter::CDF: Histogram values should be integer!\n"
           " Bin %d = %f", index, yObs));
 
       //convert randomly to integer
       // ex. yObs = 9.785 =>
       //      yObs --> 10 with P = 78.5%
       //      yObs --> 9  with P = 21.5%
       double U = fRandom->Rndm();
       double yObsLower = (unsigned int) yObs;
       if (U > (yObs - yObsLower))
     yObs = yObsLower;
       else
     yObs = yObsLower + 1;
    }
 
    return ROOT::Math::poisson_cdf((unsigned int) yObs, yExp);
 }

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

virtual

Draw the fit in the current pad.

Implements BCFitter.

Definition at line 389 of file BCHistogramFitter.cxx.

 {
    if (!fHistogram) {
       BCLog::OutError("BCHistogramFitter::DrawFit : Histogram not defined.");
       return;
    }
 
    if (!fFitFunction) {
       BCLog::OutError("BCHistogramFitter::DrawFit : Fit function not defined.");
       return;
    }
 
    if (!fErrorBandXY || GetBestFitParameters().empty()) {
       BCLog::OutError("BCHistogramFitter::DrawFit : Fit not performed yet.");
       return;
    }
 
    // 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"))
       fHistogram->Draw(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
    fHistogram->Draw(TString::Format("%ssame", 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(fHistogram, "Data", "L");
       legend->AddEntry(fGraphFitFunction, "Best fit", "L");
       legend->AddEntry(fErrorBand, "Error band", "F");
       legend->Draw();
    }
 
    gPad->RedrawAxis();
 }

int BCHistogramFitter::Fit ( )

virtual

Performs the fit.

Returns: An error code.

Implements BCFitter.

Definition at line 351 of file BCHistogramFitter.cxx.

 {
    // set histogram
    if (!fHistogram) {
       BCLog::OutError("BCHistogramFitter::Fit : Histogram not defined.");
       return 0;
    }
 
    // set function
    if (!fFitFunction) {
       BCLog::OutError("BCHistogramFitter::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
    if( !CalculatePValueFast(GetBestFitParameters()))
       BCLog::OutWarning(
        "BCHistogramFitter::Fit : Could not use the fast p-value evaluation.");
 
    // print summary to screen
    PrintShortFitSummary();
 
    // no error
    return 1;
 }

int BCHistogramFitter::Fit	(	TH1D *	hist,
		TF1 *	func
	)

Performs the fit.

Parameters

hist	The histogram (TH1D).
func	The fit function.

Returns: An error code.

Definition at line 328 of file BCHistogramFitter.cxx.

 {
    // set histogram
    if (hist)
       SetHistogram(hist);
    else {
       BCLog::OutError("BCHistogramFitter::Fit : Histogram not defined.");
       return 0;
    }
 
    // set function
    if (func)
       SetFitFunction(func);
    else {
       BCLog::OutError("BCHistogramFitter::Fit : Fit function not defined.");
       return 0;
    }
 
    return Fit();
 }

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

virtual

Plots the histogram

Parameters

options	Options for plotting.
filename	Name of the file which the histogram is printed into. The following options are available: F : plots the fit function on top of the data E0 : plots the fit function and the 68% prob. uncertainty band of the fit function on top of the data E1 : plots the expectation from the fit function and the uncertainty bin-by-bin as error bars. Returns the y-value of the 1-dimensional fit function at an x and for a set of parameters.
x	A vector with the x-value.
parameters	A set of parameters.

Reimplemented from BCFitter.

Definition at line 318 of file BCHistogramFitter.cxx.

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

TGraph* BCHistogramFitter::GetErrorBand ( )

inline

Returns: pointer to the error band

Definition at line 91 of file BCHistogramFitter.h.

92 { return fErrorBand; };

TF1* BCHistogramFitter::GetFitFunction ( )

inline

Returns: The fit function

Definition at line 86 of file BCHistogramFitter.h.

87 { return fFitFunction; };

TGraph* BCHistogramFitter::GetGraphFitFunction ( )

inline

Returns: pointer to a graph for the fit function

Definition at line 96 of file BCHistogramFitter.h.

97 { return fGraphFitFunction; };

TH1D* BCHistogramFitter::GetHistogram ( )

inline

Returns: The data histogram

Definition at line 75 of file BCHistogramFitter.h.

76 { return fHistogram; };

TH1D* BCHistogramFitter::GetHistogramExpected ( )

inline

Returns: The histogram of expected counts

Definition at line 80 of file BCHistogramFitter.h.

81 { return fHistogramExpected; };

double BCHistogramFitter::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 267 of file BCHistogramFitter.cxx.

 {
    // initialize probability
    double loglikelihood = 0;
 
    // set the parameters of the function
    fFitFunction->SetParameters(&params[0]);
 
    // get the number of bins
    int nbins = fHistogram->GetNbinsX();
 
    // get bin width
    double dx = fHistogram->GetBinWidth(1);
 
    // get function value of lower bin edge
    double fedgelow = fFitFunction->Eval(fHistogram->GetBinLowEdge(1));
 
    // loop over all bins
    for (int ibin = 1; ibin <= nbins; ++ibin) {
       // get upper bin edge
       double xedgehi = fHistogram->GetBinLowEdge(ibin) + dx;
 
       // get function value at upper bin edge
       double fedgehi = fFitFunction->Eval(xedgehi);
 
       // get the number of observed events
       double y = fHistogram->GetBinContent(ibin);
 
       double yexp = 0.;
 
       // use ROOT's TH1D::Integral method
       if (fFlagIntegration)
     yexp = fFitFunction->Integral(xedgehi - dx, xedgehi);
 
       // use linear interpolation
       else {
     yexp = fedgelow * dx + (fedgehi - fedgelow) * dx / 2.;
 
     // make the upper edge the lower edge for the next iteration
     fedgelow = fedgehi;
       }
 
       // get the value of the Poisson distribution
       loglikelihood += BCMath::LogPoisson(y, yexp);
    }
 
    return loglikelihood;
 }

int BCHistogramFitter::SetFitFunction ( TF1 * func)

Parameters

func	The fit function

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

Definition at line 220 of file BCHistogramFitter.cxx.

 {
    // check if function exists
    if (!func) {
       BCLog::OutError("BCHistogramFitter::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("HistogramFitter 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 BCHistogramFitter::SetFlagIntegration ( bool flag)

inline

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

Definition at line 126 of file BCHistogramFitter.h.

127 { fFlagIntegration = flag; };

int BCHistogramFitter::SetHistogram ( TH1D * hist)

Parameters

hist	The histogram containing the data

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

Definition at line 106 of file BCHistogramFitter.cxx.

 {
    // check if histogram exists
    if (!hist) {
       BCLog::OutError("BCHistogramFitter::SetHistogram : TH1D not created.");
       return 0;
    }
 
    // set pointer to histogram
    fHistogram = hist;
 
    // 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.
    BCDataSet * ds = new BCDataSet();
 
    // create data points and add them to the data set.
    // the x value is the lower edge of the bin, and
    // the y value is the bin count
    int nbins = fHistogram->GetNbinsX();
    for (int i = 0; i < nbins; ++i) {
       BCDataPoint* dp = new BCDataPoint(2);
       dp ->SetValue(0, fHistogram->GetBinLowEdge(i + 1));
       dp ->SetValue(1, fHistogram->GetBinContent(i + 1));
       ds->AddDataPoint(dp);
    }
 
    // set the new data set.
    SetDataSet(ds);
 
    // calculate the lower and upper edge in x.
    double xmin = hist->GetBinLowEdge(1);
    double xmax = hist->GetBinLowEdge(nbins + 1);
 
    // calculate the minimum and maximum range in y.
    double histymin = hist->GetMinimum();
    double histymax = hist->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, ymin, ymax);
 
    // set the indeces for fitting.
    SetFitFunctionIndices(0, 1);
 
    // no error
    return 1;
 }

int BCHistogramFitter::SetHistogramExpected ( const std::vector< double > & parameters)

Parameters

hist	The histogram with the expected counts (typically non-integer values!)

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

Definition at line 162 of file BCHistogramFitter.cxx.

 {
    //clear up previous memory
    if (fHistogramExpected) {
       delete fHistogramExpected;
    }
    //copy all properties from the data histogram
    fHistogramExpected = new TH1D(*fHistogram);
 
    // get the number of bins
    int nBins = fHistogramExpected->GetNbinsX();
 
    // get bin width
    double dx = fHistogramExpected->GetBinWidth(1);
 
    //set the parameters of fit function
    fFitFunction->SetParameters(&parameters[0]);
 
    // get function value of lower bin edge
    double fedgelow = fFitFunction->Eval(fHistogramExpected->GetBinLowEdge(1));
 
    // loop over all bins, skip underflow
    for (int ibin = 1; ibin <= nBins; ++ibin) {
       // get upper bin edge
       double xedgehi = fHistogramExpected->GetBinLowEdge(ibin) + dx;
 
       //expected count
       double yexp = 0.;
 
       // use ROOT's TH1D::Integral method
       if (fFlagIntegration)
     yexp = fFitFunction->Integral(xedgehi - dx, xedgehi);
 
       // use linear interpolation
       else {
     // get function value at upper bin edge
     double fedgehi = fFitFunction->Eval(xedgehi);
     yexp = fedgelow * dx + (fedgehi - fedgelow) * dx / 2.;
 
     // make the upper edge the lower edge for the next iteration
     fedgelow = fedgehi;
       }
 
       //write the expectation for the bin
       fHistogramExpected->SetBinContent(ibin, yexp);
 
       //avoid automatic error as sqrt(yexp), used e.g. in Kolmogorov correction factor
       fHistogramExpected->SetBinError(ibin, 0.0);
 
       // but the data under this model have that sqrt(yexp) uncertainty
       fHistogram->SetBinError(ibin, sqrt(yexp));
 
    }
    return 1;
 }

Member Data Documentation

TGraph* BCHistogramFitter::fErrorBand

private

Pointer to the error band (for legend)

Definition at line 240 of file BCHistogramFitter.h.

TF1* BCHistogramFitter::fFitFunction

private

The fit function

Definition at line 231 of file BCHistogramFitter.h.

bool BCHistogramFitter::fFlagIntegration

private

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

Definition at line 236 of file BCHistogramFitter.h.

TGraph* BCHistogramFitter::fGraphFitFunction

private

Pointer to a graph for displaying the fit function

Definition at line 244 of file BCHistogramFitter.h.

TH1D* BCHistogramFitter::fHistogram

private

The histogram containing the data.

Definition at line 227 of file BCHistogramFitter.h.

TH1D* BCHistogramFitter::fHistogramExpected

private

The histogram containing the expected data.

Definition at line 249 of file BCHistogramFitter.h.

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation