AdaptiveMCMCHandler.h

Go to the documentation of this file.

#pragma once
 
// MaCh3 Includes
#include "Manager/Manager.h"
#include "Parameters/ParameterHandlerUtils.h"
 
namespace adaptive_mcmc{
 
class AdaptiveMCMCHandler{
 public:
  AdaptiveMCMCHandler();
 
  virtual ~AdaptiveMCMCHandler();
 
  void Print();
 
  bool InitFromConfig(const YAML::Node& adapt_manager, const std::string& matrix_name_str,
                      const std::vector<double>* parameters, const std::vector<double>* fixed);
 
  void CreateNewAdaptiveCovariance();
 
  void SetAdaptiveBlocks(const std::vector<std::vector<int>>& block_indices);
 
  void SaveAdaptiveToFile(const std::string& outFileName, const std::string& systematicName, const bool is_final=false);
 
  void SetThrowMatrixFromFile(const std::string& matrix_file_name,
                              const std::string& matrix_name,
                              const std::string& means_name,
                              bool& use_adaptive);
 
  void UpdateAdaptiveCovariance();
 
  bool IndivStepScaleAdapt();
 
  bool UpdateMatrixAdapt();
 
  bool AdaptionUpdate();
 
  bool SkipAdaption();
 
  void SetParams(const std::vector<double>* params){
    _fCurrVal = params;
  }
 
  void SetFixed(const std::vector<double>* fix){
    _fFixedPars = fix;
  }
 
  int GetNumParams() const {
    return static_cast<int>(_fCurrVal->size());
  }
 
  bool IsFixed(const int ipar) const {
    if(!_fFixedPars){
      return false;
    }
    return ((*_fFixedPars)[ipar] < 0);
  }
 
  double CurrVal(const int par_index);
 
  int GetTotalSteps() const {
    return total_steps;
  }
 
  void SetTotalSteps(const int nsteps) {
    total_steps = nsteps;
  }
 
  void IncrementNSteps() {
    total_steps++;
  }
 
  TMatrixDSym* GetAdaptiveCovariance() const {
    return adaptive_covariance;
  }
 
  std::vector<double> GetParameterMeans() const {
    return par_means;
  }
 
  std::string GetOutFileName() const {
    return output_file_name;
  }
 
 private:
  int start_adaptive_throw;
 
  int start_adaptive_update;
 
  int end_adaptive_update;
 
  int adaptive_update_step;
 
  int adaptive_save_n_iterations;
 
  std::string output_file_name;
 
  std::vector<int> adapt_block_matrix_indices;
 
  std::vector<int> adapt_block_sizes;
 
  // Variables directedly linked to adaption
  std::vector<double> par_means;
 
  TMatrixDSym* adaptive_covariance;
 
  int total_steps;
 
  double adaption_scale;
 
  const std::vector<double>* _fFixedPars;
 
  const std::vector<double>* _fCurrVal;
};
 
} // adaptive_mcmc namespace