The base class for all user-defined models. More...

#include <BCModel.h>

Inheritance diagram for BCModel:

Collaboration diagram for BCModel:

Public Member Functions
Constructors and destructors
	BCModel (const char *name="model")

	BCModel (const BCModel &bcmodel)

virtual	~BCModel ()

Assignment operators
BCModel &	operator= (const BCModel &bcmodel)

Member functions (get)
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

Member functions (set)
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 ()

Member functions (miscellaneous methods)
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)

virtual double	LogLikelihood (const std::vector< double > &params)=0

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)

virtual void	MarginalizePreprocess ()

virtual void	MarginalizePostprocess ()

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	MCMCIterationInterface ()

virtual void	MCMCUserIterationInterface ()

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

Protected Attributes
std::string	fName

double	fModelAPriori

double	fModelAPosteriori

BCDataSet *	fDataSet

BCDataPoint *	fDataPointLowerBoundaries

BCDataPoint *	fDataPointUpperBoundaries

std::vector< bool >	fDataFixedValues

double	fPValue

double	fChi2NDoF

double	fPValueNDoF

bool	flag_discrete

int	fGoFNIterationsMax

int	fGoFNIterationsRun

int	fGoFNChains

std::vector< TNamed * >	fPriorContainer

bool	fPriorConstantAll

std::vector< bool >	fPriorContainerConstant

std::vector< bool >	fPriorContainerInterpolate

Protected Attributes inherited from BCIntegrate
int	fID

TMinuit *	fMinuit

double	fMinuitArglist [2]

int	fMinuitErrorFlag

bool	fFlagIgnorePrevOptimization

double	fSAT0

double	fSATmin

TTree *	fTreeSA

bool	fFlagWriteSAToFile

int	fSANIterations

double	fSATemperature

double	fSALogProb

std::vector< double >	fSAx

std::vector< BCH1D * >	fMarginalized1D

std::vector< BCH2D * >	fMarginalized2D

bool	fFlagMarginalized

Protected Attributes inherited from BCEngineMCMC
BCParameterSet	fParameters

unsigned	fMCMCNChains

unsigned	fMCMCNLag

std::vector< unsigned >	fMCMCNIterations

int	fMCMCCurrentIteration

int	fMCMCCurrentChain

unsigned	fMCMCNIterationsUpdate

unsigned	fMCMCNIterationsUpdateMax

int	fMCMCNIterationsConvergenceGlobal

bool	fMCMCFlagConvergenceGlobal

unsigned	fMCMCNIterationsMax

unsigned	fMCMCNIterationsRun

unsigned	fMCMCNIterationsPreRunMin

std::vector< int >	fMCMCNTrialsTrue

unsigned	fMCMCNTrials

bool	fMCMCFlagWriteChainToFile

bool	fMCMCFlagWritePreRunToFile

std::vector< double >	fMCMCTrialFunctionScaleFactor

std::vector< double >	fMCMCTrialFunctionScaleFactorStart

bool	fMCMCFlagPreRun

bool	fMCMCFlagRun

std::vector< double >	fMCMCInitialPosition

double	fMCMCEfficiencyMin

double	fMCMCEfficiencyMax

int	fMCMCFlagInitialPosition

bool	fMCMCFlagOrderParameters

int	fMCMCPhase

std::vector< double >	fMCMCx

std::vector< double >	fMCMCxMax

std::vector< double >	fMCMCxMean

std::vector< double >	fMCMCxVar

std::vector< double >	fMCMCprob

std::vector< double >	fMCMCprobMax

std::vector< double >	fMCMCprobMean

std::vector< double >	fMCMCprobVar

bool	fMCMCRValueUseStrict

double	fMCMCRValueCriterion

double	fMCMCRValueParametersCriterion

double	fMCMCRValue

std::vector< double >	fMCMCRValueParameters

TRandom3 *	fRandom

std::vector< TH1D * >	fMCMCH1Marginalized

std::vector< TH2D * >	fMCMCH2Marginalized

std::vector< TTree * >	fMCMCTrees

std::vector< double >	fMCMCBestFitParameters

double	fMCMCLogMaximum

std::vector< double >	fMarginalModes

Private Member Functions
int	CompareStrings (const char string1, const char string2)

BCDataPoint *	VectorToDataPoint (const std::vector< double > &data)

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)

Detailed Description

The base class for all user-defined models.

Author: Daniel Kollar; Kevin Kröninger

Version: 1.0

Date: 08.2008 This class represents a model. It contains a container of prior distributions and the likelihood. The methods that implement the prior and the likelihood have to be overloaded by the user in the user defined model class derived from this class.

Definition at line 50 of file BCModel.h.

Constructor & Destructor Documentation

BCModel::BCModel ( const char * name = "model")

A constructor.

Parameters

name	The name of the model

Definition at line 36 of file BCModel.cxx.

                                   :
    BCIntegrate(),
    fName((char *) name),
    fModelAPriori(0),
    fModelAPosteriori(0),
    fDataSet(0),
    fDataPointLowerBoundaries(0),
    fDataPointUpperBoundaries(0),
    fPValue(-1),
    fChi2NDoF(-1),
    fPValueNDoF(-1),
    flag_discrete(false),
    fGoFNIterationsMax(100000),
    fGoFNIterationsRun(2000),
    fGoFNChains(5),
    fPriorConstantAll(false)
 {
 }

BCModel::BCModel ( const BCModel & bcmodel)

The copy constructor.

Definition at line 56 of file BCModel.cxx.

                                         : BCIntegrate(bcmodel)
 {
    Copy(bcmodel);
 }

BCModel::~BCModel ( )

virtual

The default destructor.

Definition at line 104 of file BCModel.cxx.

 {
    for (unsigned int i = 0; i < GetNParameters(); ++i)
       delete fPriorContainer[i];
    fPriorContainer.clear();
 
    delete fDataPointLowerBoundaries;
    delete fDataPointUpperBoundaries;
 }

Member Function Documentation

int BCModel::AddParameter ( BCParameter * parameter)

virtual

Adds a parameter to the model.

Parameters

parameter A model parameter

See Also: AddParameter(const char * name, double lowerlimit, double upperlimit);

Reimplemented from BCEngineMCMC.

Definition at line 225 of file BCModel.cxx.

 {
    if ( !BCEngineMCMC::AddParameter(parameter))
       return 1;
 
    // add empty object to prior container
    fPriorContainer.push_back(0);
 
    // don't interpolate the prior histogram by default
    fPriorContainerInterpolate.push_back(false);
 
    // prior assumed to be non-constant in general case
    fPriorContainerConstant.push_back(false);
 
    return 0;
 }

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

Returns the prior probability.

Parameters

parameters A set of parameter values

Returns: The prior probability p(parameters)

See Also: GetPrior(std::vector<double> parameters)

Definition at line 267 of file BCModel.cxx.

 {
    return exp(this->LogAPrioriProbability(parameters) );
 }

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

Definition at line 451 of file BCModel.cxx.

 {
    BCH1D * hist = 0;
 
    // print log
    BCLog::OutSummary("Do goodness-of-fit-test");
 
    // create model test
    BCGoFTest * goftest = new BCGoFTest("modeltest");
 
    // set this model as the model to be tested
    goftest->SetTestModel(this);
 
    // set the point in parameter space which is tested an initialize
    // the model testing
    if (!goftest->SetTestPoint(par))
       return 0;
 
    // disable the creation of histograms to save _a lot_ of memory
    // (histograms are not needed for p-value calculation)
    goftest->MCMCSetFlagFillHistograms(false);
 
    // set parameters of the MCMC for the GoFTest
    goftest->MCMCSetNChains(fGoFNChains);
    goftest->MCMCSetNIterationsMax(fGoFNIterationsMax);
    goftest->MCMCSetNIterationsRun(fGoFNIterationsRun);
 
    // get p-value
    fPValue = goftest->GetCalculatedPValue(flag_histogram);
 
    // get histogram
    if (flag_histogram) {
       hist = new BCH1D();
       hist->SetHistogram(goftest->GetHistogramLogProb());
    }
 
    // delete model test
    delete goftest;
 
    // return histogram
    return hist;
 }

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

inlinevirtual

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 in BCHistogramFitter, and BCGraphFitter.

Definition at line 502 of file BCModel.h.

503 {return 0.0;}

int BCModel::CompareStrings	(	const char *	string1,
		const char *	string2
	)

private

Compares to strings

Definition at line 1094 of file BCModel.cxx.

 {
    int flag_same = 0;
 
    if (strlen(string1) != strlen(string2))
       return -1;
 
    for (int i = 0; i < int(strlen(string1)); i++)
       if (string1[i] != string2[i])
          flag_same = -1;
 
    return flag_same;
 }

void BCModel::Copy ( const BCModel & bcmodel)

Copy from object

Parameters

bcmodel Object to copy from.

Definition at line 62 of file BCModel.cxx.

 {
    //  called for the second time in copy constructor? do copy-and-swap instead
    //   BCIntegrate::Copy(bcmodel);
    fName                            = bcmodel.fName;
    fModelAPriori                    = bcmodel.fModelAPriori;
    fModelAPosteriori                = bcmodel.fModelAPosteriori;
    if (fDataSet)
       fDataSet = bcmodel.fDataSet;
    else
       fDataSet = 0;
 
    if (bcmodel.fDataPointLowerBoundaries)
       fDataPointLowerBoundaries = new BCDataPoint(*bcmodel.fDataPointLowerBoundaries);
    else
       fDataPointLowerBoundaries = 0;
    if (bcmodel.fDataPointUpperBoundaries)
       fDataPointUpperBoundaries = new BCDataPoint(*bcmodel.fDataPointUpperBoundaries);
    else
       fDataPointUpperBoundaries = 0;
 
    fDataFixedValues                 = bcmodel.fDataFixedValues;
 
    fPValue                          = bcmodel.fPValue;
    fChi2NDoF                        = bcmodel.fChi2NDoF;
    fPValueNDoF                      = bcmodel.fPValueNDoF;
    flag_discrete                    = bcmodel.flag_discrete;
    fGoFNIterationsMax               = bcmodel.fGoFNIterationsMax;
    fGoFNIterationsRun               = bcmodel.fGoFNIterationsRun;
    fGoFNChains                      = bcmodel.fGoFNChains;
    for (int i = 0; i < int(bcmodel.fPriorContainer.size()); ++i) {
       if (bcmodel.fPriorContainer.at(i))
          fPriorContainer.push_back(new TNamed(*bcmodel.fPriorContainer.at(i)));
       else
          fPriorContainer.push_back(0);
    }
    fPriorConstantAll                = bcmodel.fPriorConstantAll;
    fPriorContainerConstant          = bcmodel.fPriorContainerConstant;
    fPriorContainerInterpolate       = bcmodel.fPriorContainerInterpolate;
 }

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

virtual

Constrains a data point

Parameters

x	A vector of double

Definition at line 495 of file BCModel.cxx.

 {
    // ...
 }

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

virtual

Overloaded function to evaluate integral.

Reimplemented from BCIntegrate.

Definition at line 330 of file BCModel.cxx.

 {
    return exp(LogEval(parameters));
 }

double BCModel::GetChi2NDoF ( )

inline

Definition at line 441 of file BCModel.h.

442 { return fChi2NDoF; }

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

For a Gaussian problem, calculate the chi2 of the longest run of consecutive values above/below the expected values

Parameters

dataIndex	component of datapoint with the observed value
sigmaIndex	component of datapoint with uncertainty

Definition at line 368 of file BCModel.cxx.

 {
    std::vector<double> x;
    return x;
 }

BCDataPoint * BCModel::GetDataPoint ( unsigned int index) const

Parameters

index The index of the data point.

Returns: The data point in the current data set at index

Definition at line 132 of file BCModel.cxx.

 {
    if (fDataSet)
       return fDataSet->GetDataPoint(index);
 
    BCLog::OutWarning("BCModel::GetDataPoint : No data set defined.");
    return 0;
 }

BCDataPoint* BCModel::GetDataPointLowerBoundaries ( ) const

inline

Returns: The lower boundaries of possible data values.

Definition at line 105 of file BCModel.h.

106 { return fDataPointLowerBoundaries; }

double BCModel::GetDataPointLowerBoundary ( unsigned int index) const

Parameters

index The index of the variable.

Returns: The lower boundary of possible data values for a particular variable.

Definition at line 142 of file BCModel.cxx.

 {
     return fDataPointLowerBoundaries -> GetValue(index);
 }

BCDataPoint* BCModel::GetDataPointUpperBoundaries ( ) const

inline

Returns: The upper boundaries of possible data values.

Definition at line 110 of file BCModel.h.

111 { return fDataPointUpperBoundaries; }

double BCModel::GetDataPointUpperBoundary ( unsigned int index) const

Parameters

index The index of the variable.

Returns: The upper boundary of possible data values for a particular variable.

Definition at line 148 of file BCModel.cxx.

 {
     return fDataPointUpperBoundaries -> GetValue(index);
 }

BCDataSet* BCModel::GetDataSet ( ) const

inline

Returns: The data set.

Definition at line 100 of file BCModel.h.

101 { return fDataSet; }

bool BCModel::GetFlagBoundaries ( ) const

Checks if the boundaries have been defined

Returns: true, if the boundaries have been set, false otherwise

Definition at line 154 of file BCModel.cxx.

 {
    if (!fDataPointLowerBoundaries)
       return false;
 
    if (!fDataPointUpperBoundaries)
       return false;
 
    if (fDataPointLowerBoundaries->GetNValues() != fDataSet->GetDataPoint(0)->GetNValues())
       return false;
 
    if (fDataPointUpperBoundaries->GetNValues() != fDataSet->GetDataPoint(0)->GetNValues())
       return false;
 
    return true;
 }

double BCModel::GetModelAPosterioriProbability ( ) const

inline

Returns: The a posteriori probability.

Definition at line 95 of file BCModel.h.

96 { return fModelAPosteriori; }

double BCModel::GetModelAPrioriProbability ( ) const

inline

Returns: The a priori probability.

Definition at line 90 of file BCModel.h.

91 { return fModelAPriori; }

const std::string& BCModel::GetName ( ) const

inline

Returns: The name of the model.

Definition at line 85 of file BCModel.h.

86 { return fName; }

unsigned BCModel::GetNDataPoints ( ) const

Returns: The number of data points in the current data set.

Definition at line 123 of file BCModel.cxx.

 {
    if (fDataSet)
       return fDataSet->GetNDataPoints();
    else
       return 0;
    }

double BCModel::GetPValue ( )

inline

Returns: The p-value

Definition at line 435 of file BCModel.h.

436 { return fPValue; }

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

Calculate p-value from Chi2 distribution for Gaussian problems

Parameters

par	Parameter set for the calculation of the likelihood
sigma_index	Index of the sigma/uncertainty for the data points (for data in format "x y erry" the index would be 2)

Definition at line 351 of file BCModel.cxx.

 {
    double ll = LogLikelihood(par);
    int n = GetNDataPoints();
 
    double sum_sigma = 0;
    for (int i = 0; i < n; i++)
       sum_sigma += log(GetDataPoint(i)->GetValue(sigma_index));
 
    double chi2 = -2. * (ll + (double) n / 2. * log(2. * M_PI) + sum_sigma);
 
    fPValue = TMath::Prob(chi2, n);
 
    return fPValue;
 }

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

Definition at line 375 of file BCModel.cxx.

 {
    double ll = LogLikelihood(par);
    int n = GetNDataPoints();
    int npar = GetNParameters();
 
    double sum_sigma = 0;
    for (int i = 0; i < n; i++)
       sum_sigma += log(GetDataPoint(i)->GetValue(sigma_index));
 
    double chi2 = -2. * (ll + (double) n / 2. * log(2. * M_PI) + sum_sigma);
 
    fChi2NDoF = chi2 / double(n - npar);
    fPValueNDoF = TMath::Prob(chi2, n - npar);
 
    return fPValueNDoF;
 }

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

Calculate p-value from Kolmogorov-Smirnov test statistic for 1D - datasets.

Parameters

par	Parameter set for the calculation of the likelihood
index	Index of the data point in the BCDataSet (for data in format "x y erry" the index would be 1)

Definition at line 394 of file BCModel.cxx.

 {
    if (flag_discrete) {
       BCLog::OutError(Form("BCModel::GetPvalueFromKolmogorov : "
             "test defined only for continuous distributions."));
       return -1.;
    }
 
    //calculate the ECDF from the 1D data
    std::vector<double> yData = fDataSet->GetDataComponents(index);
    TH1D * ECDF = BCMath::ECDF(yData);
 
    int N = GetNDataPoints();
 
    // calculated expected CDF for unique points only
    std::set<double> uniqueObservations;
    for (int i = 0; i < N; i++)
       uniqueObservations.insert(CDF(par, i, false));
 
    int nUnique = uniqueObservations.size();
    if (nUnique != ECDF->GetNbinsX() + 1) {
       BCLog::OutError(Form("BCModel::GetPvalueFromKolmogorov : "
             "Number of unique data points doesn't match (%d vs %d)", nUnique,
             ECDF->GetNbinsX() + 1));
       return -1.;
    }
 
    // find maximum distance
    double distMax = 0.;
 
    // current distance
    double dist = 0.;
 
    std::set<double>::const_iterator iter = uniqueObservations.begin();
    for (int iBin = 0; iBin < nUnique; ++iBin) {
       // distance between current points
       dist = TMath::Abs(*iter - ECDF->GetBinContent(iBin + 1));
       // update maximum if necessary
       distMax = TMath::Max(dist, distMax);
 
       // advance to next entry in the set
       ++iter;
    }
 
    // correct for total #points, not unique #points.
    // would need sqrt(n1*n2/(n1+n2)) if we had two experimental datasets
    double z = distMax * sqrt(N);
 
    fPValue = TMath::KolmogorovProb(z);
 
    // clean up
    delete ECDF;
 
    return fPValue;
 }

double BCModel::GetPValueNDoF ( )

inline

Definition at line 438 of file BCModel.h.

439 { return fPValueNDoF; }

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

Calculates the matrix element of the Hessian matrix

Parameters

parameter1	The parameter for the first derivative
parameter2	The parameter for the first derivative

Returns: The matrix element of the Hessian matrix

Definition at line 501 of file BCModel.cxx.

 {
    // check number of entries in vector
    if (point.size() != GetNParameters()) {
       BCLog::OutError("BCModel::HessianMatrixElement : Invalid number of entries in the vector.");
       return -1;
    }
 
    // define steps
    double nsteps = 1e5;
    double dx1 = par1->GetRangeWidth() / nsteps;
    double dx2 = par2->GetRangeWidth() / nsteps;
 
    // define points at which to evaluate
    std::vector<double> xpp = point;
    std::vector<double> xpm = point;
    std::vector<double> xmp = point;
    std::vector<double> xmm = point;
 
    unsigned idx1 = fParameters.Index(par1->GetName());
    unsigned idx2 = fParameters.Index(par2->GetName());
 
    xpp[idx1] += dx1;
    xpp[idx2] += dx2;
 
    xpm[idx1] += dx1;
    xpm[idx2] -= dx2;
 
    xmp[idx1] -= dx1;
    xmp[idx2] += dx2;
 
    xmm[idx1] -= dx1;
    xmm[idx2] -= dx2;
 
    // calculate probability at these points
    double ppp = Likelihood(xpp);
    double ppm = Likelihood(xpm);
    double pmp = Likelihood(xmp);
    double pmm = Likelihood(xmm);
 
    // return derivative
    return (ppp + pmm - ppm - pmp) / (4. * dx1 * dx2);
 }

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

virtual

Returns the likelihood

Parameters

params A set of parameter values

Returns: The likelihood

Definition at line 324 of file BCModel.cxx.

 {
    return exp(LogLikelihood(params));
 }

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

virtual

Returns natural logarithm of the prior probability. Method needs to be overloaded by the user.

Parameters

parameters A set of parameter values

Returns: The prior probability p(parameters)

See Also: GetPrior(std::vector<double> parameters)

Reimplemented in BCGoFTest, BCMVCDataModel, BCSummaryPriorModel, and BCRooInterface.

Definition at line 273 of file BCModel.cxx.

 {
    double logprob = 0;
 
    // loop over all parameters, assume prior factorizes
    // into n independent parts
    for (unsigned i = 0; i < fParameters.Size(); ++i) {
       BCParameter * par = fParameters[i];
 
       // avoid fixed and zero-width parameters
       if (par->Fixed() or not par->GetRangeWidth())
          continue;
 
       if (fPriorContainerConstant[i]) {
          logprob -= log(par->GetRangeWidth());
          continue;
       }
 
       if (fPriorContainer[i]) {
          // check what type of object is stored
          TF1 * f = dynamic_cast<TF1*>(fPriorContainer[i]);
          TH1 * h = dynamic_cast<TH1*>(fPriorContainer[i]);
 
          if (f) // TF1
             logprob += log(f->Eval(parameters[i]));
          else if (h) { // TH1
             if(fPriorContainerInterpolate[i])
                logprob += log(h->Interpolate(parameters[i]));
             else
                logprob += log(h->GetBinContent(h->FindBin(parameters[i])));
          }
          else
             BCLog::OutError(Form(
                   "BCModel::LogAPrioriProbability : Prior for parameter %s "
                   "is defined but not recognized.",
                   par->GetName().c_str())); // this should never happen
       }
       // use constant only if user has defined it
       else {
          BCLog::OutError(Form(
                "BCModel::LogAPrioriProbability: Prior for parameter %s "
                "is undefined. Using constant prior to proceed.",
                par->GetName().c_str()));
          logprob -= log(par->GetRangeWidth());
       }
    }
 
    return logprob;
 }

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

virtual

Overloaded function to evaluate integral.

Reimplemented from BCIntegrate.

Definition at line 336 of file BCModel.cxx.

 {
    return LogProbabilityNN(parameters);
 }

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

pure virtual

Calculates natural logarithm of the likelihood. Method needs to be overloaded by the user.

Parameters

params A set of parameter values

Returns: Natural logarithm of the likelihood

Implemented in BCMTF, BCEfficiencyFitter, BCMVCombination, BCHistogramFitter, BCGraphFitter, BCGoFTest, BCMVCDataModel, BCSummaryPriorModel, BCMVCPhysicsModel, and BCRooInterface.

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

Returns natural logarithm of the a posteriori probability given a set of parameter values

Parameters

parameters A set of parameter values

Returns: The a posteriori probability

Definition at line 255 of file BCModel.cxx.

 {
    // check if normalized
   if (GetIntegral() <= 0.) {
       BCLog::OutError("BCModel::LogProbability. Normalization not available or zero.");
       return 0.;
    }
 
   return LogProbabilityNN(parameters) - log(GetIntegral());
 }

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

inline

Returns the natural logarithm of likelihood times prior probability given a set of parameter values

Parameters

parameters A set of parameter values

Returns: The likelihood times prior probability

Definition at line 378 of file BCModel.h.

379 { return LogLikelihood(parameters) + LogAPrioriProbability(parameters); }

BCModel & BCModel::operator= ( const BCModel & bcmodel)

Defaut assignment operator

Definition at line 115 of file BCModel.cxx.

 {
    Copy(bcmodel);
 
    return *this;
 }

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

Prints matrix elements of the Hessian matrix

Parameters

parameters The parameter values at which point to evaluate the matrix

Definition at line 1057 of file BCModel.cxx.

 {
    // check number of entries in vector
    if (parameters.size() != GetNParameters()) {
       BCLog::OutError("BCModel::PrintHessianMatrix : Invalid number of entries in the vector");
       return;
    }
 
    // print to screen
    BCLog::OutSummary("Hessian matrix elements: ");
    BCLog::OutSummary("Parameter values:");
 
    for (int i = 0; i < int(parameters.size()); i++)
       BCLog::OutSummary(Form("Parameter %d : %f", i, parameters.at(i)));
 
    BCLog::OutSummary("Hessian matrix:");
    // loop over all parameter pairs
    for (unsigned int i = 0; i < GetNParameters(); i++)
       for (unsigned int j = 0; j < i; j++) {
          // calculate Hessian matrix element
          double hessianmatrixelement = HessianMatrixElement(
                fParameters[i], fParameters[j], parameters);
 
          // print to screen
          BCLog::OutSummary(Form("%d %d : %f", i, j, hessianmatrixelement));
       }
 }

void BCModel::PrintResults ( const char * file)

Prints a summary of the Markov Chain Monte Carlo to a file.

Definition at line 816 of file BCModel.cxx.

 {
    // print summary of Markov Chain Monte Carlo
 
    // open file
    std::ofstream ofi(file);
 
    // check if file is open
    if (!ofi.is_open()) {
       std::cerr << "Couldn't open file " << file << std::endl;
       return;
    }
 
    // number of parameters and chains
    unsigned npar = GetNParameters();
    unsigned nchains = MCMCGetNChains();
 
    // check convergence
    bool flag_conv = MCMCGetNIterationsConvergenceGlobal() > 0;
 
    ofi << std::endl
          << " -----------------------------------------------------" << std::endl
          << " Summary" << std::endl
          << " -----------------------------------------------------" << std::endl
          << std::endl;
 
    ofi << " Model summary" << std::endl << " =============" << std::endl
          << " Model: " << fName.data() << std::endl
          << " Number of parameters: " << npar << std::endl
          << " List of Parameters and ranges:" << std::endl;
    for (unsigned i = 0; i < npar; ++i) {
      ofi << "  (" << i << ") Parameter \""
          << fParameters[i]->GetName() << "\"" << ": "
          << "[" << fParameters[i]->GetLowerLimit() << ", "
          << fParameters[i]->GetUpperLimit() << "]";
      if (fParameters[i]->Fixed()) {
        ofi << " (fixed)";
      }
      ofi << std::endl;
    }
    ofi << std::endl;
 
    ofi << " Results of the optimization" << std::endl
          << " ===========================" << std::endl
          << " Optimization algorithm used: "
          << DumpUsedOptimizationMethod()<< std::endl;
 
    if ( ! GetBestFitParameters().empty()) {
      ofi << " Log of the maximum posterior: " << GetLogMaximum() << std::endl;
       ofi << " List of parameters and global mode:" << std::endl;
       for (unsigned i = 0; i < npar; ++i) {
         ofi << "  (" << i << ") Parameter \""
             << fParameters[i]->GetName() << "\": "
             << GetBestFitParameter(i);
         if (fParameters[i]->Fixed()) {
           ofi << " (fixed)";
         }
         else if (GetBestFitParameterErrors().size() == npar) {
           if(GetBestFitParameterError(i) >= 0.)
             ofi << " +- " << GetBestFitParameterError(i);
           else
             ofi << " (no error estimate available) ";
         }
         else {
           ofi << " (no error estimate available) ";
         }
         ofi << std::endl;
       }
       ofi << std::endl;
    }
    else {
       ofi << " No best fit information available." << std::endl;
       ofi << std::endl;
    }
 
    if (fPValue >= 0.) {
       ofi << " Results of the model test" << std::endl
             << " =========================" << std::endl
             << " p-value: " << fPValue << std::endl;
       if (fPValueNDoF >= 0)
          ofi << " p-value corrected for degrees of freedom: " << fPValueNDoF << std::endl;
 
       ofi << std::endl;
    }
 
    if (GetIntegral() >= 0.) {
       ofi << " Results of the integration" << std::endl
             << " ============================" << std::endl
             << " Integration method used: "
             << DumpUsedIntegrationMethod() << std::endl;
       ofi << " Evidence: " << GetIntegral();
       if (GetError() >= 0)
         ofi << " +- " << GetError() << std::endl;
       else
         ofi << " (no error estimate available) " << std::endl;
       ofi << std::endl;
    }
 
    // give warning if MCMC did not converge
    if (!flag_conv && fMCMCFlagRun)
       ofi << " WARNING: the Markov Chain did not converge!" << std::endl
       << " Be cautious using the following results!" << std::endl
       << std::endl;
 
    // print results of marginalization (if MCMC was run)
    if (fFlagMarginalized) {
       ofi << " Results of the marginalization" << std::endl
           << " ==============================" << std::endl
           << " Marginalization algorithm used: "
           << DumpUsedMarginalizationMethod() << std::endl
           << " List of parameters and properties of the marginalized"
           << std::endl << " distributions:" << std::endl;
       for (unsigned i = 0; i < npar; ++i) {
          if ( ! fParameters[i]->FillHistograms())
             continue;
 
          // get marginalized histogram
          BCH1D * bch1d = GetMarginalized(fParameters[i]);
 
          ofi << "  (" << i << ") Parameter \""
              << fParameters[i]->GetName() << "\":";
 
          if (!bch1d) {
             ofi << " fixed (or histogram does not exist) " << std::endl;
             continue;
          }
          else
             ofi << std::endl;
 
          ofi << "      Mean +- sqrt(V):                " << std::setprecision(4)
              << bch1d->GetMean() << " +- " << std::setprecision(4)
              << bch1d->GetRMS() << std::endl
 
              << "      Median +- central 68% interval: "
              << std::setprecision(4) << bch1d->GetMedian() << " +  "
              << std::setprecision(4) << bch1d->GetQuantile(0.84) - bch1d->GetMedian()
              << " - " << std::setprecision(4)
              << bch1d->GetMedian() - bch1d->GetQuantile(0.16) << std::endl
 
              << "      (Marginalized) mode:            " << bch1d->GetMode() << std::endl;
 
          ofi << "       5% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.05) << std::endl
              << "      10% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.10) << std::endl
              << "      16% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.16) << std::endl
              << "      84% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.85) << std::endl
              << "      90% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.90) << std::endl
              << "      95% quantile:                   " << std::setprecision(4)
              << bch1d->GetQuantile(0.95) << std::endl;
 
          std::vector<double> v;
          v = bch1d->GetSmallestIntervals(0.68);
          ofi << "      Smallest interval(s) containing at least 68% and local mode(s):"
              << std::endl;
          for (unsigned j = 0; j < v.size(); j += 5)
             ofi << "       (" << v[j] << ", " << v[j + 1]
                 << ") (local mode at " << v[j + 3] << " with rel. height "
                 << v[j + 2] << "; rel. area " << v[j + 4] << ")"
                 << std::endl;
          ofi << std::endl;
       }
    }
    if (fMCMCFlagRun) {
       ofi << " Status of the MCMC" << std::endl << " ==================" << std::endl
           << " Convergence reached:                    " << (flag_conv ? "yes" : "no")
           << std::endl;
 
       if (flag_conv)
          ofi << " Number of iterations until convergence: "
              << MCMCGetNIterationsConvergenceGlobal() << std::endl;
       else
          ofi << " WARNING: the Markov Chain did not converge! Be\n"
              << " cautious using the following results!" << std::endl
              << std::endl;
       ofi << " Number of chains:                       " << MCMCGetNChains() << std::endl
           << " Number of iterations per chain:         " << MCMCGetNIterationsRun() << std::endl
           << " Average efficiencies:" << std::endl;
 
       std::vector<double> efficiencies;
       efficiencies.assign(npar, 0.);
 
       for (unsigned ipar = 0; ipar < npar; ++ipar)
          for (unsigned ichain = 0; ichain < nchains; ++ichain) {
             unsigned index = ichain * npar + ipar;
             efficiencies[ipar] +=
                double(MCMCGetNTrialsTrue().at(index)) / double(MCMCGetNTrials()) / double(nchains) * 100.;
          }
 
       for (unsigned ipar = 0; ipar < npar; ++ipar)
          ofi << "  (" << ipar << ") Parameter \""
              << fParameters[ipar]->GetName().data() << "\": "
              << efficiencies.at(ipar) << "%" << std::endl;
       ofi << std::endl;
    }
 
    ofi << " -----------------------------------------------------" << std::endl
        << " Notation:" << std::endl
        << " Mean        : mean value of the marg. pdf" << std::endl
        << " Median      : median of the marg. pdf" << std::endl
        << " Marg. mode  : most probable value of the marg. pdf" << std::endl
        << " V           : Variance of the marg. pdf" << std::endl
        << " Quantiles   : most commonly used quantiles" <<std::endl
        << " -----------------------------------------------------" << std::endl
        << std::endl;
 
    // close file
    ofi.close();
 }

void BCModel::PrintShortFitSummary ( int chi2flag = 0)

Prints a short summary of the fit results on the screen.

Definition at line 1030 of file BCModel.cxx.

 {
    BCLog::OutSummary("---------------------------------------------------");
    BCLog::OutSummary(Form("Fit summary for model \'%s\':", GetName().data()));
    BCLog::OutSummary(Form("   Number of parameters:  Npar  = %i", GetNParameters()));
    if (GetNDataPoints()) {
       BCLog::OutSummary(Form("   Number of data points: Ndata = %i", GetNDataPoints()));
       BCLog::OutSummary("   Number of degrees of freedom:");
       BCLog::OutSummary(Form("      NDoF = Ndata - Npar = %i", GetNDataPoints() - GetNParameters()));
    }
    if (!GetBestFitParameters().empty())
       BCLog::OutSummary("   Best fit parameters (global):");
    for (unsigned int i = 0; i < GetNParameters(); ++i)
       BCLog::OutSummary(Form("      %s = %.3g", GetParameter(i)->GetName().data(), GetBestFitParameter(i)));
 
    if (GetPValue() >= 0) {
       BCLog::OutSummary("   Goodness-of-fit test:");
       BCLog::OutSummary(Form("      p-value = %.3g", GetPValue()));
       if (chi2flag) {
          BCLog::OutSummary(Form("      p-value corrected for NDoF = %.3g", GetPValueNDoF()));
          BCLog::OutSummary(Form("      chi2 / NDoF = %.3g", GetChi2NDoF()));
       }
    }
    BCLog::OutSummary("---------------------------------------------------");
 }

void BCModel::PrintSummary ( )

Prints a summary on the screen.

Definition at line 772 of file BCModel.cxx.

 {
    // model summary
    BCLog::OutSummary(Form("Model : %s", fName.data()));
    BCLog::OutSummary(Form("Number of parameters : %u", GetNParameters()));
    BCLog::OutSummary("Parameters:");
 
    // parameter summary
    for (unsigned i = 0; i < GetNParameters(); i++)
       fParameters[i]->PrintSummary();
 
    // best fit parameters
    if ( !GetBestFitParameters().empty()) {
      BCLog::OutSummary(Form("Log of the maximum posterior: %f", GetLogMaximum()));
       BCLog::OutSummary("Best fit parameters:");
 
       for (unsigned i = 0; i < GetNParameters(); i++) {
         if ( fParameters[i]->Fixed() )
           BCLog::OutSummary(Form(" %s = %f (fixed)", fParameters[i]->GetName().data(), GetBestFitParameter(i)));
         else
           BCLog::OutSummary(Form(" %s = %f (global)", fParameters[i]->GetName().data(), GetBestFitParameter(i)));
 
         if ( fMarginalModes.size() == GetNParameters())
           BCLog::OutSummary(Form(" %s = %f (marginalized)", fParameters[i]->GetName().data(), GetBestFitParametersMarginalized()[i]));
 
       }
    }
 
    // model testing
    if (fPValue >= 0) {
       double likelihood = Likelihood(GetBestFitParameters());
       BCLog::OutSummary(" Model testing:");
       BCLog::OutSummary(Form("  p(data|lambda*) = %f", likelihood));
       BCLog::OutSummary(Form("  p-value         = %f", fPValue));
    }
 
    // normalization
    if (GetIntegral() > 0) {
       BCLog::OutSummary(" Evidence:");
       BCLog::OutSummary(Form(" - evidence : %f", GetIntegral()));
    }
 }

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

Returns the a posteriori probability given a set of parameter values

Parameters

parameters A set of parameter values

Returns: The a posteriori probability

Definition at line 249 of file BCModel.cxx.

 {
    return exp(LogProbability(parameter));
 }

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

Returns the likelihood times prior probability given a set of parameter values

Parameters

params A set of parameter values

Returns: The likelihood times prior probability

Definition at line 243 of file BCModel.cxx.

 {
    return exp(LogProbabilityNN(params) );
 }

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

virtual

Sampling function used for importance sampling. Method needs to be overloaded by the user.

Parameters

parameters A set of parameter values

Returns: The probability density at the parameter values

Definition at line 342 of file BCModel.cxx.

 {
    double probability = 1;
    for (unsigned i = 0 ; i < GetNParameters() ; ++i)
       probability *= 1. / fParameters[i]->GetRangeWidth();
    return probability;
 }

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

Definition at line 194 of file BCModel.cxx.

 {
    // check if data set exists
    if (!fDataSet) {
       BCLog::OutError("BCModel::SetDataBoundaries : Need to define data set first.");
       return;
    }
 
    // check if index is within range
    if (index > fDataSet->GetDataPoint(0)->GetNValues()) {
       BCLog::OutError("BCModel::SetDataBoundaries : Index out of range.");
       return;
    }
 
    // check if boundary data points exist
    if (!fDataPointLowerBoundaries)
       fDataPointLowerBoundaries = new BCDataPoint(fDataSet->GetDataPoint(0)->GetNValues());
 
    if (!fDataPointUpperBoundaries)
       fDataPointUpperBoundaries = new BCDataPoint(fDataSet->GetDataPoint(0)->GetNValues());
 
    if (fDataFixedValues.size() == 0)
       fDataFixedValues.assign(fDataSet->GetDataPoint(0)->GetNValues(), false);
 
    // set boundaries
    fDataPointLowerBoundaries->SetValue(index, lowerboundary);
    fDataPointUpperBoundaries->SetValue(index, upperboundary);
    fDataFixedValues[index] = fixed;
 }

void BCModel::SetDataPointLowerBoundaries ( BCDataPoint * datasetlowerboundaries)

inline

Sets the data point containing the lower boundaries of possible data values

Definition at line 193 of file BCModel.h.

194 { fDataPointLowerBoundaries = datasetlowerboundaries; }

void BCModel::SetDataPointLowerBoundary	(	int	index,
		double	lowerboundary
	)

Sets the lower boundary of possible data values for a particular variable

Definition at line 546 of file BCModel.cxx.

 {
    fDataPointLowerBoundaries -> SetValue(index, lowerboundary);
 }

void BCModel::SetDataPointUpperBoundaries ( BCDataPoint * datasetupperboundaries)

inline

Sets the data point containing the upper boundaries of possible data values

Definition at line 199 of file BCModel.h.

200 { fDataPointUpperBoundaries = datasetupperboundaries; }

void BCModel::SetDataPointUpperBoundary	(	int	index,
		double	upperboundary
	)

Sets the upper boundary of possible data values for a particular variable

Definition at line 552 of file BCModel.cxx.

 {
    fDataPointUpperBoundaries -> SetValue(index, upperboundary);
 }

void BCModel::SetDataSet ( BCDataSet * dataset)

inline

Sets the data set.

Parameters

dataset A data set

Definition at line 178 of file BCModel.h.

179 { fDataSet = dataset; }

void BCModel::SetGoFNChains ( int n)

inline

Set number of chains in the MCMC of the p-value evaluation using MCMC

Definition at line 466 of file BCModel.h.

467 { fGoFNChains=n; }

void BCModel::SetGoFNIterationsMax ( int n)

inline

Set maximum number of iterations in the MCMC pre-run of the p-value evaluation using MCMC

Definition at line 454 of file BCModel.h.

455 { fGoFNIterationsMax=n; }

void BCModel::SetGoFNIterationsRun ( int n)

inline

Set number of iterations in the MCMC normal run of the p-value evaluation using MCMC

Definition at line 460 of file BCModel.h.

461 { fGoFNIterationsRun=n; }

void BCModel::SetModelAPosterioriProbability ( double probability)

inline

Sets the a posteriori probability for a model.

Parameters

model	The model
probability	The a posteriori probability

Definition at line 159 of file BCModel.h.

160 { fModelAPosteriori = probability; }

void BCModel::SetModelAPrioriProbability ( double probability)

inline

Sets the a priori probability for a model.

Parameters

model	The model
probability	The a priori probability

Definition at line 152 of file BCModel.h.

153 { fModelAPriori = probability; }

void BCModel::SetName ( const char * name)

inline

Sets the name of the model.

Parameters

name	Name of the model

Definition at line 145 of file BCModel.h.

146 { fName = name; }

int BCModel::SetPrior	(	int	index,
		TF1 *	f
	)

Set prior for a parameter.

Parameters

index	The parameter index
f	A pointer to a function describing the prior

Returns: An error code.

Definition at line 558 of file BCModel.cxx.

 {
    // check index range
    if (index < 0 && index >= int(GetNParameters())) {
       BCLog::OutError("BCModel::SetPrior : Index out of range.");
       return 0;
    }
 
    if (fPriorContainer[index])
       delete fPriorContainer[index];
 
    // copy function
    fPriorContainer[index] = new TF1(*f);
 
    fPriorContainerConstant[index] = false;
 
    // no error
    return 1;
 }

int BCModel::SetPrior	(	const char *	name,
		TF1 *	f
	)

Set prior for a parameter.

Parameters

name	The parameter name
f	A pointer to a function describing the prior

Returns: An error code.

Definition at line 579 of file BCModel.cxx.

 {
    // find index
    int index = -1;
    for (unsigned int i = 0; i < GetNParameters(); i++)
       if (name == GetParameter(i)->GetName())
          index = i;
 
    // set prior
    return SetPrior(index, f);
 }

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

Set prior for a parameter.

Parameters

index	parameter index
h	pointer to a histogram describing the prior
flag	whether or not to use linear interpolation

Returns: An error code.

Definition at line 682 of file BCModel.cxx.

 {
    // check index range
    if (index < 0 && index >= int(GetNParameters())) {
       BCLog::OutError("BCModel::SetPrior : Index out of range.");
       return 0;
    }
 
    // if the histogram exists
    if(h) {
 
       // check if histogram is 1d
       if (h->GetDimension() != 1) {
          BCLog::OutError(Form("BCModel::SetPrior : Histogram given for parameter %d is not 1D.",index));
          return 0;
       }
 
       // normalize the histogram
       h->Scale(1./h->Integral("width"));
 
       if(fPriorContainer[index])
          delete fPriorContainer[index];
 
       // set function
       fPriorContainer[index] = new TH1(*h);
 
       if (interpolate)
          fPriorContainerInterpolate[index] = true;
 
       fPriorContainerConstant[index] = false;
    }
 
    // no error
    return 1;
 }

int BCModel::SetPrior	(	const char *	name,
		TH1 *	h,
		bool	flag = `false`
	)

Set prior for a parameter.

Parameters

name	parameter name
h	pointer to a histogram describing the prior
flag	whether or not to use linear interpolation

Returns: An error code.

Definition at line 719 of file BCModel.cxx.

 {
    // find index
    int index = -1;
    for (unsigned int i = 0; i < GetNParameters(); i++)
       if (name == GetParameter(i)->GetName())
          index = i;
 
    // set prior
    return SetPrior(index, h, interpolate);
 }

int BCModel::SetPriorConstant ( int index)

Set constant prior for this parameter

Parameters

index the index of the parameter

Returns: An error code

Definition at line 732 of file BCModel.cxx.

 {
    // check index range
    if (index < 0 && index >= int(GetNParameters())) {
       BCLog::OutError("BCModel::SetPriorConstant : Index out of range.");
       return 0;
    }
 
    if(fPriorContainer[index]) {
       delete fPriorContainer[index];
       fPriorContainer[index] = 0;
    }
 
    // set prior to a constant
    fPriorContainerConstant[index] = true;
 
    // no error
    return 1;
 }

int BCModel::SetPriorConstant ( const char * name)

inline

Set constant prior for this parameter

Parameters

name	the name of the parameter

Returns: An error code

Definition at line 316 of file BCModel.h.

317 { return SetPriorConstant(fParameters.Index(name)); }

int BCModel::SetPriorConstantAll ( )

Enable caching the constant value of the prior, so LogAPrioriProbability is called only once. Note that the prior for ALL parameters is assumed to be constant. The value is computed from the parameter ranges, so make sure these are defined before this method is called.

Returns: An error code

Definition at line 753 of file BCModel.cxx.

 {
    if ( !fParameters.Size())
       BCLog::OutWarning("BCModel::SetPriorConstantAll : No parameters defined.");
 
    // loop over all 1-d priors
    for (unsigned i = 0; i < fParameters.Size(); ++i) {
       if (fPriorContainer[i]) {
          delete fPriorContainer[i];
          fPriorContainer[i]=0;
       }
       fPriorContainerConstant[i] = true;
    }
 
    // no error
    return 1;
 }

int BCModel::SetPriorDelta	(	int	index,
		double	value
	)

Set delta-function prior for a parameter. Note: this sets the parameter range to the specified value. The old parameter range is lost.

Parameters

index	The parameter index
value	The position of the delta function.

Returns: An error code.

Definition at line 592 of file BCModel.cxx.

 {
    // set range to value
    GetParameter(index)->Fix(value);
 
    // set prior
    return 1;
 }

int BCModel::SetPriorDelta	(	const char *	name,
		double	value
	)

Set delta-function prior for a parameter. Note: this sets the parameter range to the specified value. The old parameter range is lost.

Parameters

name	The parameter name
value	The position of the delta function.

Returns: An error code.

Definition at line 602 of file BCModel.cxx.

 {
    fParameters.Get(name)->Fix(value);
 
    return 1;
 }

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

Set Gaussian prior for a parameter.

Parameters

index	The parameter index
mean	The mean of the Gaussian
sigma	The sigma of the Gaussian

Returns: An error code.

Definition at line 610 of file BCModel.cxx.

 {
    // check index range
    if (index < 0 || index >= int(GetNParameters())) {
       BCLog::OutError("BCModel::SetPriorGauss : Index out of range.");
       return 0;
    }
 
    // create new function
    TF1 * f = new TF1(Form("prior_%s", GetParameter(index)->GetName().c_str()),
          "1./sqrt(2.*TMath::Pi())/[1] * exp(- (x-[0])*(x-[0])/2./[1]/[1])",
          GetParameter(index)->GetLowerLimit(),
          GetParameter(index)->GetUpperLimit());
    f->SetParameter(0, mean);
    f->SetParameter(1, sigma);
 
    // set prior
    return SetPrior(index, f);
 }

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

Set Gaussian prior for a parameter.

Parameters

name	The parameter name
mean	The mean of the Gaussian
sigma	The sigma of the Gaussian

Returns: An error code.

Definition at line 631 of file BCModel.cxx.

 {
    // find index
    int index = -1;
    for (unsigned int i = 0; i < GetNParameters(); i++)
       if (name == GetParameter(i)->GetName())
          index = i;
 
    // set prior
    return SetPriorGauss(index, mean, sigma);
 }

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

Set Gaussian prior for a parameter with two different widths.

Parameters

index	The parameter index
mean	The mean of the Gaussian
sigmadown	The sigma (down) of the Gaussian
sigmaup	The sigma (up)of the Gaussian

Returns: An error code.

Definition at line 644 of file BCModel.cxx.

 {
    // check index range
    if (index < 0 || index >= int(GetNParameters())) {
       BCLog::OutError("BCModel::SetPriorGauss : Index out of range.");
       return 0;
    }
 
    // create new function
    TF1 * f = new TF1(Form("prior_%s", GetParameter(index)->GetName().c_str()),
          BCMath::SplitGaussian,
          GetParameter(index)->GetLowerLimit(),
          GetParameter(index)->GetUpperLimit(),
          3);
    f->SetParameter(0, mean);
    f->SetParameter(1, sigmadown);
    f->SetParameter(2, sigmaup);
 
    // set prior
    return SetPrior(index, f);
 
    return 0;
 }

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

Set Gaussian prior for a parameter with two different widths.

Parameters

name	The parameter name
mean	The mean of the Gaussian
sigmadown	The sigma (down) of the Gaussian
sigmaup	The sigma (up)of the Gaussian

Returns: An error code.

Definition at line 669 of file BCModel.cxx.

 {
    // find index
    int index = -1;
    for (unsigned int i = 0; i < GetNParameters(); i++)
       if (name == GetParameter(i)->GetName())
          index = i;
 
    // set prior
    return SetPriorGauss(index, mean, sigmadown, sigmaup);
 }

void BCModel::SetSingleDataPoint ( BCDataPoint * datapoint)

Sets a single data point as data set.

Parameters

datapoint A data point

Definition at line 172 of file BCModel.cxx.

 {
    // create new data set consisting of a single data point
    BCDataSet * dataset = new BCDataSet();
 
    // add the data point
    dataset->AddDataPoint(datapoint);
 
    // set this new data set
    SetDataSet(dataset);
 }

void BCModel::SetSingleDataPoint	(	BCDataSet *	dataset,
		unsigned int	index
	)

Definition at line 185 of file BCModel.cxx.

 {
    if (index > dataset->GetNDataPoints())
       return;
 
    SetSingleDataPoint(dataset->GetDataPoint(index));
 }

BCDataPoint * BCModel::VectorToDataPoint ( const std::vector< double > & data)

private

Converts a vector of doubles into a BCDataPoint

Definition at line 1086 of file BCModel.cxx.

 {
    BCDataPoint * datapoint = new BCDataPoint(data.size());
    datapoint->SetValues(data);
    return datapoint;
 }

Member Data Documentation

double BCModel::fChi2NDoF

protected

Definition at line 538 of file BCModel.h.

std::vector<bool> BCModel::fDataFixedValues

protected

Definition at line 532 of file BCModel.h.

BCDataPoint* BCModel::fDataPointLowerBoundaries

protected

data point containing the lower boundaries of possible data values

Definition at line 526 of file BCModel.h.

BCDataPoint* BCModel::fDataPointUpperBoundaries

protected

data point containing the upper boundaries of possible data values

Definition at line 530 of file BCModel.h.

BCDataSet* BCModel::fDataSet

protected

A data set

Definition at line 522 of file BCModel.h.

int BCModel::fGoFNChains

protected

Number of chains in the MCMC of the p-value evaluation using MCMC

Definition at line 558 of file BCModel.h.

int BCModel::fGoFNIterationsMax

protected

Maximum number of iterations in the MCMC pre-run of the p-value evaluation using MCMC

Definition at line 548 of file BCModel.h.

int BCModel::fGoFNIterationsRun

protected

Number of iterations in the MCMC normal run of the p-value evaluation using MCMC

Definition at line 553 of file BCModel.h.

bool BCModel::flag_discrete

protected

true for a discrete probability, false for continuous pdf

Definition at line 543 of file BCModel.h.

double BCModel::fModelAPosteriori

protected

The model a posteriori probability.

Definition at line 518 of file BCModel.h.

double BCModel::fModelAPriori

protected

The model prior probability.

Definition at line 514 of file BCModel.h.

std::string BCModel::fName

protected

Name of the model.

Definition at line 510 of file BCModel.h.

bool BCModel::fPriorConstantAll

protected

Flag to indicate that all parameters have constant prior.

Definition at line 566 of file BCModel.h.

std::vector<TNamed*> BCModel::fPriorContainer

protected

A vector of prior functions/histograms/graphs.

Definition at line 562 of file BCModel.h.

std::vector<bool> BCModel::fPriorContainerConstant

protected

List the parameters whose prior is constant

Definition at line 570 of file BCModel.h.

std::vector<bool> BCModel::fPriorContainerInterpolate

protected

List the parameters for which the histogram prior should be interpolated

Definition at line 574 of file BCModel.h.

double BCModel::fPValue

protected

The p-value

Definition at line 536 of file BCModel.h.

double BCModel::fPValueNDoF

protected

Definition at line 539 of file BCModel.h.

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

Public Member Functions

Protected Attributes

Private Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation