Base class responsible for handling of systematic error parameters. Capable of using PCA or using adaptive throw matrix. More...

#include <Parameters/ParameterHandlerBase.h>

Inheritance diagram for ParameterHandlerBase:

[legend]

Collaboration diagram for ParameterHandlerBase:

[legend]

Public Member Functions
	ParameterHandlerBase (const std::vector< std::string > &YAMLFile, std::string name, double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	ETA - constructor for a YAML file.

	ParameterHandlerBase (std::string name, std::string file, double threshold=-1, int FirstPCAdpar=-999, int LastPCAdpar=-999)
	"Usual" constructors from root file

virtual	~ParameterHandlerBase ()
	Destructor.

void	SetCovMatrix (TMatrixDSym *cov)
	Set covariance matrix.

void	SetName (const std::string &name)
	Set matrix name.

void	SetParName (const int i, const std::string &name)
	change parameter name

void	SetSingleParameter (const int parNo, const double parVal)
	Set value of single param to a given value.

void	SetPar (const int i, const double val)
	Set all the covariance matrix parameters to a user-defined value.

void	SetParCurrProp (const int i, const double val)
	Set current parameter value.

void	SetParProp (const int i, const double val)
	Set proposed parameter value.

void	SetParameters (const std::vector< double > &pars={})
	Set parameter values using vector, it has to have same size as covariance class.

void	SetFlatPrior (const int i, const bool eL)
	Set if parameter should have flat prior or not.

void	SetRandomThrow (const int i, const double rand)
	Set random value useful for debugging/CI.

double	GetRandomThrow (const int i) const
	Get random value useful for debugging/CI.

void	SetBranches (TTree &tree, const bool SaveProposal=false)
	set branches for output file

void	SetStepScale (const double scale)
	Set global step scale for covariance object.

void	SetIndivStepScale (const int ParameterIndex, const double StepScale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)

void	SetIndivStepScale (const std::vector< double > &stepscale)
	DB Function to set fIndivStepScale from a vector (Can be used from execs and inside covariance constructors)

void	SetPrintLength (const unsigned int PriLen)
	KS: In case someone really want to change this.

void	SaveUpdatedMatrixConfig ()
	KS: After step scale, prefit etc. value were modified save this modified config.

void	ThrowParProp (const double mag=1.)
	Throw the proposed parameter by mag sigma. Should really just have the user specify this throw by having argument double.

void	ThrowParCurr (const double mag=1.)
	Helper function to throw the current parameter by mag sigma. Can study bias in MCMC with this; put different starting parameters.

void	ThrowParameters ()
	Throw the parameters according to the covariance matrix. This shouldn't be used in MCMC code ase it can break Detailed Balance;.

void	RandomConfiguration ()
	Randomly throw the parameters in their 1 sigma range.

int	CheckBounds () const _noexcept_
	Check if parameters were proposed outside physical boundary.

double	CalcLikelihood () const _noexcept_
	Calc penalty term based on inverted covariance matrix.

virtual double	GetLikelihood ()
	Return CalcLikelihood if some params were thrown out of boundary return LARGE_LOGL

TMatrixDSym *	GetCovMatrix () const
	Return covariance matrix.

TMatrixDSym *	GetInvCovMatrix () const
	Return inverted covariance matrix.

double	GetInvCovMatrix (const int i, const int j) const
	Return inverted covariance matrix.

double	GetCorrThrows (const int i) const
	Return correlated throws.

bool	GetFlatPrior (const int i) const
	Get if param has flat prior or not.

std::string	GetName () const
	Get name of covariance.

std::string	GetParName (const int i) const
	Get name of parameter.

int	GetParIndex (const std::string &name) const
	Get index based on name.

std::string	GetParFancyName (const int i) const
	Get fancy name of the Parameter.

std::string	GetInputFile () const
	Get name of input file.

double	GetDiagonalError (const int i) const
	Get diagonal error for ith parameter.

double	GetError (const int i) const
	Get the error for the ith parameter.

void	ResetIndivStepScale ()
	Adaptive Step Tuning Stuff.

void	InitialiseAdaption (const YAML::Node &adapt_manager)
	Initialise adaptive MCMC.

void	SaveAdaptiveToFile (const std::string &outFileName, const std::string &systematicName)
	Save adaptive throw matrix to file.

bool	GetDoAdaption () const
	Do we adapt or not.

void	SetThrowMatrix (TMatrixDSym *cov)
	Use new throw matrix, used in adaptive MCMC.

void	UpdateThrowMatrix (TMatrixDSym *cov)

void	SetNumberOfSteps (const int nsteps)
	Set number of MCMC step, when running adaptive MCMC it is updated with given frequency. We need number of steps to determine frequency.

TMatrixDSym *	GetThrowMatrix () const
	Get matrix used for step proposal.

double	GetThrowMatrix (const int i, const int j) const
	Get matrix used for step proposal.

TMatrixD *	GetThrowMatrix_CholDecomp () const
	Get the Cholesky decomposition of the throw matrix.

TH2D *	GetCorrelationMatrix ()
	KS: Convert covariance matrix to correlation matrix and return TH2D which can be used for fancy plotting.

const double *	RetPointer (const int iParam)
	DB Pointer return to param position.

const std::vector< double > &	GetParPropVec ()
	Get a reference to the proposed parameter values Can be useful if you want to track these without having to copy values using getProposed()

int	GetNumParams () const
	Get total number of parameters.

std::vector< double >	GetPreFitValues () const
	Get the pre-fit values of the parameters.

std::vector< double >	GetProposed () const
	Get vector of all proposed parameter values.

double	GetParProp (const int i) const
	Get proposed parameter value.

double	GetParCurr (const int i) const
	Get current parameter value.

double	GetParInit (const int i) const
	Get prior parameter value.

double	GetUpperBound (const int i) const
	Get upper parameter bound in which it is physically valid.

double	GetLowerBound (const int i) const
	Get lower parameter bound in which it is physically valid.

double	GetIndivStepScale (const int ParameterIndex) const
	Get individual step scale for selected parameter.

double	GetGlobalStepScale () const
	Get global step scale for covariance object.

int	GetNParameters () const
	Get number of params which will be different depending if using Eigen decomposition or not.

void	PrintNominal () const
	Print prior value for every parameter.

void	PrintNominalCurrProp () const
	Print prior, current and proposed value for each parameter.

void	PrintParameters () const

void	PrintIndivStepScale () const
	Print step scale for each parameter.

virtual void	ProposeStep ()
	Generate a new proposed state.

void	Randomize () _noexcept_
	"Randomize" the parameters in the covariance class for the proposed step. Used the proposal kernel and the current parameter value to set proposed step

void	CorrelateSteps () _noexcept_
	Use Cholesky throw matrix for better step proposal.

void	UpdateAdaptiveCovariance ()
	Method to update adaptive MCMC [12].

void	AcceptStep () _noexcept_
	Accepted this step.

void	ToggleFixAllParameters ()
	fix parameters at prior values

void	ToggleFixParameter (const int i)
	fix parameter at prior values

void	ToggleFixParameter (const std::string &name)
	Fix parameter at prior values.

bool	IsParameterFixed (const int i) const
	Is parameter fixed or not.

bool	IsParameterFixed (const std::string &name) const
	Is parameter fixed or not.

void	ConstructPCA (const double eigen_threshold, int FirstPCAdpar, int LastPCAdpar)
	CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold.

bool	IsPCA () const
	is PCA, can use to query e.g. LLH scans

YAML::Node	GetConfig () const
	Getter to return a copy of the YAML node.

adaptive_mcmc::AdaptiveMCMCHandler *	GetAdaptiveHandler () const
	Get pointer for AdaptiveHandler.

void	SetTune (const std::string &TuneName)
	KS: Set proposed parameter values vector to be base on tune values, for example set proposed values to be of generated or maybe PostND.

PCAHandler *	GetPCAHandler () const
	Get pointer for PCAHandler.

Protected Member Functions
void	Init (const std::string &name, const std::string &file)
	Initialisation of the class using matrix from root file.

void	Init (const std::vector< std::string > &YAMLFile)
	Initialisation of the class using config.

void	ReserveMemory (const int size)
	Initialise vectors with parameters information.

void	MakePosDef (TMatrixDSym *cov=nullptr)
	Make matrix positive definite by adding small values to diagonal, necessary for inverting matrix.

void	MakeClosestPosDef (TMatrixDSym *cov)
	HW: Finds closest possible positive definite matrix in Frobenius Norm \|\|.\|\|_frob Where \|\|X\|\|_frob=sqrt[sum_ij(x_ij^2)] (basically just turns an n,n matrix into vector in n^2 space then does Euclidean norm)

void	SetThrowMatrixFromFile (const std::string &matrix_file_name, const std::string &matrix_name, const std::string &means_name)
	sets throw matrix from a file

bool	AppliesToSample (const int SystIndex, const std::string &SampleName) const
	Check if parameter is affecting given sample name.

void	FlipParameterValue (const int index, const double FlipPoint)
	KS: Flip parameter around given value, for example mass ordering around 0.

void	CircularParBounds (const int i, const double LowBound, const double UpBound)
	HW :: This method is a tad hacky but modular arithmetic gives me a headache.

void	EnableSpecialProposal (const YAML::Node &param, const int Index)
	Enable special proposal.

void	SpecialStepProposal ()
	Perform Special Step Proposal.

Protected Attributes
bool	doSpecialStepProposal
	Check if any of special step proposal were enabled.

const std::string	inputFile
	The input root file we read in.

std::string	matrixName
	Name of cov matrix.

TMatrixDSym *	covMatrix
	The covariance matrix.

TMatrixDSym *	invCovMatrix
	The inverse covariance matrix.

std::vector< std::vector< double > >	InvertCovMatrix
	KS: Same as above but much faster as TMatrixDSym cache miss.

std::vector< std::unique_ptr< TRandom3 > >	random_number
	KS: Set Random numbers for each thread so each thread has different seed.

double *	randParams
	Random number taken from gaussian around prior error used for corr_throw.

double *	corr_throw
	Result of multiplication of Cholesky matrix and randParams.

double	_fGlobalStepScale
	Global step scale applied to all params in this class.

int	PrintLength
	KS: This is used when printing parameters, sometimes we have super long parameters name, we want to flexibly adjust couts.

std::vector< std::string >	_fNames
	ETA _fNames is set automatically in the covariance class to be something like xsec_i, this is currently to make things compatible with the Diagnostic tools.

std::vector< std::string >	_fFancyNames
	Fancy name for example rather than xsec_0 it is MAQE, useful for human reading.

YAML::Node	_fYAMLDoc
	Stores config describing systematics.

int	_fNumPar
	Number of systematic parameters.

std::vector< double >	_fPreFitValue
	Parameter value dictated by the prior model. Based on it penalty term is calculated.

std::vector< double >	_fCurrVal
	Current value of the parameter.

std::vector< double >	_fPropVal
	Proposed value of the parameter.

std::vector< double >	_fError
	Prior error on the parameter.

std::vector< double >	_fLowBound
	Lowest physical bound, parameter will not be able to go beyond it.

std::vector< double >	_fUpBound
	Upper physical bound, parameter will not be able to go beyond it.

std::vector< double >	_fIndivStepScale
	Individual step scale used by MCMC algorithm.

std::vector< bool >	_fFlatPrior
	Whether to apply flat prior or not.

std::vector< std::vector< std::string > >	_fSampleNames
	Tells to which samples object param should be applied.

TMatrixDSym *	throwMatrix
	Matrix which we use for step proposal before Cholesky decomposition (not actually used for step proposal)

TMatrixD *	throwMatrix_CholDecomp
	Matrix which we use for step proposal after Cholesky decomposition.

double **	throwMatrixCholDecomp
	Throw matrix that is being used in the fit, much faster as TMatrixDSym cache miss.

bool	pca
	perform PCA or not

bool	use_adaptive
	Are we using AMCMC?

std::unique_ptr< PCAHandler >	PCAObj
	Struct containing information about PCA.

std::unique_ptr< adaptive_mcmc::AdaptiveMCMCHandler >	AdaptiveHandler
	Struct containing information about adaption.

std::unique_ptr< ParameterTunes >	Tunes
	Struct containing information about adaption.

std::vector< int >	FlipParameterIndex
	Indices of parameters with flip symmetry.

std::vector< double >	FlipParameterPoint
	Central points around which parameters are flipped.

std::vector< int >	CircularBoundsIndex
	Indices of parameters with circular bounds.

std::vector< std::pair< double, double > >	CircularBoundsValues
	Circular bounds for each parameter (lower, upper)

Detailed Description

Base class responsible for handling of systematic error parameters. Capable of using PCA or using adaptive throw matrix.

See also: For more details, visit the Wiki.

Author: Dan Barrow; Ed Atkin; Kamil Skwarczynski

Definition at line 15 of file ParameterHandlerBase.h.

Constructor & Destructor Documentation

◆ ParameterHandlerBase() [1/2]

ParameterHandlerBase::ParameterHandlerBase	(	const std::vector< std::string > &	YAMLFile,
		std::string	name,
		double	threshold = `-1`,
		int	FirstPCAdpar = `-999`,
		int	LastPCAdpar = `-999`
	)

ETA - constructor for a YAML file.

Parameters

YAMLFile	A vector of strings representing the YAML files used for initialisation of matrix
name	Matrix name
threshold	PCA threshold from 0 to 1. Default is -1 and means no PCA
FirstPCAdpar	First PCA parameter that will be decomposed.
LastPCAdpar	First PCA parameter that will be decomposed.

Definition at line 24 of file ParameterHandlerBase.cpp.

                     : inputFile(YAMLFile[0].c_str()), matrixName(name), pca(true) {
// ********************************************
  MACH3LOG_INFO("Constructing instance of ParameterHandler using");
  doSpecialStepProposal = false;
  for(unsigned int i = 0; i < YAMLFile.size(); i++)
  {
    MACH3LOG_INFO("{}", YAMLFile[i]);
  }
  MACH3LOG_INFO("as an input");
 
  if (threshold < 0 || threshold >= 1) {
    MACH3LOG_INFO("Principal component analysis but given the threshold for the principal components to be less than 0, or greater than (or equal to) 1. This will not work");
    MACH3LOG_INFO("Please specify a number between 0 and 1");
    MACH3LOG_INFO("You specified: ");
    MACH3LOG_INFO("Am instead calling the usual non-PCA constructor...");
    pca = false;
  }
 
  Init(YAMLFile);
  // Call the innocent helper function
  if (pca) ConstructPCA(threshold, FirstPCA, LastPCA);
}

◆ ParameterHandlerBase() [2/2]

ParameterHandlerBase::ParameterHandlerBase	(	std::string	name,
		std::string	file,
		double	threshold = `-1`,
		int	FirstPCAdpar = `-999`,
		int	LastPCAdpar = `-999`
	)

"Usual" constructors from root file

Parameters

name	Matrix name
file	Path to matrix root file

Definition at line 5 of file ParameterHandlerBase.cpp.

                     : inputFile(file), pca(false) {
// ********************************************
  MACH3LOG_DEBUG("Constructing instance of ParameterHandler");
  doSpecialStepProposal = false;
  if (threshold < 0 || threshold >= 1) {
    MACH3LOG_INFO("NOTE: {} {}", name, file);
    MACH3LOG_INFO("Principal component analysis but given the threshold for the principal components to be less than 0, or greater than (or equal to) 1. This will not work");
    MACH3LOG_INFO("Please specify a number between 0 and 1");
    MACH3LOG_INFO("You specified: ");
    MACH3LOG_INFO("Am instead calling the usual non-PCA constructor...");
    pca = false;
  }
  Init(name, file);
 
  // Call the innocent helper function
  if (pca) ConstructPCA(threshold, FirstPCA, LastPCA);
}

◆ ~ParameterHandlerBase()

ParameterHandlerBase::~ParameterHandlerBase ( )

virtual

Destructor.

Definition at line 50 of file ParameterHandlerBase.cpp.

                                           {
// ********************************************
  delete[] randParams;
  delete[] corr_throw;
 
  if (covMatrix != nullptr) delete covMatrix;
  if (invCovMatrix != nullptr) delete invCovMatrix;
  if (throwMatrix_CholDecomp != nullptr) delete throwMatrix_CholDecomp;
  if (throwMatrix != nullptr) delete throwMatrix;
  for(int i = 0; i < _fNumPar; i++) {
    delete[] throwMatrixCholDecomp[i];
  }
  delete[] throwMatrixCholDecomp;
}

Member Function Documentation

◆ AcceptStep()

void ParameterHandlerBase::AcceptStep ( )

Accepted this step.

Definition at line 654 of file ParameterHandlerBase.cpp.

                                                 {
// ********************************************
  if (!pca) {
    #ifdef MULTITHREAD
    #pragma omp parallel for
    #endif
    for (int i = 0; i < _fNumPar; ++i) {
      // Update state so that current state is proposed state
      _fCurrVal[i] = _fPropVal[i];
    }
  } else {
    PCAObj->AcceptStep();
  }
}

◆ AppliesToSample()

bool ParameterHandlerBase::AppliesToSample	(	const int	SystIndex,
		const std::string &	SampleName
	)		const

protected

Check if parameter is affecting given sample name.

Parameters

SystIndex	number of parameter
SampleName	The Sample name used to filter parameters.

Definition at line 1271 of file ParameterHandlerBase.cpp.

                                                                                                 {
// ********************************************
  // Empty means apply to all
  if (_fSampleNames[SystIndex].size() == 0) return true;
 
  // Make a copy and to lower case to not be case sensitive
  std::string SampleNameCopy = SampleName;
  std::transform(SampleNameCopy.begin(), SampleNameCopy.end(), SampleNameCopy.begin(), ::tolower);
 
  // Check for unsupported wildcards in SampleNameCopy
  if (SampleNameCopy.find('*') != std::string::npos) {
    MACH3LOG_ERROR("Wildcards ('*') are not supported in sample name: '{}'", SampleName);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  bool Applies = false;
 
  for (size_t i = 0; i < _fSampleNames[SystIndex].size(); i++) {
    // Convert to low case to not be case sensitive
    std::string pattern = _fSampleNames[SystIndex][i];
    std::transform(pattern.begin(), pattern.end(), pattern.begin(), ::tolower);
 
    // Replace '*' in the pattern with '.*' for regex matching
    std::string regexPattern = "^" + std::regex_replace(pattern, std::regex("\\*"), ".*") + "$";
    try {
      std::regex regex(regexPattern);
      if (std::regex_match(SampleNameCopy, regex)) {
        Applies = true;
        break;
      }
    } catch (const std::regex_error& e) {
      // Handle regex error (for invalid patterns)
      MACH3LOG_ERROR("Regex error: {}", e.what());
    }
  }
  return Applies;
}

◆ CalcLikelihood()

double ParameterHandlerBase::CalcLikelihood ( ) const

Calc penalty term based on inverted covariance matrix.

Definition at line 756 of file ParameterHandlerBase.cpp.

                                                             {
// ********************************************
  double logL = 0.0;
  #ifdef MULTITHREAD
  #pragma omp parallel for reduction(+:logL)
  #endif
  for(int i = 0; i < _fNumPar; ++i){
    if(_fFlatPrior[i]){
      //HW: Flat prior, no need to calculate anything
      continue;
    }
 
    #ifdef MULTITHREAD
    #pragma omp simd
    #endif
    for (int j = 0; j <= i; ++j) {
      if (!_fFlatPrior[j]) {
        //KS: Since matrix is symmetric we can calculate non diagonal elements only once and multiply by 2, can bring up to factor speed decrease.
        double scale = (i != j) ? 1. : 0.5;
        logL += scale * (_fPropVal[i] - _fPreFitValue[i])*(_fPropVal[j] - _fPreFitValue[j])*InvertCovMatrix[i][j];
      }
    }
  }
  return logL;
}

◆ CheckBounds()

int ParameterHandlerBase::CheckBounds ( ) const

Check if parameters were proposed outside physical boundary.

Definition at line 783 of file ParameterHandlerBase.cpp.

                                                       {
// ********************************************
  int NOutside = 0;
  #ifdef MULTITHREAD
  #pragma omp parallel for reduction(+:NOutside)
  #endif
  for (int i = 0; i < _fNumPar; ++i){
    if(_fPropVal[i] > _fUpBound[i] || _fPropVal[i] < _fLowBound[i]){
      NOutside++;
    }
  }
  return NOutside;
}

◆ CircularParBounds()

void ParameterHandlerBase::CircularParBounds	(	const int	i,
		const double	LowBound,
		const double	UpBound
	)

protected

HW :: This method is a tad hacky but modular arithmetic gives me a headache.

Author: Henry Wallace

Definition at line 671 of file ParameterHandlerBase.cpp.

                                                                                                         {
// *************************************
  if(_fPropVal[index] > UpBound) {
    _fPropVal[index] = LowBound + std::fmod(_fPropVal[index] - UpBound, UpBound - LowBound);
  } else if (_fPropVal[index] < LowBound) {
    _fPropVal[index] = UpBound - std::fmod(LowBound - _fPropVal[index], UpBound - LowBound);
  }
}

◆ ConstructPCA()

void ParameterHandlerBase::ConstructPCA	(	const double	eigen_threshold,
		int	FirstPCAdpar,
		int	LastPCAdpar
	)

CW: Calculate eigen values, prepare transition matrices and remove param based on defined threshold.

Parameters

eigen_threshold	PCA threshold from 0 to 1. Default is -1 and means no PCA
FirstPCAdpar	First PCA parameter that will be decomposed.
LastPCAdpar	First PCA parameter that will be decomposed.

See also: For more details, visit the Wiki.

Definition at line 66 of file ParameterHandlerBase.cpp.

                                                                                                       {
// ********************************************
  if(AdaptiveHandler) {
    MACH3LOG_ERROR("Adaption has been enabled and now trying to enable PCA. Right now both configuration don't work with each other");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  PCAObj = std::make_unique<PCAHandler>();
  //Check whether first and last pcadpar are set and if not just PCA everything
  if(FirstPCAdpar == -999 || LastPCAdpar == -999){
    if(FirstPCAdpar == -999 && LastPCAdpar == -999){
      FirstPCAdpar = 0;
      LastPCAdpar = covMatrix->GetNrows()-1;
    }
    else{
      MACH3LOG_ERROR("You must either leave FirstPCAdpar and LastPCAdpar at -999 or set them both to something");
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
  }
 
  PCAObj->ConstructPCA(covMatrix, FirstPCAdpar, LastPCAdpar, eigen_threshold, _fNumPar);
  PCAObj->SetupPointers(&_fCurrVal, &_fPropVal);
  // Make a note that we have now done PCA
  pca = true;
}

◆ CorrelateSteps()

void ParameterHandlerBase::CorrelateSteps ( )

Use Cholesky throw matrix for better step proposal.

Definition at line 632 of file ParameterHandlerBase.cpp.

                                                     {
// ************************************************
  //KS: Using custom function compared to ROOT one with 8 threads we have almost factor 2 performance increase, by replacing TMatrix with just double we increase it even more
  M3::MatrixVectorMulti(corr_throw, throwMatrixCholDecomp, randParams, _fNumPar);
 
  // If not doing PCA
  if (!pca) {
    #ifdef MULTITHREAD
    #pragma omp parallel for
    #endif
    for (int i = 0; i < _fNumPar; ++i) {
      if (!IsParameterFixed(i) > 0.) {
        _fPropVal[i] = _fCurrVal[i] + corr_throw[i]*_fGlobalStepScale*_fIndivStepScale[i];
      }
    }
    // If doing PCA throw uncorrelated in PCA basis (orthogonal basis by definition)
  } else { 
    PCAObj->CorrelateSteps(_fIndivStepScale, _fGlobalStepScale, randParams, corr_throw);
  }
}

◆ EnableSpecialProposal()

void ParameterHandlerBase::EnableSpecialProposal	(	const YAML::Node &	param,
		const int	Index
	)

protected

Enable special proposal.

Definition at line 297 of file ParameterHandlerBase.cpp.

                                                                                      {
// ********************************************
  doSpecialStepProposal = true;
 
  bool CircEnabled = false;
  bool FlipEnabled = false;
 
  if (param["CircularBounds"]) {
    CircEnabled = true;
  }
 
  if (param["FlipParameter"]) {
    FlipEnabled = true;
  }
 
  if (!CircEnabled && !FlipEnabled) {
    MACH3LOG_ERROR("None of Special Proposal were enabled even though param {}, has SpecialProposal entry in Yaml", GetParFancyName(Index));
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  if (CircEnabled) {
    CircularBoundsIndex.push_back(Index);
    CircularBoundsValues.push_back(Get<std::pair<double, double>>(param["CircularBounds"], __FILE__, __LINE__));
    MACH3LOG_INFO("Enabling CircularBounds for parameter {} with range [{}, {}]",
                  GetParFancyName(Index),
                  CircularBoundsValues.back().first,
                  CircularBoundsValues.back().second);
    // KS: Make sure circular bounds are within physical bounds. If we are outside of physics bound MCMC will never explore such phase space region
    if (CircularBoundsValues.back().first < _fLowBound.at(Index) || CircularBoundsValues.back().second > _fUpBound.at(Index)) {
      MACH3LOG_ERROR("Circular bounds [{}, {}] for parameter {} exceed physical bounds [{}, {}]",
                     CircularBoundsValues.back().first, CircularBoundsValues.back().second,
                     GetParFancyName(Index),
                     _fLowBound.at(Index), _fUpBound.at(Index));
      throw MaCh3Exception(__FILE__, __LINE__);
    }
  }
 
  if (FlipEnabled) {
    FlipParameterIndex.push_back(Index);
    FlipParameterPoint.push_back(Get<double>(param["FlipParameter"], __FILE__, __LINE__));
    MACH3LOG_INFO("Enabling Flipping for parameter {} with value {}",
                  GetParFancyName(Index),
                  FlipParameterPoint.back());
  }
 
  if (CircEnabled && FlipEnabled) {
    if (FlipParameterPoint.back() < CircularBoundsValues.back().first || FlipParameterPoint.back() > CircularBoundsValues.back().second) {
      MACH3LOG_ERROR("FlipParameter value {} for parameter {} is outside the CircularBounds [{}, {}]",
                     FlipParameterPoint.back(), GetParFancyName(Index), CircularBoundsValues.back().first, CircularBoundsValues.back().second);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    const double low = CircularBoundsValues.back().first;
    const double high = CircularBoundsValues.back().second;
 
    // Sanity check: ensure flipping any x in [low, high] keeps the result in [low, high]
    const double flipped_low = 2 * FlipParameterPoint.back() - low;
    const double flipped_high = 2 * FlipParameterPoint.back() - high;
    const double min_flip = std::min(flipped_low, flipped_high);
    const double max_flip = std::max(flipped_low, flipped_high);
 
    if (min_flip < low || max_flip > high) {
      MACH3LOG_ERROR("Flipping about point {} for parameter {} would leave circular bounds [{}, {}]",
                     FlipParameterPoint.back(), GetParFancyName(Index), low, high);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
  }
}

◆ FlipParameterValue()

void ParameterHandlerBase::FlipParameterValue	(	const int	index,
		const double	FlipPoint
	)

protected

KS: Flip parameter around given value, for example mass ordering around 0.

Parameters

index	parameter index you want to flip
FlipPoint	Value around which flipping is done

Definition at line 681 of file ParameterHandlerBase.cpp.

                                                                                     {
// *************************************
  if(random_number[0]->Uniform() < 0.5) {
    _fPropVal[index] = 2 * FlipPoint - _fPropVal[index];
  }
}

◆ GetParPropVec()

const std::vector< double > & ParameterHandlerBase::GetParPropVec ( )

inline

Get a reference to the proposed parameter values Can be useful if you want to track these without having to copy values using getProposed()

Definition at line 239 of file ParameterHandlerBase.h.

239{return _fPropVal;}

◆ GetPCAHandler()

PCAHandler * ParameterHandlerBase::GetPCAHandler ( ) const

inline

Get pointer for PCAHandler.

Definition at line 357 of file ParameterHandlerBase.h.

                                           {
    if (!pca) {
      MACH3LOG_ERROR("Am not running in PCA mode");
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    return PCAObj.get();
  }

◆ Init() [1/2]

void ParameterHandlerBase::Init	(	const std::string &	name,
		const std::string &	file
	)

protected

Initialisation of the class using matrix from root file.

Definition at line 93 of file ParameterHandlerBase.cpp.

                                                                            {
// ********************************************
  // Set the covariance matrix from input ROOT file (e.g. flux, ND280, NIWG)
  TFile *infile = new TFile(file.c_str(), "READ");
  if (infile->IsZombie()) {
    MACH3LOG_ERROR("Could not open input covariance ROOT file {} !!!", file);
    MACH3LOG_ERROR("Was about to retrieve matrix with name {}", name);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  TMatrixDSym *CovMat = static_cast<TMatrixDSym*>(infile->Get(name.c_str()));
 
  if (!CovMat) {
    MACH3LOG_ERROR("Could not find covariance matrix name {} in file {}", name, file);
    MACH3LOG_ERROR("Are you really sure {} exists in the file?", name);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  } 
 
  PrintLength = 35;
 
  const int nThreads = M3::GetNThreads();
  //KS: set Random numbers for each thread so each thread has different seed
  //or for one thread if without MULTITHREAD
  random_number.reserve(nThreads);
  for (int iThread = 0; iThread < nThreads; iThread++) {
    random_number.emplace_back(std::make_unique<TRandom3>(0));
  }
  // Not using adaptive by default
  use_adaptive = false;
  // Set the covariance matrix
  _fNumPar = CovMat->GetNrows();
    
  InvertCovMatrix.resize(_fNumPar, std::vector<double>(_fNumPar, 0.0));
  throwMatrixCholDecomp = new double*[_fNumPar]();
  // Set the defaults to true
  for(int i = 0; i < _fNumPar; i++) {
    throwMatrixCholDecomp[i] = new double[_fNumPar]();
    for (int j = 0; j < _fNumPar; j++) {
      throwMatrixCholDecomp[i][j] = 0.;
    }
  }
  SetName(name);
  MakePosDef(CovMat);
  SetCovMatrix(CovMat);
  if (_fNumPar <= 0) {
    MACH3LOG_CRITICAL("Covariance matrix {} has {} entries!", GetName(), _fNumPar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  ReserveMemory(_fNumPar);
 
  infile->Close();
 
  MACH3LOG_INFO("Created covariance matrix named: {}", GetName());
  MACH3LOG_INFO("from file: {}", file);
  delete infile;
}

◆ Init() [2/2]

void ParameterHandlerBase::Init ( const std::vector< std::string > & YAMLFile )

protected

Initialisation of the class using config.

Parameters

YAMLFile A vector of strings representing the YAML files used for initialisation of matrix

Definition at line 154 of file ParameterHandlerBase.cpp.

                                                                    {
// ********************************************
  _fYAMLDoc["Systematics"] = YAML::Node(YAML::NodeType::Sequence);
  for(unsigned int i = 0; i < YAMLFile.size(); i++)
  {
    YAML::Node YAMLDocTemp = M3OpenConfig(YAMLFile[i]);
    for (const auto& item : YAMLDocTemp["Systematics"]) {
      _fYAMLDoc["Systematics"].push_back(item);
    }
  }
 
  const int nThreads = M3::GetNThreads();
  //KS: set Random numbers for each thread so each thread has different seed
  //or for one thread if without MULTITHREAD
  random_number.reserve(nThreads);
  for (int iThread = 0; iThread < nThreads; iThread++) {
    random_number.emplace_back(std::make_unique<TRandom3>(0));
  }
  PrintLength = 35;
 
  // Set the covariance matrix
  _fNumPar = int(_fYAMLDoc["Systematics"].size());
 
  use_adaptive = false;
 
  InvertCovMatrix.resize(_fNumPar, std::vector<double>(_fNumPar, 0.0));
  throwMatrixCholDecomp = new double*[_fNumPar]();
  for(int i = 0; i < _fNumPar; i++) {
    throwMatrixCholDecomp[i] = new double[_fNumPar]();
    for (int j = 0; j < _fNumPar; j++) {
      throwMatrixCholDecomp[i][j] = 0.;
    }
  }
  ReserveMemory(_fNumPar);
 
  TMatrixDSym* _fCovMatrix = new TMatrixDSym(_fNumPar);
  int i = 0;
  std::vector<std::map<std::string,double>> Correlations(_fNumPar);
  std::map<std::string, int> CorrNamesMap;
 
  //ETA - read in the systematics. Would be good to add in some checks to make sure
  //that there are the correct number of entries i.e. are the _fNumPar for Names,
  //PreFitValues etc etc.
  for (auto const &param : _fYAMLDoc["Systematics"])
  {
    _fFancyNames[i] = Get<std::string>(param["Systematic"]["Names"]["FancyName"], __FILE__ , __LINE__);
    _fPreFitValue[i] = Get<double>(param["Systematic"]["ParameterValues"]["PreFitValue"], __FILE__ , __LINE__);
    _fIndivStepScale[i] = Get<double>(param["Systematic"]["StepScale"]["MCMC"], __FILE__ , __LINE__);
    _fError[i] = Get<double>(param["Systematic"]["Error"], __FILE__ , __LINE__);
    _fSampleNames[i] = GetFromManager<std::vector<std::string>>(param["Systematic"]["SampleNames"], {}, __FILE__, __LINE__);
    if(_fError[i] <= 0) {
      MACH3LOG_ERROR("Error for param {}({}) is negative and equal to {}", _fFancyNames[i], i, _fError[i]);
      throw MaCh3Exception(__FILE__ , __LINE__ );
    }
    //ETA - a bit of a fudge but works
    auto TempBoundsVec = GetBounds(param["Systematic"]["ParameterBounds"]);
    _fLowBound[i] = TempBoundsVec[0];
    _fUpBound[i] = TempBoundsVec[1];
 
    //ETA - now for parameters which are optional and have default values
    _fFlatPrior[i] = GetFromManager<bool>(param["Systematic"]["FlatPrior"], false, __FILE__ , __LINE__);
 
    // Allow to fix param, this setting should be used only for params which are permanently fixed like baseline, please use global config for fixing param more flexibly
    if(GetFromManager<bool>(param["Systematic"]["FixParam"], false, __FILE__ , __LINE__)) {
      ToggleFixParameter(_fFancyNames[i]);
    }
 
    if(param["Systematic"]["SpecialProposal"]) {
      EnableSpecialProposal(param["Systematic"]["SpecialProposal"], i);
    }
 
    //Fill the map to get the correlations later as well
    CorrNamesMap[param["Systematic"]["Names"]["FancyName"].as<std::string>()]=i;
 
    //Also loop through the correlations
    if(param["Systematic"]["Correlations"]) {
      for(unsigned int Corr_i = 0; Corr_i < param["Systematic"]["Correlations"].size(); ++Corr_i){
        for (YAML::const_iterator it = param["Systematic"]["Correlations"][Corr_i].begin(); it!=param["Systematic"]["Correlations"][Corr_i].end();++it) {
          Correlations[i][it->first.as<std::string>()] = it->second.as<double>();
        }
      }
    }
    i++;
  } // end loop over para
  if(i != _fNumPar) {
    MACH3LOG_CRITICAL("Inconsistent number of params in Yaml  {} vs {}, this indicate wrong syntax", i, i, _fNumPar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  // ETA Now that we've been through all systematic let's fill the covmatrix
  //This makes the root TCov from YAML
  for(int j = 0; j < _fNumPar; j++) {
    (*_fCovMatrix)(j, j) = _fError[j]*_fError[j];
    //Get the map of parameter name to correlation from the Correlations object
    for (auto const& pair : Correlations[j]) {
      auto const& key = pair.first;
      auto const& val = pair.second;
      int index = -1;
      //If you found the parameter name then get the index
      if (CorrNamesMap.find(key) != CorrNamesMap.end()) {
        index = CorrNamesMap[key];
      } else {
        MACH3LOG_ERROR("Parameter {} not in list! Check your spelling?", key);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      double Corr1 = val;
      double Corr2 = 0;
      if(Correlations[index].find(_fFancyNames[j]) != Correlations[index].end()) {
        Corr2 = Correlations[index][_fFancyNames[j]];
        //Do they agree to better than float precision?
        if(std::abs(Corr2 - Corr1) > FLT_EPSILON) {
          MACH3LOG_ERROR("Correlations are not equal between {} and {}", _fFancyNames[j], key);
          MACH3LOG_ERROR("Got : {} and {}", Corr2, Corr1);
          throw MaCh3Exception(__FILE__ , __LINE__ );
        }
      } else {
        MACH3LOG_ERROR("Correlation does not appear reciprocally between {} and {}", _fFancyNames[j], key);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      (*_fCovMatrix)(j, index)= (*_fCovMatrix)(index, j) = Corr1*_fError[j]*_fError[index];
    }
  }
 
  //Now make positive definite
  MakePosDef(_fCovMatrix);
  SetCovMatrix(_fCovMatrix);
 
  if (_fNumPar <= 0) {
    MACH3LOG_ERROR("ParameterHandler object has {} systematics!", _fNumPar);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  Tunes = std::make_unique<ParameterTunes>(_fYAMLDoc["Systematics"]);
 
  MACH3LOG_INFO("Created covariance matrix from files: ");
  for(const auto &file : YAMLFile){
    MACH3LOG_INFO("{} ", file);
  }
  MACH3LOG_INFO("----------------");
  MACH3LOG_INFO("Found {} systematics parameters in total", _fNumPar);
  MACH3LOG_INFO("----------------");
}

◆ InitialiseAdaption()

void ParameterHandlerBase::InitialiseAdaption ( const YAML::Node & adapt_manager )

Initialise adaptive MCMC.

Parameters

adapt_manager Node having from which we load all adaptation options

Definition at line 1103 of file ParameterHandlerBase.cpp.

                                                                          {
// ********************************************
  if(PCAObj){
    MACH3LOG_ERROR("PCA has been enabled and now trying to enable Adaption. Right now both configuration don't work with each other");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  AdaptiveHandler = std::make_unique<adaptive_mcmc::AdaptiveMCMCHandler>();
  // Now we read the general settings [these SHOULD be common across all matrices!]
  bool success = AdaptiveHandler->InitFromConfig(adapt_manager, matrixName, &_fCurrVal, &_fError);
  if(!success) return;
  AdaptiveHandler->Print();
 
  // Next let"s check for external matrices
  // We"re going to grab this info from the YAML manager
  if(!GetFromManager<bool>(adapt_manager["AdaptionOptions"]["Covariance"][matrixName]["UseExternalMatrix"], false, __FILE__ , __LINE__)) {
    MACH3LOG_WARN("Not using external matrix for {}, initialising adaption from scratch", matrixName);
    // If we don't have a covariance matrix to start from for adaptive tune we need to make one!
    use_adaptive = true;
    AdaptiveHandler->CreateNewAdaptiveCovariance();
    return;
  }
 
  // Finally, we accept that we want to read the matrix from a file!
  auto external_file_name = GetFromManager<std::string>(adapt_manager["AdaptionOptions"]["Covariance"][matrixName]["ExternalMatrixFileName"], "", __FILE__ , __LINE__);
  auto external_matrix_name = GetFromManager<std::string>(adapt_manager["AdaptionOptions"]["Covariance"][matrixName]["ExternalMatrixName"], "", __FILE__ , __LINE__);
  auto external_mean_name = GetFromManager<std::string>(adapt_manager["AdaptionOptions"]["Covariance"][matrixName]["ExternalMeansName"], "", __FILE__ , __LINE__);
 
  AdaptiveHandler->SetThrowMatrixFromFile(external_file_name, external_matrix_name, external_mean_name, use_adaptive);
  SetThrowMatrix(AdaptiveHandler->GetAdaptiveCovariance());
 
  MACH3LOG_INFO("Successfully Set External Throw Matrix Stored in {}", external_file_name);
}

◆ IsParameterFixed() [1/2]

bool ParameterHandlerBase::IsParameterFixed ( const int i ) const

inline

Is parameter fixed or not.

Parameters

i	Parameter index

Definition at line 320 of file ParameterHandlerBase.h.

                                           {
    if (_fError[i] < 0) { return true; }
    else                { return false; }
  }

◆ IsParameterFixed() [2/2]

bool ParameterHandlerBase::IsParameterFixed ( const std::string & name ) const

Is parameter fixed or not.

Parameters

name	Name of parameter you want to check if is fixed

Definition at line 932 of file ParameterHandlerBase.cpp.

                                                                       {
// ********************************************
  const int Index = GetParIndex(name);
  if(Index != M3::_BAD_INT_) {
    return IsParameterFixed(Index);
  }
 
  MACH3LOG_WARN("I couldn't find parameter with name {}, therefore don't know if it fixed", name);
  return false;
}

◆ IsPCA()

bool ParameterHandlerBase::IsPCA ( ) const

inline

is PCA, can use to query e.g. LLH scans

Definition at line 336 of file ParameterHandlerBase.h.

336{ return pca; }

◆ MakeClosestPosDef()

void ParameterHandlerBase::MakeClosestPosDef ( TMatrixDSym * cov )

protected

HW: Finds closest possible positive definite matrix in Frobenius Norm ||.||_frob Where ||X||_frob=sqrt[sum_ij(x_ij^2)] (basically just turns an n,n matrix into vector in n^2 space then does Euclidean norm)

Definition at line 1171 of file ParameterHandlerBase.cpp.

                                                             {
// ********************************************
  // Want to get cov' = (cov_sym+cov_polar)/2
  // cov_sym=(cov+cov^T)/2
  // cov_polar-> SVD cov to cov=USV^T then cov_polar=VSV^T
 
  //Get frob norm of cov
  //  Double_t cov_norm=cov->E2Norm();
  
  TMatrixDSym* cov_trans = cov;
  cov_trans->T();
  TMatrixDSym cov_sym = 0.5*(*cov+*cov_trans); //If cov is symmetric does nothing, otherwise just ensures symmetry
 
  //Do SVD to get polar form
  TDecompSVD cov_sym_svd=TDecompSVD(cov_sym);
  if(!cov_sym_svd.Decompose()){
    MACH3LOG_ERROR("Cannot do SVD on input matrix!");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  
  TMatrixD cov_sym_v = cov_sym_svd.GetV();
  TMatrixD cov_sym_vt = cov_sym_v;
  cov_sym_vt.T();
  //SVD returns as vector (grrr) so need to get into matrix form for multiplying!
  TVectorD cov_sym_sigvect = cov_sym_svd.GetSig();
 
  const Int_t nCols = cov_sym_v.GetNcols(); //square so only need rows hence lack of cols
  TMatrixDSym cov_sym_sig(nCols);
  TMatrixDDiag cov_sym_sig_diag(cov_sym_sig);
  cov_sym_sig_diag=cov_sym_sigvect;
 
  //Can finally get H=VSV
  TMatrixDSym cov_sym_polar = cov_sym_sig.SimilarityT(cov_sym_vt);//V*S*V^T (this took forver to find!)
  
  //Now we can construct closest approximater Ahat=0.5*(B+H)
  TMatrixDSym cov_closest_approx  = 0.5*(cov_sym+cov_sym_polar);//Not fully sure why this is even needed since symmetric B -> U=V
  //Get norm of transformed
  //  Double_t approx_norm=cov_closest_approx.E2Norm();
  //MACH3LOG_INFO("Initial Norm: {:.6f} | Norm after transformation: {:.6f} | Ratio: {:.6f}", cov_norm, approx_norm, cov_norm / approx_norm);
  
  *cov = cov_closest_approx;
  //Now can just add a makeposdef!
  MakePosDef(cov);
}

◆ MakePosDef()

void ParameterHandlerBase::MakePosDef ( TMatrixDSym * cov = nullptr )

protected

Make matrix positive definite by adding small values to diagonal, necessary for inverting matrix.

Parameters

cov	Matrix which we evaluate Positive Definitiveness

Definition at line 992 of file ParameterHandlerBase.cpp.

                                                      {
// ********************************************
  if(cov == nullptr){
    cov = &*covMatrix;
    MACH3LOG_WARN("Passed nullptr to cov matrix in {}", matrixName);
  }
 
  //DB Save original warning state and then increase it in this function to suppress 'matrix not positive definite' messages
  //Means we no longer need to overload
  int originalErrorWarning = gErrorIgnoreLevel;
  gErrorIgnoreLevel = kFatal;
  
  //DB Loop 1000 times adding 1e-9 which tops out at 1e-6 shift on the diagonal before throwing error
  int MaxAttempts = 1e5;
  int iAttempt = 0;
  bool CanDecomp = false;
  TDecompChol chdcmp;
  
  for (iAttempt = 0; iAttempt < MaxAttempts; iAttempt++) {
    chdcmp = TDecompChol(*cov);
    if (chdcmp.Decompose()) {
      CanDecomp = true;
      break;
    } else {
      #ifdef MULTITHREAD
      #pragma omp parallel for
      #endif
      for (int iVar = 0 ; iVar < _fNumPar; iVar++) {
        (*cov)(iVar,iVar) += pow(10, -9);
      }
    }
  }
 
  if (!CanDecomp) {
    MACH3LOG_ERROR("Tried {} times to shift diagonal but still can not decompose the matrix", MaxAttempts);
    MACH3LOG_ERROR("This indicates that something is wrong with the input matrix");
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
  if(!use_adaptive || AdaptiveHandler->GetTotalSteps() < 2) {
    MACH3LOG_INFO("Had to shift diagonal {} time(s) to allow the covariance matrix to be decomposed", iAttempt);
  }
  //DB Resetting warning level
  gErrorIgnoreLevel = originalErrorWarning;
}

◆ PrintIndivStepScale()

void ParameterHandlerBase::PrintIndivStepScale ( ) const

Print step scale for each parameter.

Definition at line 980 of file ParameterHandlerBase.cpp.

                                                     {
// ********************************************
  MACH3LOG_INFO("============================================================");
  MACH3LOG_INFO("{:<{}} | {:<11}", "Parameter:", PrintLength, "Step scale:");
  for (int iParam = 0; iParam < _fNumPar; iParam++) {
    MACH3LOG_INFO("{:<{}} | {:<11}", _fFancyNames[iParam].c_str(), PrintLength, _fIndivStepScale[iParam]);
  }
  MACH3LOG_INFO("============================================================");
}

◆ PrintNominal()

void ParameterHandlerBase::PrintNominal ( ) const

Print prior value for every parameter.

Definition at line 728 of file ParameterHandlerBase.cpp.

                                              {
// ********************************************
  MACH3LOG_INFO("Prior values for {} ParameterHandler:", GetName());
  for (int i = 0; i < _fNumPar; i++) {
    MACH3LOG_INFO("    {}   {} ", GetParFancyName(i), GetParInit(i));
  }
}

◆ PrintNominalCurrProp()

void ParameterHandlerBase::PrintNominalCurrProp ( ) const

Print prior, current and proposed value for each parameter.

Definition at line 738 of file ParameterHandlerBase.cpp.

                                                      {
// ********************************************
  MACH3LOG_INFO("Printing parameters for {}", GetName());
  // Dump out the PCA parameters too
  if (pca) {
    PCAObj->Print();
  }
  MACH3LOG_INFO("{:<30} {:<10} {:<10} {:<10}", "Name", "Prior", "Current", "Proposed");
  for (int i = 0; i < _fNumPar; ++i) {
    MACH3LOG_INFO("{:<30} {:<10.2f} {:<10.2f} {:<10.2f}", GetParFancyName(i), _fPreFitValue[i], _fCurrVal[i], _fPropVal[i]);
  }
}

◆ PrintParameters()

void ParameterHandlerBase::PrintParameters ( ) const

inline

Warning: only for backward compatibility

Todo:: remove it

Definition at line 292 of file ParameterHandlerBase.h.

292{PrintNominalCurrProp();};

ParameterHandlerBase::PrintNominalCurrProp

void PrintNominalCurrProp() const

Print prior, current and proposed value for each parameter.

Definition: ParameterHandlerBase.cpp:738

◆ ProposeStep()

void ParameterHandlerBase::ProposeStep ( )

virtual

Generate a new proposed state.

Reimplemented in PyParameterHandlerBase.

Definition at line 561 of file ParameterHandlerBase.cpp.

                                       {
// ************************************************
  // Make the random numbers for the step proposal
  Randomize();
  CorrelateSteps();
  if(use_adaptive) UpdateAdaptiveCovariance();
 
  // KS: According to Dr Wallace we update using previous not proposed step
  // this way we do special proposal after adaptive after.
  // This way we can shortcut and skip rest of proposal
  if(!doSpecialStepProposal) return;
 
  SpecialStepProposal();
}

◆ RandomConfiguration()

void ParameterHandlerBase::RandomConfiguration ( )

Randomly throw the parameters in their 1 sigma range.

Definition at line 505 of file ParameterHandlerBase.cpp.

                                               {
// *************************************
  // Have the 1 sigma for each parameter in each covariance class, sweet!
  // Don't want to change the prior array because that's what determines our likelihood
  // Want to change the _fPropVal, _fCurrVal, _fPreFitValue
  // _fPreFitValue and the others will already be set
  for (int i = 0; i < _fNumPar; ++i) {
    // Check if parameter is fixed first: if so don't randomly throw
    if (IsParameterFixed(i)) continue;
    // Check that the sigma range is larger than the parameter range
    // If not, throw in the valid parameter range instead
    const double paramrange = _fUpBound[i] - _fLowBound[i];
    const double sigma = sqrt((*covMatrix)(i,i));
    double throwrange = sigma;
    if (paramrange < sigma) throwrange = paramrange;
 
    _fPropVal[i] = _fPreFitValue[i] + random_number[0]->Gaus(0, 1)*throwrange;
    // Try again if we the initial parameter proposal falls outside of the range of the parameter
    int throws = 0;
    while (_fPropVal[i] > _fUpBound[i] || _fPropVal[i] < _fLowBound[i]) {
      if (throws > 1000) {
        MACH3LOG_WARN("Tried {} times to throw parameter {} but failed", throws, i);
        MACH3LOG_WARN("Matrix: {}", matrixName);
        MACH3LOG_WARN("Param: {}", _fNames[i]);
        throw MaCh3Exception(__FILE__ , __LINE__ );
      }
      _fPropVal[i] = _fPreFitValue[i] + random_number[0]->Gaus(0, 1)*throwrange;
      throws++;
    }
    MACH3LOG_INFO("Setting current step in {} param {} = {} from {}", matrixName, i, _fPropVal[i], _fCurrVal[i]);
    _fCurrVal[i] = _fPropVal[i];
  }
  if (pca) PCAObj->TransferToPCA();
}

◆ Randomize()

void ParameterHandlerBase::Randomize ( )

"Randomize" the parameters in the covariance class for the proposed step. Used the proposal kernel and the current parameter value to set proposed step

Definition at line 596 of file ParameterHandlerBase.cpp.

                                                {
// ************************************************
  if (!pca) {
    //KS: By multithreading here we gain at least factor 2 with 8 threads with ND only fit
    #ifdef MULTITHREAD
    #pragma omp parallel for
    #endif
    for (int i = 0; i < _fNumPar; ++i) {
      // If parameter isn't fixed
      if (!IsParameterFixed(i) > 0.0) {
        randParams[i] = random_number[M3::GetThreadIndex()]->Gaus(0, 1);
        // If parameter IS fixed
      } else {
        randParams[i] = 0.0;
      }
    } // end for
  // If we're in the PCA basis we instead throw parameters there (only _fNumParPCA parameter)
  } else {
    // Scale the random parameters by the sqrt of eigen values for the throw
    #ifdef MULTITHREAD
    #pragma omp parallel for
    #endif
    for (int i = 0; i < PCAObj->GetNumberPCAedParameters(); ++i)
    {
      // If parameter IS fixed or out of bounds
      if (PCAObj->IsParameterFixedPCA(i)) {
        randParams[i] = 0.0;
      } else {
        randParams[i] = random_number[M3::GetThreadIndex()]->Gaus(0,1);
      }
    }
  }
}

◆ ReserveMemory()

void ParameterHandlerBase::ReserveMemory ( const int size )

protected

Initialise vectors with parameters information.

Parameters

size	integer telling size to which we will resize all vectors/allocate memory

Definition at line 390 of file ParameterHandlerBase.cpp.

                                                          {
// ********************************************
  _fNames = std::vector<std::string>(SizeVec);
  _fFancyNames = std::vector<std::string>(SizeVec);
  _fPreFitValue = std::vector<double>(SizeVec);
  _fError = std::vector<double>(SizeVec);
  _fCurrVal = std::vector<double>(SizeVec);
  _fPropVal = std::vector<double>(SizeVec);
  _fLowBound = std::vector<double>(SizeVec);
  _fUpBound = std::vector<double>(SizeVec);
  _fFlatPrior = std::vector<bool>(SizeVec);
  _fIndivStepScale = std::vector<double>(SizeVec);
  _fSampleNames = std::vector<std::vector<std::string>>(_fNumPar);
 
  corr_throw = new double[SizeVec];
  // set random parameter vector (for correlated steps)
  randParams = new double[SizeVec];
 
  // Set the defaults to true
  for(int i = 0; i < SizeVec; i++) {
    _fPreFitValue.at(i) = 1.;
    _fError.at(i) = 1.;
    _fCurrVal.at(i) = 0.;
    _fPropVal.at(i) = 0.;
    _fLowBound.at(i) = -999.99;
    _fUpBound.at(i) = 999.99;
    _fFlatPrior.at(i) = false;
    _fIndivStepScale.at(i) = 1.;
    corr_throw[i] = 0.0;
    randParams[i] = 0.0;
  }
 
  _fGlobalStepScale = 1.0;
}

◆ ResetIndivStepScale()

void ParameterHandlerBase::ResetIndivStepScale ( )

Adaptive Step Tuning Stuff.

Definition at line 1038 of file ParameterHandlerBase.cpp.

                                               {
// ********************************************
  std::vector<double> stepScales(_fNumPar);
  for (int i = 0; i <_fNumPar; i++) {
    stepScales[i] = 1.;
  }
  _fGlobalStepScale = 1.0;
  SetIndivStepScale(stepScales);
}

◆ RetPointer()

const double * ParameterHandlerBase::RetPointer ( const int iParam )

inline

DB Pointer return to param position.

Parameters

iParam The index of the parameter in the vector.

Returns: A pointer to the parameter value at the specified index.

Warning: ETA - This might be a bit squiffy? If the vector gots moved from say a push_back then the pointer is no longer valid... maybe need a better way to deal with this? It was fine before when the return was to an element of a new array. There must be a clever C++ way to be careful

Definition at line 235 of file ParameterHandlerBase.h.

235{return &(_fPropVal.data()[iParam]);}

◆ SaveAdaptiveToFile()

void ParameterHandlerBase::SaveAdaptiveToFile	(	const std::string &	outFileName,
		const std::string &	systematicName
	)

inline

Save adaptive throw matrix to file.

Definition at line 192 of file ParameterHandlerBase.h.

192 {

193 AdaptiveHandler->SaveAdaptiveToFile(outFileName, systematicName); }

◆ SaveUpdatedMatrixConfig()

void ParameterHandlerBase::SaveUpdatedMatrixConfig ( )

KS: After step scale, prefit etc. value were modified save this modified config.

Definition at line 1246 of file ParameterHandlerBase.cpp.

                                                   {
// ********************************************
  if (!_fYAMLDoc)
  {
    MACH3LOG_CRITICAL("Yaml node hasn't been initialised for matrix {}, something is not right", matrixName);
    MACH3LOG_CRITICAL("I am not throwing error but should be investigated");
    return;
  }
 
  YAML::Node copyNode = _fYAMLDoc;
  int i = 0;
 
  for (YAML::Node param : copyNode["Systematics"])
  {
    //KS: Feel free to update it, if you need updated prefit value etc
    param["Systematic"]["StepScale"]["MCMC"] = MaCh3Utils::FormatDouble(_fIndivStepScale[i], 4);
    i++;
  }
  // Save the modified node to a file
  std::ofstream fout("Modified_Matrix.yaml");
  fout << copyNode;
  fout.close();
}

◆ SetThrowMatrixFromFile()

void ParameterHandlerBase::SetThrowMatrixFromFile	(	const std::string &	matrix_file_name,
		const std::string &	matrix_name,
		const std::string &	means_name
	)

protected

sets throw matrix from a file

Parameters

matrix_file_name	name of file matrix lives in
matrix_name	name of matrix in file
means_name	name of means vec in file

◆ SpecialStepProposal()

void ParameterHandlerBase::SpecialStepProposal ( )

protected

Perform Special Step Proposal.

Warning: KS: Following Asher comment we do "Step->Circular Bounds->Flip"

Definition at line 577 of file ParameterHandlerBase.cpp.

                                               {
// ************************************************
 
  // HW It should now automatically set dcp to be with [-pi, pi]
  for (size_t i = 0; i < CircularBoundsIndex.size(); ++i) {
    CircularParBounds(CircularBoundsIndex[i], CircularBoundsValues[i].first, CircularBoundsValues[i].second);
  }
 
  // Okay now we've done the standard steps, we can add in our nice flips hierarchy flip first
  for (size_t i = 0; i < FlipParameterIndex.size(); ++i) {
    FlipParameterValue(FlipParameterIndex[i], FlipParameterPoint[i]);
  }
}

◆ ThrowParameters()

void ParameterHandlerBase::ThrowParameters ( )

Throw the parameters according to the covariance matrix. This shouldn't be used in MCMC code ase it can break Detailed Balance;.

Definition at line 452 of file ParameterHandlerBase.cpp.

                                           {
// *************************************
  // First draw new randParams
  Randomize();
 
  M3::MatrixVectorMulti(corr_throw, throwMatrixCholDecomp, randParams, _fNumPar);
 
  // KS: We use PCA very rarely on top PCA functionality isn't implemented for this function.
  // Use __builtin_expect to give compiler a hint which option is more likely, which should help
  // with better optimisation. This isn't critical but more to have example
  if (__builtin_expect(!pca, 1)) {
    #ifdef MULTITHREAD
    #pragma omp parallel for
    #endif
    for (int i = 0; i < _fNumPar; ++i) {
      // Check if parameter is fixed first: if so don't randomly throw
      if (IsParameterFixed(i)) continue;
 
      _fPropVal[i] = _fPreFitValue[i] + corr_throw[i];
      int throws = 0;
      // Try again if we the initial parameter proposal falls outside of the range of the parameter
      while (_fPropVal[i] > _fUpBound[i] || _fPropVal[i] < _fLowBound[i]) {
        randParams[i] = random_number[M3::GetThreadIndex()]->Gaus(0, 1);
        const double corr_throw_single = M3::MatrixVectorMultiSingle(throwMatrixCholDecomp, randParams, _fNumPar, i);
        _fPropVal[i] = _fPreFitValue[i] + corr_throw_single;
        if (throws > 10000) 
        {
          //KS: Since we are multithreading there is danger that those messages
          //will be all over the place, small price to pay for faster code
          MACH3LOG_WARN("Tried {} times to throw parameter {} but failed", throws, i);
          MACH3LOG_WARN("Matrix: {}", matrixName);
          MACH3LOG_WARN("Param: {}", _fNames[i]);
          MACH3LOG_WARN("Setting _fPropVal:  {} to {}", _fPropVal[i], _fPreFitValue[i]);
          MACH3LOG_WARN("I live at {}:{}", __FILE__, __LINE__);
          _fPropVal[i] = _fPreFitValue[i];
          //throw MaCh3Exception(__FILE__ , __LINE__ );
        }
        throws++;
      }
      _fCurrVal[i] = _fPropVal[i];
    }
  }
  else
  {
    PCAObj->ThrowParameters(random_number, throwMatrixCholDecomp,
                            randParams, corr_throw,
                            _fPreFitValue, _fLowBound, _fUpBound, _fNumPar);
  } // end if pca
}

◆ ThrowParCurr()

void ParameterHandlerBase::ThrowParCurr ( const double mag = 1. )

Helper function to throw the current parameter by mag sigma. Can study bias in MCMC with this; put different starting parameters.

Definition at line 709 of file ParameterHandlerBase.cpp.

                                                        {
// ********************************************
  Randomize();
  if (!pca) {
    // Get the correlated throw vector
    M3::MatrixVectorMulti(corr_throw, throwMatrixCholDecomp, randParams, _fNumPar);
    // The number of sigmas to throw
    // Should probably have this as a default parameter input to the function instead
    for (int i = 0; i < _fNumPar; i++) {
      if (!IsParameterFixed(i) > 0.){
        _fCurrVal[i] = corr_throw[i]*mag;
      }
    }
  } else {
    PCAObj->ThrowParCurr(mag, randParams);
  }
}

◆ ThrowParProp()

void ParameterHandlerBase::ThrowParProp ( const double mag = 1. )

Throw the proposed parameter by mag sigma. Should really just have the user specify this throw by having argument double.

Definition at line 691 of file ParameterHandlerBase.cpp.

                                                        {
// ********************************************
  Randomize();
  if (!pca) {
    // Make the correlated throw
    M3::MatrixVectorMulti(corr_throw, throwMatrixCholDecomp, randParams, _fNumPar);
    // Number of sigmas we throw
    for (int i = 0; i < _fNumPar; i++) {
      if (!IsParameterFixed(i) > 0.)
        _fPropVal[i] = _fCurrVal[i] + corr_throw[i]*mag;
    }
  } else {
    PCAObj->ThrowParProp(mag, randParams);
  }
}

◆ ToggleFixAllParameters()

void ParameterHandlerBase::ToggleFixAllParameters ( )

fix parameters at prior values

Definition at line 892 of file ParameterHandlerBase.cpp.

                                                  {
// ********************************************
  // fix or unfix all parameters by multiplying by -1
  if(!pca) {
    for (int i = 0; i < _fNumPar; i++) _fError[i] *= -1.0;
  } else{
    PCAObj->ToggleFixAllParameters();
  }
}

◆ ToggleFixParameter() [1/2]

void ParameterHandlerBase::ToggleFixParameter ( const int i )

fix parameter at prior values

Parameters

i	Parameter index

Definition at line 903 of file ParameterHandlerBase.cpp.

                                                         {
// ********************************************
  if(!pca) {
    if (i > _fNumPar) {
      MACH3LOG_ERROR("Can't {} for parameter {} because size of covariance ={}", __func__, i, _fNumPar);
      MACH3LOG_ERROR("Fix this in your config file please!");
      throw MaCh3Exception(__FILE__ , __LINE__ );
    } else {
      _fError[i] *= -1.0;
      MACH3LOG_INFO("Setting {}(parameter {}) to fixed at {}", GetParFancyName(i), i, _fCurrVal[i]);
    }
  } else {
    PCAObj->ToggleFixParameter(i, _fNames);
  }
}

◆ ToggleFixParameter() [2/2]

void ParameterHandlerBase::ToggleFixParameter ( const std::string & name )

Fix parameter at prior values.

Parameters

name	Name of parameter you want to fix

Definition at line 920 of file ParameterHandlerBase.cpp.

                                                                   {
// ********************************************
  const int Index = GetParIndex(name);
  if(Index != M3::_BAD_INT_) {
    ToggleFixParameter(Index);
    return;
  }
 
  MACH3LOG_WARN("I couldn't find parameter with name {}, therefore will not fix it", name);
}

◆ UpdateAdaptiveCovariance()

void ParameterHandlerBase::UpdateAdaptiveCovariance ( )

Method to update adaptive MCMC [12].

Definition at line 1138 of file ParameterHandlerBase.cpp.

                                                   {
// ********************************************
  // Updates adaptive matrix
  // First we update the total means
 
  // Skip this if we're at a large number of steps
  if(AdaptiveHandler->SkipAdaption()) {
    AdaptiveHandler->IncrementNSteps();
    return;
  }
 
  // Call main adaption function
  AdaptiveHandler->UpdateAdaptiveCovariance();
 
  //This is likely going to be the slow bit!
  if(AdaptiveHandler->IndivStepScaleAdapt()) {
    ResetIndivStepScale();
  }
 
  if(AdaptiveHandler->UpdateMatrixAdapt()) {
    TMatrixDSym* update_matrix = static_cast<TMatrixDSym*>(AdaptiveHandler->GetAdaptiveCovariance()->Clone());
    UpdateThrowMatrix(update_matrix); //Now we update and continue!
    //Also Save the adaptive to file
    AdaptiveHandler->SaveAdaptiveToFile(AdaptiveHandler->GetOutFileName(), GetName());
  }
 
  AdaptiveHandler->IncrementNSteps();
}

◆ UpdateThrowMatrix()

void ParameterHandlerBase::UpdateThrowMatrix ( TMatrixDSym * cov )

Definition at line 1092 of file ParameterHandlerBase.cpp.

                                                            {
// ********************************************
  delete throwMatrix;
  throwMatrix = nullptr;
  delete throwMatrix_CholDecomp;
  throwMatrix_CholDecomp = nullptr;
  SetThrowMatrix(cov);
}

Member Data Documentation

◆ _fCurrVal

std::vector<double> ParameterHandlerBase::_fCurrVal

protected

Current value of the parameter.

Definition at line 447 of file ParameterHandlerBase.h.

◆ _fError

std::vector<double> ParameterHandlerBase::_fError

protected

Prior error on the parameter.

Definition at line 451 of file ParameterHandlerBase.h.

◆ _fFancyNames

std::vector<std::string> ParameterHandlerBase::_fFancyNames

protected

Fancy name for example rather than xsec_0 it is MAQE, useful for human reading.

Definition at line 439 of file ParameterHandlerBase.h.

◆ _fFlatPrior

std::vector<bool> ParameterHandlerBase::_fFlatPrior

protected

Whether to apply flat prior or not.

Definition at line 459 of file ParameterHandlerBase.h.

◆ _fGlobalStepScale

double ParameterHandlerBase::_fGlobalStepScale

protected

Global step scale applied to all params in this class.

Definition at line 431 of file ParameterHandlerBase.h.

◆ _fIndivStepScale

std::vector<double> ParameterHandlerBase::_fIndivStepScale

protected

Individual step scale used by MCMC algorithm.

Definition at line 457 of file ParameterHandlerBase.h.

◆ _fLowBound

std::vector<double> ParameterHandlerBase::_fLowBound

protected

Lowest physical bound, parameter will not be able to go beyond it.

Definition at line 453 of file ParameterHandlerBase.h.

◆ _fNames

std::vector<std::string> ParameterHandlerBase::_fNames

protected

ETA _fNames is set automatically in the covariance class to be something like xsec_i, this is currently to make things compatible with the Diagnostic tools.

Definition at line 437 of file ParameterHandlerBase.h.

◆ _fNumPar

int ParameterHandlerBase::_fNumPar

protected

Number of systematic parameters.

Definition at line 443 of file ParameterHandlerBase.h.

◆ _fPreFitValue

std::vector<double> ParameterHandlerBase::_fPreFitValue

protected

Parameter value dictated by the prior model. Based on it penalty term is calculated.

Definition at line 445 of file ParameterHandlerBase.h.

◆ _fPropVal

std::vector<double> ParameterHandlerBase::_fPropVal

protected

Proposed value of the parameter.

Definition at line 449 of file ParameterHandlerBase.h.

◆ _fSampleNames

std::vector<std::vector<std::string> > ParameterHandlerBase::_fSampleNames

protected

Tells to which samples object param should be applied.

Definition at line 461 of file ParameterHandlerBase.h.

◆ _fUpBound

std::vector<double> ParameterHandlerBase::_fUpBound

protected

Upper physical bound, parameter will not be able to go beyond it.

Definition at line 455 of file ParameterHandlerBase.h.

◆ _fYAMLDoc

YAML::Node ParameterHandlerBase::_fYAMLDoc

protected

Stores config describing systematics.

Definition at line 441 of file ParameterHandlerBase.h.

◆ AdaptiveHandler

std::unique_ptr<adaptive_mcmc::AdaptiveMCMCHandler> ParameterHandlerBase::AdaptiveHandler

protected

Struct containing information about adaption.

Definition at line 478 of file ParameterHandlerBase.h.

◆ CircularBoundsIndex

std::vector<int> ParameterHandlerBase::CircularBoundsIndex

protected

Indices of parameters with circular bounds.

Definition at line 487 of file ParameterHandlerBase.h.

◆ CircularBoundsValues

std::vector<std::pair<double,double> > ParameterHandlerBase::CircularBoundsValues

protected

Circular bounds for each parameter (lower, upper)

Definition at line 489 of file ParameterHandlerBase.h.

◆ corr_throw

double* ParameterHandlerBase::corr_throw

protected

Result of multiplication of Cholesky matrix and randParams.

Definition at line 429 of file ParameterHandlerBase.h.

◆ covMatrix

TMatrixDSym* ParameterHandlerBase::covMatrix

protected

The covariance matrix.

Definition at line 417 of file ParameterHandlerBase.h.

◆ doSpecialStepProposal

bool ParameterHandlerBase::doSpecialStepProposal

protected

Check if any of special step proposal were enabled.

Definition at line 409 of file ParameterHandlerBase.h.

◆ FlipParameterIndex

std::vector<int> ParameterHandlerBase::FlipParameterIndex

protected

Indices of parameters with flip symmetry.

Definition at line 483 of file ParameterHandlerBase.h.

◆ FlipParameterPoint

std::vector<double> ParameterHandlerBase::FlipParameterPoint

protected

Central points around which parameters are flipped.

Definition at line 485 of file ParameterHandlerBase.h.

◆ inputFile

const std::string ParameterHandlerBase::inputFile

protected

The input root file we read in.

Definition at line 412 of file ParameterHandlerBase.h.

◆ invCovMatrix

TMatrixDSym* ParameterHandlerBase::invCovMatrix

protected

The inverse covariance matrix.

Definition at line 419 of file ParameterHandlerBase.h.

◆ InvertCovMatrix

std::vector<std::vector<double> > ParameterHandlerBase::InvertCovMatrix

protected

KS: Same as above but much faster as TMatrixDSym cache miss.

Definition at line 421 of file ParameterHandlerBase.h.

◆ matrixName

std::string ParameterHandlerBase::matrixName

protected

Name of cov matrix.

Definition at line 415 of file ParameterHandlerBase.h.

◆ pca

bool ParameterHandlerBase::pca

protected

perform PCA or not

Definition at line 471 of file ParameterHandlerBase.h.

◆ PCAObj

std::unique_ptr<PCAHandler> ParameterHandlerBase::PCAObj

protected

Struct containing information about PCA.

Definition at line 476 of file ParameterHandlerBase.h.

◆ PrintLength

int ParameterHandlerBase::PrintLength

protected

KS: This is used when printing parameters, sometimes we have super long parameters name, we want to flexibly adjust couts.

Definition at line 434 of file ParameterHandlerBase.h.

◆ random_number

std::vector<std::unique_ptr<TRandom3> > ParameterHandlerBase::random_number

protected

KS: Set Random numbers for each thread so each thread has different seed.

Definition at line 424 of file ParameterHandlerBase.h.

◆ randParams

double* ParameterHandlerBase::randParams

protected

Random number taken from gaussian around prior error used for corr_throw.

Definition at line 427 of file ParameterHandlerBase.h.

◆ throwMatrix

TMatrixDSym* ParameterHandlerBase::throwMatrix

protected

Matrix which we use for step proposal before Cholesky decomposition (not actually used for step proposal)

Definition at line 464 of file ParameterHandlerBase.h.

◆ throwMatrix_CholDecomp

TMatrixD* ParameterHandlerBase::throwMatrix_CholDecomp

protected

Matrix which we use for step proposal after Cholesky decomposition.

Definition at line 466 of file ParameterHandlerBase.h.

◆ throwMatrixCholDecomp

double** ParameterHandlerBase::throwMatrixCholDecomp

protected

Throw matrix that is being used in the fit, much faster as TMatrixDSym cache miss.

Definition at line 468 of file ParameterHandlerBase.h.

◆ Tunes

std::unique_ptr<ParameterTunes> ParameterHandlerBase::Tunes

protected

Struct containing information about adaption.

Definition at line 480 of file ParameterHandlerBase.h.

◆ use_adaptive

bool ParameterHandlerBase::use_adaptive

protected

Are we using AMCMC?

Definition at line 473 of file ParameterHandlerBase.h.

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

Parameters/ParameterHandlerBase.h
Parameters/ParameterHandlerBase.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ParameterHandlerBase() [1/2]

◆ ParameterHandlerBase() [2/2]

◆ ~ParameterHandlerBase()

Member Function Documentation

◆ AcceptStep()

◆ AppliesToSample()

◆ CalcLikelihood()

◆ CheckBounds()

◆ CircularParBounds()

◆ ConstructPCA()

◆ CorrelateSteps()

◆ EnableSpecialProposal()

◆ FlipParameterValue()

◆ GetParPropVec()

◆ GetPCAHandler()

◆ Init() [1/2]

◆ Init() [2/2]

◆ InitialiseAdaption()

◆ IsParameterFixed() [1/2]

◆ IsParameterFixed() [2/2]

◆ IsPCA()

◆ MakeClosestPosDef()

◆ MakePosDef()

◆ PrintIndivStepScale()

◆ PrintNominal()

◆ PrintNominalCurrProp()

◆ PrintParameters()

◆ ProposeStep()

◆ RandomConfiguration()

◆ Randomize()

◆ ReserveMemory()

◆ ResetIndivStepScale()

◆ RetPointer()

◆ SaveAdaptiveToFile()

◆ SaveUpdatedMatrixConfig()

◆ SetThrowMatrixFromFile()

◆ SpecialStepProposal()

◆ ThrowParameters()

◆ ThrowParCurr()

◆ ThrowParProp()

◆ ToggleFixAllParameters()

◆ ToggleFixParameter() [1/2]

◆ ToggleFixParameter() [2/2]

◆ UpdateAdaptiveCovariance()

◆ UpdateThrowMatrix()

Member Data Documentation

◆ _fCurrVal

◆ _fError

◆ _fFancyNames

◆ _fFlatPrior

◆ _fGlobalStepScale

◆ _fIndivStepScale

◆ _fLowBound

◆ _fNames

◆ _fNumPar

◆ _fPreFitValue

◆ _fPropVal

◆ _fSampleNames

◆ _fUpBound

◆ _fYAMLDoc

◆ AdaptiveHandler

◆ CircularBoundsIndex

◆ CircularBoundsValues

◆ corr_throw

◆ covMatrix

◆ doSpecialStepProposal

◆ FlipParameterIndex

◆ FlipParameterPoint

◆ inputFile

◆ invCovMatrix

◆ InvertCovMatrix

◆ matrixName

◆ pca

◆ PCAObj

◆ PrintLength