Returns 0 on success, nonzero on error.
47 {
48 int error = 0;
49
50
51
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",
72
75
76
77 {
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);
82 const auto vacuum =
83 ini.GetReal(
"Main",
"default_vacuum",
main.defaultVacuum);
85 main.inputFormat = inputFormat;
88 main.defaultVacuum = vacuum;
89 }
91 ini.GetReal("Main", "finite_difference",
93
95 unsigned i = static_cast<unsigned>(std::time(nullptr));
98 } else {
100 }
102 ini.GetInteger("Main", "max_force_calls",
105 ini.GetBoolean("Main", "remove_net_force",
109
110
111
112 std::string potTok = ini.Get("Potential", "potential", "");
113
114
115 if (potTok == "ase_nwcem" || potTok == "ASE_NWCEM") {
116 potTok = "ase_nwchem";
117 }
119 magic_enum::enum_cast<PotType>(potTok, magic_enum::case_insensitive)
122 "Potential", "mpi_poll_period",
125 ini.GetBoolean(
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",
147
151 } else {
153 }
155 "Potential", "log_potential",
158 "Potential", "thread_safe",
160
161
166 ini.Get("AMS", "forcefield",
169 ini.Get("AMS", "resources",
177 }
178
183 ini.Get("AMS_IO", "forcefield",
189 }
190
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",
211 }
212
215 ini.Get("XTBPot", "paramset",
220 ini.GetReal("XTBPot", "electronic_temperature",
223 ini.GetInteger("XTBPot", "max_iterations",
229 }
230
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!");
242 }
243 }
244
248 ini.Get("D3Pot", "functional",
249 ini.Get("D4Pot", "functional",
252 "D3Pot", "atm",
253 ini.GetBoolean("D4Pot", "atm",
256 ini.Get("D3Pot", "damping",
259 ini.GetReal("D4Pot", "charge",
261 }
264 ini.Get("ExprPot", "expression",
268 }
271 ini.GetInteger("MOPACPot", "charge",
274 ini.GetInteger("MOPACPot", "spin",
277 ini.GetInteger("MOPACPot", "model",
280 ini.Get("MOPACPot", "engine_path",
282 }
283
284
285
286 {
288 ini.Get("SocketNWChemPot", "host",
291 "SocketNWChemPot", "port",
294 ini.GetInteger(
295 "SocketNWChemPot", "mem_in_gb",
298 ini.Get("SocketNWChemPot", "nwchem_settings",
300 .nwchem_settings);
302 ini.Get("SocketNWChemPot", "unix_socket_path",
304 .unix_socket_path);
306 ini.GetBoolean("SocketNWChemPot", "unix_socket_mode",
308 .unix_socket_mode);
310 ini.GetBoolean("SocketNWChemPot", "make_template_input",
312 .make_template_input);
313 }
314
315
316
317 project_ssot_ini(ini, params);
318
319
320
322 ini.GetBoolean("Debug", "write_movies",
325 ini.GetInteger(
326 "Debug", "write_movies_interval",
329 ini.GetBoolean(
330 "Debug", "write_deprecated_outs",
333 ini.GetBoolean(
334 "Debug", "estimate_neb_eigenvalues",
337 toLowerCase(ini.Get("Debug", "neb_mmf_estimator",
339
340
341
344 ini.GetReal("Structure Comparison", "distance_difference",
346 .distance_difference);
348 ini.GetReal("Structure Comparison", "neighbor_cutoff",
350 .neighbor_cutoff);
352 ini.GetBoolean("Structure Comparison", "check_rotation",
354 .check_rotation);
356 ini.GetReal("Structure Comparison", "energy_difference",
358 .energy_difference);
361 ini.GetBoolean("Structure Comparison", "indistinguishable_atoms",
363 .indistinguishable_atoms);
366 ini.GetBoolean("Structure Comparison", "remove_translation",
368 .remove_translation);
369
370
371
373 ini.GetBoolean(
374 "Process Search", "minimize_first",
377 ini.GetReal("Process Search", "minimization_offset",
379 .minimization_offset);
381 ini.GetBoolean(
382 "Process Search", "known_saddles",
384
385
386 auto inp_optMethod =
387 magic_enum::enum_cast<OptType>(ini.Get("Optimizer", "opt_method", "none"),
388 magic_enum::case_insensitive)
392 }
394 ini.Get("Optimizer", "opt_backend",
401 }
402
404 toLowerCase(ini.Get(
405 "Optimizer", "convergence_metric",
410 *label;
411 } else {
413 "unknown convergence_metric {}",
416 }
417
418 if (ini.HasSection("Refine")) {
420 magic_enum::enum_cast<OptType>(ini.Get("Refine", "opt_method", ""),
421 magic_enum::case_insensitive)
424 ini.GetReal(
425 "Refine", "threshold",
427 }
428
430 "Optimizer", "converged_force",
433 static_cast<size_t>(ini.GetInteger(
434 "Optimizer", "max_iterations",
437 ini.GetReal("Optimizer", "max_move",
439
440 if (ini.HasSection("QuickMin")) {
442 ini.GetReal(
443 "QuickMin", "time_step",
449 ini.GetBoolean("Optimizer", "qm_steepest_descent",
451 .quickmin.steepest_descent);
452 }
453 if (ini.HasSection("FIRE")) {
456 ini.GetReal(
457 "FIRE", "time_step",
463 ini.GetReal("FIRE", "time_step_max",
465 .max_time_step_input);
469 }
470
471 {
472 const char *lbfgs_sec = ini.HasSection("LBFGS") ? "LBFGS" : "Optimizer";
474 ini.GetInteger(
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);
489 lbfgs.angle_reset =
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);
493 lbfgs.curvature =
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);
497 lbfgs.secant =
498 toLowerCase(ini.Get(lbfgs_sec, "lbfgs_secant", lbfgs.secant));
499 lbfgs.precon =
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));
503 lbfgs.accept =
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);
507 lbfgs.cautious_eps =
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);
512 lbfgs.precon_mu =
513 ini.GetReal(lbfgs_sec, "lbfgs_precon_mu", lbfgs.precon_mu);
514 lbfgs.precon_rcut =
515 ini.GetReal(lbfgs_sec, "lbfgs_precon_rcut", lbfgs.precon_rcut);
516 }
517 {
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));
527 xtsci.highs =
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)));
533 }
534 xtsci.highs = ini.GetBoolean("Optimizer", "xtsci_highs", xtsci.highs);
536 }
537 if (ini.HasSection("CG")) {
539 ini.GetBoolean(
540 "CG", "cg_no_overshooting",
543 ini.GetBoolean("CG", "cg_knock_out_max_move",
545 .cg.knock_out_max_move);
547 ini.GetBoolean(
548 "CG", "cg_line_search",
551 ini.GetReal(
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);
562 }
563 if (ini.HasSection("SD")) {
565 ini.GetReal("SD", "sd_alpha",
568 ini.GetBoolean(
569 "SD", "sd_twopoint",
571 }
572
573
574
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);
591 }
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",
610 {
611 const auto rotTok =
612 toLowerCase(ini.Get("Dimer", "rotation_backend", "classical"));
614 magic_enum::enum_cast<DimerRotationBackend>(
615 rotTok, magic_enum::case_insensitive)
617 }
618
619
621 ini.GetBoolean("Surrogate", "use_surrogate", false);
626 }
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");
637 }
638 }
639
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");
653 }
654
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));
666 }
667
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",
688 }
689
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);
718 static_cast<long>(
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", "");
730 }
731
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",
748 }
749
750
752 ini.GetBoolean("Surrogate", "gp_linear_path_always",
754 .linear_path_always);
755
756
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"));
769 }
770
771
773 ini.GetReal("Davidson", "tolerance",
776 ini.GetInteger(
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"));
786 }
787
788
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",
810
811
813 ini.GetReal("IRA", "distance_threshold",
816 ini.GetReal("IRA", "symmetry_threshold",
820
821
823 "GPR Dimer", "finite_angle",
826 "GPR Dimer", "converged_angle",
829 ini.GetReal(
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",
853 ini.GetReal(
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",
881 ini.GetBoolean(
882 "GPR Dimer", "nogp_init_translations",
885 ini.GetBoolean(
886 "GPR Dimer", "has_many_iterations",
888
890 ini.Get("GPR Dimer", "hyperparameter_opt_method",
892 .gpr_params.hyper_opt_method);
894 ini.GetReal(
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);
906 ini.GetReal(
907 "GPR Dimer", "prior_mean",
910 ini.GetReal("GPR Dimer", "prior_variance",
912 .gpr_params.prior_sigma2);
914 ini.GetReal(
915 "GPR Dimer", "prior_degrees_of_freedom",
917
919 ini.GetBoolean("GPR Dimer", "check_derivatives",
921 .opt_params.check_derivatives);
923 static_cast<int>(
924 ini.GetInteger("GPR Dimer", "opt_max_iterations",
926 .opt_params.max_iterations));
928 ini.GetReal(
929 "GPR Dimer", "opt_tol_func",
932 ini.GetReal(
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);
943
945 static_cast<int>(
946 ini.GetInteger("GPR Dimer", "report_level",
948 .debug_params.report_level));
950 static_cast<int>(
951 ini.GetInteger("GPR Dimer", "debug_level",
953 .debug_params.debug_level));
955 ini.Get(
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",
981
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);
998
999
1000
1002 "Prefactor", "default_value",
1005 ini.GetReal("Prefactor", "max_value",
1008 ini.GetReal("Prefactor", "min_value",
1011 "Prefactor", "within_radius",
1014 ini.GetReal(
1015 "Prefactor", "min_displacement",
1018 ini.Get("Prefactor", "rate_estimation",
1021 ini.Get("Prefactor", "configuration",
1024 ini.GetBoolean(
1025 "Prefactor", "all_free_atoms",
1028 ini.Get("Prefactor", "filter_scheme",
1031 "Prefactor", "filter_fraction",
1033
1034
1035
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"));
1042 }
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",
1058
1059
1060 const std::string neb_section = "Nudged Elastic Band";
1061
1063 ini.GetInteger(neb_section, "images",
1066 ini.GetBoolean(
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");
1084 }
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)
1097 }
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",
1110
1112 ini.GetReal(neb_section, "spring",
1115 ini.GetBoolean(
1116 neb_section, "elastic_band",
1119 ini.GetBoolean(
1120 neb_section, "doubly_nudged",
1123 ini.GetBoolean(
1124 neb_section, "doubly_nudged_switching",
1126
1128 ini.GetBoolean(
1129 neb_section, "energy_weighted",
1132 ini.GetReal(
1133 neb_section, "ew_trigger",
1136 ini.GetReal(
1137 neb_section, "ew_ksp_min",
1140 ini.GetReal(
1141 neb_section, "ew_ksp_max",
1143
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",
1160 ini.GetBoolean(
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",
1172
1174 ini.GetBoolean(
1175 neb_section, "climbing_image_method",
1178 ini.GetBoolean(neb_section, "climbing_image_converged_only",
1180 .climbing_image.converged_only);
1182 ini.GetReal(
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);
1197
1199 oci.
use_mmf = ini.GetBoolean(neb_section,
"ci_mmf", oci.use_mmf);
1200 oci.trigger_force =
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);
1210
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);
1232
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);
1245 init.sidpp_alpha =
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;
1261 }
1262 init.oversampling =
1263 ini.GetBoolean(neb_section, "oversampling", init.oversampling);
1264 init.oversampling_factor = ini.GetInteger(neb_section, "oversampling_factor",
1265 init.oversampling_factor);
1266
1268 neb_section, "minimize_endpoints",
1271 ini.GetBoolean(
1272 neb_section, "minimize_endpoints_for_ipath",
1274
1275
1276
1278 "Dynamics", "time_step",
1284 ini.GetReal("Dynamics", "time",
1291 static_cast<long>(std::floor(
1294 0.5));
1295 } else {
1297 }
1299 toLowerCase(ini.Get("Dynamics", "thermostat", "andersen"));
1301 "Dynamics", "andersen_alpha",
1304 ini.GetReal(
1305 "Dynamics", "andersen_collision_period",
1311 ini.GetReal("Dynamics", "nose_mass",
1314 ini.GetReal("Dynamics", "langevin_friction",
1316 .langevin_friction_input);
1320 {
1322 th.path_beads = ini.GetInteger("Dynamics", "path_beads", th.path_beads);
1323 th.path_springs =
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));
1336 if (seed < 0) {
1337 throw std::invalid_argument("[Dynamics] path_seed must be non-negative");
1338 }
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 " +
1343 th.path_springs);
1344 }
1345 }
1346
1347
1348
1350 ini.GetBoolean(
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",
1372 .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",
1393 .corr_time_input);
1397
1398
1399
1401 ini.GetReal("TAD", "low_temperature",
1404 ini.GetReal("TAD", "min_prefactor",
1407 ini.GetReal("TAD", "confidence",
1409
1410
1411
1414 toLowerCase(ini.Get("Replica Exchange", "temperature_distribution",
1418 ini.GetInteger(
1419 "Replica Exchange", "replicas",
1422 ini.GetInteger("Replica Exchange", "exchange_trials",
1424 .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",
1439 .temperature_high);
1441 ini.GetReal("Replica Exchange", "exchange_period",
1443 .exchange_period_input);
1448
1449
1450
1452 ini.GetReal(
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",
1478
1479
1480
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);
1493 ini.GetReal(
1494 "Saddle Search", "displace_radius",
1497 "Saddle Search", "max_energy",
1500 ini.GetInteger(
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);
1513 ini.GetReal(
1514 "Saddle Search", "converged_force",
1517 ini.GetReal(
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);
1543 }
1544
1545 {
1546 std::string atomListStr =
1547 ini.Get("Saddle Search", "displace_atom_list", "");
1548 if (!atomListStr.empty()) {
1549 std::stringstream ss(atomListStr);
1550 std::string token;
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)));
1558 }
1559 }
1560 }
1561 }
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);
1597 }
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);
1629 ini.GetBoolean(
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);
1647 {
1649 irc.
after = ini.GetBoolean(
"Saddle Search",
"irc_after", irc.after);
1650 irc.step_size =
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);
1654 irc.max_steps =
1655 ini.GetInteger("Saddle Search", "irc_max_steps", irc.max_steps);
1656 }
1657
1658
1659
1661 ini.GetReal(
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",
1677 ini.GetInteger(
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",
1697 .displacement_algorithm);
1699 }
1702 toLowerCase(ini.Get("Basin Hopping", "displacement_distribution",
1709 .displacement_distribution);
1711 }
1713 ini.GetReal(
1714 "Basin Hopping", "swap_probability",
1717 "Basin Hopping", "jump_max",
1720 ini.GetInteger(
1721 "Basin Hopping", "jump_steps",
1724 ini.GetBoolean("Basin Hopping", "adjust_displacement",
1726 .adjust_displacement);
1728 ini.GetInteger(
1729 "Basin Hopping", "adjust_period",
1732 ini.GetReal(
1733 "Basin Hopping", "adjust_fraction",
1736 ini.GetReal(
1737 "Basin Hopping", "target_ratio",
1740 ini.GetBoolean(
1741 "Basin Hopping", "write_unique",
1744 "Basin Hopping", "stop_energy",
1746
1747
1748
1751 "Global Optimization", "move_method",
1754 toLowerCase(
1755 ini.Get("Global Optimization", "decision_method",
1762 .decision_method);
1764 }
1766 ini.GetInteger(
1767 "Global Optimization", "steps",
1770 "Global Optimization", "beta",
1773 "Global Optimization", "alpha",
1776 ini.GetInteger(
1777 "Global Optimization", "mdmin",
1780 ini.GetReal("Global Optimization", "target_energy",
1782 .target_energy);
1783
1784
1785
1791 ini.GetReal("BGSD", "gradientfinitedifference",
1793 .gradient_finite_difference);
1795 ini.GetReal(
1796 "BGSD", "grad2energyconvergence",
1799 ini.GetReal(
1800 "BGSD", "grad2forceconvergence",
1802
1803
1804
1806 ini.GetReal("Monte Carlo", "step_size",
1809 ini.GetInteger("Monte Carlo", "steps",
1811
1812
1813 {
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);
1825 o.beta_hbar_omega =
1826 ini.GetReal("Instanton", "beta_hbar_omega", o.beta_hbar_omega);
1827 o.max_iterations =
1828 ini.GetInteger("Instanton", "max_iterations", o.max_iterations);
1829 o.force_tolerance =
1830 ini.GetReal("Instanton", "force_tolerance", o.force_tolerance);
1831 o.hessian_stride =
1832 ini.GetInteger("Instanton", "hessian_stride", o.hessian_stride);
1833 o.saddle_filename =
1834 ini.Get("Instanton", "saddle_filename", o.saddle_filename);
1835 o.temperature = ini.GetReal("Instanton", "temperature", o.temperature);
1836 o.temperatures.clear();
1837 {
1838 const std::string list = ini.Get("Instanton", "temperatures", "");
1839 std::stringstream ss(list);
1840 std::string token;
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) {
1845 continue;
1846 }
1847 try {
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 "
1853 "values, not " +
1854 token);
1855 }
1856 }
1857 }
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);
1867 }
1868 o.newton_limit =
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");
1873 }
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");
1882 }
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");
1890 }
1891 o.energy_shift = ini.GetReal("Instanton", "energy_shift", o.energy_shift);
1892 o.discretization.clear();
1893 {
1894 const std::string list = ini.Get("Instanton", "discretization", "");
1895 std::stringstream ss(list);
1896 std::string token;
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) {
1901 continue;
1902 }
1903 try {
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 " +
1910 token);
1911 }
1912 }
1913 }
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 " +
1919 o.friction);
1920 }
1921 o.friction_eta = ini.GetReal("Instanton", "friction_eta", o.friction_eta);
1922 {
1923 const std::string list = ini.Get("Instanton", "friction_eta_beads", "");
1924 o.friction_eta_beads.clear();
1925 size_t start = 0;
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
1930 : comma - start);
1931 if (!token.empty()) {
1932 try {
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 "
1937 "numbers, not " +
1938 token);
1939 }
1940 }
1941 if (comma == std::string::npos) {
1942 break;
1943 }
1944 start = comma + 1;
1945 }
1946 }
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)");
1952 }
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");
1958 }
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);
1965 }
1966 if (o.mode != "splitting" && o.mode != "rate") {
1967 throw std::invalid_argument("[Instanton] mode must be splitting or rate, "
1968 "not " +
1969 o.mode);
1970 }
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);
1978 o.pi_thermostat =
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);
1982 o.pi_pile_scale =
1983 ini.GetReal("Instanton", "pi_pile_scale", o.pi_pile_scale);
1984 o.pi_seed = ini.GetInteger("Instanton", "pi_seed", o.pi_seed);
1985 o.pi_direction =
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);
1998 }
1999
2000
2001
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",
2040 ini.GetInteger(
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",
2061
2063}
#define EONC_LOG_ERROR(...)
#define EONC_LOG_WARNING(...)
const gp_surrogate_options_t & gp_surrogate_options() const
const potential_options_t & potential_options() const
const saddle_search_options_t & saddle_search_options() const
const global_optimization_options_t & global_optimization_options() const
const basin_hopping_options_t & basin_hopping_options() const
const char DISP_LISTED_ATOMS[]
const char DISP_NOT_FCC_OR_HCP[]
const char DISP_MIN_COORDINATED[]
const char DISP_LAST_ATOM[]
void set_write_con_forces(bool enabled) noexcept
Whether written .con frames carry "Forces of Component" sections.
double random(long newSeed=0)
static main_options_t & main_options(Parameters &p)
static gp_surrogate_options_t & gp_surrogate_options(Parameters &p)
static lanczos_options_t & lanczos_options(Parameters &p)
static ase_nwchem_options_t & ase_nwchem_options(Parameters &p)
static hyperdynamics_options_t & hyperdynamics_options(Parameters &p)
static monte_carlo_options_t & monte_carlo_options(Parameters &p)
static xtb_options_t & xtb_options(Parameters &p)
static socket_nwchem_options_t & socket_nwchem_options(Parameters &p)
static replica_exchange_options_t & replica_exchange_options(Parameters &p)
static dftd_options_t & dftd_options(Parameters &p)
static ase_orca_options_t & ase_orca_options(Parameters &p)
static ira_options_t & ira_options(Parameters &p)
static oh_tst_options_t & oh_tst_options(Parameters &p)
static gpr_dimer_options_t & gpr_dimer_options(Parameters &p)
static prefactor_options_t & prefactor_options(Parameters &p)
static bgsd_options_t & bgsd_options(Parameters &p)
static ams_options_t & ams_options(Parameters &p)
static tad_options_t & tad_options(Parameters &p)
static artn_options_t & artn_options(Parameters &p)
static expr_options_t & expr_options(Parameters &p)
static global_optimization_options_t & global_optimization_options(Parameters &p)
static mopac_options_t & mopac_options(Parameters &p)
static metatomic_options_t & metatomic_options(Parameters &p)
static davidson_options_t & davidson_options(Parameters &p)
static basin_hopping_options_t & basin_hopping_options(Parameters &p)
static parallel_replica_options_t & parallel_replica_options(Parameters &p)
static catlearn_options_t & catlearn_options(Parameters &p)
static zbl_options_t & zbl_options(Parameters &p)
std::string scm_pythondir
struct eonc::ams_options_t::env_t env
std::string nperp_limitation
std::string displacement_algorithm
double push_apart_distance
bool significant_structure
bool single_atom_displace
std::string displacement_distribution
double initial_random_structure_probability
double grad2force_convergence
double gradient_finite_difference
double grad2energy_convergence
bool diagonal_preconditioner
Heuristic | (H v)_i / v_i | preconditioner (not true diag(H); off by default).
std::string phva_atoms
PHVA mobile/active set for the Ritz space; "All" = all free atoms.
bool estimate_neb_eigenvalues
long write_movies_interval
bool write_deprecated_outs
std::string decision_method
std::string hyper_opt_method
struct eonc::gpr_dimer_options_t::prune_params_t prune_params
struct eonc::gpr_dimer_options_t::gpr_params_t gpr_params
long max_outer_iterations
long max_inner_iterations
struct eonc::gpr_dimer_options_t::debug_params_t debug_params
std::string trans_opt_method
struct eonc::gpr_dimer_options_t::opt_params_t opt_params
std::string rot_opt_method
std::string checkpoint_path
std::string boost_atom_list
std::string bias_potential
double distance_threshold
double symmetry_threshold
double band_slack
When converged_only is on, the rest of the band may still be this many times the force tolerance.
struct eonc::neb_options_t::climbing_image_options_t::hybrid_dimer_t ocineb
double pressure
Hydrostatic pressure in eV/Angstrom^3.
struct eonc::neb_options_t::spring_options_t::energy_weighting_t weighting
bool geometric
Parallel force k (d_next^2 - d_prev^2).
struct eonc::neb_options_t::spring_options_t::onsager_machlup_t om
std::string match_method
"ira" uses IRACompare. "hungarian" is accepted and falls back to ira.
struct eonc::neb_options_t::climbing_image_options_t climbing_image
struct eonc::neb_options_t::band_options_t band
struct eonc::neb_options_t::endpoint_options_t endpoints
struct eonc::neb_options_t::spring_options_t spring
struct eonc::neb_options_t::solid_state_options_t solid_state
double quantum_temperature
Temperature in kelvin for the harmonic quantum free-energy profile.
bool match_endpoints
Permute+rotate the reactant onto the product before interpolation.
long tunnel_wall_points
Force calls past each end minimum of the converged band, along its end segment continued outward,...
struct eonc::neb_options_t::path_initialization_t initialization
struct eonc::neb_options_t::mmf_peak_options_t mmf_peaks
std::string symmetry_products
std::string product_filename
std::string reactant_filename
struct eonc::optimizer_options_t::refine_t refine
double record_interval_input
double dephase_time_input
double state_check_interval
double state_check_interval_input
bool thread_safe
When false, NEB/dimer/process_search never share one Potential across threads, even if the backend re...
std::string filter_scheme
std::string configuration
double exchange_period_input
double sampling_time_input
std::string temperature_distribution
double state_check_interval
double state_check_interval_input
double record_interval_input
bool linear_interpolation
double max_init_curvature
long nonlocal_count_abort
double max_single_displace
bool nonnegative_displacement_abort
struct eonc::saddle_search_options_t::dynamics_t dynamics
std::string displace_type
double displace_magnitude
std::string minmode_method
std::vector< long > displace_atom_list
struct eonc::saddle_search_options_t::confine_positive_t confine_positive
double nonlocal_distance_abort
struct eonc::saddle_search_options_t::irc_t irc
double zero_mode_abort_curvature
std::string nwchem_settings
std::string unix_socket_path
double langevin_friction_input
double andersen_tcol_input