struct gpr::InputParameters

Overview

Structure of the input parameters. All input parameters are pairs of string names and values. More…

#include <Structures.h>
 
struct InputParameters {
    // fields
 
    KeyValuePair<int> i_dist = {“i_dist”, 0};
    KeyValuePair<int> i_run = {“i_run”, 0};
    KeyValuePair<double[4]> dist_sp = {“dist_sp”, {0., 0., 0., 0.}};
    KeyValuePair<int> actdist_fro = {“actdist_fro”, 5};
    KeyValuePair<double*> R_all_init = {“R_all_init”, nullptr};
    KeyValuePair<double*> E_all_init = {“E_all_init”, nullptr};
    KeyValuePair<double*> G_all_init = {“G_all_init”, nullptr};
    KeyValuePair<double[3]> R_init = {“R_init”, {0., 0., 0.}};
    KeyValuePair<double> E_init = {“E_init”, 0.};
    KeyValuePair<double[3]> G_init = {“G_init”, {0., 0., 0.}};
    KeyValuePair<double[3]> orient_init = {“orient_init”, {0., 0., 0.}};
    KeyValuePair<double> dimer_sep = {“dimer_sep”, 0.};
    KeyValuePair<std::string> method_rot = {“method_rot”, “none”};
    KeyValuePair<std::string> method_trans = {“method_trans”, “none”};
    KeyValuePair<double[2]> param_trans = {“param_trans”, {0., 0.}};
    KeyValuePair<int> eval_image1 = {“eval_image1”, 0};
    KeyValuePair<double> T_dimer = {“T_dimer”, 0.};
    KeyValuePair<int> convergence_force_norm = {“convergence_force_norm”, 0};
    KeyValuePair<int> initrot_nogp = {“initrot_nogp”, 0};
    KeyValuePair<double> T_anglerot_init = {“T_anglerot_init”, 0.};
    KeyValuePair<int> num_iter_initrot = {“num_iter_initrot”, 0};
    KeyValuePair<double> T_anglerot_gp = {“T_anglerot_gp”, 0.};
    KeyValuePair<int> num_iter_rot_gp = {“num_iter_rot_gp”, 0};
    KeyValuePair<int> divisor_T_dimer_gp = {“divisor_T_dimer_gp”, 0};
    KeyValuePair<double> disp_max = {“disp_max”, 0.};
    KeyValuePair<double> ratio_at_limit = {“ratio_at_limit”, 0.};
    KeyValuePair<int> num_bigiter_initloc = {“num_bigiter_initloc”, 0};
    KeyValuePair<int> num_bigiter_initparam = {“num_bigiter_initparam”, 0};
    KeyValuePair<int> num_bigiter = {“num_bigiter”, 0};
    KeyValuePair<int> num_iter = {“num_iter”, 0};
    KeyValuePair<int> islarge_num_iter = {“islarge_num_iter”, 0};
    KeyValuePair<std::string> load_file = {“load_file”, “none”};
    KeyValuePair<std::string> save_file = {“save_file”, “none”};
    KeyValuePair<bool> use_prune = {“use_prune”, false};
    KeyValuePair<int> start_prune_at = {“start_prune_at”, 10};
    KeyValuePair<int> nprune_vals = {“nprune_vals”, 3};
    KeyValuePair<double> prune_threshold = {“prune_threshold”, 0.5};
    KeyValuePair<std::string> debug_output_dir = {“debug_output_dir”, “output”};
    KeyValuePair<std::string> debug_output_file_R = {“debug_output_file_R”,                                                      “position”};
    KeyValuePair<std::string> debug_output_file_E = {“debug_output_file_E”,                                                      “energy”};
    KeyValuePair<std::string> debug_output_file_G = {“debug_output_file_G”,                                                      “gradient”};
    KeyValuePair<std::string> debug_output_file_extension = {         “debug_output_file_extension”, “dat”};
    KeyValuePair<double> debug_offset_from_mid_point = {         “debug_offset_from_mid_point”, 3.};
    KeyValuePair<double> debug_dy = {“debug_dy”, 0.1};
    KeyValuePair<double> debug_dz = {“debug_dz”, 0.1};
    KeyValuePair<int> debug_level = {“debug_level”, 0};
    KeyValuePair<std::string> pot_general = {“pot_general”, “none”};
    KeyValuePair<std::string*> conf_info = {“conf_info”, nullptr};
    KeyValuePair<std::string*> conf_info_inactive = {“conf_info_inactive”,                                                      nullptr};
    KeyValuePair<double[9]> cell_dimensions = {         “cell_dimensions”, {0., 0., 0., 0., 0., 0., 0., 0., 0.}};
    KeyValuePair<double> gp_sigma2 = {“gp_sigma2”, 0.};
    KeyValuePair<double> jitter_sigma2 = {“jitter_sigma2”, 0.};
    KeyValuePair<std::string> optimization_alg = {“optimization_alg”,                                                   “SCG_opt”};
    KeyValuePair<double> sigma2 = {“sigma2”, 0.};
    KeyValuePair<double> magnSigma2 = {“magnSigma2”, 0.};
    KeyValuePair<double> constSigma2 = {“constSigma2”, 0.};
    KeyValuePair<double> prior_mu = {“prior_mu”, 0.};
    KeyValuePair<double> prior_nu = {“prior_nu”, 0.};
    KeyValuePair<double> prior_s2 = {“prior_s2”, 0.};
    KeyValuePair<DistanceMetricType> es_dist_metric = {“es_dist_metric”,                                                        DistanceMetricType::EMD};
    KeyValuePair<double> es_threshold = {“es_threshold”, 1.2};
    KeyValuePair<DistanceMetricType> fps_metric = {“fps_metric”,                                                    DistanceMetricType::EMD};
    KeyValuePair<int> fps_history = {“fps_history”, 5};
    KeyValuePair<double> rotation_removal_projection_threshold = {         “rotation_removal_projection_threshold”,         std::numeric_limits<double>::infinity()};
    KeyValuePair<std::string> rot_opt = {“rot_opt”, “lbfgs”};
    KeyValuePair<std::string> check_derivative = {“check_derivative”, “false”};
    KeyValuePair<int> report_level = {“report_level”, 1};
    KeyValuePair<int> max_iter = {“max_iter”, 400};
    KeyValuePair<double> tolerance_func = {“tolerance_func”, 1e-4};
    KeyValuePair<double> tolerance_sol = {“tolerance_sol”, 1e-4};
    KeyValuePair<double> lambda_limit = {“lambda_limit”, 1e20};
    KeyValuePair<double> lambda = {“lambda”, 10.};
    KeyValuePair<std::string> curvature_mode = {“curvature_mode”, “exact”};
    KeyValuePair<double> learning_rate = {“learning_rate”, 0.8};
    KeyValuePair<double> learning_rate_decay = {“learning_rate_decay”, 0.999};
    KeyValuePair<double> beta1 = {“beta1”, 0.9};
    KeyValuePair<double> beta2 = {“beta2”, 0.99};
    KeyValuePair<double> epsilon = {“epsilon”, 1.0e-8};
    KeyValuePair<double> weight_decay = {“weight_decay”, 0.0};
    KeyValuePair<bool> amsgrad = {“amsgrad”, true};
 
    // methods
 
    void print();
};

Detailed Documentation

Structure of the input parameters. All input parameters are pairs of string names and values.

Fields

KeyValuePair<int> actdist_fro = {“actdist_fro”, 5}

Activation distance for moving+frozen atom pairs (inf if all active).

KeyValuePair<double*> R_all_init = {“R_all_init”, nullptr}

Coordinates of the initial data points (N_obs x D).

KeyValuePair<double*> E_all_init = {“E_all_init”, nullptr}

Energies at the initial data points (N_obs x 1).

KeyValuePair<double*> G_all_init = {“G_all_init”, nullptr}

Gradients at the initial data points (N_obs x D).

KeyValuePair<double[3]> R_init = {“R_init”, {0., 0., 0.}}

Coordinates of the middle point of the initial dimer (1 x D).

KeyValuePair<double> E_init = {“E_init”, 0.}

Energy at the middle point of the initial dimer (if not empty, ‘R_init’ should be included in ‘R_all_init’).

KeyValuePair<double[3]> G_init = {“G_init”, {0., 0., 0.}}

Gradient at the middle point of the initial dimer (1 x D) (if not empty, ‘R_init’ should be included in ‘R_all_init’).

KeyValuePair<double[3]> orient_init = {“orient_init”, {0., 0., 0.}}

Unit vector along the direction of the initial dimer (1 x D).

KeyValuePair<double> dimer_sep = {“dimer_sep”, 0.}

Dimer separation (distance from the middle point of the dimer to the two images).

KeyValuePair<std::string> method_rot = {“method_rot”, “none”}

A function defining the rotation step.

KeyValuePair<std::string> method_trans = {“method_trans”, “none”}

A function defining the translation step.

KeyValuePair<double[2]> param_trans = {“param_trans”, {0., 0.}}

Parameters of the translation method (shape depends on ‘method_trans’).

KeyValuePair<int> eval_image1 = {“eval_image1”, 0}

Indicator if image 1 of the dimer is evaluted (1) or not (0) after each relaxation phase in addition to the middle point of the dimer.

KeyValuePair<double> T_dimer = {“T_dimer”, 0.}

Final convergence threshold for ‘maxF_R’, which is the maximum component of the force acting on the middle point of the dimer (i.e., the algorithm is stopped when all components of the accurate force are below ‘T_dimer’).

KeyValuePair<int> convergence_force_norm = {“convergence_force_norm”, 0}

Norm used for force convergence testing. 0 = L2 norm (default, used in published results), 1 = L-infinity norm (max absolute component, matches MATLAB reference), 2 = max force on atom (max per-atom force magnitude).

KeyValuePair<int> initrot_nogp = {“initrot_nogp”, 0}

Indicator if the initial rotations are performed without GP (1) or with GP (0).

KeyValuePair<double> T_anglerot_init = {“T_anglerot_init”, 0.}

Convergence threshold for rotation angle in the initial rotations (the dimer is not rotated when the estimated rotation angle is less than this).

KeyValuePair<int> num_iter_initrot = {“num_iter_initrot”, 0}

Maximum number of initial rotations (0 if initial rotations skipped).

KeyValuePair<double> T_anglerot_gp = {“T_anglerot_gp”, 0.}

Convergence threshold for rotation angle during a relaxation phase.

KeyValuePair<int> num_iter_rot_gp = {“num_iter_rot_gp”, 0}

Maximum number of rotation iterations per translation during a relaxation phase.

KeyValuePair<int> divisor_T_dimer_gp = {“divisor_T_dimer_gp”, 0}

If this option is set on (> 0), the convergence threshold for a relaxation phase is 1/’divisor_T_dimer_gp’ of the smallest accurate ‘maxF_R’ obtained so far, but not less than 1/10 of ‘T_dimer’ (otherwise the GP convergence threshold is always 1/10 of ‘T_dimer’).

KeyValuePair<double> disp_max = {“disp_max”, 0.}

Maximum displacement of the middle point of the dimer from the nearest observed data point (the relaxation phase is stopped if ‘disp_max’ is reached).

KeyValuePair<double> ratio_at_limit = {“ratio_at_limit”, 0.}

Limit for the ratio (< 1) of inter-atomic distances between image and its “nearest” observed data point (the relaxation phase is stopped if ‘ratio_at_limit’ is reached for any image).

KeyValuePair<int> num_bigiter_initloc = {“num_bigiter_initloc”, 0}

Number of outer iterations started from the initial location ‘R_init’ (after that, each relaxation phase is started from the latest converged dimer).

KeyValuePair<int> num_bigiter_initparam = {“num_bigiter_initparam”, 0}

Number of outer iterations where the hyperparameter optimization is started from values initialized based on the range of the current data (after that, the optimization is started from the values of the previous round).

KeyValuePair<int> num_bigiter = {“num_bigiter”, 0}

Maximum number of outer iterations (new pairs of observations).

KeyValuePair<int> num_iter = {“num_iter”, 0}

Maximum number of inner iterations (steps during a relaxation phase).

KeyValuePair<int> islarge_num_iter = {“islarge_num_iter”, 0}

indicator if ‘num_iter’ is assumed to be much larger than required for dimer convergence on accurate energy surface (if not, the next relaxation phase is continued from the current path if ‘num_iter’ is reached).

KeyValuePair<std::string> load_file = {“load_file”, “none”}

Path to the data file required to continue from a cancelled run (empty if started normally from the beginning).

KeyValuePair<std::string> save_file = {“save_file”, “none”}

Path to the data file required to continue from a cancelled run (empty if started normally from the beginning).

KeyValuePair<int> start_prune_at = {“start_prune_at”, 10}

Number of values to keep before prune begins

KeyValuePair<int> nprune_vals = {“nprune_vals”, 3}

Number of values drop

KeyValuePair<double> prune_threshold = {“prune_threshold”, 0.5}

Threshold below which candidates will be dropped