#include <BCRooInterface.h>

Inheritance diagram for BCRooInterface:

Collaboration diagram for BCRooInterface:

Public Member Functions
	BCRooInterface (const char *name="", bool fillChain=false)

	~BCRooInterface ()

void	DefineParameters ()

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

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

void	Initialize (RooAbsData &data, RooAbsPdf &model, RooAbsPdf &prior, const RooArgSet *params, const RooArgSet &listPOI)

void	Initialize (const char rootFile, const char wsName="batWS", const char dataName="data", const char modelName="model", const char priorName="priorPOI", const char priorNuisanceName="priorNuisance", const char paramsName="parameters", const char listPOIName="POI")

void	SetNumBins (const char *parname, int nbins)

void	SetNumBins (int nbins)

void	SetupRooStatsMarkovChain ()

void	MCMCIterationInterface ()

RooStats::MarkovChain *	GetRooStatsMarkovChain ()

RooArgSet *	GetArgSetForMarkovChain ()

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

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

Private Member Functions
void	AddToCurrentChainElement (double xij, int chainNum, int poiNum)

bool	EqualsLastChainElement (int chainNum)

double	GetWeightForChain (int chainNum)

Private Attributes
RooAbsData *	fData

RooAbsPdf *	fModel

RooAbsReal *	fNll

RooArgSet *	fObservables

RooArgList *	fParams

RooArgList *	fParamsPOI

RooAbsPdf *	fPrior

int	_default_nbins

RooRealVar *	priorhelpvar

bool	_addeddummyprior

bool	_fillChain

bool	fFirstComparison

RooStats::MarkovChain *	_roostatsMarkovChain

RooArgSet	_parametersForMarkovChainPrevious

RooArgSet	_parametersForMarkovChainCurrent

std::vector< std::vector < double > >	fPreviousStep

std::vector< std::vector < double > >	fCurrentStep

std::vector< double >	fVecWeights

std::list< std::pair< const char *, int > >	_nbins_list

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

Definition at line 23 of file BCRooInterface.h.

Constructor & Destructor Documentation

BCRooInterface::BCRooInterface	(	const char *	name = `""`,
		bool	fillChain = `false`
	)

Definition at line 144 of file BCRooInterface.cxx.

                                                                :
       BCModel(name),
       fData(NULL),
       fModel(NULL),
       fNll(NULL),
       fObservables(NULL),
       fParams(NULL),
       fParamsPOI(NULL),
       fPrior(NULL),
       _default_nbins(150),
       priorhelpvar(NULL),
       _addeddummyprior(false),
       _fillChain(fillChain),
       fFirstComparison(false),
       _roostatsMarkovChain(NULL)
 {
    // todo this interface not ready for grid marginalization yet
    SetMarginalizationMethod(BCIntegrate::kMargMetropolis);
 }

BCRooInterface::~BCRooInterface ( )

Definition at line 165 of file BCRooInterface.cxx.

 {  // default destructor
    if(_fillChain) {
       delete _roostatsMarkovChain;
    }
 }

Member Function Documentation

void BCRooInterface::AddToCurrentChainElement	(	double	xij,
		int	chainNum,
		int	poiNum
	)

private

Definition at line 355 of file BCRooInterface.cxx.

 {
    fCurrentStep[chainNum][poiNum] = xij;
 }

void BCRooInterface::DefineParameters ( )

Definition at line 173 of file BCRooInterface.cxx.

 {  // define for BAT the list of parameters, range and plot binning
 
    int nParams = fParams->getSize();
    for (int iParam=0; iParam<nParams; iParam++) {
       RooRealVar* ipar = (RooRealVar*) fParams->at(iParam);
       BCParameter * bcpar = new BCParameter(ipar->GetName(),ipar->getMin(),ipar->getMax());
       bcpar->SetNbins(_default_nbins);
       this->AddParameter(bcpar);
       std::cout << "added parameter: " << bcpar->GetName() << " defined in range [ " << bcpar->GetLowerLimit() << " - "
             << bcpar->GetUpperLimit() << " ] with number of bins: " << bcpar->GetNbins() << " \n";
    }
 
    for(std::list< std::pair<const char*,int> >::iterator listiter = _nbins_list.begin(); listiter != _nbins_list.end(); listiter++) {
       GetParameter((*listiter).first)->SetNbins((*listiter).second);
       std::cout << "adjusted parameter: " << (*listiter).first << " to number of bins: " << (*listiter).second << " \n";
    }
 }

bool BCRooInterface::EqualsLastChainElement ( int chainNum)

private

Definition at line 360 of file BCRooInterface.cxx.

 {
    bool equals = true;
     std::vector<double>::iterator itPrevious = fPreviousStep[chainNum].begin();
 
    if(fFirstComparison == true) {
       fFirstComparison = false;
       _parametersForMarkovChainPrevious = _parametersForMarkovChainCurrent;
       return true;
    }
 
 
    for (std::vector<double>::iterator itCurrent = fCurrentStep[chainNum].begin(); itCurrent != fCurrentStep[chainNum].end(); ++itCurrent) {
       if(*itCurrent != *itPrevious) {
          equals = false;
          fPreviousStep[chainNum] = fCurrentStep[chainNum];
          break;
       }
    ++itPrevious;
    }
 
    if(equals == true) {
       fVecWeights[chainNum] += 1.0;
    }
 
    return equals;
 
 }

RooArgSet* BCRooInterface::GetArgSetForMarkovChain ( )

inline

Definition at line 63 of file BCRooInterface.h.

63 {return &_parametersForMarkovChainCurrent;}

RooStats::MarkovChain* BCRooInterface::GetRooStatsMarkovChain ( )

inline

Definition at line 62 of file BCRooInterface.h.

62 { return _roostatsMarkovChain;}

double BCRooInterface::GetWeightForChain ( int chainNum)

private

Definition at line 389 of file BCRooInterface.cxx.

 {
    double retval = fVecWeights[chainNum];
    fVecWeights[chainNum]= 1.0 ;
    return retval;
 }

void BCRooInterface::Initialize	(	RooAbsData &	data,
		RooAbsPdf &	model,
		RooAbsPdf &	prior,
		const RooArgSet *	params,
		const RooArgSet &	listPOI
	)

Definition at line 20 of file BCRooInterface.cxx.

 {
 
    fData = &data;
    fModel = &model;
 
    // make the product of both priors to get the full prior probability function
    RooAbsPdf* prior_total = &prior_trans;
    if (prior_total!=0 ) {
       fPrior = prior_total;
    }
    else {
       std::cout << "No prior PDF: without taking action the program would crash\n";
       std::cout << "No prior PDF: adding dummy uniform pdf on the interval [0..1]\n";
       priorhelpvar = new RooRealVar("priorhelpvar","",0.0, 1.0 );
       _addeddummyprior = true;
       RooUniform* priorhelpdist = new RooUniform("priorhelpdist","", *priorhelpvar);
       fPrior = priorhelpdist;
    }
 
    std::cout << "Imported parameters:\n";
    fParams = new RooArgList(listPOI);
    const RooArgSet* paramsTmp = params;
    if (paramsTmp!=0)
       fParams->add(*paramsTmp);
    fParams->Print("v");
 
    fParamsPOI = new RooArgList(listPOI);
    // create the log-likelihood function
    //    fNll = new RooNLLVar("fNll","",*fModel,*fData,true/*extended*/);
 
    RooArgSet* constrainedParams = fModel->getParameters(*fData);
    fNll = fModel->createNLL(*fData, RooFit::Constrain(*constrainedParams) );
 
    DefineParameters();
 
    if(_fillChain) {
       SetupRooStatsMarkovChain();
    }
 }

void BCRooInterface::Initialize	(	const char *	rootFile,
		const char *	wsName = `"batWS"`,
		const char *	dataName = `"data"`,
		const char *	modelName = `"model"`,
		const char *	priorName = `"priorPOI"`,
		const char *	priorNuisanceName = `"priorNuisance"`,
		const char *	paramsName = `"parameters"`,
		const char *	listPOIName = `"POI"`
	)

Definition at line 67 of file BCRooInterface.cxx.

 {
    // retrieve the RooFit inputs from the ROOT file
 
    /*
    // hard coded names in the workspace
    char* rootFile = "bat_workspace.root";
    char* wsName= "batWS";
    char* dataName= "data";
    char* modelName= "model";
    char* priorName= "priorPOI";
    char* priorNuisanceName= "priorNuisance";
    char* paramsName= "parameters";
    char* listPOIName= "POI";
    */
 
    std::cout << "Opening " << rootFile << std::endl;
    TFile* file = TFile::Open(rootFile);
    std::cout << "content :\n";
    file->ls();
 
    RooWorkspace* bat_ws = (RooWorkspace*) file->Get(wsName);
    bat_ws->Print("v");
 
    fData = (RooAbsData*) bat_ws->data(dataName);
    fModel = (RooAbsPdf*) bat_ws->function(modelName);
 
    // make the product of both priors to get the full prior probability function
    RooAbsPdf* priorPOI = (RooAbsPdf*) bat_ws->function(priorName);
    RooAbsPdf* priorNuisance = (RooAbsPdf*) bat_ws->pdf(priorNuisanceName);
    if (priorNuisance!=0 && priorPOI!=0) {
       fPrior = new RooProdPdf("fPrior","complete prior",*priorPOI,*priorNuisance);
    }
    else {
       if ( priorNuisance!=0 )
          fPrior=priorNuisance;
       else if ( priorPOI!=0 )
          fPrior = priorPOI;
       else{
          std::cout << "No prior PDF: without taking action the program would crash\n";
          std::cout << "No prior PDF: adding dummy uniform pdf on the interval [0..1]\n";
          priorhelpvar = new RooRealVar("priorhelpvar","",0.0, 1.0 );
          _addeddummyprior = true;
          RooUniform* priorhelpdist = new RooUniform("priorhelpdist","", *priorhelpvar);
          fPrior = priorhelpdist;
       }
    }
 
    std::cout << "Imported parameters:\n";
    fParams   = new RooArgList(*(bat_ws->set(listPOIName)));
    RooArgSet* paramsTmp = (RooArgSet*) bat_ws->set(paramsName);
    if (paramsTmp!=0) {
       fParams->add(*paramsTmp);
    }
    if (_addeddummyprior == true ) {
       fParams->add(*priorhelpvar);
    }
    fParams->Print("v");
 
    // create the log-likelihood function
    //fNll = new RooNLLVar("fNll","",*fModel,*fData,true/*extended*/);
    RooArgSet* constrainedParams = fModel->getParameters(*fData);
    fNll = fModel->createNLL(*fData, RooFit::Constrain(*constrainedParams) );
 
    file->Close();
 
    DefineParameters();
 }

double BCRooInterface::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 from BCModel.

Definition at line 209 of file BCRooInterface.cxx.

 {  // this method returs the logarithm of the prior probability for the parameters: p(parameters).
    // retrieve the values of the parameters to be tested
    int nParams = fParams->getSize();
    for (int iParam=0; iParam<nParams; iParam++) {
       RooRealVar* ipar = (RooRealVar*) fParams->at(iParam);
       ipar->setVal(parameters.at(iParam));
    }
    // compute the log of the prior function
    RooArgSet* tmpArgSet = new RooArgSet(*fParams);
    double prob = fPrior->getVal(tmpArgSet);
    delete tmpArgSet;
    if (prob<1e-300)
       prob = 1e-300;
    return log(prob);
 }

double BCRooInterface::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 193 of file BCRooInterface.cxx.

 {  // this methods returns the logarithm of the conditional probability: p(data|parameters)
 
    // retrieve the values of the parameters to be tested
    int nParams = fParams->getSize();
    for (int iParam=0; iParam<nParams; iParam++) {
       RooRealVar* ipar = (RooRealVar*) fParams->at(iParam);
       ipar->setVal(parameters.at(iParam));
    }
 
    // compute the log of the likelihood function
    double logprob = -fNll->getVal();
    return logprob;
 }

void BCRooInterface::MCMCIterationInterface ( )

virtual

Interface allowing to execute arbitrary code for each iteration of the MCMC. The frequency of calling this method is influenced by the setup of the Lag and whether or not the MCMC is run with ordered parameters. This method needs to be overloaded in the derived class.

Reimplemented from BCEngineMCMC.

Definition at line 294 of file BCRooInterface.cxx.

 {
    //fIterationInterfacecount+=1;
 
    if(_fillChain) {
       //std::cout << "Hei-ho running with fillChain!" << std::endl;
       // get number of chains
       int nchains = MCMCGetNChains();
 
       // get number of parameters
       int npar = GetNParameters();
       //std::cout << "number of parameters is: " << npar << std::endl;
 
       // loop over all chains and fill histogram
       for (int i = 0; i < nchains; ++i) {
          // get the current values of the parameters. These are
          // stored in fMCMCx.
 
          // std::cout << "log(likelihood*prior)" << *GetMarkovChainValue() << std::endl; //does not work this way?!
          TIterator* setiter = fParams->createIterator();
          int j = 0;
 
          //store only POI in RooStats MarkovChain object
          //TIterator* setiter = fParamsPOI->createIterator();
          //int j = 0;
 
          while(setiter->Next()){
 
             //check parameter names
             const BCParameter * tempBCparam = GetParameter(j);
 
             //_parametersForMarkovChainCurrent->Print();
 
             const char * paramnamepointer = (tempBCparam->GetName()).c_str();
             double xij = fMCMCx.at(i * npar + j);
             AddToCurrentChainElement(xij, i, j);
             RooRealVar* parampointer = (RooRealVar*) &(_parametersForMarkovChainCurrent[paramnamepointer]);
             parampointer->setVal(xij);
             //std::cout << "Chain " << i << " param: " << tempBCparam->GetName() << " Value: " << xij << std::endl;
             j++;
          }
 
 
          // will only work if _parametersForMarkovChain had correct info!
 
          //test stuff begin
          //var1->setVal( RooRandom::randomGenerator()->Uniform(100.) );
          //
          //_roostatsMarkovChain->Add(_parametersForMarkovChain_test, 0.001, 1.0);
          //
          //test stuff end
 
          if( !(EqualsLastChainElement(i)) ) {
             double weight = GetWeightForChain(i);
             _roostatsMarkovChain->Add(_parametersForMarkovChainPrevious, -1.* MCMCGetLogProbx(j), weight);
             _parametersForMarkovChainPrevious = _parametersForMarkovChainCurrent;
          }
       }
    }
 }

void BCRooInterface::SetNumBins	(	const char *	parname,
		int	nbins
	)

Definition at line 226 of file BCRooInterface.cxx.

 {
    for(std::list< std::pair<const char*,int> >::iterator listiter = _nbins_list.begin(); listiter != _nbins_list.end(); listiter++) {
       if(!strcmp((*listiter).first, parname)) {
          (*listiter).second = nbins;
          return;
       }
    }
    _nbins_list.push_back( std::make_pair(parname,nbins) );
 }

void BCRooInterface::SetNumBins ( int nbins)

Definition at line 237 of file BCRooInterface.cxx.

 {
    _default_nbins = nbins;
 }

void BCRooInterface::SetupRooStatsMarkovChain ( )

Definition at line 242 of file BCRooInterface.cxx.

 {
    //RooArgSet * tempRooArgSetPointer = new RooArgSet(* fParams, "paramsMarkovChainPointer");
    //_parametersForMarkovChain = RooArgSet(* fParams, "paramsMarkovChainPointer");
    //fParams->snapshot(_parametersForMarkovChain);
 
    //store only POI in RooStats MarkovChain object
    //_parametersForMarkovChainPrevious.add(*fParamsPOI);
    //_parametersForMarkovChainCurrent.add(*fParamsPOI);
 
    _parametersForMarkovChainPrevious.add(*fParams);
    _parametersForMarkovChainCurrent.add(*fParams);
 
    std::cout << "size of _parametersForMarkovChain: " << _parametersForMarkovChainCurrent.getSize() << std::endl;
    std::cout << "size of fParamsPOI: " << fParamsPOI->getSize() << std::endl;
    //std::cout << "size of tempRooArgSetPointer: " << tempRooArgSetPointer->getSize() << std::endl;
 
    _roostatsMarkovChain = new RooStats::MarkovChain();
    //test stuff begin
    //the following way of creating the MArkovChain object does not work!:
    //_roostatsMarkovChain = new RooStats::MarkovChain(_parametersForMarkovChain);
    //test stuff end
    std::cout << "setting up parameters for RooStats markov chain" << std::endl;
    _parametersForMarkovChainPrevious.writeToStream(std::cout, false);
 
    //initialize fPreviousStep, fCurrentStep, fVecWeights
    int nchains = MCMCGetNChains();
    for(int countChains = 1; countChains<=nchains ; countChains++ ) {
       double tempweight = 1.0;
       fVecWeights.push_back(tempweight);
          std::vector<double> tempvec;
       TIterator* setiter = fParamsPOI->createIterator();
       double tempval = 0.;
       while(setiter->Next()){
          tempvec.push_back(tempval);
       }
       fPreviousStep.push_back(tempvec);
       fCurrentStep.push_back(tempvec);
    }
 
    fFirstComparison = true;
 
    //test stuff begin
    //var1 = new RooRealVar("var1","var1", 10., 0., 100.);
    //fParamsTest   = new RooArgList();
    //fParamsTest->add(*var1);
    //_parametersForMarkovChain_test.add(*fParamsTest);
    //fIterationInterfacecount = 0;
    //test stuff end
 }

Member Data Documentation

bool BCRooInterface::_addeddummyprior

private

Definition at line 83 of file BCRooInterface.h.

int BCRooInterface::_default_nbins

private

Definition at line 80 of file BCRooInterface.h.

bool BCRooInterface::_fillChain

private

Definition at line 85 of file BCRooInterface.h.

std::list< std::pair<const char*,int> > BCRooInterface::_nbins_list

private

Definition at line 95 of file BCRooInterface.h.

RooArgSet BCRooInterface::_parametersForMarkovChainCurrent

private

Definition at line 89 of file BCRooInterface.h.

RooArgSet BCRooInterface::_parametersForMarkovChainPrevious

private

Definition at line 88 of file BCRooInterface.h.

RooStats::MarkovChain* BCRooInterface::_roostatsMarkovChain

private

Definition at line 87 of file BCRooInterface.h.

std::vector< std::vector<double> > BCRooInterface::fCurrentStep

private

Definition at line 92 of file BCRooInterface.h.

RooAbsData* BCRooInterface::fData

private

Definition at line 73 of file BCRooInterface.h.

bool BCRooInterface::fFirstComparison

private

Definition at line 86 of file BCRooInterface.h.

RooAbsPdf* BCRooInterface::fModel

private

Definition at line 74 of file BCRooInterface.h.

RooAbsReal* BCRooInterface::fNll

private

Definition at line 75 of file BCRooInterface.h.

RooArgSet* BCRooInterface::fObservables

private

Definition at line 76 of file BCRooInterface.h.

RooArgList* BCRooInterface::fParams

private

Definition at line 77 of file BCRooInterface.h.

RooArgList* BCRooInterface::fParamsPOI

private

Definition at line 78 of file BCRooInterface.h.

std::vector< std::vector<double> > BCRooInterface::fPreviousStep

private

Definition at line 91 of file BCRooInterface.h.

RooAbsPdf* BCRooInterface::fPrior

private

Definition at line 79 of file BCRooInterface.h.

std::vector< double > BCRooInterface::fVecWeights

private

Definition at line 93 of file BCRooInterface.h.

RooRealVar* BCRooInterface::priorhelpvar

private

Definition at line 82 of file BCRooInterface.h.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation