#include <BCMVCombination.h>

Inheritance diagram for BCMVCombination:

Collaboration diagram for BCMVCombination:

Classes
struct	NuisanceParameter

Public Member Functions
	BCMVCombination ()

	~BCMVCombination ()

void	AddObservable (std::string name, double min, double max)

void	AddUncertainty (std::string name)

void	AddMeasurement (std::string name, std::string observable, double value, std::vector< double > uncertainties)

int	GetNObservables ()

int	GetNUncertainties ()

int	GetNMeasurements ()

int	GetNActiveMeasurements ()

BCMVCUncertainty *	GetUncertainty (int index)

BCMVCMeasurement *	GetMeasurement (int index)

TMatrixD	GetCovarianceMatrix ()

TMatrixD	GetBLUEWeights ()

TVectorD	GetBLUECentralValues ()

TVectorD	GetBLUEUncertainties ()

TVectorD	GetBLUEUncertainties (int index)

TMatrixD	GetBLUECovarianceMatrix ()

TMatrixD	GetBLUECovarianceMatrix (int index)

TMatrixD	GetBLUECorrelationMatrix (int index)

TMatrixD	GetBLUECorrelationMatrix ()

std::vector< int >	GetVectorObservable ()

TVectorD	GetVectorMeasurements ()

int	GetIndexMeasurement (std::string measurement, std::string observable)

int	GetIndexUncertainty (std::string name)

int	GetIndexObservable (std::string name)

int	ReadInput (std::string filename)

void	CalculateCorrelationMatrix (int index)

void	CalculateCovarianceMatrix (std::vector< double > nuisance=std::vector< double >(0))

void	CalculateHelperVectors ()

bool	PositiveDefinite ()

void	CalculateBLUE ()

void	PrepareAnalysis ()

void	PrintBLUEResults (std::string filename)

void	PrintMatrix (TMatrixT< double > &matrix, std::string name="matrix")

void	PrintVector (TVectorD &vector, std::string name="vector")

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

Public Member Functions inherited from BCModel
	BCModel (const char *name="model")

	BCModel (const BCModel &bcmodel)

virtual	~BCModel ()

BCModel &	operator= (const BCModel &bcmodel)

const std::string &	GetName () const

double	GetModelAPrioriProbability () const

double	GetModelAPosterioriProbability () const

BCDataSet *	GetDataSet () const

BCDataPoint *	GetDataPointLowerBoundaries () const

BCDataPoint *	GetDataPointUpperBoundaries () const

double	GetDataPointLowerBoundary (unsigned int index) const

double	GetDataPointUpperBoundary (unsigned int index) const

bool	GetFlagBoundaries () const

unsigned	GetNDataPoints () const

BCDataPoint *	GetDataPoint (unsigned int index) const

void	SetName (const char *name)

void	SetModelAPrioriProbability (double probability)

void	SetModelAPosterioriProbability (double probability)

virtual int	AddParameter (BCParameter *parameter)

void	SetDataSet (BCDataSet *dataset)

void	SetSingleDataPoint (BCDataPoint *datapoint)

void	SetSingleDataPoint (BCDataSet *dataset, unsigned int index)

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

void	SetDataPointLowerBoundaries (BCDataPoint *datasetlowerboundaries)

void	SetDataPointUpperBoundaries (BCDataPoint *datasetupperboundaries)

void	SetDataPointLowerBoundary (int index, double lowerboundary)

void	SetDataPointUpperBoundary (int index, double upperboundary)

int	SetPrior (int index, TF1 *f)

int	SetPrior (const char name, TF1 f)

int	SetPriorDelta (int index, double value)

int	SetPriorDelta (const char *name, double value)

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

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

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

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

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

int	SetPrior (const char name, TH1 h, bool flag=false)

int	SetPriorConstant (int index)

int	SetPriorConstant (const char *name)

int	SetPriorConstantAll ()

void	Copy (const BCModel &bcmodel)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

double	GetPValue ()

double	GetPValueNDoF ()

double	GetChi2NDoF ()

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

void	SetGoFNIterationsMax (int n)

void	SetGoFNIterationsRun (int n)

void	SetGoFNChains (int n)

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

void	PrintSummary ()

void	PrintResults (const char *file)

void	PrintShortFitSummary (int chi2flag=0)

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

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::vector< BCMVCUncertainty * >	fUncertainties

std::vector< BCMVCMeasurement * >	fMeasurements

TMatrixD	fCovarianceMatrix

TMatrixD	fInvCovarianceMatrix

double	fDetCovariance

TVectorD	fVectorMeasurements

TVectorD	fVectorActiveMeasurements

std::vector< int >	fVectorObservable

std::vector< int >	fVectorActiveObservable

TMatrixD	fBLUEWeights

TVectorD	fBLUECentral

TVectorD	fBLUEUncertainties

std::vector< TVectorD >	fBLUEUncertaintiesPerSource

TMatrixD	fBLUECovarianceMatrix

std::vector< TMatrixD >	fBLUECovarianceMatrices

std::vector< TMatrixD >	fBLUECorrelationMatrices

TMatrixD	fBLUECorrelationMatrix

int	fNObservables

int	fNNuisanceCorrelation

std::vector< NuisanceParameter >	fNuisanceCorrelation

std::vector< BCMVCObservable * >	fObservables

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

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

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

Definition at line 26 of file BCMVCombination.h.

Constructor & Destructor Documentation

BCMVCombination::BCMVCombination ( )

Definition at line 26 of file BCMVCombination.cxx.

   : BCModel("BCMVCombination")
   , fDetCovariance(0)
   , fNObservables(0)
   , fNNuisanceCorrelation(0)
 {
 }

BCMVCombination::~BCMVCombination ( )

Definition at line 35 of file BCMVCombination.cxx.

 {
   int nuncertainties = GetNUncertainties();
   int nmeasurements = GetNMeasurements();
 
   for (int i = 0; i < nuncertainties; ++i) {
     BCMVCUncertainty* u = GetUncertainty(i);
     delete u;
   }
   fUncertainties.clear();
 
   for (int i = 0; i < nmeasurements; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     delete m;
   }
   fMeasurements.clear();
 }

Member Function Documentation

void BCMVCombination::AddMeasurement	(	std::string	name,
		std::string	observable,
		double	value,
		std::vector< double >	uncertainties
	)

Definition at line 83 of file BCMVCombination.cxx.

 {
   // get index of the corresponding observable
   int index = GetIndexObservable(observable);
 
   // check if observable exists
   if (index < 0) {
     BCLog::OutWarning(Form("BCMVCombination::AddMeasurement. Observable \"%s\" does not exist. Measurement was not added.", observable.c_str()));
     return;
   }
 
   BCMVCMeasurement* m = new BCMVCMeasurement(name);
   m->SetObservable(index);
   m->SetCentralValue(value);
   m->SetUncertainties(uncertainties);
 
   fMeasurements.push_back(m);
 
   fVectorObservable.push_back(index);
 
   int n = GetNMeasurements();
   fVectorMeasurements.ResizeTo(n);
   fVectorMeasurements[n-1]=value;
 }

void BCMVCombination::AddObservable	(	std::string	name,
		double	min,
		double	max
	)

Definition at line 54 of file BCMVCombination.cxx.

 {
   // check if observable exists already
   int index = GetIndexObservable(name);
 
   if (index >= 0)
     return;
 
   BCMVCObservable* obs = new BCMVCObservable();
   obs->SetName(name);
   obs->SetMinMax(min, max);
   fObservables.push_back(obs);
 
   fNObservables++;
 
   AddParameter(name.c_str(), min, max);
 
   SetPriorConstant(name.c_str());
 }

void BCMVCombination::AddUncertainty ( std::string name)

Definition at line 75 of file BCMVCombination.cxx.

 {
   BCMVCUncertainty* u = new BCMVCUncertainty(name);
 
   fUncertainties.push_back(u);
 }

void BCMVCombination::CalculateBLUE ( )

Definition at line 492 of file BCMVCombination.cxx.

 {
   int nmeas = GetNMeasurements();
   int nactivemeas = GetNActiveMeasurements();
   int nobs = GetNObservables();
   int nunc = GetNUncertainties();
 
   // calculate U matrix
   //  TMatrixD u(nmeas, nobs);
   TMatrixD u(nactivemeas, nobs);
 
   int counter = 0;
   for (int i = 0; i < nmeas; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
 
     // if measurement is active fill matrix u
     if (m->GetFlagActive()) {
       for (int j = 0; j < nobs; ++j) {
    if (m->GetObservable() == j)
      u[counter][j] = 1;
    else
      u[counter][j] = 0;
       }
       counter++;
     }
   }
 
   // calculate weight matrix
   TMatrixD ut = u;
   ut.Transpose(ut);
 
   TMatrixD m1 = ut * fInvCovarianceMatrix;
   TMatrixD m2 = m1 * u;
   m2.Invert();
 
   fBLUEWeights.Clear();
   //  fBLUEWeights.ResizeTo(nobs, nmeas);
   fBLUEWeights.ResizeTo(nobs, nactivemeas);
 
   fBLUEWeights = m2*m1;
 
   // calculate central values
   fBLUECentral.Clear();
   fBLUECentral.ResizeTo(nobs);
 
   //  fBLUECentral = fBLUEWeights * fVectorMeasurements;
   fBLUECentral = fBLUEWeights * fVectorActiveMeasurements;
 
   // calculate covariance matrix
   fBLUECovarianceMatrix.Clear();
   fBLUECovarianceMatrix.ResizeTo(nobs, nobs);
 
   TMatrixD weightt = fBLUEWeights;
   weightt.Transpose(weightt);
 
   fBLUECovarianceMatrix = fBLUEWeights * fCovarianceMatrix * weightt;
 
   // calculate uncertainties, covariance and correlation matrices for each uncertainty
   for (int i = 0; i < nunc; ++i) {
 
     // calculate covariance matrix
     BCMVCUncertainty* u = GetUncertainty(i);
     if (!u->GetFlagActive())
       continue;
 
     TMatrixD cov = u->GetCovarianceMatrix();
     TMatrixD mat = fBLUEWeights * cov * weightt;
     fBLUECovarianceMatrices.push_back(mat);
 
     // calculate uncertainties
     TVectorD vec(nobs);
     for (int j = 0; j < nobs; ++j) {
       double sigma_j = sqrt(mat[j][j]);
       vec[j] = sigma_j;
     }
     fBLUEUncertaintiesPerSource.push_back(vec);
 
     TMatrixD mat2(nobs, nobs);
     for (int j = 0; j < nobs; ++j)
       for (int k = 0; k < nobs; ++k) {
    mat2[j][k] = mat[j][k]/vec[j]/vec[k];
       }
     fBLUECorrelationMatrices.push_back(mat2);
   }
 
   // calculate uncertainties
   fBLUEUncertainties.Clear();
   fBLUEUncertainties.ResizeTo(nobs);
 
   for (int i = 0; i < nobs; ++i)
     fBLUEUncertainties[i] = sqrt(fBLUECovarianceMatrix[i][i]);
 
   // calculate correlation matrix
   fBLUECorrelationMatrix.Clear();
   fBLUECorrelationMatrix.ResizeTo(nobs, nobs);
 
   for (int i = 0; i < nobs; ++i)
     for (int j = 0; j < nobs; ++j)
       fBLUECorrelationMatrix[i][j] = fBLUECovarianceMatrix[i][j] / fBLUEUncertainties[i] / fBLUEUncertainties[j];
 }

void BCMVCombination::CalculateCorrelationMatrix ( int index)

Definition at line 354 of file BCMVCombination.cxx.

 {
   BCMVCUncertainty* u = fUncertainties.at(index);
 
   int n = GetNMeasurements();
   int nactive = GetNActiveMeasurements();
 
   TMatrixD cov(nactive, nactive);
 
   TMatrixD corr = u->GetCorrelationMatrix();
 
   int counteri = 0;
   for (int i = 0; i < n; ++i) {
     BCMVCMeasurement* mi = GetMeasurement(i);
     double sigma_i = mi->GetUncertainty(index);
 
     // skip line if not active
     if (!mi->GetFlagActive())
       continue;
 
     int counterj = 0;
     for (int j = 0; j < n; ++j) {
       BCMVCMeasurement* mj = GetMeasurement(j);
       double sigma_j = mj->GetUncertainty(index);
 
       if (mj->GetFlagActive()) {
    cov[counteri][counterj] = corr[i][j]*sigma_i*sigma_j;
    counterj++;
       }
     }
     counteri++;
   }
 
   u->SetCovarianceMatrix(cov);
 }

void BCMVCombination::CalculateCovarianceMatrix ( std::vector< double > nuisance = std::vector<double>(0))

Definition at line 391 of file BCMVCombination.cxx.

 {
   int n = GetNUncertainties();
   int nmeasurements = GetNMeasurements();
   int nnuisance = fNNuisanceCorrelation;
 
   fCovarianceMatrix.Clear();
   fCovarianceMatrix.ResizeTo(GetNActiveMeasurements(), GetNActiveMeasurements());
 
   // loop over all uncertainties
   for (int unc_i = 0; unc_i < n; ++unc_i) {
     BCMVCUncertainty* u = fUncertainties.at(unc_i);
 
     // shrink covariance matrix such that it fits only active measurements
     TMatrixD mat_small = u->GetCovarianceMatrix();
 
     // loop over all measurements (i)
     int counteri = 0;
     for (int meas_i = 0; meas_i < nmeasurements; ++meas_i) {
       BCMVCMeasurement* mi = GetMeasurement(meas_i);
 
       // skip line if not active
       if (!mi->GetFlagActive())
    continue;
 
       // loop over all measurements (j)
       int counterj = 0;
       for (int meas_j = 0; meas_j < nmeasurements; ++meas_j) {
    BCMVCMeasurement* mj = GetMeasurement(meas_j);
 
    // skip line if not active
    if (!mj->GetFlagActive())
      continue;
 
    // modify matrix if nuisance parameter present
    if (parameters.size() > 0) {
 
      // loop over all nuisance parameters
      for (int  nuis_k = 0; nuis_k < nnuisance; ++nuis_k) {
 
        // get nuisance parameter
        NuisanceParameter p = fNuisanceCorrelation.at(nuis_k);
 
        // compare
        if (p.index_uncertainty == unc_i) {
          double sigma_i = GetMeasurement(p.index_measurement1)->GetUncertainty(unc_i);
          double sigma_j = GetMeasurement(p.index_measurement2)->GetUncertainty(unc_i);
          double pre = p.pre;
 
          // check if indices agree
          if (meas_i == p.index_measurement1 && meas_j == p.index_measurement2) {
       mat_small[counteri][counterj] = pre * parameters.at(p.index_rhoparameter) * sigma_i*sigma_j;
       mat_small[counterj][counteri] = mat_small[counteri][counterj];
          }
        }
      } // end loop: nuisance parameters
    }
 
    // increase counter of active measurements
    counterj++;
       } // end loop: measurements j
 
       // increase counter of active measurements
       counteri++;
     } // end loop: measurements i
 
     // add matrix if active
     if (u->GetFlagActive())
       fCovarianceMatrix += mat_small;
   }
   fInvCovarianceMatrix.Clear();
   fInvCovarianceMatrix.ResizeTo(fCovarianceMatrix);
   fInvCovarianceMatrix = fCovarianceMatrix;
   fInvCovarianceMatrix.Invert();
 
   fDetCovariance = fCovarianceMatrix.Determinant();
 }

void BCMVCombination::CalculateHelperVectors ( )

Definition at line 321 of file BCMVCombination.cxx.

 {
   int nmeasurements  = GetNMeasurements();
 
   fVectorMeasurements.Clear();
   fVectorMeasurements.ResizeTo(nmeasurements);
   fVectorObservable.clear();
 
   for (int i = 0; i < nmeasurements; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     fVectorMeasurements[i] =  m->GetCentralValue();
     fVectorObservable.push_back(m->GetObservable());
   }
 
   int nactive = GetNActiveMeasurements();
 
   fVectorActiveMeasurements.Clear();
   fVectorActiveMeasurements.ResizeTo(nactive);
   fVectorActiveObservable.clear();
 
   int counter = 0;
   for (int i = 0; i < nmeasurements; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     if (m->GetFlagActive()) {
       fVectorActiveMeasurements[counter] =  m->GetCentralValue();
       fVectorActiveObservable.push_back(m->GetObservable());
       counter++;
     }
   }
 
 }

TVectorD BCMVCombination::GetBLUECentralValues ( )

inline

Definition at line 88 of file BCMVCombination.h.

89 { return fBLUECentral; };

TMatrixD BCMVCombination::GetBLUECorrelationMatrix ( int index)

inline

Definition at line 114 of file BCMVCombination.h.

115 { return fBLUECorrelationMatrices.at(index); };

TMatrixD BCMVCombination::GetBLUECorrelationMatrix ( )

inline

Definition at line 118 of file BCMVCombination.h.

119 { return fBLUECorrelationMatrix; };

TMatrixD BCMVCombination::GetBLUECovarianceMatrix ( )

inline

Definition at line 102 of file BCMVCombination.h.

103 { return fBLUECovarianceMatrix; };

TMatrixD BCMVCombination::GetBLUECovarianceMatrix ( int index)

inline

Definition at line 108 of file BCMVCombination.h.

109 { return fBLUECovarianceMatrices.at(index); };

TVectorD BCMVCombination::GetBLUEUncertainties ( )

inline

Definition at line 92 of file BCMVCombination.h.

93 { return fBLUEUncertainties; };

TVectorD BCMVCombination::GetBLUEUncertainties ( int index)

inline

Definition at line 98 of file BCMVCombination.h.

99 { return fBLUEUncertaintiesPerSource.at(index); };

TMatrixD BCMVCombination::GetBLUEWeights ( )

inline

Definition at line 84 of file BCMVCombination.h.

85 { return fBLUEWeights; };

TMatrixD BCMVCombination::GetCovarianceMatrix ( )

inline

Definition at line 80 of file BCMVCombination.h.

81 { return fCovarianceMatrix; };

int BCMVCombination::GetIndexMeasurement	(	std::string	measurement,
		std::string	observable
	)

Definition at line 802 of file BCMVCombination.cxx.

 {
   int index_observable = GetIndexObservable(observable);
 
   int nmeasurements = GetNMeasurements();
 
   for (int i = 0; i < nmeasurements; ++i) {
     if ((measurement == GetMeasurement(i)->GetName()) && (index_observable == GetMeasurement(i)->GetObservable()))
       return i;
   }
 
   return -1;
 }

int BCMVCombination::GetIndexObservable ( std::string name)

Definition at line 832 of file BCMVCombination.cxx.

 {
   int n = GetNObservables();
 
   // go through the list of parameters and compare strings
   for (int i = 0; i < n; ++i) {
     //    if (name == std::string(GetParameter(i)->GetName()))
     if (name == std::string(fObservables.at(i)->GetName()))
       return i;
   }
 
   // return -1 if not in the list
   return -1;
 }

int BCMVCombination::GetIndexUncertainty ( std::string name)

Definition at line 817 of file BCMVCombination.cxx.

 {
   int nuncertainties = GetNUncertainties();
 
   int index = -1;
 
   for (int i = 0; i < nuncertainties; ++i) {
     if (name == GetUncertainty(i)->GetName())
       index = i;
   }
 
   return index;
 }

BCMVCMeasurement* BCMVCombination::GetMeasurement ( int index)

inline

Definition at line 76 of file BCMVCombination.h.

77 { return fMeasurements.at(index); }

int BCMVCombination::GetNActiveMeasurements ( )

Definition at line 306 of file BCMVCombination.cxx.

 {
   int n = GetNMeasurements();
 
   int counter = 0;
 
   for (int i = 0; i < n; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     if (m->GetFlagActive())
       counter++;
   }
   return counter;
 }

int BCMVCombination::GetNMeasurements ( )

inline

Definition at line 65 of file BCMVCombination.h.

66 { return int(fMeasurements.size()); };

int BCMVCombination::GetNObservables ( )

inline

Definition at line 57 of file BCMVCombination.h.

58 { return fNObservables; };

int BCMVCombination::GetNUncertainties ( )

inline

Definition at line 61 of file BCMVCombination.h.

62 { return int(fUncertainties.size()); };

BCMVCUncertainty* BCMVCombination::GetUncertainty ( int index)

inline

Definition at line 72 of file BCMVCombination.h.

73 { return fUncertainties.at(index); }

TVectorD BCMVCombination::GetVectorMeasurements ( )

inline

Definition at line 126 of file BCMVCombination.h.

127 { return fVectorMeasurements; };

std::vector<int> BCMVCombination::GetVectorObservable ( )

inline

Definition at line 122 of file BCMVCombination.h.

123 { return fVectorObservable; };

double BCMVCombination::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.

Reimplemented in BCMVCPhysicsModel.

Definition at line 109 of file BCMVCombination.cxx.

 {
   double logprob = 0.;
 
   if (fNNuisanceCorrelation > 0) {
     CalculateCovarianceMatrix(parameters);
     if (!PositiveDefinite())
       return -1e90;
   }
 
   int nmeas = GetNActiveMeasurements();
 
   // copy parameters into a vector
   TVectorD observables(nmeas);
 
   for (int i = 0; i < nmeas; ++i) {
     observables[i] = parameters[fVectorActiveObservable[i]];
   }
 
   TVectorD prod1 = observables - fVectorActiveMeasurements;
   TVectorD prod2 = fInvCovarianceMatrix * prod1;
   double prod = prod1 * prod2;
 
   logprob = -0.5 * prod - log(TMath::Power(2*TMath::Pi(), nmeas/2.) * sqrt(fabs(fDetCovariance)));
 
   return logprob;
 }

bool BCMVCombination::PositiveDefinite ( )

Definition at line 470 of file BCMVCombination.cxx.

 {
   TMatrixDEigen m(fCovarianceMatrix);
 
   // calculate real part of all eigenvalues
   TVectorD eigen_re = m.GetEigenValuesRe();
 
   int n_eigen = eigen_re.GetNoElements();
 
   bool flag_ispositive = true;
 
   // check if eigenvalues are positive
   for (int i = 0; i < n_eigen; ++i) {
     if (eigen_re[i] < 0)
       flag_ispositive = false;
   }
 
   // true if all eigenvalues are positive
   return flag_ispositive;
 }

void BCMVCombination::PrepareAnalysis ( )

Definition at line 287 of file BCMVCombination.cxx.

 {
   int nuncertainties = GetNUncertainties();
 
   // prepare analysis
   for (int i = 0; i < nuncertainties; ++i)
     CalculateCorrelationMatrix(i);
 
   CalculateCovarianceMatrix();
 
   if (!PositiveDefinite()) {
     BCLog::OutWarning("BCMVCombination::PrepareAnalysis. Covariance matrix is not positive definite.");
   }
 
   CalculateHelperVectors();
 
 }

void BCMVCombination::PrintBLUEResults ( std::string filename)

Definition at line 594 of file BCMVCombination.cxx.

 {
   // open file
   std::ofstream ofi(filename.c_str());
 
   // check if file is open
   if (!ofi.is_open()) {
     std::cerr << "Couldn't open file " << filename << std::endl;
     return;
   }
 
   int nobs = GetNObservables();
   int nmeas = GetNMeasurements();
   int nunc = GetNUncertainties();
 
   ofi << std::endl;
   ofi << "Summary of the combination" << std::endl;
   ofi << "==========================" << std::endl << std::endl;
 
   ofi << "* Observables:" << std::endl;
   ofi << "  Observable (range): " << std::endl;
   for (int i = 0; i < nobs; ++i)
     ofi << "  " << std::setiosflags(std::ios::left) << GetParameter(i)->GetName()
    << " (" << GetParameter(i)->GetLowerLimit() << " - " << GetParameter(i)->GetUpperLimit() << ")" << std::endl;
   ofi << std::endl;
 
   ofi << "* Measurements:" << std::endl;
   ofi << "  Measurement (observable): central value +- total uncertainty" << std::endl;
   for (int i = 0; i < nmeas; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     if (m->GetFlagActive()) {
       double total2 = 0;
       for (int j = 0; j < nunc; ++j) {
    if (GetUncertainty(j)->GetFlagActive())
      total2+=m->GetUncertainty(j)*m->GetUncertainty(j);
       }
       ofi << "  " << std::setiosflags(std::ios::left) << std::setw(20) << m->GetName()
      << std::setiosflags(std::ios::left) << " (" << GetParameter(m->GetObservable())->GetName() << ")"
      << ": " << std::setiosflags(std::ios::left) << std::setw(7) << std::setprecision(4) << m->GetCentralValue()
      << " +- " << std::setiosflags(std::ios::left) << std::setw(7) << std::setprecision(4) << sqrt(total2) << std::endl;
     }
   }
   ofi << std::endl;
 
   ofi << "* Uncertainties:" << std::endl;
   ofi << "  Measurement (observable): Uncertainty (";
   for (int j = 0; j < nunc-1; ++j )
     if (GetUncertainty(j)->GetFlagActive())
       ofi << GetUncertainty(j)->GetName() << ", ";
   if (GetUncertainty(nunc-1)->GetFlagActive())
     ofi << GetUncertainty(nunc-1)->GetName() << ")" << std::endl;
   else
     ofi << ")" << std::endl;
 
   for (int i = 0; i < nmeas; ++i) {
     BCMVCMeasurement* m = GetMeasurement(i);
     if (m->GetFlagActive()) {
       ofi << "  " << std::setiosflags(std::ios::left) << std::setw(20) << m->GetName()
      << std::setiosflags(std::ios::left) << " (" << GetParameter(m->GetObservable())->GetName() << "): ";
       for (int j = 0; j < nunc; ++j )
    if (GetUncertainty(j)->GetFlagActive())
      ofi << std::setiosflags(std::ios::left) << std::setw(7) << m->GetUncertainty(j);
       ofi << std::endl;
     }
   }
   ofi << std::endl;
 
   for (int i = 0; i < nunc; ++i) {
     BCMVCUncertainty* u = GetUncertainty(i);
 
     if (!u->GetFlagActive())
       continue;
 
     ofi << "  " << u->GetName() << " " << "(correlation matrix)" << std::endl;
     TMatrixD mat = u->GetCorrelationMatrix();
 
     int counterk = 0;
     for (int k = 0; k < nmeas; ++k) {
       BCMVCMeasurement* mk = GetMeasurement(k);
 
       // skip line if not active
       if (!mk->GetFlagActive())
    continue;
 
       ofi << "  ";
 
       int counterj = 0;
       for (int j = 0; j < nmeas; ++j) {
    BCMVCMeasurement* mj = GetMeasurement(j);
 
    if (mj->GetFlagActive()) {
      ofi << std::setw(7) << std::showpos << mat[k][j] << " ";
      counterj++;
    }
       }
       ofi << std::noshowpos << std::endl;
       counterk++;
     }
     ofi << std::endl;
   }
 
   ofi << "* BLUE results: " << std::endl;
   ofi << "  Observable: estimate +- total uncertainty" << std::endl;
   for (int i = 0; i < nobs; ++i) {
     if (i < fBLUECentral.GetNoElements())
       ofi << "  " << GetParameter(i)->GetName() << ": " << fBLUECentral[i] << " +- " << std::setprecision(4) << fBLUEUncertainties[i] << std::endl;
   }
   ofi << std::endl;
 
   ofi << "  Observable: Uncertainty (";
   for (int j = 0; j < nunc-1; ++j )
     if (GetUncertainty(j)->GetFlagActive())
       ofi << GetUncertainty(j)->GetName() << ", ";
   if (GetUncertainty(nunc-1)->GetFlagActive())
     ofi << GetUncertainty(nunc-1)->GetName() << ")" << std::endl;
   else
     ofi << ")" << std::endl;
 
   for (int i = 0; i < nobs; ++i) {
     ofi << "  " << std::setiosflags(std::ios::left) << GetParameter(i)->GetName()<< ":";
     int counterj = 0;
     for (int j = 0; j < nunc; ++j )
       if (GetUncertainty(j)->GetFlagActive()) {
    ofi << " " << std::setiosflags(std::ios::left) << std::setw(7) << std::setprecision(4) << GetBLUEUncertainties(counterj)[i];
    counterj++;
       }
     ofi << std::endl;
   }
   ofi << std::endl;
 
   if (nobs > 1) {
     ofi << "  Individual correlation matrices " << std::endl;
     for (int i = 0; i < nunc; ++i) {
       if (GetUncertainty(i)->GetFlagActive()) {
    TMatrixD mat = GetBLUECorrelationMatrix(i);
    ofi << "  " << GetUncertainty(i)->GetName() << std::endl;
    for (int j = 0; j < nobs; ++j) {
      ofi << "  ";
      for (int k = 0; k < nobs; ++k) {
        ofi << std::setw(7) << std::setprecision(4) << std::showpos << mat[j][k] << " ";
      }
      ofi << std::noshowpos << std::endl;
    }
    ofi << std::endl;
       }
     }
   }
 
   if (nobs > 1) {
     ofi << "  Overall correlation matrix" << std::endl;
     TMatrixD mat = fBLUECorrelationMatrix;
     for (int j = 0; j < nobs; ++j) {
       ofi << "  ";
       for (int k = 0; k < nobs; ++k)
    ofi << std::setw(7) << std::setprecision(4) << std::showpos << mat[j][k] << " ";
       ofi << std::noshowpos << std::endl;
     }
     ofi << std::endl;
   }
 
   ofi << "  Weights [%]:" <<std::endl;
   int counter = 0;
   for (int j = 0; j < nmeas; ++j) {
     if (GetMeasurement(j)->GetFlagActive()) {
       ofi << "  " << std::setw(20) << GetMeasurement(j)->GetName() << " : ";
       for (int k = 0; k < nobs; ++k)
    ofi << std::setw(7) << std::setprecision(4) << std::showpos << fBLUEWeights[k][counter]*100. << " ";
       ofi << std::endl;
       counter++;
     }
   }
   ofi << std::endl;
 
   // close file
   ofi.close();
 }

void BCMVCombination::PrintMatrix	(	TMatrixT< double > &	matrix,
		std::string	name = `"matrix"`
	)

Definition at line 772 of file BCMVCombination.cxx.

 {
   int nrows = matrix.GetNrows();
   int ncols = matrix.GetNcols();
 
   std::cout << std::endl;
   std::cout << name.c_str() << " (" << nrows << "x" << ncols << "):" << std::endl;
 
   for (int i = 0; i < nrows; ++i) {
     for (int j = 0; j < ncols; ++j)
       std::cout << std::setprecision(3) << std::setw(7) << matrix[i][j] << " ";
     std::cout << std::endl;
   }
 }

void BCMVCombination::PrintVector	(	TVectorD &	vector,
		std::string	name = `"vector"`
	)

Definition at line 788 of file BCMVCombination.cxx.

 {
   int nrows = vector.GetNoElements();
 
   std::cout << std::endl;
   std::cout << name.c_str() << " (" << nrows << "):" << std::endl;
 
   for (int i = 0; i < nrows; ++i) {
     std::cout << std::setprecision(3) << std::setw(7) << vector[i] << " ";
     std::cout << std::endl;
   }
 }

int BCMVCombination::ReadInput ( std::string filename)

Definition at line 138 of file BCMVCombination.cxx.

 {
   // open input file
   ifstream infile;
   infile.open(filename.c_str(), std::ifstream::in);
 
   // check if file is open
   if (!infile.is_open()) {
     BCLog::OutWarning(Form("BCMVCombination::ReadInput. Could not open input file %s.", filename.c_str()));
     return 0;
   }
 
   int nobservables;
   int nmeasurements;
   int nuncertainties;
   int nnuisance;
 
   infile >> nobservables >> nmeasurements >> nuncertainties >> nnuisance;
 
   std::vector<std::string> observable_names;
 
   for (int i = 0; i < nobservables; ++i) {
     std::string name;
     double min;
     double max;
     infile >> name >> min >> max;
 
     // add observable
     AddObservable(name.c_str(), min, max);
   }
 
   for (int i = 0; i < nuncertainties; ++i) {
     std::string name;
     infile >> name;
 
     // add uncertainty
     AddUncertainty(name);
   }
 
   for (int i = 0; i < nmeasurements; ++i) {
     std::string name;
     std::string observable;
     double central;
     std::vector<double> uncertainties(0);
 
     infile >> name;
     infile >> observable;
     infile >> central;
 
     for (int j = 0; j < nuncertainties; ++j) {
       double uncertainty;
       infile >> uncertainty;
       uncertainties.push_back(uncertainty);
     }
 
     // add measurement
     AddMeasurement(name, observable, central, uncertainties);
   }
 
   for (int i = 0; i < nuncertainties; ++i) {
     TMatrixD mat(nmeasurements, nmeasurements);
 
     for (int j = 0; j < nmeasurements; ++j)
       for (int k = 0; k < nmeasurements; ++k) {
    double corr;
    infile >> corr;
    mat[j][k] = corr;
       }
 
     // set correlation matrix
     GetUncertainty(i)->SetCorrelationMatrix(mat);
   }
 
   for (int i = 0; i < nnuisance; ++i) {
     std::string uncertainty;
     std::string measurement1;
     std::string observable1;
     std::string measurement2;
     std::string observable2;
     std::string parname;
     double min;
     double max;
     double pre;
     std::string priorshape;
 
     infile >> uncertainty >> measurement1 >> observable1 >> measurement2 >> observable2 >> parname;
 
     // check if parameter exists already
     int index = -1;
 
     for (unsigned int i = 0; i < GetNParameters(); i++)
       if (parname.c_str() == GetParameter(i)->GetName())
    index = i;
 
     if (index >= 0)
       infile >> pre;
 
     else if (index < 0) {
       // read properties of parameter
       infile >> min >> max >> priorshape;
 
       // add nuisance parameter
       AddParameter(parname.c_str(), min, max);
 
       // set pre-factor
       pre = 1;
 
       // set index
       index = GetNParameters()-1;
 
       if (priorshape == "flat") {
    SetPriorConstant(parname.c_str());
       }
       else if (priorshape == "gauss") {
    double mean;
    double std;
 
    infile >> mean >> std;
 
    SetPriorGauss(parname.c_str(), mean, std);
       }
       else {
    BCLog::OutWarning(Form("BCMVCombination::ReadInput. Unknown prior shape %s.", priorshape.c_str()));
       }
     }
 
     // increase counter of nuisance parametera
     fNNuisanceCorrelation++;
 
     NuisanceParameter p;
     p.index_uncertainty  = GetIndexUncertainty(uncertainty);
     p.index_measurement1 = GetIndexMeasurement(measurement1, observable1);
     p.index_measurement2 = GetIndexMeasurement(measurement2, observable2);
     p.index_rhoparameter = index;
     p.pre = pre;
 
     fNuisanceCorrelation.push_back(p);
   }
 
   // close input file
   infile.close();
 
   PrepareAnalysis();
 
   // no error
   return 1;
 }

Member Data Documentation

TVectorD BCMVCombination::fBLUECentral

protected

Definition at line 215 of file BCMVCombination.h.

std::vector<TMatrixD> BCMVCombination::fBLUECorrelationMatrices

protected

Definition at line 230 of file BCMVCombination.h.

TMatrixD BCMVCombination::fBLUECorrelationMatrix

protected

Definition at line 233 of file BCMVCombination.h.

std::vector<TMatrixD> BCMVCombination::fBLUECovarianceMatrices

protected

Definition at line 227 of file BCMVCombination.h.

TMatrixD BCMVCombination::fBLUECovarianceMatrix

protected

Definition at line 224 of file BCMVCombination.h.

TVectorD BCMVCombination::fBLUEUncertainties

protected

Definition at line 218 of file BCMVCombination.h.

std::vector<TVectorD> BCMVCombination::fBLUEUncertaintiesPerSource

protected

Definition at line 221 of file BCMVCombination.h.

TMatrixD BCMVCombination::fBLUEWeights

protected

Definition at line 212 of file BCMVCombination.h.

TMatrixD BCMVCombination::fCovarianceMatrix

protected

Definition at line 191 of file BCMVCombination.h.

double BCMVCombination::fDetCovariance

protected

Definition at line 197 of file BCMVCombination.h.

TMatrixD BCMVCombination::fInvCovarianceMatrix

protected

Definition at line 194 of file BCMVCombination.h.

std::vector<BCMVCMeasurement*> BCMVCombination::fMeasurements

protected

Definition at line 188 of file BCMVCombination.h.

int BCMVCombination::fNNuisanceCorrelation

protected

Definition at line 239 of file BCMVCombination.h.

int BCMVCombination::fNObservables

protected

Definition at line 236 of file BCMVCombination.h.

std::vector<NuisanceParameter> BCMVCombination::fNuisanceCorrelation

protected

Definition at line 242 of file BCMVCombination.h.

std::vector<BCMVCObservable*> BCMVCombination::fObservables

protected

Definition at line 245 of file BCMVCombination.h.

std::vector<BCMVCUncertainty*> BCMVCombination::fUncertainties

protected

Definition at line 185 of file BCMVCombination.h.

TVectorD BCMVCombination::fVectorActiveMeasurements

protected

Definition at line 203 of file BCMVCombination.h.

std::vector<int> BCMVCombination::fVectorActiveObservable

protected

Definition at line 209 of file BCMVCombination.h.

TVectorD BCMVCombination::fVectorMeasurements

protected

Definition at line 200 of file BCMVCombination.h.

std::vector<int> BCMVCombination::fVectorObservable

protected

Definition at line 206 of file BCMVCombination.h.

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

Classes

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation