53 magic_enum::enum_cast<JobType>(ini.Get(
"Main",
"job",
""),
54 magic_enum::case_insensitive)
57 ini.GetReal(
"Main",
"temperature",
60 ini.GetInteger(
"Main",
"random_seed",
63 ini.GetBoolean(
"Main",
"checkpoint",
70 ini.GetBoolean(
"Main",
"write_con_forces",
79 const auto inputFormat = ini.Get(
"Main",
"input_format",
main.inputFormat);
80 const auto cell = ini.Get(
"Main",
"cell",
main.cell);
81 const auto pbc = ini.GetBoolean(
"Main",
"pbc",
main.pbc);
83 ini.GetReal(
"Main",
"default_vacuum",
main.defaultVacuum);
85 main.inputFormat = inputFormat;
88 main.defaultVacuum = vacuum;
91 ini.GetReal(
"Main",
"finite_difference",
95 unsigned i =
static_cast<unsigned>(std::time(
nullptr));
102 ini.GetInteger(
"Main",
"max_force_calls",
105 ini.GetBoolean(
"Main",
"remove_net_force",
112 std::string potTok = ini.Get(
"Potential",
"potential",
"");
115 if (potTok ==
"ase_nwcem" || potTok ==
"ASE_NWCEM") {
116 potTok =
"ase_nwchem";
119 magic_enum::enum_cast<PotType>(potTok, magic_enum::case_insensitive)
122 "Potential",
"mpi_poll_period",
126 "Potential",
"lammps_logging",
129 static_cast<int>(ini.GetInteger(
130 "Potential",
"lammps_threads",
133 "Potential",
"emt_rasmussen",
136 ini.Get(
"Potential",
"ext_pot_path",
139 ini.Get(
"Potential",
"potentials_path",
142 "Potential",
"pair_switch_width",
145 ini.GetReal(
"Potential",
"pair_cutoff",
155 "Potential",
"log_potential",
158 "Potential",
"thread_safe",
166 ini.Get(
"AMS",
"forcefield",
169 ini.Get(
"AMS",
"resources",
183 ini.Get(
"AMS_IO",
"forcefield",
194 ini.Get(
"AMS_ENV",
"amshome",
197 ini.Get(
"AMS_ENV",
"scm_tmpdir",
200 ini.Get(
"AMS_ENV",
"scmlicense",
203 ini.Get(
"AMS_ENV",
"scm_pythondir",
206 ini.Get(
"AMS_ENV",
"amsbin",
209 ini.Get(
"AMS_ENV",
"amsresources",
215 ini.Get(
"XTBPot",
"paramset",
220 ini.GetReal(
"XTBPot",
"electronic_temperature",
223 ini.GetInteger(
"XTBPot",
"max_iterations",
233 ini.GetReal(
"ZBLPot",
"cut_inner",
236 ini.GetReal(
"ZBLPot",
"cut_global",
240 throw std::runtime_error(
241 "Switching function must begin before the global cutoff!");
248 ini.Get(
"D3Pot",
"functional",
249 ini.Get(
"D4Pot",
"functional",
253 ini.GetBoolean(
"D4Pot",
"atm",
256 ini.Get(
"D3Pot",
"damping",
259 ini.GetReal(
"D4Pot",
"charge",
264 ini.Get(
"ExprPot",
"expression",
271 ini.GetInteger(
"MOPACPot",
"charge",
274 ini.GetInteger(
"MOPACPot",
"spin",
277 ini.GetInteger(
"MOPACPot",
"model",
280 ini.Get(
"MOPACPot",
"engine_path",
288 ini.Get(
"SocketNWChemPot",
"host",
291 "SocketNWChemPot",
"port",
295 "SocketNWChemPot",
"mem_in_gb",
298 ini.Get(
"SocketNWChemPot",
"nwchem_settings",
302 ini.Get(
"SocketNWChemPot",
"unix_socket_path",
306 ini.GetBoolean(
"SocketNWChemPot",
"unix_socket_mode",
310 ini.GetBoolean(
"SocketNWChemPot",
"make_template_input",
312 .make_template_input);
317 project_ssot_ini(ini, params);
322 ini.GetBoolean(
"Debug",
"write_movies",
326 "Debug",
"write_movies_interval",
330 "Debug",
"write_deprecated_outs",
334 "Debug",
"estimate_neb_eigenvalues",
337 toLowerCase(ini.Get(
"Debug",
"neb_mmf_estimator",
344 ini.GetReal(
"Structure Comparison",
"distance_difference",
346 .distance_difference);
348 ini.GetReal(
"Structure Comparison",
"neighbor_cutoff",
352 ini.GetBoolean(
"Structure Comparison",
"check_rotation",
356 ini.GetReal(
"Structure Comparison",
"energy_difference",
361 ini.GetBoolean(
"Structure Comparison",
"indistinguishable_atoms",
363 .indistinguishable_atoms);
366 ini.GetBoolean(
"Structure Comparison",
"remove_translation",
368 .remove_translation);
374 "Process Search",
"minimize_first",
377 ini.GetReal(
"Process Search",
"minimization_offset",
379 .minimization_offset);
382 "Process Search",
"known_saddles",
387 magic_enum::enum_cast<OptType>(ini.Get(
"Optimizer",
"opt_method",
"none"),
388 magic_enum::case_insensitive)
394 ini.Get(
"Optimizer",
"opt_backend",
405 "Optimizer",
"convergence_metric",
413 "unknown convergence_metric {}",
418 if (ini.HasSection(
"Refine")) {
420 magic_enum::enum_cast<OptType>(ini.Get(
"Refine",
"opt_method",
""),
421 magic_enum::case_insensitive)
425 "Refine",
"threshold",
430 "Optimizer",
"converged_force",
433 static_cast<size_t>(ini.GetInteger(
434 "Optimizer",
"max_iterations",
437 ini.GetReal(
"Optimizer",
"max_move",
440 if (ini.HasSection(
"QuickMin")) {
443 "QuickMin",
"time_step",
449 ini.GetBoolean(
"Optimizer",
"qm_steepest_descent",
451 .quickmin.steepest_descent);
453 if (ini.HasSection(
"FIRE")) {
463 ini.GetReal(
"FIRE",
"time_step_max",
465 .max_time_step_input);
472 const char *lbfgs_sec = ini.HasSection(
"LBFGS") ?
"LBFGS" :
"Optimizer";
475 lbfgs_sec,
"lbfgs_memory",
478 ini.GetReal(lbfgs_sec,
"lbfgs_inverse_curvature",
480 .lbfgs.inverse_curvature);
483 ini.GetReal(lbfgs_sec,
"lbfgs_max_inverse_curvature",
485 .lbfgs.max_inverse_curvature);
488 ini.GetBoolean(lbfgs_sec,
"lbfgs_auto_scale", lbfgs.auto_scale);
490 ini.GetBoolean(lbfgs_sec,
"lbfgs_angle_reset", lbfgs.angle_reset);
491 lbfgs.distance_reset =
492 ini.GetBoolean(lbfgs_sec,
"lbfgs_distance_reset", lbfgs.distance_reset);
494 toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_curvature", lbfgs.curvature));
495 lbfgs.project_rigid =
496 ini.GetBoolean(lbfgs_sec,
"lbfgs_project_rigid", lbfgs.project_rigid);
498 toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_secant", lbfgs.secant));
500 toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_precon", lbfgs.precon));
501 lbfgs.step = toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_step", lbfgs.step));
502 lbfgs.h0 = toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_h0", lbfgs.h0));
504 toLowerCase(ini.Get(lbfgs_sec,
"lbfgs_accept", lbfgs.accept));
505 lbfgs.extra_updates =
506 ini.GetInteger(lbfgs_sec,
"lbfgs_extra_updates", lbfgs.extra_updates);
508 ini.GetReal(lbfgs_sec,
"lbfgs_cautious_eps", lbfgs.cautious_eps);
509 lbfgs.cautious_alpha =
510 ini.GetReal(lbfgs_sec,
"lbfgs_cautious_alpha", lbfgs.cautious_alpha);
511 lbfgs.precon_A = ini.GetReal(lbfgs_sec,
"lbfgs_precon_A", lbfgs.precon_A);
513 ini.GetReal(lbfgs_sec,
"lbfgs_precon_mu", lbfgs.precon_mu);
515 ini.GetReal(lbfgs_sec,
"lbfgs_precon_rcut", lbfgs.precon_rcut);
520 toLowerCase(ini.Get(
"Optimizer",
"xtsci_method", xtsci.method));
521 if (ini.HasSection(
"Xtsci")) {
522 xtsci.method = toLowerCase(ini.Get(
523 "Xtsci",
"method", ini.Get(
"Xtsci",
"xtsci_method", xtsci.method)));
524 xtsci.qn_step = toLowerCase(ini.Get(
"Xtsci",
"qn_step", xtsci.qn_step));
525 xtsci.precon = toLowerCase(ini.Get(
"Xtsci",
"precon", xtsci.precon));
526 xtsci.accept = toLowerCase(ini.Get(
"Xtsci",
"accept", xtsci.accept));
528 ini.GetBoolean(
"Xtsci",
"highs",
529 ini.GetBoolean(
"Xtsci",
"xtsci_highs", xtsci.highs));
530 xtsci.manifold = toLowerCase(
531 ini.Get(
"Xtsci",
"manifold",
532 ini.Get(
"Xtsci",
"xtsci_manifold", xtsci.manifold)));
534 xtsci.highs = ini.GetBoolean(
"Optimizer",
"xtsci_highs", xtsci.highs);
537 if (ini.HasSection(
"CG")) {
540 "CG",
"cg_no_overshooting",
543 ini.GetBoolean(
"CG",
"cg_knock_out_max_move",
545 .cg.knock_out_max_move);
548 "CG",
"cg_line_search",
552 "CG",
"cg_line_converged",
555 ini.GetInteger(
"CG",
"cg_max_iter_before_reset",
557 .cg.max_iter_before_reset);
559 ini.GetInteger(
"CG",
"cg_max_iter_line_search",
561 .cg.line_search_max_iter);
563 if (ini.HasSection(
"SD")) {
565 ini.GetReal(
"SD",
"sd_alpha",
576 ini.GetReal(
"Dimer",
"finite_angle",
579 ini.GetBoolean(
"Dimer",
"improved",
582 ini.GetReal(
"Dimer",
"converged_angle",
585 "Dimer",
"max_iterations",
587 if (
auto dimerOpt = magic_enum::enum_cast<OptType>(
588 ini.Get(
"Dimer",
"opt_method",
"cg"), magic_enum::case_insensitive);
593 ini.GetInteger(
"Dimer",
"rotations_min",
596 ini.GetInteger(
"Dimer",
"rotations_max",
599 ini.GetReal(
"Dimer",
"torque_min",
602 ini.GetReal(
"Dimer",
"torque_max",
605 "Dimer",
"remove_rotation",
608 ini.GetReal(
"Dimer",
"lor_residual_tol",
612 toLowerCase(ini.Get(
"Dimer",
"rotation_backend",
"classical"));
614 magic_enum::enum_cast<DimerRotationBackend>(
615 rotTok, magic_enum::case_insensitive)
621 ini.GetBoolean(
"Surrogate",
"use_surrogate",
false);
628 "Surrogate",
"gp_uncertainty",
630 if (ini.HasSection(
"Surrogate")) {
632 magic_enum::enum_cast<PotType>(ini.Get(
"Surrogate",
"potential",
""),
633 magic_enum::case_insensitive)
636 throw std::runtime_error(
"We only support catlearn for GP right now");
640 if (ini.HasSection(
"CatLearn")) {
642 ini.Get(
"CatLearn",
"catl_path",
"");
644 ini.Get(
"CatLearn",
"model",
"catl_model");
646 ini.Get(
"CatLearn",
"prior",
"catl_prior");
648 ini.GetBoolean(
"CatLearn",
"use_derivatives",
"catl_deriv");
650 ini.GetBoolean(
"CatLearn",
"use_fingerprint",
"catl_fingerprint");
652 "CatLearn",
"parallel_hyperparameter_opt",
"catl_parallel");
655 if (ini.HasSection(
"ASE_ORCA")) {
657 ini.Get(
"ASE_ORCA",
"orca_path",
"");
659 ini.Get(
"ASE_ORCA",
"nproc",
"1");
661 ini.Get(
"ASE_ORCA",
"simpleinput",
"");
663 static_cast<int>(ini.GetInteger(
"ASE_ORCA",
"charge", 0));
665 static_cast<int>(ini.GetInteger(
"ASE_ORCA",
"multiplicity", 1));
668 if (ini.HasSection(
"ASE_NWCHEM")) {
670 ini.Get(
"ASE_NWCHEM",
"nwchem_path",
"");
672 ini.Get(
"ASE_NWCHEM",
"nproc",
"1");
674 ini.Get(
"ASE_NWCHEM",
"mpi_launcher",
677 ini.Get(
"ASE_NWCHEM",
"multiplicity",
"");
679 ini.GetReal(
"ASE_NWCHEM",
"scf_thresh", 1e-5);
681 ini.GetInteger(
"ASE_NWCHEM",
"scf_maxiter", 200);
683 ini.Get(
"ASE_NWCHEM",
"basis",
686 ini.Get(
"ASE_NWCHEM",
"memory",
690 if (ini.HasSection(
"Metatomic")) {
692 ini.Get(
"Metatomic",
"model_path",
"");
694 ini.Get(
"Metatomic",
"device",
"cpu");
696 ini.Get(
"Metatomic",
"length_unit",
"angstrom");
698 ini.Get(
"Metatomic",
"extensions_directory",
"");
700 ini.GetBoolean(
"Metatomic",
"check_consistency",
false);
702 ini.GetReal(
"Metatomic",
"uncertainty_threshold", -1.0);
704 ini.Get(
"Metatomic",
"energy_output",
707 ini.Get(
"Metatomic",
"energy_uncertainty_output",
709 .energy_uncertainty_output);
711 ini.Get(
"Metatomic",
"force_output",
714 ini.GetBoolean(
"Metatomic",
"non_conservative",
false);
716 ini.GetBoolean(
"Metatomic",
"random_rotation",
false);
719 ini.GetInteger(
"Metatomic",
"n_symmetry_rotations", 0));
721 ini.GetBoolean(
"Metatomic",
"deterministic",
true);
723 ini.GetBoolean(
"Metatomic",
"deterministic_strict",
false);
725 _variant.
base = ini.Get(
"Metatomic",
"variant_base",
"");
726 _variant.energy = ini.Get(
"Metatomic",
"variant_energy",
"");
727 _variant.energy_uncertainty =
728 ini.Get(
"Metatomic",
"variant_energy_uncertainty",
"");
729 _variant.force = ini.Get(
"Metatomic",
"variant_force",
"");
732 if (ini.HasSection(
"Serve")) {
736 static_cast<uint16_t
>(ini.GetInteger(
739 ini.GetInteger(
"Serve",
"replicas",
742 static_cast<uint16_t
>(ini.GetInteger(
743 "Serve",
"gateway_port",
746 ini.Get(
"Serve",
"endpoints",
752 ini.GetBoolean(
"Surrogate",
"gp_linear_path_always",
754 .linear_path_always);
758 ini.GetReal(
"Lanczos",
"tolerance",
761 "Lanczos",
"max_iterations",
764 ini.GetBoolean(
"Lanczos",
"quit_early",
766 if (ini.HasValue(
"Lanczos",
"phva_atoms")) {
768 toLowerCase(ini.Get(
"Lanczos",
"phva_atoms",
"All"));
773 ini.GetReal(
"Davidson",
"tolerance",
777 "Davidson",
"max_iterations",
780 ini.GetBoolean(
"Davidson",
"diagonal_preconditioner",
782 .diagonal_preconditioner);
783 if (ini.HasValue(
"Davidson",
"phva_atoms")) {
785 toLowerCase(ini.Get(
"Davidson",
"phva_atoms",
"All"));
790 ini.GetReal(
"ARTn",
"push_step_size",
793 ini.GetReal(
"ARTn",
"force_threshold",
796 ini.GetInteger(
"ARTn",
"max_iterations",
801 ini.Get(
"ARTn",
"nperp_limitation",
804 "ARTn",
"lanczos_min_size",
813 ini.GetReal(
"IRA",
"distance_threshold",
816 ini.GetReal(
"IRA",
"symmetry_threshold",
823 "GPR Dimer",
"finite_angle",
826 "GPR Dimer",
"converged_angle",
830 "GPR Dimer",
"relaxation_converged_angle",
833 static_cast<long>(ini.GetInteger(
834 "GPR Dimer",
"max_initial_rotation_iterations",
837 static_cast<long>(ini.GetInteger(
838 "GPR Dimer",
"max_relaxation_rotation_iterations",
841 static_cast<long>(ini.GetInteger(
842 "GPR Dimer",
"divisor_t_dimer",
846 "GPR Dimer",
"max_outer_iterations",
850 "GPR Dimer",
"max_inner_iterations",
854 "GPR Dimer",
"max_midpoint_displacement",
857 ini.Get(
"GPR Dimer",
"rotation_opt_method",
860 ini.Get(
"GPR Dimer",
"translation_opt_method",
863 "GPR Dimer",
"active_radius",
866 ini.GetReal(
"GPR Dimer",
"dimer_separation",
869 ini.GetReal(
"GPR Dimer",
"convex_region_step_size",
872 ini.GetReal(
"GPR Dimer",
"max_step_size",
875 "GPR Dimer",
"ratio_at_limit",
878 "GPR Dimer",
"nogp_initial_rotations",
882 "GPR Dimer",
"nogp_init_translations",
886 "GPR Dimer",
"has_many_iterations",
890 ini.Get(
"GPR Dimer",
"hyperparameter_opt_method",
892 .gpr_params.hyper_opt_method);
895 "GPR Dimer",
"gpr_variance",
898 ini.GetReal(
"GPR Dimer",
"gpr_jitter_variance",
900 .gpr_params.jitter_sigma2);
902 ini.GetReal(
"GPR Dimer",
"gpr_noise_variance",
904 .gpr_params.noise_sigma2);
907 "GPR Dimer",
"prior_mean",
910 ini.GetReal(
"GPR Dimer",
"prior_variance",
912 .gpr_params.prior_sigma2);
915 "GPR Dimer",
"prior_degrees_of_freedom",
919 ini.GetBoolean(
"GPR Dimer",
"check_derivatives",
921 .opt_params.check_derivatives);
924 ini.GetInteger(
"GPR Dimer",
"opt_max_iterations",
926 .opt_params.max_iterations));
929 "GPR Dimer",
"opt_tol_func",
933 "GPR Dimer",
"opt_tol_sol",
936 ini.GetReal(
"GPR Dimer",
"opt_lambda_limit",
938 .opt_params.lambda_limit);
940 ini.GetReal(
"GPR Dimer",
"opt_lambda_init",
942 .opt_params.lambda_init);
946 ini.GetInteger(
"GPR Dimer",
"report_level",
948 .debug_params.report_level));
951 ini.GetInteger(
"GPR Dimer",
"debug_level",
953 .debug_params.debug_level));
956 "GPR Dimer",
"debug_output_directory",
959 ini.Get(
"GPR Dimer",
"debug_position_basename",
961 .debug_params.pos_file);
963 ini.Get(
"GPR Dimer",
"debug_energy_basename",
965 .debug_params.energy_file);
967 ini.Get(
"GPR Dimer",
"debug_gradient_basename",
969 .debug_params.grad_file);
972 ini.GetReal(
"GPR Dimer",
"debug_midpoint_offset",
974 .debug_params.offset_mid_point);
976 "GPR Dimer",
"debug_y_step",
979 "GPR Dimer",
"debug_z_step",
983 ini.GetBoolean(
"GPR Dimer",
"use_prune",
985 .prune_params.use_prune);
987 static_cast<int>(ini.GetInteger(
988 "GPR Dimer",
"start_prune_at",
991 static_cast<int>(ini.GetInteger(
992 "GPR Dimer",
"nprune_vals",
995 ini.GetReal(
"GPR Dimer",
"prune_threshold",
997 .prune_params.threshold);
1002 "Prefactor",
"default_value",
1005 ini.GetReal(
"Prefactor",
"max_value",
1008 ini.GetReal(
"Prefactor",
"min_value",
1011 "Prefactor",
"within_radius",
1015 "Prefactor",
"min_displacement",
1018 ini.Get(
"Prefactor",
"rate_estimation",
1021 ini.Get(
"Prefactor",
"configuration",
1025 "Prefactor",
"all_free_atoms",
1028 ini.Get(
"Prefactor",
"filter_scheme",
1031 "Prefactor",
"filter_fraction",
1036 if (ini.HasValue(
"Hessian",
"phva_atoms")) {
1038 toLowerCase(ini.Get(
"Hessian",
"phva_atoms",
"All"));
1039 }
else if (ini.HasValue(
"Hessian",
"atom_list")) {
1041 toLowerCase(ini.Get(
"Hessian",
"atom_list",
"All"));
1044 "Hessian",
"zero_freq_value",
1047 ini.Get(
"Hessian",
"fd_scheme",
1050 ini.GetBoolean(
"Hessian",
"resume",
1053 ini.Get(
"Hessian",
"checkpoint_path",
1056 ini.GetBoolean(
"Hessian",
"write_modes",
1060 const std::string neb_section =
"Nudged Elastic Band";
1063 ini.GetInteger(neb_section,
"images",
1067 neb_section,
"solid_state",
1070 ini.GetReal(neb_section,
"solid_state_weight",
1073 neb_section,
"solid_state_pressure",
1076 neb_section,
"temperature",
1079 neb_section,
"tunnel_wall_points",
1082 throw std::invalid_argument(
1083 "[Nudged Elastic Band] tunnel_wall_points must be 0 or more");
1086 neb_section,
"max_iterations",
1089 neb_section,
"converged_force",
1091 auto neb_optMethod =
1092 magic_enum::enum_cast<OptType>(ini.Get(neb_section,
"opt_method",
"none"),
1093 magic_enum::case_insensitive)
1099 neb_section,
"setup_mmf_peaks",
1102 neb_section,
"mmf_peak_tolerance",
1105 ini.GetBoolean(neb_section,
"match_endpoints",
1108 ini.Get(neb_section,
"match_method",
1112 ini.GetReal(neb_section,
"spring",
1116 neb_section,
"elastic_band",
1120 neb_section,
"doubly_nudged",
1124 neb_section,
"doubly_nudged_switching",
1129 neb_section,
"energy_weighted",
1133 neb_section,
"ew_trigger",
1137 neb_section,
"ew_ksp_min",
1141 neb_section,
"ew_ksp_max",
1145 neb_section,
"geometric_spring",
1148 ini.Get(neb_section,
"band_precon",
1151 ini.GetReal(neb_section,
"band_precon_mu",
1154 ini.Get(neb_section,
"band_stepper",
1157 neb_section,
"onsager_machlup",
1161 neb_section,
"om_optimize_k",
1164 ini.GetReal(neb_section,
"om_k_scale",
1167 ini.GetReal(neb_section,
"om_k_min",
1170 ini.GetReal(neb_section,
"om_k_max",
1175 neb_section,
"climbing_image_method",
1178 ini.GetBoolean(neb_section,
"climbing_image_converged_only",
1180 .climbing_image.converged_only);
1183 neb_section,
"climbing_image_band_slack",
1186 ini.GetBoolean(neb_section,
"old_tangent",
1188 .climbing_image.use_old_tangent);
1190 ini.GetReal(neb_section,
"ci_after",
1192 .climbing_image.trigger_force);
1194 ini.GetReal(neb_section,
"ci_after_rel",
1196 .climbing_image.trigger_factor);
1199 oci.
use_mmf = ini.GetBoolean(neb_section,
"ci_mmf", oci.use_mmf);
1201 ini.GetReal(neb_section,
"ci_mmf_after", oci.trigger_force);
1202 oci.trigger_factor =
1203 ini.GetReal(neb_section,
"ci_mmf_after_rel", oci.trigger_factor);
1204 oci.max_steps = ini.GetInteger(neb_section,
"ci_mmf_nsteps", oci.max_steps);
1205 oci.ci_stability_count = ini.GetInteger(
1206 neb_section,
"ci_mmf_ci_stability_count", oci.ci_stability_count);
1207 oci.angle_tol = ini.GetReal(neb_section,
"ci_mmf_angle", oci.angle_tol);
1208 oci.restore_unhelpful = ini.GetBoolean(
1209 neb_section,
"ci_mmf_restore_unhelpful", oci.restore_unhelpful);
1212 zoom.
enabled = ini.GetBoolean(neb_section,
"zoom_neb", zoom.enabled);
1213 zoom.alpha = ini.GetReal(neb_section,
"zoom_alpha", zoom.alpha);
1214 zoom.offset = ini.GetInteger(neb_section,
"zoom_offset", zoom.offset);
1215 zoom.mode = magic_enum::enum_cast<neb_options_t::zoom_options_t::Mode>(
1216 ini.Get(neb_section,
"zoom_mode",
1217 std::string(magic_enum::enum_name(zoom.mode))),
1218 magic_enum::case_insensitive)
1219 .value_or(zoom.mode);
1220 zoom.activation_threshold =
1221 ini.GetReal(neb_section,
"zoom_after", zoom.activation_threshold);
1222 zoom.interpolation =
1223 magic_enum::enum_cast<neb_options_t::zoom_options_t::Interpolation>(
1224 ini.Get(neb_section,
"zoom_interpolation",
1225 std::string(magic_enum::enum_name(zoom.interpolation))),
1226 magic_enum::case_insensitive)
1227 .value_or(zoom.interpolation);
1228 zoom.stability_count =
1229 ini.GetInteger(neb_section,
"zoom_ci_stability", zoom.stability_count);
1230 zoom.max_iterations =
1231 ini.GetInteger(neb_section,
"zoom_max_iterations", zoom.max_iterations);
1235 magic_enum::enum_cast<NEBInit>(ini.Get(neb_section,
"initializer",
""),
1236 magic_enum::case_insensitive)
1238 init.input_path = ini.Get(neb_section,
"initial_path_in", init.input_path);
1239 init.max_iterations =
1240 ini.GetInteger(neb_section,
"init_max_iterations", init.max_iterations);
1241 init.nsteps = ini.GetInteger(neb_section,
"init_nsteps", init.nsteps);
1242 init.max_move = ini.GetReal(neb_section,
"init_max_move", init.max_move);
1243 init.force_tolerance =
1244 ini.GetReal(neb_section,
"init_force_threshold", init.force_tolerance);
1246 ini.GetReal(neb_section,
"sidpp_growth_alpha", init.sidpp_alpha);
1247 init.sidpp_frontier_tol =
1248 ini.GetReal(neb_section,
"sidpp_frontier_tol", init.sidpp_frontier_tol);
1249 init.sidpp_reparam =
1250 ini.GetBoolean(neb_section,
"sidpp_reparameterize", init.sidpp_reparam);
1251 init.sidpp_ideal_ksp =
1252 ini.GetBoolean(neb_section,
"sidpp_ideal_ksp", init.sidpp_ideal_ksp);
1253 auto neb_ipath_optMethod =
1254 magic_enum::enum_cast<OptType>(
1255 ini.Get(neb_section,
"ipath_opt_method",
"none"),
1256 magic_enum::case_insensitive)
1260 neb_ipath_optMethod;
1263 ini.GetBoolean(neb_section,
"oversampling", init.oversampling);
1264 init.oversampling_factor = ini.GetInteger(neb_section,
"oversampling_factor",
1265 init.oversampling_factor);
1268 neb_section,
"minimize_endpoints",
1272 neb_section,
"minimize_endpoints_for_ipath",
1278 "Dynamics",
"time_step",
1284 ini.GetReal(
"Dynamics",
"time",
1291 static_cast<long>(std::floor(
1299 toLowerCase(ini.Get(
"Dynamics",
"thermostat",
"andersen"));
1301 "Dynamics",
"andersen_alpha",
1305 "Dynamics",
"andersen_collision_period",
1311 ini.GetReal(
"Dynamics",
"nose_mass",
1314 ini.GetReal(
"Dynamics",
"langevin_friction",
1316 .langevin_friction_input);
1322 th.path_beads = ini.GetInteger(
"Dynamics",
"path_beads", th.path_beads);
1324 toLowerCase(ini.Get(
"Dynamics",
"path_springs", th.path_springs));
1325 th.path_eco_omega_max =
1326 ini.GetReal(
"Dynamics",
"path_eco_omega_max", th.path_eco_omega_max);
1327 th.path_gle_file = ini.Get(
"Dynamics",
"path_gle_file", th.path_gle_file);
1328 th.path_pile_tau_input =
1329 ini.GetReal(
"Dynamics",
"path_pile_tau", th.path_pile_tau_input);
1331 th.path_pile_tau = timeUnit > 0.0 ? th.path_pile_tau_input / timeUnit : 0.0;
1332 th.path_pile_scale =
1333 ini.GetReal(
"Dynamics",
"path_pile_scale", th.path_pile_scale);
1334 const long seed = ini.GetInteger(
"Dynamics",
"path_seed",
1335 static_cast<long>(th.path_seed));
1337 throw std::invalid_argument(
"[Dynamics] path_seed must be non-negative");
1339 th.path_seed =
static_cast<std::uint64_t
>(seed);
1340 if (th.path_springs !=
"trotter" && th.path_springs !=
"eco") {
1341 throw std::invalid_argument(
1342 "[Dynamics] path_springs must be trotter or eco, not " +
1351 "Parallel Replica",
"stop_after_transition",
1354 ini.GetBoolean(
"Parallel Replica",
"refine_transition",
1356 .refine_transition);
1358 ini.GetBoolean(
"Parallel Replica",
"dephase_loop_stop",
1360 .dephase_loop_stop);
1362 ini.GetReal(
"Parallel Replica",
"dephase_time",
1364 .dephase_time_input);
1370 ini.GetInteger(
"Parallel Replica",
"dephase_loop_max",
1375 ini.GetReal(
"Parallel Replica",
"state_check_interval",
1377 .state_check_interval_input);
1383 ini.GetReal(
"Parallel Replica",
"state_save_interval",
1385 .state_check_interval_input);
1391 ini.GetReal(
"Parallel Replica",
"post_transition_time",
1401 ini.GetReal(
"TAD",
"low_temperature",
1404 ini.GetReal(
"TAD",
"min_prefactor",
1407 ini.GetReal(
"TAD",
"confidence",
1414 toLowerCase(ini.Get(
"Replica Exchange",
"temperature_distribution",
1416 .temperature_distribution));
1419 "Replica Exchange",
"replicas",
1422 ini.GetInteger(
"Replica Exchange",
"exchange_trials",
1426 ini.GetReal(
"Replica Exchange",
"sampling_time",
1428 .sampling_time_input);
1434 ini.GetReal(
"Replica Exchange",
"temperature_low",
1437 ini.GetReal(
"Replica Exchange",
"temperature_high",
1441 ini.GetReal(
"Replica Exchange",
"exchange_period",
1443 .exchange_period_input);
1453 "Hyperdynamics",
"bb_rmd_time",
1459 toLowerCase(ini.Get(
1460 "Hyperdynamics",
"bb_boost_atomlist",
1463 ini.GetReal(
"Hyperdynamics",
"bb_dvmax",
1466 ini.GetReal(
"Hyperdynamics",
"bb_stretch_threshold",
1469 ini.GetReal(
"Hyperdynamics",
"bb_ds_curvature",
1472 ini.GetReal(
"Hyperdynamics",
"bb_rcut",
1475 toLowerCase(ini.Get(
1476 "Hyperdynamics",
"bias_potential",
1482 ini.Get(
"Saddle Search",
"method",
1485 toLowerCase(ini.Get(
1486 "Saddle Search",
"min_mode_method",
1489 ini.GetReal(
"Saddle Search",
"displace_magnitude",
1491 .displace_magnitude);
1494 "Saddle Search",
"displace_radius",
1497 "Saddle Search",
"max_energy",
1501 "Saddle Search",
"max_iterations",
1505 ini.GetBoolean(
"Saddle Search",
"nonnegative_displacement_abort",
1507 .nonnegative_displacement_abort);
1509 ini.GetReal(
"Saddle Search",
"max_single_displace",
1511 .max_single_displace);
1514 "Saddle Search",
"converged_force",
1518 "Saddle Search",
"perp_force_ratio",
1521 toLowerCase(ini.Get(
"Saddle Search",
"client_displace_type",
1524 ini.GetInteger(
"Saddle Search",
"nonlocal_count_abort",
1526 .nonlocal_count_abort);
1528 ini.GetReal(
"Saddle Search",
"nonlocal_distance_abort",
1530 .nonlocal_distance_abort);
1546 std::string atomListStr =
1547 ini.Get(
"Saddle Search",
"displace_atom_list",
"");
1548 if (!atomListStr.empty()) {
1549 std::stringstream ss(atomListStr);
1551 while (std::getline(ss, token,
',')) {
1552 size_t start = token.find_first_not_of(
" \t");
1553 size_t end = token.find_last_not_of(
" \t");
1554 if (start != std::string::npos) {
1557 std::stol(token.substr(start, end - start + 1)));
1563 ini.GetBoolean(
"Saddle Search",
"confine_positive",
1565 .confine_positive.enabled);
1567 .confine_positive.enabled) {
1570 ini.GetBoolean(
"Saddle Search",
"bowl_breakout",
1572 .confine_positive.bowl_breakout);
1575 ini.GetInteger(
"Saddle Search",
"bowl_active_atoms",
1577 .confine_positive.bowl_active);
1580 ini.GetReal(
"Saddle Search",
"confine_positive_min_move",
1582 .confine_positive.min_force);
1585 ini.GetReal(
"Saddle Search",
"confine_positive_scale_ratio",
1587 .confine_positive.scale_ratio);
1589 ini.GetReal(
"Saddle Search",
"confine_positive_boost",
1591 .confine_positive.boost);
1594 ini.GetInteger(
"Saddle Search",
"confine_positive_min_active",
1596 .confine_positive.min_active);
1601 ini.GetReal(
"Saddle Search",
"dynamics_temperature",
1603 .dynamics.temperature);
1606 ini.GetReal(
"Saddle Search",
"dynamics_state_check_interval",
1608 .dynamics.state_check_interval_input);
1616 ini.GetReal(
"Saddle Search",
"dynamics_record_interval",
1618 .dynamics.record_interval_input);
1625 ini.GetBoolean(
"Saddle Search",
"dynamics_linear_interpolation",
1627 .dynamics.linear_interpolation);
1630 "Saddle Search",
"remove_rotation",
1634 ini.GetReal(
"Saddle Search",
"dynamics_max_init_curvature",
1636 .dynamics.max_init_curvature);
1639 ini.GetReal(
"Saddle Search",
"zero_mode_abort_curvature",
1641 .zero_mode_abort_curvature);
1643 prfo.
enabled = ini.GetBoolean(
"Saddle Search",
"prfo_refine", prfo.enabled);
1644 prfo.force = ini.GetReal(
"Saddle Search",
"prfo_refine_force", prfo.force);
1645 prfo.max_iterations = ini.GetInteger(
1646 "Saddle Search",
"prfo_refine_max_iterations", prfo.max_iterations);
1649 irc.
after = ini.GetBoolean(
"Saddle Search",
"irc_after", irc.after);
1651 ini.GetReal(
"Saddle Search",
"irc_step_size", irc.step_size);
1652 irc.converged_force = ini.GetReal(
"Saddle Search",
"irc_converged_force",
1653 irc.converged_force);
1655 ini.GetInteger(
"Saddle Search",
"irc_max_steps", irc.max_steps);
1662 "Basin Hopping",
"displacement",
1665 ini.GetReal(
"Basin Hopping",
"push_apart_distance",
1667 .push_apart_distance);
1670 ini.GetReal(
"Basin Hopping",
"initial_random_structure_probability",
1672 .initial_random_structure_probability);
1674 ini.GetInteger(
"Basin Hopping",
"steps",
1678 "Basin Hopping",
"quenching_steps",
1681 ini.GetBoolean(
"Basin Hopping",
"single_atom_displace",
1683 .single_atom_displace);
1685 ini.GetBoolean(
"Basin Hopping",
"significant_structure",
1687 .significant_structure);
1689 toLowerCase(ini.Get(
"Basin Hopping",
"displacement_algorithm",
1691 .displacement_algorithm));
1697 .displacement_algorithm);
1702 toLowerCase(ini.Get(
"Basin Hopping",
"displacement_distribution",
1704 .displacement_distribution));
1709 .displacement_distribution);
1714 "Basin Hopping",
"swap_probability",
1717 "Basin Hopping",
"jump_max",
1721 "Basin Hopping",
"jump_steps",
1724 ini.GetBoolean(
"Basin Hopping",
"adjust_displacement",
1726 .adjust_displacement);
1729 "Basin Hopping",
"adjust_period",
1733 "Basin Hopping",
"adjust_fraction",
1737 "Basin Hopping",
"target_ratio",
1741 "Basin Hopping",
"write_unique",
1744 "Basin Hopping",
"stop_energy",
1751 "Global Optimization",
"move_method",
1755 ini.Get(
"Global Optimization",
"decision_method",
1767 "Global Optimization",
"steps",
1770 "Global Optimization",
"beta",
1773 "Global Optimization",
"alpha",
1777 "Global Optimization",
"mdmin",
1780 ini.GetReal(
"Global Optimization",
"target_energy",
1791 ini.GetReal(
"BGSD",
"gradientfinitedifference",
1793 .gradient_finite_difference);
1796 "BGSD",
"grad2energyconvergence",
1800 "BGSD",
"grad2forceconvergence",
1806 ini.GetReal(
"Monte Carlo",
"step_size",
1809 ini.GetInteger(
"Monte Carlo",
"steps",
1815 o.mode = ini.Get(
"Instanton",
"mode", o.mode);
1816 o.reactant_filename =
1817 ini.Get(
"Instanton",
"reactant_filename", o.reactant_filename);
1818 o.product_filename =
1819 ini.Get(
"Instanton",
"product_filename", o.product_filename);
1820 o.initial_path = ini.Get(
"Instanton",
"initial_path", o.initial_path);
1821 o.initial_ring = ini.Get(
"Instanton",
"initial_ring", o.initial_ring);
1822 o.physical_bath_filename = ini.Get(
"Instanton",
"physical_bath_filename",
1823 o.physical_bath_filename);
1824 o.beads = ini.GetInteger(
"Instanton",
"beads", o.beads);
1826 ini.GetReal(
"Instanton",
"beta_hbar_omega", o.beta_hbar_omega);
1828 ini.GetInteger(
"Instanton",
"max_iterations", o.max_iterations);
1830 ini.GetReal(
"Instanton",
"force_tolerance", o.force_tolerance);
1832 ini.GetInteger(
"Instanton",
"hessian_stride", o.hessian_stride);
1834 ini.Get(
"Instanton",
"saddle_filename", o.saddle_filename);
1835 o.temperature = ini.GetReal(
"Instanton",
"temperature", o.temperature);
1836 o.temperatures.clear();
1838 const std::string list = ini.Get(
"Instanton",
"temperatures",
"");
1839 std::stringstream ss(list);
1841 while (std::getline(ss, token,
',')) {
1842 const size_t start = token.find_first_not_of(
" \t");
1843 const size_t end = token.find_last_not_of(
" \t");
1844 if (start == std::string::npos) {
1848 o.temperatures.push_back(
1849 std::stod(token.substr(start, end - start + 1)));
1850 }
catch (
const std::exception &) {
1851 throw std::invalid_argument(
1852 "[Instanton] temperatures must be comma-separated kelvin "
1858 o.half_ring = ini.GetBoolean(
"Instanton",
"half_ring", o.half_ring);
1859 o.symmetrize = ini.GetBoolean(
"Instanton",
"symmetrize", o.symmetrize);
1860 o.initial_hessians =
1861 ini.Get(
"Instanton",
"initial_hessians", o.initial_hessians);
1862 if (o.initial_hessians !=
"saddle" &&
1863 o.initial_hessians !=
"finite_difference") {
1864 throw std::invalid_argument(
"[Instanton] initial_hessians must be saddle "
1865 "or finite_difference, not " +
1866 o.initial_hessians);
1869 ini.GetInteger64(
"Instanton",
"newton_limit", o.newton_limit);
1870 if (o.newton_limit < 0) {
1871 throw std::invalid_argument(
1872 "[Instanton] newton_limit must be nonnegative");
1874 o.reactant_hessian_filename = ini.Get(
1875 "Instanton",
"reactant_hessian_filename", o.reactant_hessian_filename);
1876 o.saddle_hessian_filename = ini.Get(
"Instanton",
"saddle_hessian_filename",
1877 o.saddle_hessian_filename);
1878 o.lanczos_step = ini.GetReal(
"Instanton",
"lanczos_step", o.lanczos_step);
1879 if (!(o.lanczos_step > 0.0) || !std::isfinite(o.lanczos_step)) {
1880 throw std::invalid_argument(
"[Instanton] lanczos_step must be finite and "
1881 "positive in sqrt(amu) Angstrom");
1883 o.physical_hessian_step = ini.GetReal(
"Instanton",
"physical_hessian_step",
1884 o.physical_hessian_step);
1885 if (!(o.physical_hessian_step > 0.0) ||
1886 !std::isfinite(o.physical_hessian_step)) {
1887 throw std::invalid_argument(
1888 "[Instanton] physical_hessian_step must be finite and positive "
1889 "in sqrt(amu) Angstrom");
1891 o.energy_shift = ini.GetReal(
"Instanton",
"energy_shift", o.energy_shift);
1892 o.discretization.clear();
1894 const std::string list = ini.Get(
"Instanton",
"discretization",
"");
1895 std::stringstream ss(list);
1897 while (std::getline(ss, token,
',')) {
1898 const size_t start = token.find_first_not_of(
" \t");
1899 const size_t end = token.find_last_not_of(
" \t");
1900 if (start == std::string::npos) {
1904 o.discretization.push_back(
1905 std::stod(token.substr(start, end - start + 1)));
1906 }
catch (
const std::exception &) {
1907 throw std::invalid_argument(
1908 "[Instanton] discretization must be comma-separated positive "
1909 "link weights, not " +
1914 o.friction = toLowerCase(ini.Get(
"Instanton",
"friction", o.friction));
1915 if (o.friction !=
"none" && o.friction !=
"implicit" &&
1916 o.friction !=
"explicit") {
1917 throw std::invalid_argument(
1918 "[Instanton] friction must be none, implicit or explicit, not " +
1921 o.friction_eta = ini.GetReal(
"Instanton",
"friction_eta", o.friction_eta);
1923 const std::string list = ini.Get(
"Instanton",
"friction_eta_beads",
"");
1924 o.friction_eta_beads.clear();
1926 while (start < list.size()) {
1927 const size_t comma = list.find(
',', start);
1928 const std::string token =
1929 list.substr(start, comma == std::string::npos ? std::string::npos
1931 if (!token.empty()) {
1933 o.friction_eta_beads.push_back(std::stod(token));
1934 }
catch (
const std::exception &) {
1935 throw std::invalid_argument(
1936 "[Instanton] friction_eta_beads must be comma-separated "
1941 if (comma == std::string::npos) {
1947 o.collapse_fraction =
1948 ini.GetReal(
"Instanton",
"collapse_fraction", o.collapse_fraction);
1949 if (!(o.collapse_fraction >= 0.0 && o.collapse_fraction < 1.0)) {
1950 throw std::invalid_argument(
1951 "[Instanton] collapse_fraction must be in [0, 1)");
1953 o.rotation_zero_fraction = ini.GetReal(
1954 "Instanton",
"rotation_zero_fraction", o.rotation_zero_fraction);
1955 if (!(o.rotation_zero_fraction > 0.0)) {
1956 throw std::invalid_argument(
1957 "[Instanton] rotation_zero_fraction must be positive");
1959 o.bead_ladder = ini.GetBoolean(
"Instanton",
"bead_ladder", o.bead_ladder);
1960 o.hessian_final = ini.Get(
"Instanton",
"hessian_final", o.hessian_final);
1961 o.springs = toLowerCase(ini.Get(
"Instanton",
"springs", o.springs));
1962 if (o.springs !=
"trotter" && o.springs !=
"eco") {
1963 throw std::invalid_argument(
1964 "[Instanton] springs must be trotter or eco, not " + o.springs);
1966 if (o.mode !=
"splitting" && o.mode !=
"rate") {
1967 throw std::invalid_argument(
"[Instanton] mode must be splitting or rate, "
1971 o.pi_planes = ini.GetInteger(
"Instanton",
"pi_planes", o.pi_planes);
1972 o.pi_beads = ini.GetInteger(
"Instanton",
"pi_beads", o.pi_beads);
1973 o.pi_equilibration_steps = ini.GetInteger(
1974 "Instanton",
"pi_equilibration_steps", o.pi_equilibration_steps);
1975 o.pi_sampling_steps =
1976 ini.GetInteger(
"Instanton",
"pi_sampling_steps", o.pi_sampling_steps);
1977 o.pi_time_step = ini.GetReal(
"Instanton",
"pi_time_step", o.pi_time_step);
1979 toLowerCase(ini.Get(
"Instanton",
"pi_thermostat", o.pi_thermostat));
1980 o.pi_gle_file = ini.Get(
"Instanton",
"pi_gle_file", o.pi_gle_file);
1981 o.pi_pile_tau = ini.GetReal(
"Instanton",
"pi_pile_tau", o.pi_pile_tau);
1983 ini.GetReal(
"Instanton",
"pi_pile_scale", o.pi_pile_scale);
1984 o.pi_seed = ini.GetInteger(
"Instanton",
"pi_seed", o.pi_seed);
1986 toLowerCase(ini.Get(
"Instanton",
"pi_direction", o.pi_direction));
1987 o.pi_reactant_extent =
1988 ini.GetReal(
"Instanton",
"pi_reactant_extent", o.pi_reactant_extent);
1989 o.pi_recrossing_parents = ini.GetInteger(
1990 "Instanton",
"pi_recrossing_parents", o.pi_recrossing_parents);
1991 o.pi_recrossing_children = ini.GetInteger(
1992 "Instanton",
"pi_recrossing_children", o.pi_recrossing_children);
1993 o.pi_recrossing_time =
1994 ini.GetReal(
"Instanton",
"pi_recrossing_time", o.pi_recrossing_time);
1995 o.pi_recrossing_spacing = ini.GetInteger(
1996 "Instanton",
"pi_recrossing_spacing", o.pi_recrossing_spacing);
2003 ini.Get(
"OH_TST",
"reactant_filename",
2006 ini.Get(
"OH_TST",
"product_filename",
2009 ini.GetReal(
"OH_TST",
"time_step",
2012 ini.GetInteger(
"OH_TST",
"equil_steps",
2015 ini.GetInteger(
"OH_TST",
"sample_steps",
2018 ini.GetInteger(
"OH_TST",
"max_planes",
2021 ini.GetReal(
"OH_TST",
"plane_mass",
2024 ini.GetReal(
"OH_TST",
"alpha_rot",
2027 ini.GetReal(
"OH_TST",
"plane_time_step",
2032 ini.GetReal(
"OH_TST",
"dtheta_max",
2035 ini.GetReal(
"OH_TST",
"force_tol",
2041 "OH_TST",
"reactant_md_steps",
2044 ini.Get(
"OH_TST",
"symmetry_products",
2047 ini.GetReal(
"OH_TST",
"max_delta_a",
2050 ini.Get(
"OH_TST",
"thermostat",
2053 ini.Get(
"OH_TST",
"gle_a_file",
2056 ini.GetBoolean(
"OH_TST",
"pmf_scan",
2059 ini.GetInteger(
"OH_TST",
"scan_planes",