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

#include <Parameters/AdaptiveMCMCHandler.h>

Collaboration diagram for adaptive_mcmc::AdaptiveMCMCHandler:

Public Member Functions
	AdaptiveMCMCHandler ()
	Constructor. More...

virtual	~AdaptiveMCMCHandler ()
	Destructor. More...

void	Print () const
	Print all class members. More...

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. More...

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

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

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

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 More...

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

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

bool	UpdateMatrixAdapt ()
	Tell whether matrix should be updated. More...

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

bool	SkipAdaption () const
	Tell if we are Skipping Adaption. More...

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

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

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

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

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

int	GetTotalSteps () const
	Get Total Number of Steps. More...

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

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

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

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

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

Private Attributes
int	start_adaptive_throw

int	start_adaptive_update
	When do we stop update the adaptive matrix. More...

int	end_adaptive_update
	Steps between changing throw matrix. More...

int	adaptive_update_step
	Steps between changing throw matrix. More...

int	adaptive_save_n_iterations

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

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

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

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

TMatrixDSym *	adaptive_covariance
	Full adaptive covariance matrix. More...

int	total_steps
	Total number of MCMC steps. More...

double	adaption_scale
	Scaling factor. More...

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

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

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

To be fair not a clue...

Definition at line 318 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 ) const

Get Current value of parameter.

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

Definition at line 336 of file AdaptiveMCMCHandler.cpp.

                                                              {
   return (*_fCurrVal)[par_index];
 }

◆ IncrementNSteps()

void adaptive_mcmc::AdaptiveMCMCHandler::IncrementNSteps ( )

inline

Increase by one number of total steps.

Definition at line 109 of file AdaptiveMCMCHandler.h.

                          {
     total_steps++;
   }

◆ IndivStepScaleAdapt()

bool adaptive_mcmc::AdaptiveMCMCHandler::IndivStepScaleAdapt ( ) const

Tell whether we want reset step scale or not.

Definition at line 291 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	YAML node containing the configuration (`AdaptionOptions`).
matrix_name_str	Name of the covariance matrix block to configure.
parameters	Pointer to a vector of parameter values (nominal values).
fixed	Pointer to a vector of fixed parameter values.

Returns: True if adaptive MCMC configuration was successfully initialized, false otherwise.

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 87 of file AdaptiveMCMCHandler.h.

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

◆ Print()

void adaptive_mcmc::AdaptiveMCMCHandler::Print ( ) const

Print all class members.

Definition at line 325 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.

                                                                                              {
 // ********************************************
   // Skip saving if adaptive_save_n_iterations is negative,
   // unless this is the final iteration (is_final overrides the condition)
   if (adaptive_save_n_iterations < 0 && !is_final) return;
   if (is_final ||
     (adaptive_save_n_iterations > 0 &&
     ((total_steps - start_adaptive_throw) / adaptive_update_step) % adaptive_save_n_iterations == 0)) {
  
     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 76 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 71 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 187 of file AdaptiveMCMCHandler.cpp.

                                                                      {
 // ********************************************
   // Lets you set the throw matrix externally
   // Open file
   auto matrix_file = std::make_unique<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 104 of file AdaptiveMCMCHandler.h.

                                        {
     total_steps = nsteps;
   }

◆ SkipAdaption()

bool adaptive_mcmc::AdaptiveMCMCHandler::SkipAdaption ( ) const

Tell if we are Skipping Adaption.

Definition at line 310 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 239 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 298 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 175 of file AdaptiveMCMCHandler.h.

◆ _fFixedPars

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

private

Vector of fixed parameters.

Definition at line 172 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 153 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 156 of file AdaptiveMCMCHandler.h.

◆ adaption_scale

double adaptive_mcmc::AdaptiveMCMCHandler::adaption_scale

private

Scaling factor.

Definition at line 169 of file AdaptiveMCMCHandler.h.

◆ adaptive_covariance

TMatrixDSym* adaptive_mcmc::AdaptiveMCMCHandler::adaptive_covariance

private

Full adaptive covariance matrix.

Definition at line 163 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 147 of file AdaptiveMCMCHandler.h.

◆ adaptive_update_step

int adaptive_mcmc::AdaptiveMCMCHandler::adaptive_update_step

private

Steps between changing throw matrix.

Definition at line 143 of file AdaptiveMCMCHandler.h.

◆ end_adaptive_update

int adaptive_mcmc::AdaptiveMCMCHandler::end_adaptive_update

private

Steps between changing throw matrix.

Definition at line 140 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 150 of file AdaptiveMCMCHandler.h.

◆ par_means

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

private

Mean values for all parameters.

Definition at line 160 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 134 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 137 of file AdaptiveMCMCHandler.h.

◆ total_steps

int adaptive_mcmc::AdaptiveMCMCHandler::total_steps

private

Total number of MCMC steps.

Definition at line 166 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()

◆ 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