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

#include <BCGraphFitter.h>

Inheritance diagram for BCGraphFitter:

Collaboration diagram for BCGraphFitter:

Public Member Functions
Constructors and destructors
	BCGraphFitter ()

	BCGraphFitter (const char *name)

	BCGraphFitter (TGraphErrors graph, TF1 func)

	BCGraphFitter (const char name, TGraphErrors graph, TF1 *func)

	~BCGraphFitter ()

Member functions (get)
TGraphErrors *	GetGraph ()

TF1 *	GetFitFunction ()

TGraph *	GetErrorBand ()

TGraph *	GetGraphFitFunction ()

Member functions (set)
int	SetGraph (TGraphErrors *graph)

int	SetFitFunction (TF1 *func)

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

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

int	Fit ()

int	Fit (TGraphErrors graph, TF1 func)

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

virtual 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
TGraphErrors *	fGraph

TF1 *	fFitFunction

TGraph *	fErrorBand

TGraph *	fGraphFitFunction

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 graphs with functions.

Author: Daniel Kollar; Kevin Kröninger

Version: 1.0

Date: 2008 This class allows fitting of a TGraphErrors using a TF1 function. It doeasn't take the x uncertainties into account. For that look at BCGraphXFitter (not yet implemented).

Definition at line 35 of file BCGraphFitter.h.

Constructor & Destructor Documentation

BCGraphFitter::BCGraphFitter ( )

Default constructor

Definition at line 27 of file BCGraphFitter.cxx.

  : BCFitter()
  , fGraph(0)
  , fFitFunction(0)
  , fErrorBand(0)
  , fGraphFitFunction(0)
 {
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCGraphFitter::BCGraphFitter ( const char * name)

Constructor

Parameters

name	name of the model

Definition at line 40 of file BCGraphFitter.cxx.

  : BCFitter(name)
  , fGraph(0)
  , fFitFunction(0)
  , fErrorBand(0)
  , fGraphFitFunction(0)
 {
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCGraphFitter::BCGraphFitter	(	TGraphErrors *	graph,
		TF1 *	func
	)

Constructor

Parameters

graph	pointer to TGraphErrors
func	pointer to TF1

Definition at line 53 of file BCGraphFitter.cxx.

  : BCFitter()
  , fGraph(0)
  , fFitFunction(0)
  , fErrorBand(0)
  , fGraphFitFunction(0)
 {
    SetGraph(graph);
    SetFitFunction(func);
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCGraphFitter::BCGraphFitter	(	const char *	name,
		TGraphErrors *	graph,
		TF1 *	func
	)

Constructor

Parameters

name	name of the model
graph	pointer to TGraphErrors
func	pointer to TF1

Definition at line 69 of file BCGraphFitter.cxx.

  : BCFitter(name)
  , fGraph(0)
  , fFitFunction(0)
  , fErrorBand(0)
  , fGraphFitFunction(0)
 {
    SetGraph(graph);
    SetFitFunction(func);
 
    // set MCMC for marginalization
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCGraphFitter::~BCGraphFitter ( )

The default destructor.

Definition at line 206 of file BCGraphFitter.cxx.

 {
    // todo memory leak
 }

Member Function Documentation

double BCGraphFitter::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 383 of file BCGraphFitter.cxx.

                                                                                   {
 
    //format: x y error_x error_y
    std::vector<double> values = fDataSet->GetDataPoint(index)->GetValues();
 
    if (values.at(2))
       BCLog::OutWarning("BCGraphFitter::CDF: Non-zero errors in x-direction are ignored!");
 
    // get the observed value
    double yObs = values.at(1);
 
    // expectation value
    double yExp = FitFunction(values, parameters);
 
    return ROOT::Math::normal_cdf(yObs, values.at(3), yExp);
 }

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

virtual

Draw the fit in the current pad.

Implements BCFitter.

Definition at line 330 of file BCGraphFitter.cxx.

 {
    if (!fGraph)
    {
       BCLog::Out(BCLog::error, BCLog::error,"BCGraphFitter::DrawFit() : TGraphErrors not defined.");
       return;
    }
 
    if (!fFitFunction)
    {
       BCLog::Out(BCLog::error, BCLog::error,"BCGraphFitter::DrawFit() : Fit function not defined.");
       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"))
       fGraph->Draw("ap");
 
    // draw the error band as central 68% probability interval
    fErrorBand = GetErrorBandGraph(0.16, 0.84);
    fErrorBand->Draw("f same");
 
    // draw the fit function on top
    fGraphFitFunction = GetFitFunctionGraph( GetBestFitParameters() );
    fGraphFitFunction->SetLineColor(kRed);
    fGraphFitFunction->SetLineWidth(2);
    fGraphFitFunction->Draw("l same");
 
    // now draw the histogram again since it was covered by the band and
    // the best fit
    fGraph->Draw("p 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(fGraph, "Data", "P");
       legend->AddEntry(fGraphFitFunction, "Best fit", "L");
       legend->AddEntry(fErrorBand, "Error band", "F");
       legend->Draw();
    }
 
    gPad->RedrawAxis();
 }

int BCGraphFitter::Fit ( )

virtual

Performs the fit. The graph and the function has to be set beforehand.

Returns: An error code.

Implements BCFitter.

Definition at line 281 of file BCGraphFitter.cxx.

 {
    // set graph
    if (!fGraph) {
       BCLog::OutError("BCEfficiencyFitter::Fit : Graph not defined.");
       return 0;
    }
 
    // set function
    if (!fFitFunction) {
       BCLog::OutError("BCEfficiencyFitter::Fit : Fit function not defined.");
       return 0;
    }
 
    // check setup
    BCLog::Out(BCLog::detail,BCLog::detail,
          Form("Fitting %d data points with function of %d parameters",GetNDataPoints(),GetNParameters()));
    if(GetNDataPoints() <= GetNParameters())
    {
       BCLog::Out(BCLog::warning,BCLog::warning,
             Form("Number of parameters (%d) lower than or equal to number of points (%d)."
             , GetNParameters(), GetNDataPoints()));
       BCLog::Out(BCLog::warning,BCLog::warning,"Fit doesn't have much meaning.");
    }
 
    // 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 p-value from the chi2 probability
    // this is only valid for a product of gaussiang which is the case for
    // the BCGraphFitter
    GetPvalueFromChi2(GetBestFitParameters(), 3);
    GetPvalueFromChi2NDoF(GetBestFitParameters(), 3);
 
    // print summary to screen
    PrintShortFitSummary(1);
 
    return 1;
 }

int BCGraphFitter::Fit	(	TGraphErrors *	graph,
		TF1 *	func
	)

Performs the fit of the graph with the function.

Parameters

graph	pointer to TGraphErrors object
func	pointer to TF1 object

Returns: An error code.

Definition at line 262 of file BCGraphFitter.cxx.

 {
    // set graph
    if (!SetGraph(graph)) {
       BCLog::OutError("BCEfficiencyFitter::Fit : Graph not defined.");
       return 0;
    }
 
    // set function
    if (!SetFitFunction(func)) {
       return 0;
       BCLog::OutError("BCEfficiencyFitter::Fit : Fit function not defined.");
    }
 
    return Fit();
 }

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

virtual

Returns the value of the 1D fit function for a given set of parameters at a given x.

Parameters

x	point to calculate the function value at
parameters	parameters of the function

Reimplemented from BCFitter.

Definition at line 247 of file BCGraphFitter.cxx.

 {
    // set the parameters of the function
    // passing the pointer to first element of the vector is
    // not completely safe as there might be an implementation where
    // the vector elements are not stored consecutively in memory.
    // however it is much faster than copying the contents, especially
    // for large number of parameters
    fFitFunction->SetParameters(&params[0]);
 
    return fFitFunction->Eval(x[0]);
 }

TGraph* BCGraphFitter::GetErrorBand ( )

inline

Returns: pointer to the error band

Definition at line 85 of file BCGraphFitter.h.

86 { return fErrorBand; };

TF1* BCGraphFitter::GetFitFunction ( )

inline

Returns: pointer to TF1

Definition at line 80 of file BCGraphFitter.h.

81 { return fFitFunction; };

TGraphErrors* BCGraphFitter::GetGraph ( )

inline

Returns: pointer to TGraphErrors

Definition at line 75 of file BCGraphFitter.h.

76 { return fGraph; };

TGraph* BCGraphFitter::GetGraphFitFunction ( )

inline

Returns: pointer to a graph for the fit function

Definition at line 90 of file BCGraphFitter.h.

91 { return fGraphFitFunction; };

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

virtual

The log of the prior probability. It is set to be flat in all parameters.

Parameters

parameters	vector containing the parameter values The log of the conditional probability.
parameters	vector containing the parameter values

Implements BCModel.

Definition at line 213 of file BCGraphFitter.cxx.

 {
    // initialize probability
    double logl = 0.;
 
    // set the parameters of the function
    // passing the pointer to first element of the vector is
    // not completely safe as there might be an implementation where
    // the vector elements are not stored consecutively in memory.
    // however it is much faster than copying the contents, especially
    // for large number of parameters
    fFitFunction->SetParameters(&params[0]);
 
    // loop over all data points
    for (unsigned i = 0; i < GetNDataPoints(); i++)
    {
       std::vector<double> x = GetDataPoint(i)->GetValues();
 
       // her we ignore the errors on x even when they're available
       // i.e. we treat them just as the region specifiers
       double y = x[1];
       double yerr = x[3];
       double yexp = fFitFunction->Eval(x[0]);
 
       // calculate log of probability assuming
       // a Gaussian distribution for each point
       logl += BCMath::LogGaus(y, yexp, yerr, true);
    }
 
    return logl;
 }

int BCGraphFitter::SetFitFunction ( TF1 * func)

Parameters

func	pointer to TF1 object

Definition at line 162 of file BCGraphFitter.cxx.

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

int BCGraphFitter::SetGraph ( TGraphErrors * graph)

Parameters

graph pointer to TGraphErrors object

Definition at line 85 of file BCGraphFitter.cxx.

 {
    if(!graph) {
       BCLog::Out(BCLog::error,BCLog::error,"BCGraphFitter::SetGraph() : TGraphErrors not created.");
       return 0;
    }
 
    int npoints = graph->GetN();
    if(!npoints)
    {
       BCLog::Out(BCLog::error,BCLog::error,"BCGraphFitter::SetGraph() : TGraphErrors is empty.");
       return 0;
    }
    else if(npoints==1)
    {
       BCLog::Out(BCLog::error,BCLog::error,"BCGraphFitter::SetGraph() : TGraphErrors has only one point. Not able to fit.");
       return 0;
    }
 
    fGraph = graph;
 
    double * x = fGraph->GetX();
    double * y = fGraph->GetY();
    double * ex = fGraph->GetEX();
    double * ey = fGraph->GetEY();
 
    if(!ey)
    {
       BCLog::Out(BCLog::error,BCLog::error,"BCGraphFitter::SetGraph() : TGraphErrors has NO errors set on Y. Not able to fit.");
       return 0;
    }
 
    BCDataSet * ds = new BCDataSet();
 
    // fill the dataset
    // find x and y boundaries for the error band calculation
    double xmin=x[0];
    double xmax=x[0];
    double ymin=y[0];
    double ymax=y[0];
    for (int i = 0; i < npoints; ++i)
    {
       // if x errors are not set, set them to zero
       double errx = ex ? ex[i] : 0.;
 
       // create the data point
       BCDataPoint * dp = new BCDataPoint(4);
       dp->SetValue(0, x[i]);
       dp->SetValue(1, y[i]);
       dp->SetValue(2, errx);
       dp->SetValue(3, ey[i]);
       ds->AddDataPoint(dp);
 
       if(x[i]-errx < xmin)
          xmin = x[i]-errx;
       else if(x[i]+errx > xmax)
          xmax = x[i]+errx;
 
       if(y[i] - 5.*ey[i] < ymin)
          ymin = y[i] - 5.*ey[i];
       else if(y[i] + 5.*ey[i] > ymax)
          ymax = y[i] + 5.*ey[i];
    }
 
    SetDataSet(ds);
 
    // set boundaries for the error band calculation
    SetDataBoundaries(0, xmin, xmax);
    SetDataBoundaries(1, ymin, ymax);
 
    SetFitFunctionIndices(0, 1);
 
    return GetNDataPoints();
 }

Member Data Documentation

TGraph* BCGraphFitter::fErrorBand

private

Pointer to the error band (for legend)

Definition at line 159 of file BCGraphFitter.h.

TF1* BCGraphFitter::fFitFunction

private

The fit function

Definition at line 155 of file BCGraphFitter.h.

TGraphErrors* BCGraphFitter::fGraph

private

The graph containing the data.

Definition at line 151 of file BCGraphFitter.h.

TGraph* BCGraphFitter::fGraphFitFunction

private

Pointer to a graph for displaying the fit function

Definition at line 163 of file BCGraphFitter.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