The class for testing model hypotheses. More...

#include <BCGoFTest.h>

Inheritance diagram for BCGoFTest:

Collaboration diagram for BCGoFTest:

Public Member Functions
Constructors and destructors
	BCGoFTest (const char *name)

	~BCGoFTest ()

Member functions (get)
double	GetCalculatedPValue (bool flag_histogram=false)

TH1D *	GetHistogramLogProb ()

BCModel *	GetTestModel ()

Member functions (set)
void	SetTestModel (BCModel *testmodel)

int	SetTestPoint (std::vector< double > parameters)

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

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

void	MCMCUserIterationInterface ()

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	Likelihood (const std::vector< double > &params)

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

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

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

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

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

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

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

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

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

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

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

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

double	GetPValue ()

double	GetPValueNDoF ()

double	GetChi2NDoF ()

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

void	SetGoFNIterationsMax (int n)

void	SetGoFNIterationsRun (int n)

void	SetGoFNChains (int n)

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

void	PrintSummary ()

void	PrintResults (const char *file)

void	PrintShortFitSummary (int chi2flag=0)

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

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

Public Member Functions inherited from BCIntegrate
	BCIntegrate ()

	BCIntegrate (const BCIntegrate &bcintegrate)

virtual	~BCIntegrate ()

BCIntegrate &	operator= (const BCIntegrate &bcintegrate)

int	ReadMarginalizedFromFile (const char *file)

BCH1D *	GetMarginalized (const BCParameter *parameter)

BCH1D *	GetMarginalized (const char *name)

BCH1D *	GetMarginalized (unsigned index)

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

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

BCH2D *	GetMarginalized (unsigned index1, unsigned index2)

int	PrintAllMarginalized1D (const char *filebase)

int	PrintAllMarginalized2D (const char *filebase)

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

double	GetIntegral () const

BCIntegrate::BCOptimizationMethod	GetOptimizationMethod () const

BCIntegrate::BCIntegrationMethod	GetIntegrationMethod () const

BCIntegrate::BCMarginalizationMethod	GetMarginalizationMethod () const

BCIntegrate::BCSASchedule	GetSASchedule () const

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

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

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

int	GetNIterationsMin () const

int	GetNIterationsMax () const

int	GetNIterationsPrecisionCheck () const

int	GetNIterationsOutput () const

int	GetNIterations () const

double	GetRelativePrecision () const

double	GetAbsolutePrecision () const

BCCubaMethod	GetCubaIntegrationMethod () const

const BCCubaOptions::Vegas &	GetCubaVegasOptions () const

const BCCubaOptions::Suave &	GetCubaSuaveOptions () const

const BCCubaOptions::Divonne &	GetCubaDivonneOptions () const

const BCCubaOptions::Cuhre &	GetCubaCuhreOptions () const

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

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

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

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

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

double	GetError () const

TMinuit *	GetMinuit ()

int	GetMinuitErrorFlag () const

double	GetSAT0 () const

double	GetSATmin () const

double	GetBestFitParameter (unsigned index) const

double	GetBestFitParameterError (unsigned index) const

double	GetLogMaximum ()

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

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

void	SetMinuitArlist (double *arglist)

void	SetFlagIgnorePrevOptimization (bool flag)

void	SetOptimizationMethod (BCIntegrate::BCOptimizationMethod method)

void	SetIntegrationMethod (BCIntegrate::BCIntegrationMethod method)

void	SetMarginalizationMethod (BCIntegrate::BCMarginalizationMethod method)

void	SetSASchedule (BCIntegrate::BCSASchedule schedule)

void	SetNIterationsMin (int niterations)

void	SetNIterationsMax (int niterations)

void	SetNIterationsPrecisionCheck (int niterations)

void	SetNIterationsOutput (int niterations)

void	SetRelativePrecision (double relprecision)

void	SetAbsolutePrecision (double absprecision)

void	SetCubaIntegrationMethod (BCCubaMethod type)

void	SetCubaOptions (const BCCubaOptions::Vegas &options)

void	SetCubaOptions (const BCCubaOptions::Suave &options)

void	SetCubaOptions (const BCCubaOptions::Divonne &options)

void	SetCubaOptions (const BCCubaOptions::Cuhre &options)

void	SetSAT0 (double T0)

void	SetSATmin (double Tmin)

void	SetFlagWriteSAToFile (bool flag)

TTree *	GetSATree ()

void	InitializeSATree ()

double	Normalize ()

double	Integrate (BCIntegrationMethod intmethod)

double	Integrate ()

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

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

int	MarginalizeAll ()

int	MarginalizeAll (BCMarginalizationMethod margmethod)

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	MCMCCurrentPointInterface (std::vector< double > &, int, bool)

Private Attributes
std::vector< int >	fMapDataPoint

std::vector< int >	fMapDataValue

int	fPValueBelow

int	fPValueAbove

BCModel *	fTestModel

BCDataSet *	fTemporaryDataSet

double	fLogLikelihood

double	fLogLikelihoodMin

double	fLogLikelihoodMax

TH1D *	fHistogramLogProb

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 BCModel
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

Detailed Description

The class for testing model hypotheses.

Author: Daniel Kollar; Kevin Kröninger

Version: 1.0

Date: 08.2008 This class is used for calculating the p-value of a model.

Definition at line 34 of file BCGoFTest.h.

Constructor & Destructor Documentation

BCGoFTest::BCGoFTest ( const char * name)

Default constructor.

Definition at line 23 of file BCGoFTest.cxx.

                                      : BCModel(name)
 {
    // set original data set to zero
    fTemporaryDataSet = 0;
 
    // set test mode to zero
    fTestModel = 0;
 
    // reset pvalue and counter
    fPValue = 0;
    fPValueAbove = 0;
    fPValueBelow = 0;
 
    // reset loglikelihood and range
    fLogLikelihood = 0;
    fLogLikelihoodMin = 1e99;
    fLogLikelihoodMax = -1e99;
 
    // define new histogram
    fHistogramLogProb = 0;
 
    // set defaults for the MCMC
    MCMCSetNChains(5);
    MCMCSetNIterationsMax(100000);
    MCMCSetNIterationsRun(2000);
 }

BCGoFTest::~BCGoFTest ( )

Default destructor.

Definition at line 52 of file BCGoFTest.cxx.

 {
    // restore original data set
 
    // get number of data points and values
    int ndatapoints = fTemporaryDataSet->GetNDataPoints();
    int ndatavalues = fTemporaryDataSet->GetDataPoint(0)->GetNValues();
 
    for (int i = 0; i < ndatapoints; ++i)
       for (int j = 0; j < ndatavalues; ++j)
          fTestModel->GetDataSet()->GetDataPoint(i)->SetValue(j, fTemporaryDataSet->GetDataPoint(i)->GetValue(j));
 
    // restore data point limits
    for (unsigned int i = 0; i < GetNParameters(); ++i)
       fTestModel->SetDataBoundaries(
             fMapDataValue[i],
             GetParameter(i)->GetLowerLimit(),
             GetParameter(i)->GetUpperLimit());
 
    // delete temporary data set
    delete fTemporaryDataSet;
 }

Member Function Documentation

double BCGoFTest::GetCalculatedPValue ( bool flag_histogram = false)

Calculated the p-value.

Parameters

flag_histogram A histogram is either filled or not.

Returns: p-value

Definition at line 227 of file BCGoFTest.cxx.

 {
    // set histogram point to null
    fHistogramLogProb = 0;
 
    if (flag_histogram)
    {
       // perform first run to obtain limits for the log(likelihood)
       MarginalizeAll();
 
       // create histogram
       double D = fLogLikelihoodMax - fLogLikelihoodMin;
       fHistogramLogProb = new TH1D(Form("hist_%s_logprob", GetName().data()), ";ln(prob);N", 100, fLogLikelihoodMin - 0.1*D, fLogLikelihoodMax + 0.1*D);
       fHistogramLogProb->SetStats(kFALSE);
    }
    else
    {
    }
 
    // run MCMC
    MarginalizeAll();
 
    // check for convergence
    if (MCMCGetNIterationsConvergenceGlobal() < 0.)
    {
       BCLog::OutDetail(" --> MCMC did not converge in evaluation of the p-value.");
       return -1;
    }
 
    // calculate p-value
    fPValue = double(fPValueBelow) / double(fPValueBelow + fPValueAbove);
 
    // return p-value
    return fPValue;
 }

TH1D* BCGoFTest::GetHistogramLogProb ( )

inline

Returns: distribution of log(likelihood)

Definition at line 62 of file BCGoFTest.h.

63 { return fHistogramLogProb; };

BCModel* BCGoFTest::GetTestModel ( )

inline

Returns: pointer to the tested model

Definition at line 67 of file BCGoFTest.h.

68 { return fTestModel; };

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

inlinevirtual

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 from BCModel.

Definition at line 92 of file BCGoFTest.h.

93 { return 0; };

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

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

Implements BCModel.

Definition at line 77 of file BCGoFTest.cxx.

 {
    // set the original data set to the new parameters
    for (int i = 0; i < int(parameters.size()); ++i)
       fTestModel->GetDataSet()->GetDataPoint(fMapDataPoint[i])->SetValue(fMapDataValue[i], parameters.at(i));
 
    // calculate likelihood at the point of the original parameters
    double loglikelihood = fTestModel->LogLikelihood(fDataSet->GetDataPoint(0)->GetValues());
 
    // return likelihood
    return loglikelihood;
 }

void BCGoFTest::MCMCUserIterationInterface ( )

virtual

Method executed for every iteration of the MCMC. User's code should be provided via overloading in the derived class

Reimplemented from BCEngineMCMC.

Definition at line 92 of file BCGoFTest.cxx.

 {
    int nchains = MCMCGetNChains();
 
    for (int i = 0; i < nchains; ++i)
    {
       // get likelihood at the point of the original parameters
       double loglikelihood = MCMCGetLogProbx(i);
 
       // calculate pvalue
       if (loglikelihood < fLogLikelihood)
          fPValueBelow++;
       else
          fPValueAbove++;
 
       // if histogram exists already, then fill it ...
       if (fHistogramLogProb)
          fHistogramLogProb->Fill(loglikelihood);
       // ...otherwise find range
       else
       {
          if (loglikelihood > fLogLikelihoodMax)
             fLogLikelihoodMax = loglikelihood;
          else if (loglikelihood < fLogLikelihoodMin)
             fLogLikelihoodMin = loglikelihood;
       }
    }
 }

void BCGoFTest::SetTestModel ( BCModel * testmodel)

inline

Set the model to be tested.

Parameters

testmodel pointer to the model to be tested

Definition at line 77 of file BCGoFTest.h.

78 { fTestModel = testmodel; };

int BCGoFTest::SetTestPoint ( std::vector< double > parameters)

Sets the set of parameters which the p-values is calculated for.

Parameters

parameters parameters

Returns: error code

Definition at line 123 of file BCGoFTest.cxx.

 {
    // check if the boundaries of the original data set exist.
    if (!fTestModel->GetFlagBoundaries())
    {
       BCLog::OutError("BCGoFTest::SetTestDataPoint : Boundaries of the original data set are not defined.");
       return 0;
    }
 
    // reset histogram
    if (fHistogramLogProb)
    {
       delete fHistogramLogProb;
       fHistogramLogProb = 0;
    }
 
    // reset variables
    fPValue = 0;
    fPValueAbove = 0;
    fPValueBelow = 0;
 
    // create temporary data set ...
    fTemporaryDataSet = new BCDataSet();
 
    // ... and fill with the original one
 
    // get number of data points and values
    int ndatapoints = fTestModel->GetDataSet()->GetNDataPoints();
    int ndatavalues = fTestModel->GetDataSet()->GetDataPoint(0)->GetNValues();
 
    for (int i = 0; i < ndatapoints; ++i)
    {
       BCDataPoint * dp = new BCDataPoint(fTestModel->GetDataSet()->GetDataPoint(i)->GetValues());
       fTemporaryDataSet->AddDataPoint(dp);
    }
 
    // clear maps
    fMapDataPoint.clear();
    fMapDataValue.clear();
 
    int counter = 0;
 
    // remove parameters, but doesn't clear up memory
    fParameters = BCParameterSet();
 
    // loop through data points and values
    for (int i = 0; i < ndatapoints; ++i)
       for (int j = 0; j < ndatavalues; ++j)
       {
         // debugKK
         // needs to be fixed
         //         if (fTestModel->GetFixedDataAxis(j))
         //            continue;
 
          // add parameter to this model
          std::string parName = Form("parameter_%i", counter);
          AddParameter(
                parName.c_str(),
                fTestModel->GetDataPointLowerBoundary(j),
                fTestModel->GetDataPointUpperBoundary(j));
 
          // add another element to the maps
          fMapDataPoint.push_back(i);
          fMapDataValue.push_back(j);
 
          // increase counter
          counter ++;
       }
 
    // check if there are any non-fixed data values left
    if (counter == 0)
    {
       BCLog::OutError("BCGoFTest::SetTestDataPoint : No non-fixed data values left.");
       return 0;
    }
 
    // create a new data set containing the vector of parameters which
    // are to be tested
    BCDataPoint * datapoint = new BCDataPoint(parameters);
    BCDataSet * dataset = new BCDataSet();
    dataset->AddDataPoint(datapoint);
 
    // calculate likelihood of the original data set
    fLogLikelihood = fTestModel->LogLikelihood(parameters);
 
    // if data set has been set before, delete
    if (fDataSet)
       delete fDataSet;
 
    // set data set of this model
    fDataSet = dataset;
 
    // put proper range to new data set
    for (int i = 0; i < int(parameters.size()); ++i)
       SetDataBoundaries(
             i,
             fTestModel->GetParameter(i)->GetLowerLimit(),
             fTestModel->GetParameter(i)->GetUpperLimit());
 
    return 1;
 }

Member Data Documentation

TH1D* BCGoFTest::fHistogramLogProb

private

The distribution of log(likelihood).

Definition at line 127 of file BCGoFTest.h.

double BCGoFTest::fLogLikelihood

private

The log(likelihood) and its range.

Definition at line 121 of file BCGoFTest.h.

double BCGoFTest::fLogLikelihoodMax

private

Definition at line 123 of file BCGoFTest.h.

double BCGoFTest::fLogLikelihoodMin

private

Definition at line 122 of file BCGoFTest.h.

std::vector<int> BCGoFTest::fMapDataPoint

private

A map of data points and data values.

Definition at line 103 of file BCGoFTest.h.

std::vector<int> BCGoFTest::fMapDataValue

private

Definition at line 104 of file BCGoFTest.h.

int BCGoFTest::fPValueAbove

private

Definition at line 109 of file BCGoFTest.h.

int BCGoFTest::fPValueBelow

private

Counter for the evaluation of the p-value.

Definition at line 108 of file BCGoFTest.h.

BCDataSet* BCGoFTest::fTemporaryDataSet

private

A data set used for temporary storage.

Definition at line 117 of file BCGoFTest.h.

BCModel* BCGoFTest::fTestModel

private

A pointer to the model which is tested.

Definition at line 113 of file BCGoFTest.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