Contains information about adaptive covariance matrix [12]. More...

#include <Parameters/AdaptiveMCMCHandler.h>

Collaboration diagram for adaptive_mcmc::AdaptiveMCMCHandler:

Public Member Functions
	AdaptiveMCMCHandler ()
	Constructor.

virtual	~AdaptiveMCMCHandler ()
	Destructor.

void	Print ()
	Print all class members.

bool	InitFromConfig (const YAML::Node &adapt_manager, const std::string &matrix_name_str, const std::vector< double > parameters, const std::vector< double > fixed)
	Read initial values from config file.

void	CreateNewAdaptiveCovariance ()
	If we don't have a covariance matrix to start from for adaptive tune we need to make one!

void	SetAdaptiveBlocks (const std::vector< std::vector< int > > &block_indices)
	HW: sets adaptive block matrix.

void	SaveAdaptiveToFile (const std::string &outFileName, const std::string &systematicName, const bool is_final=false)
	HW: Save adaptive throw matrix to file.

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

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

bool	IndivStepScaleAdapt ()
	Tell whether we want reset step scale or not.

bool	UpdateMatrixAdapt ()
	Tell whether matrix should be updated.

bool	AdaptionUpdate ()
	To be fair not a clue...

bool	SkipAdaption ()
	Tell if we are Skipping Adaption.

void	SetParams (const std::vector< double > *params)
	Set the current values of the parameters.

void	SetFixed (const std::vector< double > *fix)
	Set the fixed parameters.

int	GetNumParams () const
	Get the current values of the parameters.

bool	IsFixed (const int ipar) const
	Check if a parameter is fixed.

double	CurrVal (const int par_index)
	Get Current value of parameter.

int	GetTotalSteps () const
	Get Total Number of Steps.

void	SetTotalSteps (const int nsteps)
	Change Total Number of Steps to new value.

void	IncrementNSteps ()
	Increase by one number of total steps.

TMatrixDSym *	GetAdaptiveCovariance () const
	Increase by one number of total steps.

std::vector< double >	GetParameterMeans () const
	Get the parameter means used in the adaptive handler.

std::string	GetOutFileName () const
	Get Name of Output File.

Private Attributes
int	start_adaptive_throw

int	start_adaptive_update
	When do we stop update the adaptive matrix.

int	end_adaptive_update
	Steps between changing throw matrix.

int	adaptive_update_step
	Steps between changing throw matrix.

int	adaptive_save_n_iterations

std::string	output_file_name
	Name of the file to save the adaptive matrices into.

std::vector< int >	adapt_block_matrix_indices
	Indices for block-matrix adaption.

std::vector< int >	adapt_block_sizes
	Size of blocks for adaption.

std::vector< double >	par_means
	Mean values for all parameters.

TMatrixDSym *	adaptive_covariance
	Full adaptive covariance matrix.

int	total_steps
	Total number of MCMC steps.

double	adaption_scale
	Scaling factor.

const std::vector< double > *	_fFixedPars
	Vector of fixed parameters.

const std::vector< double > *	_fCurrVal
	Current values of parameters.

Detailed Description

Contains information about adaptive covariance matrix [12].

Author: Henry Wallace

struct encapsulating all adaptive MCMC information

Definition at line 13 of file AdaptiveMCMCHandler.h.

Constructor & Destructor Documentation

◆ AdaptiveMCMCHandler()

adaptive_mcmc::AdaptiveMCMCHandler::AdaptiveMCMCHandler ( )

Constructor.

Definition at line 6 of file AdaptiveMCMCHandler.cpp.

                                         {
// ********************************************
  start_adaptive_throw  = 0;
  start_adaptive_update = 0;
  end_adaptive_update   = 1;
  adaptive_update_step  = 1000;
  total_steps = 0;
 
  par_means = {};
  adaptive_covariance = nullptr;
}

◆ ~AdaptiveMCMCHandler()

adaptive_mcmc::AdaptiveMCMCHandler::~AdaptiveMCMCHandler ( )

virtual

Destructor.

Definition at line 19 of file AdaptiveMCMCHandler.cpp.

                                          {
// ********************************************
  if(adaptive_covariance != nullptr) {
    delete adaptive_covariance;
  }
}

Member Function Documentation

◆ AdaptionUpdate()

bool adaptive_mcmc::AdaptiveMCMCHandler::AdaptionUpdate ( )

To be fair not a clue...

Definition at line 313 of file AdaptiveMCMCHandler.cpp.

                                         {
// ********************************************
  if(total_steps <= start_adaptive_throw) return true;
  else return false;
}

◆ CreateNewAdaptiveCovariance()

void adaptive_mcmc::AdaptiveMCMCHandler::CreateNewAdaptiveCovariance ( )

If we don't have a covariance matrix to start from for adaptive tune we need to make one!

Definition at line 91 of file AdaptiveMCMCHandler.cpp.

                                                      {
// ********************************************
  adaptive_covariance = new TMatrixDSym(GetNumParams());
  adaptive_covariance->Zero();
  par_means = std::vector<double>(GetNumParams(), 0);
}

◆ CurrVal()

double adaptive_mcmc::AdaptiveMCMCHandler::CurrVal ( const int par_index )

Get Current value of parameter.

HW Implemented as its own method to allow for different behaviour in the future

Definition at line 331 of file AdaptiveMCMCHandler.cpp.

                                                      {
  return (*_fCurrVal)[par_index];
}

◆ GetAdaptiveCovariance()

TMatrixDSym * adaptive_mcmc::AdaptiveMCMCHandler::GetAdaptiveCovariance ( ) const

inline

Increase by one number of total steps.

Definition at line 107 of file AdaptiveMCMCHandler.h.

                                             {
    return adaptive_covariance;
  }

◆ GetNumParams()

int adaptive_mcmc::AdaptiveMCMCHandler::GetNumParams ( ) const

inline

Get the current values of the parameters.

Definition at line 76 of file AdaptiveMCMCHandler.h.

                           {
    return static_cast<int>(_fCurrVal->size());
  }

◆ GetTotalSteps()

int adaptive_mcmc::AdaptiveMCMCHandler::GetTotalSteps ( ) const

inline

Get Total Number of Steps.

Definition at line 92 of file AdaptiveMCMCHandler.h.

                            {
    return total_steps;
  }

◆ IncrementNSteps()

void adaptive_mcmc::AdaptiveMCMCHandler::IncrementNSteps ( )

inline

Increase by one number of total steps.

Definition at line 102 of file AdaptiveMCMCHandler.h.

                         {
    total_steps++;
  }

◆ IndivStepScaleAdapt()

bool adaptive_mcmc::AdaptiveMCMCHandler::IndivStepScaleAdapt ( )

Tell whether we want reset step scale or not.

Definition at line 286 of file AdaptiveMCMCHandler.cpp.

                                              {
// ********************************************
  if(total_steps == start_adaptive_throw) return true;
  else return false;
}

◆ InitFromConfig()

bool adaptive_mcmc::AdaptiveMCMCHandler::InitFromConfig	(	const YAML::Node &	adapt_manager,
		const std::string &	matrix_name_str,
		const std::vector< double > *	parameters,
		const std::vector< double > *	fixed
	)

Read initial values from config file.

Parameters

adapt_manager Config file from which we update matrix

HW: This is technically wrong, should be across all systematics but will be addressed in a later PR

Definition at line 27 of file AdaptiveMCMCHandler.cpp.

                                                                                                             {
// ********************************************
  /*
   * HW: Idea is that adaption can simply read the YAML config
   * Options :
   *         External Info:
   * UseExternalMatrix [bool]     :    Use an external matrix
   * ExternalMatrixFileName [str] :    Name of file containing external info
   * ExternalMatrixName [str]     :    Name of external Matrix
   * ExternalMeansName [str]      :    Name of external means vector [for updates]
   *
   *         General Info:
   * DoAdaption [bool]            :    Do we want to do adaption?
   * AdaptionStartThrow [int]     :    Step we start throwing adaptive matrix from
   * AdaptionEndUpdate [int]      :    Step we stop updating adaptive matrix
   * AdaptionStartUpdate [int]    :    Do we skip the first N steps?
   * AdaptionUpdateStep [int]     :    Number of steps between matrix updates
   * AdaptionSaveNIterations [int]:    You don't have to save every adaptive stage so decide how often you want to save
   * Adaption blocks [vector<vector<int>>] : Splits the throw matrix into several block matrices
   * OuputFileName [std::string]  :    Name of the file that the adaptive matrices will be saved into
   */
 
  // setAdaptionDefaults();
  if(!adapt_manager["AdaptionOptions"]["Covariance"][matrix_name_str]) {
    MACH3LOG_WARN("Adaptive Settings not found for {}, this is fine if you don't want adaptive MCMC", matrix_name_str);
    return false;
  }
 
  // We"re going to grab this info from the YAML manager
  if(!GetFromManager<bool>(adapt_manager["AdaptionOptions"]["Covariance"][matrix_name_str]["DoAdaption"], false)) {
    MACH3LOG_WARN("Not using adaption for {}", matrix_name_str);
    return false;
  }
 
  if(!CheckNodeExists(adapt_manager, "AdaptionOptions", "Settings", "OutputFileName")) {
    MACH3LOG_ERROR("No OutputFileName specified in AdaptionOptions::Settings into your config file");
    MACH3LOG_ERROR("This is required if you are using adaptive MCMC");
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  start_adaptive_throw  = GetFromManager<int>(adapt_manager["AdaptionOptions"]["Settings"]["StartThrow"], 10);
  start_adaptive_update = GetFromManager<int>(adapt_manager["AdaptionOptions"]["Settings"]["StartUpdate"], 0);
  end_adaptive_update   = GetFromManager<int>(adapt_manager["AdaptionOptions"]["Settings"]["EndUpdate"], 10000);
  adaptive_update_step  = GetFromManager<int>(adapt_manager["AdaptionOptions"]["Settings"]["UpdateStep"], 100);
  adaptive_save_n_iterations  = GetFromManager<int>(adapt_manager["AdaptionOptions"]["Settings"]["SaveNIterations"], 1);
  output_file_name = GetFromManager<std::string>(adapt_manager["AdaptionOptions"]["Settings"]["OutputFileName"], "");
 
  // We also want to check for "blocks" by default all parameters "know" about each other
  // but we can split the matrix into independent block matrices
  SetParams(parameters);
  SetFixed(fixed);
 
  adaption_scale = 2.38*2.38/GetNumParams(); 
  
  // We"ll set a dummy variable here
  auto matrix_blocks = GetFromManager<std::vector<std::vector<int>>>(adapt_manager["AdaptionOptions"]["Covariance"][matrix_name_str]["MatrixBlocks"], {{}});
 
  SetAdaptiveBlocks(matrix_blocks);
  return true;
}

◆ IsFixed()

bool adaptive_mcmc::AdaptiveMCMCHandler::IsFixed ( const int ipar ) const

inline

Check if a parameter is fixed.

Definition at line 81 of file AdaptiveMCMCHandler.h.

                                     {
    if(!_fFixedPars){
      return false;
    }
    return ((*_fFixedPars)[ipar] < 0);
  }

◆ Print()

void adaptive_mcmc::AdaptiveMCMCHandler::Print ( )

Print all class members.

Definition at line 320 of file AdaptiveMCMCHandler.cpp.

                                {
// ********************************************
  MACH3LOG_INFO("Adaptive MCMC Info:");
  MACH3LOG_INFO("Throwing from New Matrix from Step : {}", start_adaptive_throw);
  MACH3LOG_INFO("Adaption Matrix Start Update       : {}", start_adaptive_update);
  MACH3LOG_INFO("Adaption Matrix Ending Updates     : {}", end_adaptive_update);
  MACH3LOG_INFO("Steps Between Updates              : {}", adaptive_update_step);
  MACH3LOG_INFO("Saving matrices to file            : {}", output_file_name);
  MACH3LOG_INFO("Will only save every {} iterations"     , adaptive_save_n_iterations);
}

◆ SaveAdaptiveToFile()

void adaptive_mcmc::AdaptiveMCMCHandler::SaveAdaptiveToFile	(	const std::string &	outFileName,
		const std::string &	systematicName,
		const bool	is_final = `false`
	)

HW: Save adaptive throw matrix to file.

Definition at line 141 of file AdaptiveMCMCHandler.cpp.

                                                                                             {
// ********************************************
  if (((total_steps - start_adaptive_throw) / adaptive_update_step) % adaptive_save_n_iterations == 0 || is_final) {
 
    TFile *outFile = new TFile(outFileName.c_str(), "UPDATE");
    if (outFile->IsZombie()) {
      MACH3LOG_ERROR("Couldn't find {}", outFileName);
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    TVectorD *outMeanVec = new TVectorD(int(par_means.size()));
    for (int i = 0; i < int(par_means.size()); i++) {
      (*outMeanVec)(i) = par_means[i];
    }
 
    std::string adaptive_cov_name = systematicName + "_posfit_matrix";
    std::string mean_vec_name = systematicName + "_mean_vec";
    if (!is_final) {
      // Some string to make the name of the saved adaptive matrix clear
      std::string total_steps_str =
          std::to_string(total_steps);
      std::string syst_name_str = systematicName;
      adaptive_cov_name =
          total_steps_str + '_' + syst_name_str + std::string("_throw_matrix");
      mean_vec_name =
          total_steps_str + '_' + syst_name_str + std::string("_mean_vec");
    }
 
    outFile->cd();
    adaptive_covariance->Write(adaptive_cov_name.c_str());
    outMeanVec->Write(mean_vec_name.c_str());
    outFile->Close();
    delete outMeanVec;
    delete outFile;
  }
}

◆ SetAdaptiveBlocks()

void adaptive_mcmc::AdaptiveMCMCHandler::SetAdaptiveBlocks ( const std::vector< std::vector< int > > & block_indices )

HW: sets adaptive block matrix.

Parameters

block_indices Values for sub-matrix blocks

Definition at line 99 of file AdaptiveMCMCHandler.cpp.

                                                                                          {
// ********************************************
  /*
   *   In order to adapt efficient we want to setup our throw matrix to be a serious of block-diagonal (ish) matrices
   *
   *   To do this we set sub-block in the config by parameter index. For example having
   *   [[0,4],[4, 6]] in your config will set up two blocks one with all indices 0<=i<4 and the other with 4<=i<6
   */
  // Set up block regions
  adapt_block_matrix_indices = std::vector<int>(GetNumParams(), 0);
 
  // Should also make a matrix of block sizes
  adapt_block_sizes = std::vector<int>(block_indices.size()+1, 0);
  adapt_block_sizes[0] = GetNumParams();
 
  if(block_indices.size()==0 || block_indices[0].size()==0) return;
 
  int block_size = static_cast<int>(block_indices.size());
  // Now we loop over our blocks
  for(int iblock=0; iblock < block_size; iblock++){
    // Loop over blocks in the block
    int sub_block_size = static_cast<int>(block_indices.size()-1);
    for(int isubblock=0; isubblock < sub_block_size ; isubblock+=2){
      int block_lb = block_indices[iblock][isubblock];
      int block_ub = block_indices[iblock][isubblock+1];
 
      if(block_lb > GetNumParams() || block_ub > GetNumParams()){
        MACH3LOG_ERROR("Cannot set matrix block with edges {}, {} for matrix of size {}",
                       block_lb, block_ub, GetNumParams());
        throw MaCh3Exception(__FILE__, __LINE__);;
      }
      for(int ipar = block_lb; ipar < block_ub; ipar++){
        adapt_block_matrix_indices[ipar] = iblock+1;
        adapt_block_sizes[iblock+1] += 1;
        adapt_block_sizes[0] -= 1;
      }
    }
  }
}

◆ SetFixed()

void adaptive_mcmc::AdaptiveMCMCHandler::SetFixed ( const std::vector< double > * fix )

inline

Set the fixed parameters.

Definition at line 71 of file AdaptiveMCMCHandler.h.

                                             {
    _fFixedPars = fix;
  }

◆ SetParams()

void adaptive_mcmc::AdaptiveMCMCHandler::SetParams ( const std::vector< double > * params )

inline

Set the current values of the parameters.

Definition at line 66 of file AdaptiveMCMCHandler.h.

                                                 {
    _fCurrVal = params;
  }

◆ SetThrowMatrixFromFile()

void adaptive_mcmc::AdaptiveMCMCHandler::SetThrowMatrixFromFile	(	const std::string &	matrix_file_name,
		const std::string &	matrix_name,
		const std::string &	means_name,
		bool &	use_adaptive
	)

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

Definition at line 182 of file AdaptiveMCMCHandler.cpp.

                                                                     {
// ********************************************
  // Lets you set the throw matrix externally
  // Open file
  std::unique_ptr<TFile>matrix_file(new TFile(matrix_file_name.c_str()));
  use_adaptive = true;
 
  if(matrix_file->IsZombie()){
    MACH3LOG_ERROR("Couldn't find {}", matrix_file_name);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  // Next we grab our matrix
  adaptive_covariance = static_cast<TMatrixDSym*>(matrix_file->Get(matrix_name.c_str()));
  if(!adaptive_covariance){
    MACH3LOG_ERROR("Couldn't find {} in {}", matrix_name, matrix_file_name);
    throw MaCh3Exception(__FILE__ , __LINE__ );
  }
 
  // Finally we grab the means vector
  TVectorD* means_vector = static_cast<TVectorD*>(matrix_file->Get(means_name.c_str()));
 
  // This is fine to not exist!
  if(means_vector){
    // Yay our vector exists! Let's loop and fill it
    // Should check this is done
    if(means_vector->GetNrows()){
      MACH3LOG_ERROR("External means vec size ({}) != matrix size ({})", means_vector->GetNrows(), GetNumParams());
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    par_means = std::vector<double>(GetNumParams());
    for(int i = 0; i < GetNumParams(); i++){
      par_means[i] = (*means_vector)(i);
    }
    MACH3LOG_INFO("Found Means in External File, Will be able to adapt");
  }
  // Totally fine if it doesn't exist, we just can't do adaption
  else{
    // We don't need a means vector, set the adaption=false
    MACH3LOG_WARN("Cannot find means vector in {}, therefore I will not be able to adapt!", matrix_file_name);
    use_adaptive = false;
  }
 
  matrix_file->Close();
  MACH3LOG_INFO("Set up matrix from external file");
}

◆ SetTotalSteps()

void adaptive_mcmc::AdaptiveMCMCHandler::SetTotalSteps ( const int nsteps )

inline

Change Total Number of Steps to new value.

Definition at line 97 of file AdaptiveMCMCHandler.h.

                                       {
    total_steps = nsteps;
  }

◆ SkipAdaption()

bool adaptive_mcmc::AdaptiveMCMCHandler::SkipAdaption ( )

Tell if we are Skipping Adaption.

Definition at line 305 of file AdaptiveMCMCHandler.cpp.

                                       {
// ********************************************
  if(total_steps > end_adaptive_update ||
    total_steps< start_adaptive_update) return true;
  else return false;
}

◆ UpdateAdaptiveCovariance()

void adaptive_mcmc::AdaptiveMCMCHandler::UpdateAdaptiveCovariance ( )

Method to update adaptive MCMC [12].

Parameters

_fCurrVal Value of each parameter necessary for updating throw matrix

Definition at line 234 of file AdaptiveMCMCHandler.cpp.

                                                   {
// ********************************************
  std::vector<double> par_means_prev = par_means;
  int steps_post_burn = total_steps - start_adaptive_update;
 
  // Step 1: Update means and compute deviations
  for (int i = 0; i < GetNumParams(); ++i) {
    if (IsFixed(i)) continue;
 
    par_means[i] =  (CurrVal(i) + par_means_prev[i]*steps_post_burn)/(steps_post_burn+1);
    // Left over from cyclic means
  }
 
  // Step 2: Update covariance
  #ifdef MULTITHREAD
  #pragma omp parallel for
  #endif
  for (int i = 0; i < GetNumParams(); ++i) {
    if (IsFixed(i)) {
      (*adaptive_covariance)(i, i) = 1.0;
      continue;
    }
 
    int block_i = adapt_block_matrix_indices[i];
 
    for (int j = 0; j <= i; ++j) {
      if (IsFixed(j) || adapt_block_matrix_indices[j] != block_i) {
        (*adaptive_covariance)(i, j) = 0.0;
        (*adaptive_covariance)(j, i) = 0.0;
        continue;
      }
 
      double cov_prev = (*adaptive_covariance)(i, j);
      double cov_updated = 0.0;
 
      if (steps_post_burn > 0) {
      // Haario-style update
        double cov_t = cov_prev * (steps_post_burn - 1) / steps_post_burn;
        double prev_means_t = steps_post_burn * par_means_prev[i] * par_means_prev[j];
        double curr_means_t = (steps_post_burn + 1) * par_means[i] * par_means[j];
        double curr_step_t = CurrVal(i) * CurrVal(j);
 
        cov_updated = cov_t + adaption_scale * (prev_means_t - curr_means_t + curr_step_t) / steps_post_burn;
      }
 
      (*adaptive_covariance)(i, j) = cov_updated;
      (*adaptive_covariance)(j, i) = cov_updated;
    }
  }
}

◆ UpdateMatrixAdapt()

bool adaptive_mcmc::AdaptiveMCMCHandler::UpdateMatrixAdapt ( )

Tell whether matrix should be updated.

Definition at line 293 of file AdaptiveMCMCHandler.cpp.

                                            {
// ********************************************
  if(total_steps >= start_adaptive_throw &&
    // Check whether the number of steps is divisible by the adaptive update step
    // e.g. if adaptive_update_step = 1000 and (total_step - start_adpative_throw) is 5000 then this is true
    (total_steps - start_adaptive_throw)%adaptive_update_step == 0) {
    return true;
  } 
  else return false;
}

Member Data Documentation

◆ _fCurrVal

const std::vector<double>* adaptive_mcmc::AdaptiveMCMCHandler::_fCurrVal

private

Current values of parameters.

Definition at line 167 of file AdaptiveMCMCHandler.h.

◆ _fFixedPars

const std::vector<double>* adaptive_mcmc::AdaptiveMCMCHandler::_fFixedPars

private

Vector of fixed parameters.

Definition at line 164 of file AdaptiveMCMCHandler.h.

◆ adapt_block_matrix_indices

std::vector<int> adaptive_mcmc::AdaptiveMCMCHandler::adapt_block_matrix_indices

private

Indices for block-matrix adaption.

Definition at line 145 of file AdaptiveMCMCHandler.h.

◆ adapt_block_sizes

std::vector<int> adaptive_mcmc::AdaptiveMCMCHandler::adapt_block_sizes

private

Size of blocks for adaption.

Definition at line 148 of file AdaptiveMCMCHandler.h.

◆ adaption_scale

double adaptive_mcmc::AdaptiveMCMCHandler::adaption_scale

private

Scaling factor.

Definition at line 161 of file AdaptiveMCMCHandler.h.

◆ adaptive_covariance

TMatrixDSym* adaptive_mcmc::AdaptiveMCMCHandler::adaptive_covariance

private

Full adaptive covariance matrix.

Definition at line 155 of file AdaptiveMCMCHandler.h.

◆ adaptive_save_n_iterations

int adaptive_mcmc::AdaptiveMCMCHandler::adaptive_save_n_iterations

private

If you don't want to save every adaption then you can specify this here

Definition at line 139 of file AdaptiveMCMCHandler.h.

◆ adaptive_update_step

int adaptive_mcmc::AdaptiveMCMCHandler::adaptive_update_step

private

Steps between changing throw matrix.

Definition at line 135 of file AdaptiveMCMCHandler.h.

◆ end_adaptive_update

int adaptive_mcmc::AdaptiveMCMCHandler::end_adaptive_update

private

Steps between changing throw matrix.

Definition at line 132 of file AdaptiveMCMCHandler.h.

◆ output_file_name

std::string adaptive_mcmc::AdaptiveMCMCHandler::output_file_name

private

Name of the file to save the adaptive matrices into.

Definition at line 142 of file AdaptiveMCMCHandler.h.

◆ par_means

std::vector<double> adaptive_mcmc::AdaptiveMCMCHandler::par_means

private

Mean values for all parameters.

Definition at line 152 of file AdaptiveMCMCHandler.h.

◆ start_adaptive_throw

int adaptive_mcmc::AdaptiveMCMCHandler::start_adaptive_throw

private

Meta variables related to adaption run time When do we start throwing

Definition at line 126 of file AdaptiveMCMCHandler.h.

◆ start_adaptive_update

int adaptive_mcmc::AdaptiveMCMCHandler::start_adaptive_update

private

When do we stop update the adaptive matrix.

Definition at line 129 of file AdaptiveMCMCHandler.h.

◆ total_steps

int adaptive_mcmc::AdaptiveMCMCHandler::total_steps

private

Total number of MCMC steps.

Definition at line 158 of file AdaptiveMCMCHandler.h.

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

Parameters/AdaptiveMCMCHandler.h
Parameters/AdaptiveMCMCHandler.cpp

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AdaptiveMCMCHandler()

◆ ~AdaptiveMCMCHandler()

Member Function Documentation

◆ AdaptionUpdate()

◆ CreateNewAdaptiveCovariance()

◆ CurrVal()

◆ GetAdaptiveCovariance()

◆ GetNumParams()

◆ GetTotalSteps()

◆ IncrementNSteps()

◆ IndivStepScaleAdapt()

◆ InitFromConfig()

◆ IsFixed()

◆ Print()

◆ SaveAdaptiveToFile()

◆ SetAdaptiveBlocks()

◆ SetFixed()

◆ SetParams()

◆ SetThrowMatrixFromFile()

◆ SetTotalSteps()

◆ SkipAdaption()

◆ UpdateAdaptiveCovariance()

◆ UpdateMatrixAdapt()

Member Data Documentation

◆ _fCurrVal

◆ _fFixedPars

◆ adapt_block_matrix_indices

◆ adapt_block_sizes

◆ adaption_scale

◆ adaptive_covariance

◆ adaptive_save_n_iterations

◆ adaptive_update_step

◆ end_adaptive_update

◆ output_file_name

◆ par_means

◆ start_adaptive_throw

◆ start_adaptive_update

◆ total_steps