Loading...
Searching...
No Matches
eonc::config Namespace Reference
Functions | |
| int | load_ini (INIReader &ini, Parameters ¶ms) |
| Parse all INI sections into the Parameters struct. | |
| void | validate_and_link (Parameters ¶ms) |
| Resolve cross-group defaults and time unit conversions. | |
| json | to_json (const Parameters ¶ms) |
| Serialize all Parameters to JSON. | |
| static std::string | lowerCopy (std::string value) |
| static std::vector< double > | temperaturesFromJson (const json &value) |
| static void | readPathIntegralKeys (const json &s, Parameters &p) |
| static void | readBathKeys (const json &s, Parameters &p) |
| void | from_json (const nlohmann::json &j, Parameters ¶ms) |
| Deserialize JSON into Parameters, then resolve computed fields. | |
| int | load_json (std::string_view json_str, Parameters ¶ms) |
| Load Parameters from a JSON string. Returns 0 on success. | |
| void | apply_ssot_defaults (Parameters ¶ms) |
| Apply SSoT defaults for covered groups (Main, Potential, Optimizer, Structure Comparison, Process Search). | |
| bool | ssot_has_field (const char *section, const char *key) |
| Return true if section/*key* (snake_case INI name) is declared in the Cap'n Proto L0 catalog for covered groups. | |
Function Documentation
◆ apply_ssot_defaults()
| void eonc::config::apply_ssot_defaults | ( | Parameters & | params | ) |
Apply SSoT defaults for covered groups (Main, Potential, Optimizer, Structure Comparison, Process Search).
Safe to call after construction; does not clear uncovered groups.
Definition at line 106 of file ParametersSSOT.cpp.
106 {
114 std::string(GD::MAIN_INI_FILENAME);
116 std::string(GD::MAIN_CON_FILENAME);
118 GD::MAIN_FINITE_DIFFERENCE;
120 GD::MAIN_MAX_FORCE_CALLS;
122 GD::MAIN_REMOVE_NET_FORCE;
124 GD::MAIN_WRITE_CON_FORCES;
126
128 pot_from_ssot(GD::POTENTIAL_POTENTIAL);
130 GD::POTENTIAL_MPI_POLL_PERIOD;
132 GD::POTENTIAL_LAMMPS_LOGGING;
134 GD::POTENTIAL_LAMMPS_THREADS;
136 GD::POTENTIAL_EMT_RASMUSSEN;
138 GD::POTENTIAL_LOG_POTENTIAL;
140 std::string(GD::POTENTIAL_EXT_POT_PATH);
142 std::string(GD::POTENTIAL_POTENTIALS_PATH);
143
145 GD::STRUCTURE_COMPARISON_DISTANCE_DIFFERENCE;
147 GD::STRUCTURE_COMPARISON_NEIGHBOR_CUTOFF;
149 GD::STRUCTURE_COMPARISON_CHECK_ROTATION;
151 .indistinguishable_atoms =
152 GD::STRUCTURE_COMPARISON_INDISTINGUISHABLE_ATOMS;
154 GD::STRUCTURE_COMPARISON_ENERGY_DIFFERENCE;
156 GD::STRUCTURE_COMPARISON_REMOVE_TRANSLATION;
157
159 GD::PROCESS_SEARCH_MINIMIZE_FIRST;
161 GD::PROCESS_SEARCH_MINIMIZATION_OFFSET;
162
164 opt_from_ssot(GD::OPTIMIZER_OPT_METHOD);
166 std::string(GD::OPTIMIZER_CONVERGENCE_METRIC);
168 GD::OPTIMIZER_MAX_ITERATIONS;
171 GD::OPTIMIZER_CONVERGED_FORCE;
173 GD::OPTIMIZER_TIME_STEP;
175 GD::OPTIMIZER_MAX_TIME_STEP;
176
178 GD::OPTIMIZER_LBFGS_MEMORY;
180 GD::OPTIMIZER_LBFGS_INVERSE_CURVATURE;
182 GD::OPTIMIZER_LBFGS_MAX_INVERSE_CURVATURE;
184 GD::OPTIMIZER_LBFGS_AUTO_SCALE;
186 GD::OPTIMIZER_LBFGS_ANGLE_RESET;
188 GD::OPTIMIZER_LBFGS_DISTANCE_RESET;
190 std::string(GD::OPTIMIZER_LBFGS_CURVATURE);
192 GD::OPTIMIZER_LBFGS_PROJECT_RIGID;
194 std::string(GD::OPTIMIZER_LBFGS_SECANT);
196 std::string(GD::OPTIMIZER_LBFGS_PRECON);
198 std::string(GD::OPTIMIZER_LBFGS_STEP);
200 std::string(GD::OPTIMIZER_LBFGS_H0);
202 std::string(GD::OPTIMIZER_LBFGS_ACCEPT);
204 GD::OPTIMIZER_LBFGS_EXTRA_UPDATES;
206 GD::OPTIMIZER_LBFGS_CAUTIOUS_EPS;
208 GD::OPTIMIZER_LBFGS_CAUTIOUS_ALPHA;
210 GD::OPTIMIZER_LBFGS_PRECON_A;
212 GD::OPTIMIZER_LBFGS_PRECON_MU;
214 GD::OPTIMIZER_LBFGS_PRECON_RCUT;
216 std::string(GD::OPTIMIZER_XTSCI_METHOD);
218 std::string(GD::OPTIMIZER_XTSCI_QN_STEP);
220 std::string(GD::OPTIMIZER_XTSCI_PRECON);
222 std::string(GD::OPTIMIZER_XTSCI_ACCEPT);
224 GD::OPTIMIZER_XTSCI_HIGHS;
226 std::string(GD::OPTIMIZER_XTSCI_MANIFOLD);
228 std::string(GD::OPTIMIZER_XTSCI_METHOD);
229
231 GD::OPTIMIZER_CG_NO_OVERSHOOTING;
233 GD::OPTIMIZER_CG_KNOCK_OUT_MAX_MOVE;
235 GD::OPTIMIZER_CG_LINE_SEARCH;
237 GD::OPTIMIZER_CG_LINE_CONVERGED;
239 GD::OPTIMIZER_CG_LINE_SEARCH_MAX_ITER;
241 GD::OPTIMIZER_CG_MAX_ITER_BEFORE_RESET;
242
244 GD::OPTIMIZER_QUICKMIN_STEEPEST_DESCENT;
247 GD::OPTIMIZER_SD_TWO_POINT;
248}
static structure_comparison_options_t & structure_comparison_options(Parameters &p)
Definition ParametersAccess.cpp:360
static main_options_t & main_options(Parameters &p)
Definition ParametersAccess.cpp:274
static process_search_options_t & process_search_options(Parameters &p)
Definition ParametersAccess.cpp:370
static optimizer_options_t & optimizer_options(Parameters &p)
Definition ParametersAccess.cpp:389
static potential_options_t & potential_options(Parameters &p)
Definition ParametersAccess.cpp:282
bool check_rotation
Definition StructureComparisonOptions.h:21
double energy_difference
Definition StructureComparisonOptions.h:23
bool remove_translation
Definition StructureComparisonOptions.h:24
bool indistinguishable_atoms
Definition StructureComparisonOptions.h:22
double neighbor_cutoff
Definition StructureComparisonOptions.h:20
double distance_difference
Definition StructureComparisonOptions.h:19
bool writeConForces
Opt-in "Forces of Component" sections in written .con frames (enables force+energy co-load on restart...
Definition ParametersOptions.h:46
bool knock_out_max_move
Definition ParametersOptions.h:284
bool no_overshooting
Definition ParametersOptions.h:283
long max_iter_before_reset
Definition ParametersOptions.h:288
long line_search_max_iter
Definition ParametersOptions.h:287
double line_converged
Definition ParametersOptions.h:286
double cautious_eps
Definition ParametersOptions.h:276
bool distance_reset
Definition ParametersOptions.h:263
double max_inverse_curvature
Definition ParametersOptions.h:260
double cautious_alpha
Definition ParametersOptions.h:277
bool project_rigid
Definition ParametersOptions.h:269
long extra_updates
Definition ParametersOptions.h:275
double inverse_curvature
Definition ParametersOptions.h:259
std::string curvature
Definition ParametersOptions.h:266
bool steepest_descent
Definition ParametersOptions.h:291
struct eonc::optimizer_options_t::sd_t sd
double max_time_step_input
Definition ParametersOptions.h:251
struct eonc::optimizer_options_t::quickmin_t quickmin
std::string convergence_metric
Definition ParametersOptions.h:244
struct eonc::optimizer_options_t::xtsci_t xtsci
struct eonc::optimizer_options_t::cg_t cg
struct eonc::optimizer_options_t::lbfgs_t lbfgs
std::string potentialsPath
Definition ParametersOptions.h:61
double minimization_offset
Definition ParametersOptions.h:190
◆ from_json()
| void eonc::config::from_json | ( | const json & | j, |
| Parameters & | p ) |
Deserialize JSON into Parameters, then resolve computed fields.
Definition at line 445 of file ParametersJSON.cpp.
445 {
446 // [Main]
447 if (j.contains("Main")) {
448 auto &m = j.at("Main");
449 if (m.contains("job"))
453 ParametersLoadAccess::main_options(p).randomSeed);
455 ParametersLoadAccess::main_options(p).temperature);
460 ParametersLoadAccess::main_options(p).iniFilename);
462 ParametersLoadAccess::main_options(p).conFilename);
464 ParametersLoadAccess::main_options(p).finiteDifference);
466 ParametersLoadAccess::main_options(p).maxForceCalls);
468 ParametersLoadAccess::main_options(p).removeNetForce);
470 ParametersLoadAccess::main_options(p).writeConForces);
471 }
472
473 // [Potential]
474 if (j.contains("Potential")) {
475 auto &s = j.at("Potential");
476 if (s.contains("potential"))
479 ParametersLoadAccess::potential_options(p).potential);
481 ParametersLoadAccess::potential_options(p).MPIPollPeriod);
483 ParametersLoadAccess::potential_options(p).LAMMPSLogging);
485 ParametersLoadAccess::potential_options(p).LAMMPSThreads);
487 ParametersLoadAccess::potential_options(p).EMTRasmussen);
489 ParametersLoadAccess::potential_options(p).LogPotential);
491 ParametersLoadAccess::potential_options(p).extPotPath);
493 ParametersLoadAccess::potential_options(p).potentialsPath);
494 }
495
496 // [Structure Comparison]
497 if (j.contains("Structure Comparison")) {
498 auto &s = j.at("Structure Comparison");
501 .distance_difference);
502 JSON_OPT(
503 s, "neighbor_cutoff",
504 ParametersLoadAccess::structure_comparison_options(p).neighbor_cutoff);
505 JSON_OPT(
506 s, "check_rotation",
507 ParametersLoadAccess::structure_comparison_options(p).check_rotation);
510 .indistinguishable_atoms);
513 .energy_difference);
516 .remove_translation);
517 }
518
519 // [Optimizer]
520 if (j.contains("Optimizer")) {
521 auto &s = j.at("Optimizer");
522 if (s.contains("opt_method"))
527 ParametersLoadAccess::optimizer_options(p).convergence_metric);
528 for (char &c :
529 ParametersLoadAccess::optimizer_options(p).convergence_metric) {
530 c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
531 }
533 ParametersLoadAccess::optimizer_options(p).convergence_metric)) {
535 std::string(*label);
536 } else {
537 throw std::invalid_argument(std::format(
538 "unknown convergence_metric: {}",
539 ParametersLoadAccess::optimizer_options(p).convergence_metric));
540 }
542 ParametersLoadAccess::optimizer_options(p).max_iterations);
544 ParametersLoadAccess::optimizer_options(p).max_move);
546 ParametersLoadAccess::optimizer_options(p).converged_force);
548 ParametersLoadAccess::optimizer_options(p).time_step_input);
550 ParametersLoadAccess::optimizer_options(p).max_time_step_input);
551 if (s.contains("LBFGS")) {
552 auto &l = s.at("LBFGS");
554 ParametersLoadAccess::optimizer_options(p).lbfgs.memory);
555 JSON_OPT(
556 l, "inverse_curvature",
557 ParametersLoadAccess::optimizer_options(p).lbfgs.inverse_curvature);
560 .lbfgs.max_inverse_curvature);
562 ParametersLoadAccess::optimizer_options(p).lbfgs.auto_scale);
564 ParametersLoadAccess::optimizer_options(p).lbfgs.angle_reset);
566 ParametersLoadAccess::optimizer_options(p).lbfgs.distance_reset);
568 ParametersLoadAccess::optimizer_options(p).lbfgs.curvature);
570 ParametersLoadAccess::optimizer_options(p).lbfgs.project_rigid);
572 ParametersLoadAccess::optimizer_options(p).lbfgs.secant);
574 ParametersLoadAccess::optimizer_options(p).lbfgs.precon);
576 ParametersLoadAccess::optimizer_options(p).lbfgs.step);
579 ParametersLoadAccess::optimizer_options(p).lbfgs.accept);
581 ParametersLoadAccess::optimizer_options(p).lbfgs.extra_updates);
583 ParametersLoadAccess::optimizer_options(p).lbfgs.cautious_eps);
585 ParametersLoadAccess::optimizer_options(p).lbfgs.cautious_alpha);
587 ParametersLoadAccess::optimizer_options(p).lbfgs.precon_A);
589 ParametersLoadAccess::optimizer_options(p).lbfgs.precon_mu);
591 ParametersLoadAccess::optimizer_options(p).lbfgs.precon_rcut);
592 }
593 if (s.contains("Xtsci")) {
594 auto &x = s.at("Xtsci");
597 }
600 }
601
602 // [Dynamics] Thermostat names on this object match the ini file.
603 // A later Thermostat object overrides the same keys.
604 if (j.contains("Dynamics")) {
605 auto &s = j.at("Dynamics");
607 ParametersLoadAccess::dynamics_options(p).time_step_input);
609 readBathKeys(s, p);
610 }
611
612 // [Thermostat]
613 if (j.contains("Thermostat")) {
615 }
616
617 // [Nudged Elastic Band]
618 if (j.contains("Nudged Elastic Band")) {
619 auto &s = j.at("Nudged Elastic Band");
622 ParametersLoadAccess::neb_options(p).max_iterations);
623 if (s.contains("opt_method"))
627 ParametersLoadAccess::neb_options(p).force_tolerance);
629 ParametersLoadAccess::neb_options(p).solid_state.enabled);
631 ParametersLoadAccess::neb_options(p).solid_state.weight);
633 ParametersLoadAccess::neb_options(p).solid_state.pressure);
634 if (s.contains("spring")) {
635 auto &sp = s.at("spring");
637 ParametersLoadAccess::neb_options(p).spring.constant);
639 ParametersLoadAccess::neb_options(p).spring.use_elastic_band);
641 ParametersLoadAccess::neb_options(p).spring.doubly_nudged);
642 }
643 if (s.contains("climbing_image")) {
644 auto &ci = s.at("climbing_image");
646 ParametersLoadAccess::neb_options(p).climbing_image.enabled);
647 JSON_OPT(
648 ci, "converged_only",
649 ParametersLoadAccess::neb_options(p).climbing_image.converged_only);
651 ParametersLoadAccess::neb_options(p).climbing_image.band_slack);
652 }
653 if (s.contains("zoom")) {
654 auto &z = s.at("zoom");
659 if (z.contains("mode")) {
661 }
663 if (z.contains("interpolation")) {
664 zoom.interpolation =
666 }
669 }
670 }
671
672 // [Dimer]
673 if (j.contains("Dimer")) {
674 auto &s = j.at("Dimer");
676 ParametersLoadAccess::dimer_options(p).rotation_angle);
679 ParametersLoadAccess::dimer_options(p).converged_angle);
681 ParametersLoadAccess::dimer_options(p).max_iterations);
682 if (s.contains("opt_method"))
686 if (s.contains("rotation_backend"))
688 s.at("rotation_backend"),
691 ParametersLoadAccess::dimer_options(p).lor_residual_tol);
692 }
693
694 // [Saddle Search]
695 if (j.contains("Saddle Search")) {
696 auto &s = j.at("Saddle Search");
698 ParametersLoadAccess::saddle_search_options(p).method);
700 ParametersLoadAccess::saddle_search_options(p).minmode_method);
702 ParametersLoadAccess::saddle_search_options(p).max_energy);
704 ParametersLoadAccess::saddle_search_options(p).max_iterations);
706 ParametersLoadAccess::saddle_search_options(p).displace_magnitude);
708 ParametersLoadAccess::saddle_search_options(p).displace_radius);
709 }
710
711 // [Serve]
712 if (j.contains("Serve")) {
713 auto &s = j.at("Serve");
715 if (s.contains("port"))
717 s.at("port").get<uint16_t>();
718 if (s.contains("replicas"))
720 s.at("replicas").get<size_t>();
721 if (s.contains("gateway_port"))
723 s.at("gateway_port").get<uint16_t>();
725 }
726
727 // [Debug]
728 if (j.contains("Debug")) {
729 auto &s = j.at("Debug");
731 ParametersLoadAccess::debug_options(p).write_movies);
733 ParametersLoadAccess::debug_options(p).write_movies_interval);
735 ParametersLoadAccess::debug_options(p).write_deprecated_outs);
736 }
737
738 // [Hessian] phva_atoms wins over the legacy atom_list, as in the ini.
739 if (j.contains("Hessian")) {
740 auto &s = j.at("Hessian");
742 if (s.contains("phva_atoms")) {
744 } else if (s.contains("atom_list")) {
746 }
748 if (s.contains("fd_scheme")) {
750 }
754 }
755
756 // [Instanton]
757 if (j.contains("Instanton")) {
758 auto &s = j.at("Instanton");
771 if (s.contains("temperatures")) {
773 }
775 if (s.contains("initial_hessians")) {
776 o.initial_hessians = s.at("initial_hessians").get<std::string>();
777 }
778 if (o.initial_hessians != "saddle" &&
779 o.initial_hessians != "finite_difference") {
780 throw std::invalid_argument(
781 "[Instanton] initial_hessians must be saddle or "
782 "finite_difference, not " +
783 o.initial_hessians);
784 }
788 if (s.contains("springs")) {
790 }
791 if (o.springs != "trotter" && o.springs != "eco") {
792 throw std::invalid_argument(
793 "[Instanton] springs must be trotter or eco, not " + o.springs);
794 }
795 if (o.mode != "splitting" && o.mode != "rate") {
796 throw std::invalid_argument("[Instanton] mode must be splitting or "
797 "rate, not " +
798 o.mode);
799 }
805 if (s.contains("pi_thermostat")) {
807 }
812 if (s.contains("pi_direction")) {
814 }
820 eonc::piqtst::validateOptions(o);
821 }
822
823 // The ini loader derives these from the femtosecond inputs whether or
824 // not the keys are present; validate_and_link does not.
825 {
828 th.andersen_tcol = timeUnit > 0.0 ? th.andersen_tcol_input / timeUnit : 0.0;
829 th.path_pile_tau = timeUnit > 0.0 ? th.path_pile_tau_input / timeUnit : 0.0;
830 }
831
832 // Resolve computed fields
833 validate_and_link(p);
834}
static std::string lowerCopy(std::string value)
Definition ParametersJSON.cpp:366
static void readBathKeys(const json &s, Parameters &p)
Definition ParametersJSON.cpp:430
void validate_and_link(Parameters ¶ms)
Resolve cross-group defaults and time unit conversions.
Definition ParametersINI.cpp:2059
static std::vector< double > temperaturesFromJson(const json &value)
Definition ParametersJSON.cpp:373
std::optional< std::string_view > convergenceMetricLabel(std::string_view metric)
Display label for a force-convergence metric, or nullopt when the name is none of the four the optimi...
Definition HelperFunctions.cpp:355
void validateOptions(const instanton_options_t &o)
Throws std::invalid_argument on an inconsistent [Instanton] pi_* key.
Definition PIQTSTJob.cpp:31
static thermostat_options_t & thermostat_options(Parameters &p)
Definition ParametersAccess.cpp:533
static dimer_options_t & dimer_options(Parameters &p)
Definition ParametersAccess.cpp:398
static constants_t & constants(Parameters &p)
Definition ParametersAccess.cpp:266
static debug_options_t & debug_options(Parameters &p)
Definition ParametersAccess.cpp:625
static hessian_options_t & hessian_options(Parameters &p)
Definition ParametersAccess.cpp:489
static instanton_options_t & instanton_options(Parameters &p)
Definition ParametersAccess.cpp:643
static saddle_search_options_t & saddle_search_options(Parameters &p)
Definition ParametersAccess.cpp:380
static dynamics_options_t & dynamics_options(Parameters &p)
Definition ParametersAccess.cpp:506
static neb_options_t & neb_options(Parameters &p)
Definition ParametersAccess.cpp:498
static serve_options_t & serve_options(Parameters &p)
Definition ParametersAccess.cpp:600
DimerRotationBackend rotation_backend
Definition ParametersOptions.h:313
struct eonc::neb_options_t::zoom_options_t zoom
std::string convergence_metric_label
Definition ParametersOptions.h:245
◆ load_ini()
| int eonc::config::load_ini | ( | INIReader & | ini, |
| Parameters & | params ) |
Parse all INI sections into the Parameters struct.
Returns 0 on success, nonzero on error.
Definition at line 44 of file ParametersINI.cpp.
44 {
45 int error = 0;
46
47 // [Main] //
48
50 magic_enum::enum_cast<JobType>(ini.Get("Main", "job", ""),
51 magic_enum::case_insensitive)
52 .value_or(JobType::Unknown);
54 ini.GetReal("Main", "temperature",
55 ParametersLoadAccess::main_options(params).temperature);
57 ini.GetInteger("Main", "random_seed",
58 ParametersLoadAccess::main_options(params).randomSeed);
60 ini.GetBoolean("Main", "checkpoint",
61 ParametersLoadAccess::main_options(params).checkpoint);
67 ini.GetBoolean("Main", "write_con_forces",
68 ParametersLoadAccess::main_options(params).writeConForces);
69 // Process-wide io mode; same pattern as the RNG seeding below.
71 ParametersLoadAccess::main_options(params).writeConForces);
73 ini.GetReal("Main", "finite_difference",
74 ParametersLoadAccess::main_options(params).finiteDifference);
75 // Initialize random generator
77 unsigned i = static_cast<unsigned>(std::time(nullptr));
79 eonc::rng::random(i);
80 } else {
82 }
84 ini.GetInteger("Main", "max_force_calls",
85 ParametersLoadAccess::main_options(params).maxForceCalls);
87 ini.GetBoolean("Main", "remove_net_force",
88 ParametersLoadAccess::main_options(params).removeNetForce);
91
92 // [Potential] //
93
94 std::string potTok = ini.Get("Potential", "potential", "");
95 // Schema / old configs: ase_nwcem is ASE_NWCHEM; socket_nwchem is
96 // SocketNWChem (magic_enum already matches the latter).
97 if (potTok == "ase_nwcem" || potTok == "ASE_NWCEM") {
98 potTok = "ase_nwchem";
99 }
101 magic_enum::enum_cast<PotType>(potTok, magic_enum::case_insensitive)
102 .value_or(PotType::UNKNOWN);
104 "Potential", "mpi_poll_period",
105 ParametersLoadAccess::potential_options(params).MPIPollPeriod);
107 ini.GetBoolean(
108 "Potential", "lammps_logging",
109 ParametersLoadAccess::potential_options(params).LAMMPSLogging);
111 static_cast<int>(ini.GetInteger(
112 "Potential", "lammps_threads",
113 ParametersLoadAccess::potential_options(params).LAMMPSThreads));
115 "Potential", "emt_rasmussen",
116 ParametersLoadAccess::potential_options(params).EMTRasmussen);
118 ini.Get("Potential", "ext_pot_path",
119 ParametersLoadAccess::potential_options(params).extPotPath);
121 ini.Get("Potential", "potentials_path",
122 ParametersLoadAccess::potential_options(params).potentialsPath);
123
127 } else {
129 }
131 "Potential", "log_potential",
132 ParametersLoadAccess::potential_options(params).LogPotential);
134 "Potential", "thread_safe",
135 ParametersLoadAccess::potential_options(params).thread_safe);
136
137 // [AMS]
142 ini.Get("AMS", "forcefield",
143 ParametersLoadAccess::ams_options(params).forcefield);
145 ini.Get("AMS", "resources",
146 ParametersLoadAccess::ams_options(params).resources);
153 }
154 // [AMS_IO]
159 ini.Get("AMS_IO", "forcefield",
160 ParametersLoadAccess::ams_options(params).forcefield);
165 }
166 // [AMS_ENV]
170 ini.Get("AMS_ENV", "amshome",
171 ParametersLoadAccess::ams_options(params).env.amshome);
173 ini.Get("AMS_ENV", "scm_tmpdir",
174 ParametersLoadAccess::ams_options(params).env.scm_tmpdir);
176 ini.Get("AMS_ENV", "scmlicense",
177 ParametersLoadAccess::ams_options(params).env.scmlicense);
179 ini.Get("AMS_ENV", "scm_pythondir",
180 ParametersLoadAccess::ams_options(params).env.scm_pythondir);
182 ini.Get("AMS_ENV", "amsbin",
183 ParametersLoadAccess::ams_options(params).env.amsbin);
185 ini.Get("AMS_ENV", "amsresources",
186 ParametersLoadAccess::ams_options(params).env.amsresources);
187 }
188 // [XTBPot]
191 ini.Get("XTBPot", "paramset",
192 ParametersLoadAccess::xtb_options(params).paramset);
196 ini.GetReal("XTBPot", "electronic_temperature",
197 ParametersLoadAccess::xtb_options(params).elec_temperature);
199 ini.GetInteger("XTBPot", "max_iterations",
200 ParametersLoadAccess::xtb_options(params).maxiter);
205 }
206 // [ZBLPot]
209 ini.GetReal("ZBLPot", "cut_inner",
210 ParametersLoadAccess::zbl_options(params).cut_inner);
212 ini.GetReal("ZBLPot", "cut_global",
213 ParametersLoadAccess::zbl_options(params).cut_global);
215 ParametersLoadAccess::zbl_options(params).cut_global) {
216 throw std::runtime_error(
217 "Switching function must begin before the global cutoff!");
218 }
219 }
220 // [D3Pot] / [D4Pot]: rgpot 3.1 Grimme DFT-D
224 ini.Get("D3Pot", "functional",
225 ini.Get("D4Pot", "functional",
228 "D3Pot", "atm",
229 ini.GetBoolean("D4Pot", "atm",
232 ini.Get("D3Pot", "damping",
233 ParametersLoadAccess::dftd_options(params).d3_damping);
235 ini.GetReal("D4Pot", "charge",
236 ParametersLoadAccess::dftd_options(params).d4_charge);
237 }
240 ini.Get("ExprPot", "expression",
241 ParametersLoadAccess::expr_options(params).expression);
244 }
247 ini.GetInteger("MOPACPot", "charge",
248 ParametersLoadAccess::mopac_options(params).charge));
250 ini.GetInteger("MOPACPot", "spin",
251 ParametersLoadAccess::mopac_options(params).spin));
253 ini.GetInteger("MOPACPot", "model",
254 ParametersLoadAccess::mopac_options(params).model));
256 ini.Get("MOPACPot", "engine_path",
257 ParametersLoadAccess::mopac_options(params).engine_path);
258 }
259 // [SocketNWChemPot]
262 ini.Get("SocketNWChemPot", "host",
263 ParametersLoadAccess::socket_nwchem_options(params).host);
265 "SocketNWChemPot", "port",
266 ParametersLoadAccess::socket_nwchem_options(params).port);
268 ini.GetInteger(
269 "SocketNWChemPot", "mem_in_gb",
270 ParametersLoadAccess::socket_nwchem_options(params).mem_in_gb);
272 ini.Get("SocketNWChemPot", "nwchem_settings",
273 ParametersLoadAccess::socket_nwchem_options(params)
274 .nwchem_settings);
276 ini.Get("SocketNWChemPot", "unix_socket_path",
277 ParametersLoadAccess::socket_nwchem_options(params)
278 .unix_socket_path);
280 ini.GetBoolean("SocketNWChemPot", "unix_socket_mode",
281 ParametersLoadAccess::socket_nwchem_options(params)
282 .unix_socket_mode);
284 ini.GetBoolean("SocketNWChemPot", "make_template_input",
285 ParametersLoadAccess::socket_nwchem_options(params)
286 .make_template_input);
287 }
288
289 // [RgpotPot] — in-process NWChemPot/CPMDPot (also accept legacy [RGPot] keys)
291 const char *sec = "RgpotPot";
292 // Prefer [RgpotPot]; fall back to [RGPot] field names used by direct-link
293 // design
297 ini.Get(sec, "basis",
298 ini.Get(sec, "nwchem_basis",
301 ini.Get(sec, "theory",
302 ini.Get(sec, "nwchem_theory",
305 ini.Get(sec, "scf_type",
306 ini.Get(sec, "nwchem_scf_type",
309 sec, "functional",
310 ini.Get(sec, "cpmd_functional",
312 // cutOffRy is the schema name. cutoff_ry and cpmd_cut_off_ry still load.
314 sec, "cutOffRy",
315 ini.GetReal(
316 sec, "cutoff_ry",
317 ini.GetReal(
318 sec, "cpmd_cut_off_ry",
321 sec, "charge",
322 ini.GetInteger(sec, "nwchem_charge",
325 sec, "multiplicity",
326 ini.GetInteger(
327 sec, "nwchem_multiplicity",
330 ini.Get(sec, "engine_path",
331 ParametersLoadAccess::rgpot_options(params).engine_path);
333 ini.Get(sec, "engine_library",
334 ParametersLoadAccess::rgpot_options(params).engine_library);
336 ini.Get(sec, "engine_root",
337 ParametersLoadAccess::rgpot_options(params).engine_root);
341 ini.GetInteger(sec, "memory_mb",
342 ParametersLoadAccess::rgpot_options(params).memory_mb);
344 ini.Get(sec, "scratch_dir",
345 ParametersLoadAccess::rgpot_options(params).scratch_dir);
347 ini.Get(sec, "input_block",
348 ParametersLoadAccess::rgpot_options(params).input_block);
350 ini.Get(sec, "permanent_dir",
351 ParametersLoadAccess::rgpot_options(params).permanent_dir);
353 ini.Get(sec, "params_path",
354 ParametersLoadAccess::rgpot_options(params).params_path);
356 ini.GetInteger(
357 sec, "ranks_per_image",
358 ParametersLoadAccess::rgpot_options(params).ranks_per_image);
360 ini.Get(sec, "model_path",
361 ParametersLoadAccess::rgpot_options(params).model_path);
365 ini.Get(sec, "length_unit",
366 ParametersLoadAccess::rgpot_options(params).length_unit);
368 sec, "extensions_directory",
369 ParametersLoadAccess::rgpot_options(params).extensions_directory);
371 ini.GetBoolean(
372 sec, "check_consistency",
373 ParametersLoadAccess::rgpot_options(params).check_consistency);
375 ini.GetReal(
376 sec, "uncertainty_threshold",
377 ParametersLoadAccess::rgpot_options(params).uncertainty_threshold);
379 ini.GetBoolean(sec, "torch_determinism_strict",
380 ParametersLoadAccess::rgpot_options(params)
381 .torch_determinism_strict);
382 // XTB dlopen knobs (also accept [XTBPot] when backend=xtb)
384 sec, "paramset",
385 ini.Get(sec, "xtb_paramset",
388 sec, "accuracy",
389 ini.GetReal(sec, "xtb_accuracy",
392 ini.GetReal(sec, "electronic_temperature",
393 ini.GetReal(sec, "xtb_electronic_temperature",
394 ParametersLoadAccess::rgpot_options(params)
395 .xtb_electronic_temperature));
397 static_cast<int>(ini.GetInteger(
398 sec, "max_iterations",
399 ini.GetInteger(sec, "xtb_max_iterations",
400 ParametersLoadAccess::rgpot_options(params)
401 .xtb_max_iterations)));
403 ini.GetReal(sec, "xtb_charge",
404 static_cast<double>(
405 ParametersLoadAccess::rgpot_options(params).charge));
407 static_cast<int>(ini.GetInteger(
408 sec, "uhf",
409 ini.GetInteger(
410 sec, "xtb_uhf",
412 const std::string be =
413 toLowerCase(ParametersLoadAccess::rgpot_options(params).backend);
414 if (be == "xtb" || be == "xtbpot" || be == "gfn" || be == "gfnxtb") {
416 ini.Get("XTBPot", "paramset",
417 ParametersLoadAccess::rgpot_options(params).xtb_paramset);
419 ini.GetReal("XTBPot", "accuracy",
420 ParametersLoadAccess::rgpot_options(params).xtb_accuracy);
422 ini.GetReal("XTBPot", "electronic_temperature",
423 ParametersLoadAccess::rgpot_options(params)
424 .xtb_electronic_temperature);
426 static_cast<int>(ini.GetInteger(
427 "XTBPot", "max_iterations",
428 ParametersLoadAccess::rgpot_options(params).xtb_max_iterations));
430 ini.GetInteger("XTBPot", "uhf",
431 ParametersLoadAccess::rgpot_options(params).xtb_uhf));
433 ini.GetReal("XTBPot", "charge",
434 ParametersLoadAccess::rgpot_options(params).xtb_charge);
435 }
436 // [RgpotPot] is the backend switch. [cpmd] is the scalar CPMD message
437 // and overrides that section when the backend is CPMD. A params_path
438 // file, applied later, owns the same fields and is not overwritten
439 // by either section. input_block from here is appended to the file.
440 if (be == "cpmd" || be == "cpmdc" || be == "cpmdpot") {
442 rg.functional =
443 ini.Get("cpmd", "functional",
444 ini.Get("cpmd", "cpmd_functional", rg.functional));
445 rg.cutoff_ry = ini.GetReal(
446 "cpmd", "cutOffRy",
447 ini.GetReal("cpmd", "cutoff_ry",
448 ini.GetReal("cpmd", "cpmd_cut_off_ry", rg.cutoff_ry)));
449 rg.charge = ini.GetInteger("cpmd", "charge", rg.charge);
450 rg.multiplicity = ini.GetInteger("cpmd", "multiplicity", rg.multiplicity);
451 rg.title = ini.Get("cpmd", "title", rg.title);
452 rg.memory_mb = ini.GetInteger("cpmd", "memory_mb", rg.memory_mb);
453 rg.input_block = ini.Get("cpmd", "input_block", rg.input_block);
454 }
455 }
456
457 // [Debug] //
458
460 ini.GetBoolean("Debug", "write_movies",
461 ParametersLoadAccess::debug_options(params).write_movies);
463 ini.GetInteger(
464 "Debug", "write_movies_interval",
465 ParametersLoadAccess::debug_options(params).write_movies_interval);
467 ini.GetBoolean(
468 "Debug", "write_deprecated_outs",
469 ParametersLoadAccess::debug_options(params).write_deprecated_outs);
471 ini.GetBoolean(
472 "Debug", "estimate_neb_eigenvalues",
473 ParametersLoadAccess::debug_options(params).estimate_neb_eigenvalues);
475 toLowerCase(ini.Get("Debug", "neb_mmf_estimator",
477
478 // [Structure Comparison] //
479
481 .distance_difference =
482 ini.GetReal("Structure Comparison", "distance_difference",
484 .distance_difference);
486 ini.GetReal("Structure Comparison", "neighbor_cutoff",
488 .neighbor_cutoff);
490 ini.GetBoolean("Structure Comparison", "check_rotation",
492 .check_rotation);
494 ini.GetReal("Structure Comparison", "energy_difference",
496 .energy_difference);
498 .indistinguishable_atoms =
499 ini.GetBoolean("Structure Comparison", "indistinguishable_atoms",
501 .indistinguishable_atoms);
503 .remove_translation =
504 ini.GetBoolean("Structure Comparison", "remove_translation",
506 .remove_translation);
507
508 // [Process Search] //
509
511 ini.GetBoolean(
512 "Process Search", "minimize_first",
513 ParametersLoadAccess::process_search_options(params).minimize_first);
515 ini.GetReal("Process Search", "minimization_offset",
516 ParametersLoadAccess::process_search_options(params)
517 .minimization_offset);
518
519 // [Optimizers] //
520 auto inp_optMethod =
521 magic_enum::enum_cast<OptType>(ini.Get("Optimizer", "opt_method", "none"),
522 magic_enum::case_insensitive)
523 .value_or(OptType::Unknown);
526 }
527
529 toLowerCase(ini.Get(
530 "Optimizer", "convergence_metric",
533 ParametersLoadAccess::optimizer_options(params).convergence_metric)) {
535 *label;
536 } else {
537 EONC_LOG_ERROR(
538 "unknown convergence_metric {}",
539 ParametersLoadAccess::optimizer_options(params).convergence_metric);
540 error = 1;
541 }
542
543 if (ini.HasSection("Refine")) {
545 magic_enum::enum_cast<OptType>(ini.Get("Refine", "opt_method", ""),
546 magic_enum::case_insensitive)
547 .value_or(OptType::None);
549 ini.GetReal(
550 "Refine", "threshold",
551 ParametersLoadAccess::optimizer_options(params).refine.threshold);
552 }
553
555 "Optimizer", "converged_force",
556 ParametersLoadAccess::optimizer_options(params).converged_force);
558 static_cast<size_t>(ini.GetInteger(
559 "Optimizer", "max_iterations",
560 ParametersLoadAccess::optimizer_options(params).max_iterations));
562 ini.GetReal("Optimizer", "max_move",
563 ParametersLoadAccess::optimizer_options(params).max_move);
564 // Handle each optimizer separately
565 if (ini.HasSection("QuickMin")) {
567 ini.GetReal(
568 "QuickMin", "time_step",
569 ParametersLoadAccess::optimizer_options(params).time_step_input);
574 ini.GetBoolean("Optimizer", "qm_steepest_descent",
575 ParametersLoadAccess::optimizer_options(params)
576 .quickmin.steepest_descent);
577 }
578 if (ini.HasSection("FIRE")) {
581 ini.GetReal(
582 "FIRE", "time_step",
583 ParametersLoadAccess::optimizer_options(params).time_step_input);
588 ini.GetReal("FIRE", "time_step_max",
589 ParametersLoadAccess::optimizer_options(params)
590 .max_time_step_input);
594 }
595 // 2014 optbench INI puts lbfgs_* on [Optimizer]. Prefer [LBFGS] when present.
596 {
597 const char *lbfgs_sec = ini.HasSection("LBFGS") ? "LBFGS" : "Optimizer";
599 ini.GetInteger(
600 lbfgs_sec, "lbfgs_memory",
601 ParametersLoadAccess::optimizer_options(params).lbfgs.memory);
603 ini.GetReal(lbfgs_sec, "lbfgs_inverse_curvature",
604 ParametersLoadAccess::optimizer_options(params)
605 .lbfgs.inverse_curvature);
606 ParametersLoadAccess::optimizer_options(params)
608 ini.GetReal(lbfgs_sec, "lbfgs_max_inverse_curvature",
609 ParametersLoadAccess::optimizer_options(params)
610 .lbfgs.max_inverse_curvature);
612 lbfgs.auto_scale =
613 ini.GetBoolean(lbfgs_sec, "lbfgs_auto_scale", lbfgs.auto_scale);
614 lbfgs.angle_reset =
615 ini.GetBoolean(lbfgs_sec, "lbfgs_angle_reset", lbfgs.angle_reset);
616 lbfgs.distance_reset =
617 ini.GetBoolean(lbfgs_sec, "lbfgs_distance_reset", lbfgs.distance_reset);
618 lbfgs.curvature =
619 toLowerCase(ini.Get(lbfgs_sec, "lbfgs_curvature", lbfgs.curvature));
620 lbfgs.project_rigid =
621 ini.GetBoolean(lbfgs_sec, "lbfgs_project_rigid", lbfgs.project_rigid);
622 lbfgs.secant =
623 toLowerCase(ini.Get(lbfgs_sec, "lbfgs_secant", lbfgs.secant));
624 lbfgs.precon =
625 toLowerCase(ini.Get(lbfgs_sec, "lbfgs_precon", lbfgs.precon));
626 lbfgs.step = toLowerCase(ini.Get(lbfgs_sec, "lbfgs_step", lbfgs.step));
627 lbfgs.h0 = toLowerCase(ini.Get(lbfgs_sec, "lbfgs_h0", lbfgs.h0));
628 lbfgs.accept =
629 toLowerCase(ini.Get(lbfgs_sec, "lbfgs_accept", lbfgs.accept));
630 lbfgs.extra_updates =
631 ini.GetInteger(lbfgs_sec, "lbfgs_extra_updates", lbfgs.extra_updates);
632 lbfgs.cautious_eps =
633 ini.GetReal(lbfgs_sec, "lbfgs_cautious_eps", lbfgs.cautious_eps);
634 lbfgs.cautious_alpha =
635 ini.GetReal(lbfgs_sec, "lbfgs_cautious_alpha", lbfgs.cautious_alpha);
636 lbfgs.precon_A = ini.GetReal(lbfgs_sec, "lbfgs_precon_A", lbfgs.precon_A);
637 lbfgs.precon_mu =
638 ini.GetReal(lbfgs_sec, "lbfgs_precon_mu", lbfgs.precon_mu);
639 lbfgs.precon_rcut =
640 ini.GetReal(lbfgs_sec, "lbfgs_precon_rcut", lbfgs.precon_rcut);
641 }
642 {
644 xtsci.method =
645 toLowerCase(ini.Get("Optimizer", "xtsci_method", xtsci.method));
646 if (ini.HasSection("Xtsci")) {
647 xtsci.method = toLowerCase(ini.Get(
648 "Xtsci", "method", ini.Get("Xtsci", "xtsci_method", xtsci.method)));
649 xtsci.qn_step = toLowerCase(ini.Get("Xtsci", "qn_step", xtsci.qn_step));
650 xtsci.precon = toLowerCase(ini.Get("Xtsci", "precon", xtsci.precon));
651 xtsci.accept = toLowerCase(ini.Get("Xtsci", "accept", xtsci.accept));
652 xtsci.highs =
653 ini.GetBoolean("Xtsci", "highs",
654 ini.GetBoolean("Xtsci", "xtsci_highs", xtsci.highs));
655 xtsci.manifold = toLowerCase(
656 ini.Get("Xtsci", "manifold",
657 ini.Get("Xtsci", "xtsci_manifold", xtsci.manifold)));
658 }
659 xtsci.highs = ini.GetBoolean("Optimizer", "xtsci_highs", xtsci.highs);
661 }
662 if (ini.HasSection("CG")) {
664 ini.GetBoolean(
665 "CG", "cg_no_overshooting",
666 ParametersLoadAccess::optimizer_options(params).cg.no_overshooting);
668 ini.GetBoolean("CG", "cg_knock_out_max_move",
669 ParametersLoadAccess::optimizer_options(params)
670 .cg.knock_out_max_move);
672 ini.GetBoolean(
673 "CG", "cg_line_search",
674 ParametersLoadAccess::optimizer_options(params).cg.line_search);
676 ini.GetReal(
677 "CG", "cg_line_converged",
678 ParametersLoadAccess::optimizer_options(params).cg.line_converged);
680 ini.GetInteger("CG", "cg_max_iter_before_reset",
681 ParametersLoadAccess::optimizer_options(params)
682 .cg.max_iter_before_reset);
684 ini.GetInteger("CG", "cg_max_iter_line_search",
685 ParametersLoadAccess::optimizer_options(params)
686 .cg.line_search_max_iter);
687 }
688 if (ini.HasSection("SD")) {
690 ini.GetReal("SD", "sd_alpha",
691 ParametersLoadAccess::optimizer_options(params).sd.alpha);
693 ini.GetBoolean(
694 "SD", "sd_twopoint",
695 ParametersLoadAccess::optimizer_options(params).sd.two_point);
696 }
697
698 // [Dimer] //
699
701 ini.GetReal("Dimer", "finite_angle",
702 ParametersLoadAccess::dimer_options(params).rotation_angle);
704 ini.GetBoolean("Dimer", "improved",
705 ParametersLoadAccess::dimer_options(params).improved);
707 ini.GetReal("Dimer", "converged_angle",
708 ParametersLoadAccess::dimer_options(params).converged_angle);
710 "Dimer", "max_iterations",
711 ParametersLoadAccess::dimer_options(params).max_iterations);
712 if (auto dimerOpt = magic_enum::enum_cast<OptType>(
713 ini.Get("Dimer", "opt_method", "cg"), magic_enum::case_insensitive);
716 }
718 ini.GetInteger("Dimer", "rotations_min",
719 ParametersLoadAccess::dimer_options(params).rotations_min);
721 ini.GetInteger("Dimer", "rotations_max",
722 ParametersLoadAccess::dimer_options(params).rotations_max);
724 ini.GetReal("Dimer", "torque_min",
725 ParametersLoadAccess::dimer_options(params).torque_min);
727 ini.GetReal("Dimer", "torque_max",
728 ParametersLoadAccess::dimer_options(params).torque_max);
730 "Dimer", "remove_rotation",
731 ParametersLoadAccess::dimer_options(params).remove_rotation);
733 ini.GetReal("Dimer", "lor_residual_tol",
734 ParametersLoadAccess::dimer_options(params).lor_residual_tol);
735 {
736 const auto rotTok =
737 toLowerCase(ini.Get("Dimer", "rotation_backend", "classical"));
739 magic_enum::enum_cast<DimerRotationBackend>(
740 rotTok, magic_enum::case_insensitive)
741 .value_or(DimerRotationBackend::Classical);
742 }
743
744 // GP Surrogate Parameters
746 ini.GetBoolean("Surrogate", "use_surrogate", false);
751 }
753 "Surrogate", "gp_uncertainty",
754 ParametersLoadAccess::gp_surrogate_options(params).uncertainty);
755 if (ini.HasSection("Surrogate")) {
757 magic_enum::enum_cast<PotType>(ini.Get("Surrogate", "potential", ""),
758 magic_enum::case_insensitive)
759 .value_or(PotType::UNKNOWN);
761 throw std::runtime_error("We only support catlearn for GP right now");
762 }
763 }
764 // [CatLearn]
765 if (ini.HasSection("CatLearn")) {
767 ini.Get("CatLearn", "catl_path", "");
769 ini.Get("CatLearn", "model", "catl_model");
771 ini.Get("CatLearn", "prior", "catl_prior");
773 ini.GetBoolean("CatLearn", "use_derivatives", "catl_deriv");
775 ini.GetBoolean("CatLearn", "use_fingerprint", "catl_fingerprint");
777 "CatLearn", "parallel_hyperparameter_opt", "catl_parallel");
778 }
779 // [ASE_ORCA]
780 if (ini.HasSection("ASE_ORCA")) {
782 ini.Get("ASE_ORCA", "orca_path", "");
784 ini.Get("ASE_ORCA", "nproc", "1");
786 ini.Get("ASE_ORCA", "simpleinput", "");
788 static_cast<int>(ini.GetInteger("ASE_ORCA", "charge", 0));
790 static_cast<int>(ini.GetInteger("ASE_ORCA", "multiplicity", 1));
791 }
792 // [ASE_NWCHEM]
793 if (ini.HasSection("ASE_NWCHEM")) {
795 ini.Get("ASE_NWCHEM", "nwchem_path", "");
797 ini.Get("ASE_NWCHEM", "nproc", "1");
799 ini.Get("ASE_NWCHEM", "mpi_launcher",
800 ParametersLoadAccess::ase_nwchem_options(params).mpi_launcher);
802 ini.Get("ASE_NWCHEM", "multiplicity", "");
804 ini.GetReal("ASE_NWCHEM", "scf_thresh", 1e-5);
806 ini.GetInteger("ASE_NWCHEM", "scf_maxiter", 200);
808 ini.Get("ASE_NWCHEM", "basis",
809 ParametersLoadAccess::ase_nwchem_options(params).basis);
811 ini.Get("ASE_NWCHEM", "memory",
812 ParametersLoadAccess::ase_nwchem_options(params).memory);
813 }
814 // [Metatomic]
815 if (ini.HasSection("Metatomic")) {
817 ini.Get("Metatomic", "model_path", "");
819 ini.Get("Metatomic", "device", "cpu");
821 ini.Get("Metatomic", "length_unit", "angstrom");
823 ini.Get("Metatomic", "extensions_directory", "");
825 ini.GetBoolean("Metatomic", "check_consistency", false);
827 ini.GetReal("Metatomic", "uncertainty_threshold", -1.0);
829 ini.Get("Metatomic", "energy_output",
830 ParametersLoadAccess::metatomic_options(params).energy_output);
832 ini.Get("Metatomic", "energy_uncertainty_output",
833 ParametersLoadAccess::metatomic_options(params)
834 .energy_uncertainty_output);
836 ini.Get("Metatomic", "force_output",
837 ParametersLoadAccess::metatomic_options(params).force_output);
839 ini.GetBoolean("Metatomic", "non_conservative", false);
841 ini.GetBoolean("Metatomic", "random_rotation", false);
843 static_cast<long>(
844 ini.GetInteger("Metatomic", "n_symmetry_rotations", 0));
846 ini.GetBoolean("Metatomic", "deterministic", true);
848 ini.GetBoolean("Metatomic", "deterministic_strict", false);
851 _variant.energy = ini.Get("Metatomic", "variant_energy", "");
852 _variant.energy_uncertainty =
853 ini.Get("Metatomic", "variant_energy_uncertainty", "");
854 _variant.force = ini.Get("Metatomic", "variant_force", "");
855 }
856 // [Serve]
857 if (ini.HasSection("Serve")) {
861 static_cast<uint16_t>(ini.GetInteger(
864 ini.GetInteger("Serve", "replicas",
865 ParametersLoadAccess::serve_options(params).replicas));
867 static_cast<uint16_t>(ini.GetInteger(
868 "Serve", "gateway_port",
869 ParametersLoadAccess::serve_options(params).gateway_port));
871 ini.Get("Serve", "endpoints",
872 ParametersLoadAccess::serve_options(params).endpoints);
873 }
874
875 // GP_NEB only
877 ini.GetBoolean("Surrogate", "gp_linear_path_always",
878 ParametersLoadAccess::gp_surrogate_options(params)
879 .linear_path_always);
880 // [Lanczos] //
881
883 ini.GetReal("Lanczos", "tolerance",
884 ParametersLoadAccess::lanczos_options(params).tolerance);
886 "Lanczos", "max_iterations",
887 ParametersLoadAccess::lanczos_options(params).max_iterations);
889 ini.GetBoolean("Lanczos", "quit_early",
890 ParametersLoadAccess::lanczos_options(params).quit_early);
891 if (ini.HasValue("Lanczos", "phva_atoms")) {
893 toLowerCase(ini.Get("Lanczos", "phva_atoms", "All"));
894 }
895
896 // [Davidson] //
898 ini.GetReal("Davidson", "tolerance",
899 ParametersLoadAccess::davidson_options(params).tolerance);
901 ini.GetInteger(
902 "Davidson", "max_iterations",
903 ParametersLoadAccess::davidson_options(params).max_iterations);
905 ini.GetBoolean("Davidson", "diagonal_preconditioner",
906 ParametersLoadAccess::davidson_options(params)
907 .diagonal_preconditioner);
908 if (ini.HasValue("Davidson", "phva_atoms")) {
910 toLowerCase(ini.Get("Davidson", "phva_atoms", "All"));
911 }
912
913 // [ARTn] //
915 ini.GetReal("ARTn", "push_step_size",
916 ParametersLoadAccess::artn_options(params).push_step_size);
918 ini.GetReal("ARTn", "force_threshold",
919 ParametersLoadAccess::artn_options(params).force_threshold);
921 ini.GetInteger("ARTn", "max_iterations",
922 ParametersLoadAccess::artn_options(params).max_iterations);
926 ini.Get("ARTn", "nperp_limitation",
927 ParametersLoadAccess::artn_options(params).nperp_limitation);
929 "ARTn", "lanczos_min_size",
930 ParametersLoadAccess::artn_options(params).lanczos_min_size);
935
936 // [IRA] //
938 ini.GetReal("IRA", "distance_threshold",
939 ParametersLoadAccess::ira_options(params).distance_threshold);
941 ini.GetReal("IRA", "symmetry_threshold",
942 ParametersLoadAccess::ira_options(params).symmetry_threshold);
945
946 // [GPR Dimer] //
948 "GPR Dimer", "finite_angle",
949 ParametersLoadAccess::gpr_dimer_options(params).rotation_angle);
951 "GPR Dimer", "converged_angle",
952 ParametersLoadAccess::gpr_dimer_options(params).converged_angle);
954 ini.GetReal(
955 "GPR Dimer", "relaxation_converged_angle",
956 ParametersLoadAccess::gpr_dimer_options(params).relax_conv_angle);
958 static_cast<long>(ini.GetInteger(
959 "GPR Dimer", "max_initial_rotation_iterations",
960 ParametersLoadAccess::gpr_dimer_options(params).init_rotations_max));
962 static_cast<long>(ini.GetInteger(
963 "GPR Dimer", "max_relaxation_rotation_iterations",
964 ParametersLoadAccess::gpr_dimer_options(params).relax_rotations_max));
966 static_cast<long>(ini.GetInteger(
967 "GPR Dimer", "divisor_t_dimer",
968 ParametersLoadAccess::gpr_dimer_options(params).divisor_t_dimer_gp));
969 ParametersLoadAccess::gpr_dimer_options(params)
971 "GPR Dimer", "max_outer_iterations",
972 ParametersLoadAccess::gpr_dimer_options(params).max_outer_iterations));
973 ParametersLoadAccess::gpr_dimer_options(params)
975 "GPR Dimer", "max_inner_iterations",
976 ParametersLoadAccess::gpr_dimer_options(params).max_inner_iterations));
978 ini.GetReal(
979 "GPR Dimer", "max_midpoint_displacement",
980 ParametersLoadAccess::gpr_dimer_options(params).midpoint_max_disp);
982 ini.Get("GPR Dimer", "rotation_opt_method",
983 ParametersLoadAccess::gpr_dimer_options(params).rot_opt_method);
985 ini.Get("GPR Dimer", "translation_opt_method",
986 ParametersLoadAccess::gpr_dimer_options(params).trans_opt_method);
988 "GPR Dimer", "active_radius",
989 ParametersLoadAccess::gpr_dimer_options(params).active_radius);
991 ini.GetReal("GPR Dimer", "dimer_separation",
992 ParametersLoadAccess::gpr_dimer_options(params).dimer_sep);
994 ini.GetReal("GPR Dimer", "convex_region_step_size",
995 ParametersLoadAccess::gpr_dimer_options(params).conv_step);
997 ini.GetReal("GPR Dimer", "max_step_size",
998 ParametersLoadAccess::gpr_dimer_options(params).max_step);
1000 "GPR Dimer", "ratio_at_limit",
1001 ParametersLoadAccess::gpr_dimer_options(params).ratio_at_limit);
1003 "GPR Dimer", "nogp_initial_rotations",
1004 ParametersLoadAccess::gpr_dimer_options(params).init_rot_gp);
1006 ini.GetBoolean(
1007 "GPR Dimer", "nogp_init_translations",
1008 ParametersLoadAccess::gpr_dimer_options(params).init_trans_gp);
1010 ini.GetBoolean(
1011 "GPR Dimer", "has_many_iterations",
1012 ParametersLoadAccess::gpr_dimer_options(params).many_iterations);
1013 // GPR Params
1015 ini.Get("GPR Dimer", "hyperparameter_opt_method",
1016 ParametersLoadAccess::gpr_dimer_options(params)
1017 .gpr_params.hyper_opt_method);
1019 ini.GetReal(
1020 "GPR Dimer", "gpr_variance",
1021 ParametersLoadAccess::gpr_dimer_options(params).gpr_params.sigma2);
1023 ini.GetReal("GPR Dimer", "gpr_jitter_variance",
1024 ParametersLoadAccess::gpr_dimer_options(params)
1025 .gpr_params.jitter_sigma2);
1027 ini.GetReal("GPR Dimer", "gpr_noise_variance",
1028 ParametersLoadAccess::gpr_dimer_options(params)
1029 .gpr_params.noise_sigma2);
1031 ini.GetReal(
1032 "GPR Dimer", "prior_mean",
1033 ParametersLoadAccess::gpr_dimer_options(params).gpr_params.prior_mu);
1035 ini.GetReal("GPR Dimer", "prior_variance",
1036 ParametersLoadAccess::gpr_dimer_options(params)
1037 .gpr_params.prior_sigma2);
1039 ini.GetReal(
1040 "GPR Dimer", "prior_degrees_of_freedom",
1041 ParametersLoadAccess::gpr_dimer_options(params).gpr_params.prior_nu);
1042 // GPR Optimization Parameters
1044 ini.GetBoolean("GPR Dimer", "check_derivatives",
1045 ParametersLoadAccess::gpr_dimer_options(params)
1046 .opt_params.check_derivatives);
1048 static_cast<int>(
1049 ini.GetInteger("GPR Dimer", "opt_max_iterations",
1050 ParametersLoadAccess::gpr_dimer_options(params)
1051 .opt_params.max_iterations));
1053 ini.GetReal(
1054 "GPR Dimer", "opt_tol_func",
1055 ParametersLoadAccess::gpr_dimer_options(params).opt_params.tol_func);
1057 ini.GetReal(
1058 "GPR Dimer", "opt_tol_sol",
1059 ParametersLoadAccess::gpr_dimer_options(params).opt_params.tol_sol);
1061 ini.GetReal("GPR Dimer", "opt_lambda_limit",
1062 ParametersLoadAccess::gpr_dimer_options(params)
1063 .opt_params.lambda_limit);
1065 ini.GetReal("GPR Dimer", "opt_lambda_init",
1066 ParametersLoadAccess::gpr_dimer_options(params)
1067 .opt_params.lambda_init);
1068 // GPR Debugging Parameters
1070 static_cast<int>(
1071 ini.GetInteger("GPR Dimer", "report_level",
1072 ParametersLoadAccess::gpr_dimer_options(params)
1073 .debug_params.report_level));
1075 static_cast<int>(
1076 ini.GetInteger("GPR Dimer", "debug_level",
1077 ParametersLoadAccess::gpr_dimer_options(params)
1078 .debug_params.debug_level));
1080 ini.Get(
1081 "GPR Dimer", "debug_output_directory",
1082 ParametersLoadAccess::gpr_dimer_options(params).debug_params.out_dir);
1084 ini.Get("GPR Dimer", "debug_position_basename",
1085 ParametersLoadAccess::gpr_dimer_options(params)
1086 .debug_params.pos_file);
1088 ini.Get("GPR Dimer", "debug_energy_basename",
1089 ParametersLoadAccess::gpr_dimer_options(params)
1090 .debug_params.energy_file);
1092 ini.Get("GPR Dimer", "debug_gradient_basename",
1093 ParametersLoadAccess::gpr_dimer_options(params)
1094 .debug_params.grad_file);
1095 ParametersLoadAccess::gpr_dimer_options(params)
1097 ini.GetReal("GPR Dimer", "debug_midpoint_offset",
1098 ParametersLoadAccess::gpr_dimer_options(params)
1099 .debug_params.offset_mid_point);
1101 "GPR Dimer", "debug_y_step",
1102 ParametersLoadAccess::gpr_dimer_options(params).debug_params.dy);
1104 "GPR Dimer", "debug_z_step",
1105 ParametersLoadAccess::gpr_dimer_options(params).debug_params.dz);
1106 // GPR Prune
1108 ini.GetBoolean("GPR Dimer", "use_prune",
1109 ParametersLoadAccess::gpr_dimer_options(params)
1110 .prune_params.use_prune);
1112 static_cast<int>(ini.GetInteger(
1113 "GPR Dimer", "start_prune_at",
1114 ParametersLoadAccess::gpr_dimer_options(params).prune_params.begin));
1116 static_cast<int>(ini.GetInteger(
1117 "GPR Dimer", "nprune_vals",
1118 ParametersLoadAccess::gpr_dimer_options(params).prune_params.n_vals));
1120 ini.GetReal("GPR Dimer", "prune_threshold",
1121 ParametersLoadAccess::gpr_dimer_options(params)
1122 .prune_params.threshold);
1123
1124 // [Prefactor] //
1125
1127 "Prefactor", "default_value",
1128 ParametersLoadAccess::prefactor_options(params).default_value);
1130 ini.GetReal("Prefactor", "max_value",
1131 ParametersLoadAccess::prefactor_options(params).max_value);
1133 ini.GetReal("Prefactor", "min_value",
1134 ParametersLoadAccess::prefactor_options(params).min_value);
1136 "Prefactor", "within_radius",
1137 ParametersLoadAccess::prefactor_options(params).within_radius);
1139 ini.GetReal(
1140 "Prefactor", "min_displacement",
1141 ParametersLoadAccess::prefactor_options(params).min_displacement);
1143 ini.Get("Prefactor", "rate_estimation",
1146 ini.Get("Prefactor", "configuration",
1149 ini.GetBoolean(
1150 "Prefactor", "all_free_atoms",
1151 ParametersLoadAccess::prefactor_options(params).all_free_atoms);
1153 ini.Get("Prefactor", "filter_scheme",
1156 "Prefactor", "filter_fraction",
1157 ParametersLoadAccess::prefactor_options(params).filter_fraction);
1158
1159 // [Hessian] //
1160 // Prefer phva_atoms; accept legacy atom_list when phva_atoms is absent.
1161 if (ini.HasValue("Hessian", "phva_atoms")) {
1163 toLowerCase(ini.Get("Hessian", "phva_atoms", "All"));
1164 } else if (ini.HasValue("Hessian", "atom_list")) {
1166 toLowerCase(ini.Get("Hessian", "atom_list", "All"));
1167 }
1169 "Hessian", "zero_freq_value",
1170 ParametersLoadAccess::hessian_options(params).zero_freq_value);
1172 ini.Get("Hessian", "fd_scheme",
1175 ini.GetBoolean("Hessian", "resume",
1176 ParametersLoadAccess::hessian_options(params).resume);
1178 ini.Get("Hessian", "checkpoint_path",
1179 ParametersLoadAccess::hessian_options(params).checkpoint_path);
1181 ini.GetBoolean("Hessian", "write_modes",
1182 ParametersLoadAccess::hessian_options(params).write_modes);
1183
1184 // [Nudged Elastic Band] //
1185 const std::string neb_section = "Nudged Elastic Band";
1186
1188 ini.GetInteger(neb_section, "images",
1189 ParametersLoadAccess::neb_options(params).image_count);
1191 ini.GetBoolean(
1192 neb_section, "solid_state",
1193 ParametersLoadAccess::neb_options(params).solid_state.enabled);
1195 ini.GetReal(neb_section, "solid_state_weight",
1196 ParametersLoadAccess::neb_options(params).solid_state.weight);
1198 neb_section, "solid_state_pressure",
1199 ParametersLoadAccess::neb_options(params).solid_state.pressure);
1201 neb_section, "max_iterations",
1202 ParametersLoadAccess::optimizer_options(params).max_iterations);
1204 neb_section, "converged_force",
1205 ParametersLoadAccess::optimizer_options(params).converged_force);
1206 auto neb_optMethod =
1207 magic_enum::enum_cast<OptType>(ini.Get(neb_section, "opt_method", "none"),
1208 magic_enum::case_insensitive)
1209 .value_or(OptType::Unknown);
1212 }
1214 neb_section, "setup_mmf_peaks",
1215 ParametersLoadAccess::neb_options(params).mmf_peaks.enabled);
1217 neb_section, "mmf_peak_tolerance",
1218 ParametersLoadAccess::neb_options(params).mmf_peaks.tolerance);
1220 ini.GetBoolean(neb_section, "match_endpoints",
1221 ParametersLoadAccess::neb_options(params).match_endpoints);
1223 ini.Get(neb_section, "match_method",
1225
1227 ini.GetReal(neb_section, "spring",
1228 ParametersLoadAccess::neb_options(params).spring.constant);
1230 ini.GetBoolean(
1231 neb_section, "elastic_band",
1232 ParametersLoadAccess::neb_options(params).spring.use_elastic_band);
1234 ini.GetBoolean(
1235 neb_section, "doubly_nudged",
1236 ParametersLoadAccess::neb_options(params).spring.doubly_nudged);
1238 ini.GetBoolean(
1239 neb_section, "doubly_nudged_switching",
1240 ParametersLoadAccess::neb_options(params).spring.use_switching);
1241
1243 ini.GetBoolean(
1244 neb_section, "energy_weighted",
1245 ParametersLoadAccess::neb_options(params).spring.weighting.enabled);
1247 ini.GetReal(
1248 neb_section, "ew_trigger",
1249 ParametersLoadAccess::neb_options(params).spring.weighting.trigger);
1251 ini.GetReal(
1252 neb_section, "ew_ksp_min",
1253 ParametersLoadAccess::neb_options(params).spring.weighting.k_min);
1255 ini.GetReal(
1256 neb_section, "ew_ksp_max",
1257 ParametersLoadAccess::neb_options(params).spring.weighting.k_max);
1258
1260 neb_section, "onsager_machlup",
1261 ParametersLoadAccess::neb_options(params).spring.om.enabled);
1263 ini.GetBoolean(
1264 neb_section, "om_optimize_k",
1265 ParametersLoadAccess::neb_options(params).spring.om.optimize_k);
1267 ini.GetReal(neb_section, "om_k_scale",
1268 ParametersLoadAccess::neb_options(params).spring.om.k_scale);
1270 ini.GetReal(neb_section, "om_k_min",
1271 ParametersLoadAccess::neb_options(params).spring.om.k_min);
1273 ini.GetReal(neb_section, "om_k_max",
1274 ParametersLoadAccess::neb_options(params).spring.om.k_max);
1275
1277 ini.GetBoolean(
1278 neb_section, "climbing_image_method",
1279 ParametersLoadAccess::neb_options(params).climbing_image.enabled);
1281 ini.GetBoolean(neb_section, "climbing_image_converged_only",
1282 ParametersLoadAccess::neb_options(params)
1283 .climbing_image.converged_only);
1285 ini.GetReal(
1286 neb_section, "climbing_image_band_slack",
1287 ParametersLoadAccess::neb_options(params).climbing_image.band_slack);
1289 ini.GetBoolean(neb_section, "old_tangent",
1290 ParametersLoadAccess::neb_options(params)
1291 .climbing_image.use_old_tangent);
1293 ini.GetReal(neb_section, "ci_after",
1294 ParametersLoadAccess::neb_options(params)
1295 .climbing_image.trigger_force);
1297 ini.GetReal(neb_section, "ci_after_rel",
1298 ParametersLoadAccess::neb_options(params)
1299 .climbing_image.trigger_factor);
1300
1303 oci.trigger_force =
1304 ini.GetReal(neb_section, "ci_mmf_after", oci.trigger_force);
1305 oci.trigger_factor =
1306 ini.GetReal(neb_section, "ci_mmf_after_rel", oci.trigger_factor);
1307 oci.max_steps = ini.GetInteger(neb_section, "ci_mmf_nsteps", oci.max_steps);
1308 oci.ci_stability_count = ini.GetInteger(
1309 neb_section, "ci_mmf_ci_stability_count", oci.ci_stability_count);
1310 oci.angle_tol = ini.GetReal(neb_section, "ci_mmf_angle", oci.angle_tol);
1311 oci.restore_unhelpful = ini.GetBoolean(
1312 neb_section, "ci_mmf_restore_unhelpful", oci.restore_unhelpful);
1313
1316 zoom.alpha = ini.GetReal(neb_section, "zoom_alpha", zoom.alpha);
1317 zoom.offset = ini.GetInteger(neb_section, "zoom_offset", zoom.offset);
1318 zoom.mode = magic_enum::enum_cast<neb_options_t::zoom_options_t::Mode>(
1319 ini.Get(neb_section, "zoom_mode",
1320 std::string(magic_enum::enum_name(zoom.mode))),
1321 magic_enum::case_insensitive)
1322 .value_or(zoom.mode);
1323 zoom.activation_threshold =
1324 ini.GetReal(neb_section, "zoom_after", zoom.activation_threshold);
1325 zoom.interpolation =
1326 magic_enum::enum_cast<neb_options_t::zoom_options_t::Interpolation>(
1327 ini.Get(neb_section, "zoom_interpolation",
1328 std::string(magic_enum::enum_name(zoom.interpolation))),
1329 magic_enum::case_insensitive)
1330 .value_or(zoom.interpolation);
1331 zoom.stability_count =
1332 ini.GetInteger(neb_section, "zoom_ci_stability", zoom.stability_count);
1333 zoom.max_iterations =
1334 ini.GetInteger(neb_section, "zoom_max_iterations", zoom.max_iterations);
1335
1337 init.method =
1338 magic_enum::enum_cast<NEBInit>(ini.Get(neb_section, "initializer", ""),
1339 magic_enum::case_insensitive)
1340 .value_or(NEBInit::LINEAR);
1341 init.input_path = ini.Get(neb_section, "initial_path_in", init.input_path);
1342 init.max_iterations =
1343 ini.GetInteger(neb_section, "init_max_iterations", init.max_iterations);
1344 init.nsteps = ini.GetInteger(neb_section, "init_nsteps", init.nsteps);
1345 init.max_move = ini.GetReal(neb_section, "init_max_move", init.max_move);
1346 init.force_tolerance =
1347 ini.GetReal(neb_section, "init_force_threshold", init.force_tolerance);
1348 init.sidpp_alpha =
1349 ini.GetReal(neb_section, "sidpp_growth_alpha", init.sidpp_alpha);
1350 init.sidpp_frontier_tol =
1351 ini.GetReal(neb_section, "sidpp_frontier_tol", init.sidpp_frontier_tol);
1352 init.sidpp_reparam =
1353 ini.GetBoolean(neb_section, "sidpp_reparameterize", init.sidpp_reparam);
1354 init.sidpp_ideal_ksp =
1355 ini.GetBoolean(neb_section, "sidpp_ideal_ksp", init.sidpp_ideal_ksp);
1356 auto neb_ipath_optMethod =
1357 magic_enum::enum_cast<OptType>(
1358 ini.Get(neb_section, "ipath_opt_method", "none"),
1359 magic_enum::case_insensitive)
1360 .value_or(OptType::Unknown);
1363 neb_ipath_optMethod;
1364 }
1365 init.oversampling =
1366 ini.GetBoolean(neb_section, "oversampling", init.oversampling);
1367 init.oversampling_factor = ini.GetInteger(neb_section, "oversampling_factor",
1368 init.oversampling_factor);
1369
1371 neb_section, "minimize_endpoints",
1372 ParametersLoadAccess::neb_options(params).endpoints.minimize);
1374 ini.GetBoolean(
1375 neb_section, "minimize_endpoints_for_ipath",
1376 ParametersLoadAccess::neb_options(params).endpoints.use_path_file);
1377
1378 // [Dynamics] //
1379
1381 "Dynamics", "time_step",
1382 ParametersLoadAccess::dynamics_options(params).time_step_input);
1387 ini.GetReal("Dynamics", "time",
1388 ParametersLoadAccess::dynamics_options(params).time_input);
1394 static_cast<long>(std::floor(
1395 ParametersLoadAccess::dynamics_options(params).time /
1396 ParametersLoadAccess::dynamics_options(params).time_step +
1397 0.5));
1398 } else {
1400 }
1402 toLowerCase(ini.Get("Dynamics", "thermostat", "andersen"));
1404 "Dynamics", "andersen_alpha",
1405 ParametersLoadAccess::thermostat_options(params).andersen_alpha);
1407 ini.GetReal(
1408 "Dynamics", "andersen_collision_period",
1409 ParametersLoadAccess::thermostat_options(params).andersen_tcol_input);
1414 ini.GetReal("Dynamics", "nose_mass",
1415 ParametersLoadAccess::thermostat_options(params).nose_mass);
1417 ini.GetReal("Dynamics", "langevin_friction",
1418 ParametersLoadAccess::thermostat_options(params)
1419 .langevin_friction_input);
1423 {
1425 th.path_beads = ini.GetInteger("Dynamics", "path_beads", th.path_beads);
1426 th.path_springs =
1427 toLowerCase(ini.Get("Dynamics", "path_springs", th.path_springs));
1428 th.path_eco_omega_max =
1429 ini.GetReal("Dynamics", "path_eco_omega_max", th.path_eco_omega_max);
1430 th.path_gle_file = ini.Get("Dynamics", "path_gle_file", th.path_gle_file);
1431 th.path_pile_tau_input =
1432 ini.GetReal("Dynamics", "path_pile_tau", th.path_pile_tau_input);
1434 th.path_pile_tau = timeUnit > 0.0 ? th.path_pile_tau_input / timeUnit : 0.0;
1435 th.path_pile_scale =
1436 ini.GetReal("Dynamics", "path_pile_scale", th.path_pile_scale);
1437 const long seed = ini.GetInteger("Dynamics", "path_seed",
1438 static_cast<long>(th.path_seed));
1439 if (seed < 0) {
1440 throw std::invalid_argument("[Dynamics] path_seed must be non-negative");
1441 }
1442 th.path_seed = static_cast<std::uint64_t>(seed);
1443 if (th.path_springs != "trotter" && th.path_springs != "eco") {
1444 throw std::invalid_argument(
1445 "[Dynamics] path_springs must be trotter or eco, not " +
1446 th.path_springs);
1447 }
1448 }
1449
1450 // [Parallel Replica]
1451
1453 ini.GetBoolean(
1454 "Parallel Replica", "stop_after_transition",
1455 ParametersLoadAccess::parallel_replica_options(params).auto_stop);
1457 ini.GetBoolean("Parallel Replica", "refine_transition",
1458 ParametersLoadAccess::parallel_replica_options(params)
1459 .refine_transition);
1461 ini.GetBoolean("Parallel Replica", "dephase_loop_stop",
1462 ParametersLoadAccess::parallel_replica_options(params)
1463 .dephase_loop_stop);
1465 ini.GetReal("Parallel Replica", "dephase_time",
1466 ParametersLoadAccess::parallel_replica_options(params)
1467 .dephase_time_input);
1469 ParametersLoadAccess::parallel_replica_options(params)
1470 .dephase_time_input /
1473 ini.GetInteger("Parallel Replica", "dephase_loop_max",
1474 ParametersLoadAccess::parallel_replica_options(params)
1475 .dephase_loop_max);
1476 ParametersLoadAccess::parallel_replica_options(params)
1477 .state_check_interval_input =
1478 ini.GetReal("Parallel Replica", "state_check_interval",
1479 ParametersLoadAccess::parallel_replica_options(params)
1480 .state_check_interval_input);
1482 ParametersLoadAccess::parallel_replica_options(params)
1483 .state_check_interval_input /
1486 ini.GetReal("Parallel Replica", "state_save_interval",
1487 0.1 * ParametersLoadAccess::parallel_replica_options(params)
1488 .state_check_interval_input);
1490 ParametersLoadAccess::parallel_replica_options(params)
1491 .record_interval_input /
1494 ini.GetReal("Parallel Replica", "post_transition_time",
1495 ParametersLoadAccess::parallel_replica_options(params)
1496 .corr_time_input);
1500
1501 // [Temperature Accelerated Dynamics] //
1502
1504 ini.GetReal("TAD", "low_temperature",
1505 ParametersLoadAccess::tad_options(params).low_temperature);
1507 ini.GetReal("TAD", "min_prefactor",
1508 ParametersLoadAccess::tad_options(params).min_prefactor);
1510 ini.GetReal("TAD", "confidence",
1511 ParametersLoadAccess::tad_options(params).confidence);
1512
1513 // [Replica Exchange] //
1514
1515 ParametersLoadAccess::replica_exchange_options(params)
1516 .temperature_distribution =
1517 toLowerCase(ini.Get("Replica Exchange", "temperature_distribution",
1518 ParametersLoadAccess::replica_exchange_options(params)
1519 .temperature_distribution));
1521 ini.GetInteger(
1522 "Replica Exchange", "replicas",
1523 ParametersLoadAccess::replica_exchange_options(params).replicas);
1525 ini.GetInteger("Replica Exchange", "exchange_trials",
1526 ParametersLoadAccess::replica_exchange_options(params)
1527 .exchange_trials);
1529 ini.GetReal("Replica Exchange", "sampling_time",
1530 ParametersLoadAccess::replica_exchange_options(params)
1531 .sampling_time_input);
1533 ParametersLoadAccess::replica_exchange_options(params)
1534 .sampling_time_input /
1537 ini.GetReal("Replica Exchange", "temperature_low",
1538 ParametersLoadAccess::main_options(params).temperature);
1540 ini.GetReal("Replica Exchange", "temperature_high",
1541 ParametersLoadAccess::replica_exchange_options(params)
1542 .temperature_high);
1544 ini.GetReal("Replica Exchange", "exchange_period",
1545 ParametersLoadAccess::replica_exchange_options(params)
1546 .exchange_period_input);
1548 ParametersLoadAccess::replica_exchange_options(params)
1549 .exchange_period_input /
1551
1552 // [Hyperdynamics] //
1553
1555 ini.GetReal(
1556 "Hyperdynamics", "bb_rmd_time",
1557 ParametersLoadAccess::hyperdynamics_options(params).rmd_time_input);
1562 toLowerCase(ini.Get(
1563 "Hyperdynamics", "bb_boost_atomlist",
1566 ini.GetReal("Hyperdynamics", "bb_dvmax",
1567 ParametersLoadAccess::hyperdynamics_options(params).dvmax);
1569 ini.GetReal("Hyperdynamics", "bb_stretch_threshold",
1570 ParametersLoadAccess::hyperdynamics_options(params).qrr);
1572 ini.GetReal("Hyperdynamics", "bb_ds_curvature",
1573 ParametersLoadAccess::hyperdynamics_options(params).prr);
1575 ini.GetReal("Hyperdynamics", "bb_rcut",
1576 ParametersLoadAccess::hyperdynamics_options(params).qcut);
1578 toLowerCase(ini.Get(
1579 "Hyperdynamics", "bias_potential",
1581
1582 // [Saddle Search] //
1583
1585 ini.Get("Saddle Search", "method",
1588 toLowerCase(ini.Get(
1589 "Saddle Search", "min_mode_method",
1592 ini.GetReal("Saddle Search", "displace_magnitude",
1593 ParametersLoadAccess::saddle_search_options(params)
1594 .displace_magnitude);
1596 ini.GetReal(
1597 "Saddle Search", "displace_radius",
1598 ParametersLoadAccess::saddle_search_options(params).displace_radius);
1600 "Saddle Search", "max_energy",
1601 ParametersLoadAccess::saddle_search_options(params).max_energy);
1603 ini.GetInteger(
1604 "Saddle Search", "max_iterations",
1605 ParametersLoadAccess::optimizer_options(params).max_iterations);
1606 ParametersLoadAccess::saddle_search_options(params)
1607 .nonnegative_displacement_abort =
1608 ini.GetBoolean("Saddle Search", "nonnegative_displacement_abort",
1609 ParametersLoadAccess::saddle_search_options(params)
1610 .nonnegative_displacement_abort);
1612 ini.GetReal("Saddle Search", "max_single_displace",
1613 ParametersLoadAccess::saddle_search_options(params)
1614 .max_single_displace);
1616 ini.GetReal(
1617 "Saddle Search", "converged_force",
1618 ParametersLoadAccess::optimizer_options(params).converged_force);
1620 ini.GetReal(
1621 "Saddle Search", "perp_force_ratio",
1622 ParametersLoadAccess::saddle_search_options(params).perp_force_ratio);
1624 toLowerCase(ini.Get("Saddle Search", "client_displace_type",
1625 eonc::EpiCenters::DISP_LOAD));
1627 ini.GetInteger("Saddle Search", "nonlocal_count_abort",
1628 ParametersLoadAccess::saddle_search_options(params)
1629 .nonlocal_count_abort);
1631 ini.GetReal("Saddle Search", "nonlocal_distance_abort",
1632 ParametersLoadAccess::saddle_search_options(params)
1633 .nonlocal_distance_abort);
1639 eonc::EpiCenters::DISP_LAST_ATOM &&
1641 eonc::EpiCenters::DISP_RANDOM &&
1646 }
1647 // Parse comma-separated atom list
1648 {
1649 std::string atomListStr =
1650 ini.Get("Saddle Search", "displace_atom_list", "");
1651 if (!atomListStr.empty()) {
1652 std::stringstream ss(atomListStr);
1653 std::string token;
1654 while (std::getline(ss, token, ',')) {
1655 size_t start = token.find_first_not_of(" \t");
1656 size_t end = token.find_last_not_of(" \t");
1657 if (start != std::string::npos) {
1658 ParametersLoadAccess::saddle_search_options(params)
1659 .displace_atom_list.push_back(
1660 std::stol(token.substr(start, end - start + 1)));
1661 }
1662 }
1663 }
1664 }
1666 ini.GetBoolean("Saddle Search", "confine_positive",
1667 ParametersLoadAccess::saddle_search_options(params)
1668 .confine_positive.enabled);
1670 .confine_positive.enabled) {
1671 ParametersLoadAccess::saddle_search_options(params)
1673 ini.GetBoolean("Saddle Search", "bowl_breakout",
1674 ParametersLoadAccess::saddle_search_options(params)
1675 .confine_positive.bowl_breakout);
1676 ParametersLoadAccess::saddle_search_options(params)
1678 ini.GetInteger("Saddle Search", "bowl_active_atoms",
1679 ParametersLoadAccess::saddle_search_options(params)
1680 .confine_positive.bowl_active);
1681 ParametersLoadAccess::saddle_search_options(params)
1683 ini.GetReal("Saddle Search", "confine_positive_min_move",
1684 ParametersLoadAccess::saddle_search_options(params)
1685 .confine_positive.min_force);
1686 ParametersLoadAccess::saddle_search_options(params)
1688 ini.GetReal("Saddle Search", "confine_positive_scale_ratio",
1689 ParametersLoadAccess::saddle_search_options(params)
1690 .confine_positive.scale_ratio);
1692 ini.GetReal("Saddle Search", "confine_positive_boost",
1693 ParametersLoadAccess::saddle_search_options(params)
1694 .confine_positive.boost);
1695 ParametersLoadAccess::saddle_search_options(params)
1697 ini.GetInteger("Saddle Search", "confine_positive_min_active",
1698 ParametersLoadAccess::saddle_search_options(params)
1699 .confine_positive.min_active);
1700 }
1704 ini.GetReal("Saddle Search", "dynamics_temperature",
1705 ParametersLoadAccess::saddle_search_options(params)
1706 .dynamics.temperature);
1707 ParametersLoadAccess::saddle_search_options(params)
1709 ini.GetReal("Saddle Search", "dynamics_state_check_interval",
1710 ParametersLoadAccess::saddle_search_options(params)
1711 .dynamics.state_check_interval_input);
1712 ParametersLoadAccess::saddle_search_options(params)
1714 ParametersLoadAccess::saddle_search_options(params)
1717 ParametersLoadAccess::saddle_search_options(params)
1719 ini.GetReal("Saddle Search", "dynamics_record_interval",
1720 ParametersLoadAccess::saddle_search_options(params)
1721 .dynamics.record_interval_input);
1723 ParametersLoadAccess::saddle_search_options(params)
1726 ParametersLoadAccess::saddle_search_options(params)
1728 ini.GetBoolean("Saddle Search", "dynamics_linear_interpolation",
1729 ParametersLoadAccess::saddle_search_options(params)
1730 .dynamics.linear_interpolation);
1732 ini.GetBoolean(
1733 "Saddle Search", "remove_rotation",
1734 ParametersLoadAccess::saddle_search_options(params).remove_rotation);
1735 ParametersLoadAccess::saddle_search_options(params)
1737 ini.GetReal("Saddle Search", "dynamics_max_init_curvature",
1738 ParametersLoadAccess::saddle_search_options(params)
1739 .dynamics.max_init_curvature);
1740 ParametersLoadAccess::saddle_search_options(params)
1741 .zero_mode_abort_curvature =
1742 ini.GetReal("Saddle Search", "zero_mode_abort_curvature",
1743 ParametersLoadAccess::saddle_search_options(params)
1744 .zero_mode_abort_curvature);
1745
1746 // [Basin Hopping] //
1747
1749 ini.GetReal(
1750 "Basin Hopping", "displacement",
1751 ParametersLoadAccess::basin_hopping_options(params).displacement);
1753 ini.GetReal("Basin Hopping", "push_apart_distance",
1754 ParametersLoadAccess::basin_hopping_options(params)
1755 .push_apart_distance);
1756 ParametersLoadAccess::basin_hopping_options(params)
1758 ini.GetReal("Basin Hopping", "initial_random_structure_probability",
1759 ParametersLoadAccess::basin_hopping_options(params)
1760 .initial_random_structure_probability);
1762 ini.GetInteger("Basin Hopping", "steps",
1763 ParametersLoadAccess::basin_hopping_options(params).steps);
1765 ini.GetInteger(
1766 "Basin Hopping", "quenching_steps",
1767 ParametersLoadAccess::basin_hopping_options(params).quenching_steps);
1769 ini.GetBoolean("Basin Hopping", "single_atom_displace",
1770 ParametersLoadAccess::basin_hopping_options(params)
1771 .single_atom_displace);
1773 ini.GetBoolean("Basin Hopping", "significant_structure",
1774 ParametersLoadAccess::basin_hopping_options(params)
1775 .significant_structure);
1777 toLowerCase(ini.Get("Basin Hopping", "displacement_algorithm",
1778 ParametersLoadAccess::basin_hopping_options(params)
1779 .displacement_algorithm));
1784 ParametersLoadAccess::basin_hopping_options(params)
1785 .displacement_algorithm);
1786 error = 1;
1787 }
1788 ParametersLoadAccess::basin_hopping_options(params)
1789 .displacement_distribution =
1790 toLowerCase(ini.Get("Basin Hopping", "displacement_distribution",
1791 ParametersLoadAccess::basin_hopping_options(params)
1792 .displacement_distribution));
1796 ParametersLoadAccess::basin_hopping_options(params)
1797 .displacement_distribution);
1798 error = 1;
1799 }
1801 ini.GetReal(
1802 "Basin Hopping", "swap_probability",
1803 ParametersLoadAccess::basin_hopping_options(params).swap_probability);
1805 "Basin Hopping", "jump_max",
1806 ParametersLoadAccess::basin_hopping_options(params).jump_max);
1808 ini.GetInteger(
1809 "Basin Hopping", "jump_steps",
1810 ParametersLoadAccess::basin_hopping_options(params).jump_steps);
1812 ini.GetBoolean("Basin Hopping", "adjust_displacement",
1813 ParametersLoadAccess::basin_hopping_options(params)
1814 .adjust_displacement);
1816 ini.GetInteger(
1817 "Basin Hopping", "adjust_period",
1818 ParametersLoadAccess::basin_hopping_options(params).adjust_period);
1820 ini.GetReal(
1821 "Basin Hopping", "adjust_fraction",
1822 ParametersLoadAccess::basin_hopping_options(params).adjust_fraction);
1824 ini.GetReal(
1825 "Basin Hopping", "target_ratio",
1826 ParametersLoadAccess::basin_hopping_options(params).target_ratio);
1828 ini.GetBoolean(
1829 "Basin Hopping", "write_unique",
1830 ParametersLoadAccess::basin_hopping_options(params).write_unique);
1832 "Basin Hopping", "stop_energy",
1833 ParametersLoadAccess::basin_hopping_options(params).stop_energy);
1834
1835 // [Global Optimization] //
1836
1837 ParametersLoadAccess::global_optimization_options(params)
1838 .move_method = toLowerCase(ini.Get(
1839 "Global Optimization", "move_method",
1842 toLowerCase(
1843 ini.Get("Global Optimization", "decision_method",
1844 ParametersLoadAccess::global_optimization_options(params)
1845 .decision_method));
1849 ParametersLoadAccess::global_optimization_options(params)
1850 .decision_method);
1851 error = 1;
1852 }
1854 ini.GetInteger(
1855 "Global Optimization", "steps",
1856 ParametersLoadAccess::global_optimization_options(params).steps);
1858 "Global Optimization", "beta",
1859 ParametersLoadAccess::global_optimization_options(params).beta);
1861 "Global Optimization", "alpha",
1862 ParametersLoadAccess::global_optimization_options(params).alpha);
1864 ini.GetInteger(
1865 "Global Optimization", "mdmin",
1866 ParametersLoadAccess::global_optimization_options(params).mdmin);
1868 ini.GetReal("Global Optimization", "target_energy",
1869 ParametersLoadAccess::global_optimization_options(params)
1870 .target_energy);
1871
1872 // [BGSD] //
1873
1879 ini.GetReal("BGSD", "gradientfinitedifference",
1880 ParametersLoadAccess::bgsd_options(params)
1881 .gradient_finite_difference);
1883 ini.GetReal(
1884 "BGSD", "grad2energyconvergence",
1885 ParametersLoadAccess::bgsd_options(params).grad2energy_convergence);
1887 ini.GetReal(
1888 "BGSD", "grad2forceconvergence",
1889 ParametersLoadAccess::bgsd_options(params).grad2force_convergence);
1890
1891 // [Monte Carlo] //
1892
1894 ini.GetReal("Monte Carlo", "step_size",
1895 ParametersLoadAccess::monte_carlo_options(params).step_size);
1897 ini.GetInteger("Monte Carlo", "steps",
1898 ParametersLoadAccess::monte_carlo_options(params).steps));
1899
1900 // [Instanton] //
1901 {
1903 o.mode = ini.Get("Instanton", "mode", o.mode);
1904 o.reactant_filename =
1905 ini.Get("Instanton", "reactant_filename", o.reactant_filename);
1906 o.product_filename =
1907 ini.Get("Instanton", "product_filename", o.product_filename);
1908 o.initial_path = ini.Get("Instanton", "initial_path", o.initial_path);
1909 o.beads = ini.GetInteger("Instanton", "beads", o.beads);
1910 o.beta_hbar_omega =
1911 ini.GetReal("Instanton", "beta_hbar_omega", o.beta_hbar_omega);
1912 o.max_iterations =
1913 ini.GetInteger("Instanton", "max_iterations", o.max_iterations);
1914 o.force_tolerance =
1915 ini.GetReal("Instanton", "force_tolerance", o.force_tolerance);
1916 o.hessian_stride =
1917 ini.GetInteger("Instanton", "hessian_stride", o.hessian_stride);
1918 o.saddle_filename =
1919 ini.Get("Instanton", "saddle_filename", o.saddle_filename);
1920 o.temperature = ini.GetReal("Instanton", "temperature", o.temperature);
1921 o.temperatures.clear();
1922 {
1923 const std::string list = ini.Get("Instanton", "temperatures", "");
1924 std::stringstream ss(list);
1925 std::string token;
1926 while (std::getline(ss, token, ',')) {
1927 const size_t start = token.find_first_not_of(" \t");
1928 const size_t end = token.find_last_not_of(" \t");
1929 if (start == std::string::npos) {
1930 continue;
1931 }
1932 try {
1933 o.temperatures.push_back(
1934 std::stod(token.substr(start, end - start + 1)));
1935 } catch (const std::exception &) {
1936 throw std::invalid_argument(
1937 "[Instanton] temperatures must be comma-separated kelvin "
1938 "values, not " +
1939 token);
1940 }
1941 }
1942 }
1943 o.half_ring = ini.GetBoolean("Instanton", "half_ring", o.half_ring);
1944 o.initial_hessians =
1945 ini.Get("Instanton", "initial_hessians", o.initial_hessians);
1946 if (o.initial_hessians != "saddle" &&
1947 o.initial_hessians != "finite_difference") {
1948 throw std::invalid_argument("[Instanton] initial_hessians must be saddle "
1949 "or finite_difference, not " +
1950 o.initial_hessians);
1951 }
1952 o.energy_shift = ini.GetReal("Instanton", "energy_shift", o.energy_shift);
1953 o.bead_ladder = ini.GetBoolean("Instanton", "bead_ladder", o.bead_ladder);
1954 o.hessian_final = ini.Get("Instanton", "hessian_final", o.hessian_final);
1955 o.springs = toLowerCase(ini.Get("Instanton", "springs", o.springs));
1956 if (o.springs != "trotter" && o.springs != "eco") {
1957 throw std::invalid_argument(
1958 "[Instanton] springs must be trotter or eco, not " + o.springs);
1959 }
1960 if (o.mode != "splitting" && o.mode != "rate") {
1961 throw std::invalid_argument("[Instanton] mode must be splitting or rate, "
1962 "not " +
1963 o.mode);
1964 }
1965 o.pi_planes = ini.GetInteger("Instanton", "pi_planes", o.pi_planes);
1966 o.pi_beads = ini.GetInteger("Instanton", "pi_beads", o.pi_beads);
1967 o.pi_equilibration_steps = ini.GetInteger(
1968 "Instanton", "pi_equilibration_steps", o.pi_equilibration_steps);
1969 o.pi_sampling_steps =
1970 ini.GetInteger("Instanton", "pi_sampling_steps", o.pi_sampling_steps);
1971 o.pi_time_step = ini.GetReal("Instanton", "pi_time_step", o.pi_time_step);
1972 o.pi_thermostat =
1973 toLowerCase(ini.Get("Instanton", "pi_thermostat", o.pi_thermostat));
1974 o.pi_gle_file = ini.Get("Instanton", "pi_gle_file", o.pi_gle_file);
1975 o.pi_pile_tau = ini.GetReal("Instanton", "pi_pile_tau", o.pi_pile_tau);
1976 o.pi_pile_scale =
1977 ini.GetReal("Instanton", "pi_pile_scale", o.pi_pile_scale);
1978 o.pi_seed = ini.GetInteger("Instanton", "pi_seed", o.pi_seed);
1979 o.pi_direction =
1980 toLowerCase(ini.Get("Instanton", "pi_direction", o.pi_direction));
1981 o.pi_reactant_extent =
1982 ini.GetReal("Instanton", "pi_reactant_extent", o.pi_reactant_extent);
1983 o.pi_recrossing_parents = ini.GetInteger(
1984 "Instanton", "pi_recrossing_parents", o.pi_recrossing_parents);
1985 o.pi_recrossing_children = ini.GetInteger(
1986 "Instanton", "pi_recrossing_children", o.pi_recrossing_children);
1987 o.pi_recrossing_time =
1988 ini.GetReal("Instanton", "pi_recrossing_time", o.pi_recrossing_time);
1989 o.pi_recrossing_spacing = ini.GetInteger(
1990 "Instanton", "pi_recrossing_spacing", o.pi_recrossing_spacing);
1991 eonc::piqtst::validateOptions(o);
1992 }
1993
1994 // [OH_TST] //
1995
1997 ini.Get("OH_TST", "reactant_filename",
1998 ParametersLoadAccess::oh_tst_options(params).reactant_filename);
2000 ini.Get("OH_TST", "product_filename",
2001 ParametersLoadAccess::oh_tst_options(params).product_filename);
2003 ini.GetReal("OH_TST", "time_step",
2004 ParametersLoadAccess::oh_tst_options(params).time_step);
2006 ini.GetInteger("OH_TST", "equil_steps",
2007 ParametersLoadAccess::oh_tst_options(params).equil_steps);
2009 ini.GetInteger("OH_TST", "sample_steps",
2010 ParametersLoadAccess::oh_tst_options(params).sample_steps);
2012 ini.GetInteger("OH_TST", "max_planes",
2013 ParametersLoadAccess::oh_tst_options(params).max_planes);
2015 ini.GetReal("OH_TST", "plane_mass",
2016 ParametersLoadAccess::oh_tst_options(params).plane_mass);
2018 ini.GetReal("OH_TST", "alpha_rot",
2019 ParametersLoadAccess::oh_tst_options(params).alpha_rot);
2021 ini.GetReal("OH_TST", "plane_time_step",
2022 ParametersLoadAccess::oh_tst_options(params).plane_time_step);
2026 ini.GetReal("OH_TST", "dtheta_max",
2027 ParametersLoadAccess::oh_tst_options(params).dtheta_max);
2029 ini.GetReal("OH_TST", "force_tol",
2030 ParametersLoadAccess::oh_tst_options(params).force_tol);
2034 ini.GetInteger(
2035 "OH_TST", "reactant_md_steps",
2036 ParametersLoadAccess::oh_tst_options(params).reactant_md_steps);
2038 ini.Get("OH_TST", "symmetry_products",
2039 ParametersLoadAccess::oh_tst_options(params).symmetry_products);
2041 ini.GetReal("OH_TST", "max_delta_a",
2042 ParametersLoadAccess::oh_tst_options(params).max_delta_a);
2044 ini.Get("OH_TST", "thermostat",
2047 ini.Get("OH_TST", "gle_a_file",
2048 ParametersLoadAccess::oh_tst_options(params).gle_a_file);
2050 ini.GetBoolean("OH_TST", "pmf_scan",
2051 ParametersLoadAccess::oh_tst_options(params).pmf_scan);
2053 ini.GetInteger("OH_TST", "scan_planes",
2054 ParametersLoadAccess::oh_tst_options(params).scan_planes);
2055
2057}
const gp_surrogate_options_t & gp_surrogate_options() const
Definition ParametersAccess.cpp:144
const potential_options_t & potential_options() const
Definition ParametersAccess.cpp:79
const saddle_search_options_t & saddle_search_options() const
Definition ParametersAccess.cpp:127
const global_optimization_options_t & global_optimization_options() const
Definition ParametersAccess.cpp:217
const basin_hopping_options_t & basin_hopping_options() const
Definition ParametersAccess.cpp:212
void set_write_con_forces(bool enabled) noexcept
Whether written .con frames carry "Forces of Component" sections.
Definition ConFileIO.cpp:505
static gp_surrogate_options_t & gp_surrogate_options(Parameters &p)
Definition ParametersAccess.cpp:417
static lanczos_options_t & lanczos_options(Parameters &p)
Definition ParametersAccess.cpp:462
static ase_nwchem_options_t & ase_nwchem_options(Parameters &p)
Definition ParametersAccess.cpp:444
static hyperdynamics_options_t & hyperdynamics_options(Parameters &p)
Definition ParametersAccess.cpp:553
static monte_carlo_options_t & monte_carlo_options(Parameters &p)
Definition ParametersAccess.cpp:583
static xtb_options_t & xtb_options(Parameters &p)
Definition ParametersAccess.cpp:299
static socket_nwchem_options_t & socket_nwchem_options(Parameters &p)
Definition ParametersAccess.cpp:341
static replica_exchange_options_t & replica_exchange_options(Parameters &p)
Definition ParametersAccess.cpp:543
static dftd_options_t & dftd_options(Parameters &p)
Definition ParametersAccess.cpp:315
static ase_orca_options_t & ase_orca_options(Parameters &p)
Definition ParametersAccess.cpp:435
static ira_options_t & ira_options(Parameters &p)
Definition ParametersAccess.cpp:617
static oh_tst_options_t & oh_tst_options(Parameters &p)
Definition ParametersAccess.cpp:634
static gpr_dimer_options_t & gpr_dimer_options(Parameters &p)
Definition ParametersAccess.cpp:407
static prefactor_options_t & prefactor_options(Parameters &p)
Definition ParametersAccess.cpp:480
static bgsd_options_t & bgsd_options(Parameters &p)
Definition ParametersAccess.cpp:592
static ams_options_t & ams_options(Parameters &p)
Definition ParametersAccess.cpp:291
static tad_options_t & tad_options(Parameters &p)
Definition ParametersAccess.cpp:525
static artn_options_t & artn_options(Parameters &p)
Definition ParametersAccess.cpp:609
static expr_options_t & expr_options(Parameters &p)
Definition ParametersAccess.cpp:323
static global_optimization_options_t & global_optimization_options(Parameters &p)
Definition ParametersAccess.cpp:573
static mopac_options_t & mopac_options(Parameters &p)
Definition ParametersAccess.cpp:331
static rgpot_options_t & rgpot_options(Parameters &p)
Definition ParametersAccess.cpp:350
static metatomic_options_t & metatomic_options(Parameters &p)
Definition ParametersAccess.cpp:453
static davidson_options_t & davidson_options(Parameters &p)
Definition ParametersAccess.cpp:471
static basin_hopping_options_t & basin_hopping_options(Parameters &p)
Definition ParametersAccess.cpp:563
static parallel_replica_options_t & parallel_replica_options(Parameters &p)
Definition ParametersAccess.cpp:516
static catlearn_options_t & catlearn_options(Parameters &p)
Definition ParametersAccess.cpp:426
static zbl_options_t & zbl_options(Parameters &p)
Definition ParametersAccess.cpp:307
struct eonc::ams_options_t::env_t env
std::string nperp_limitation
Definition ParametersOptions.h:769
std::string displacement_algorithm
Definition ParametersOptions.h:710
double push_apart_distance
Definition ParametersOptions.h:705
bool significant_structure
Definition ParametersOptions.h:708
bool adjust_displacement
Definition ParametersOptions.h:715
double adjust_fraction
Definition ParametersOptions.h:717
long quenching_steps
Definition ParametersOptions.h:707
double swap_probability
Definition ParametersOptions.h:712
bool single_atom_displace
Definition ParametersOptions.h:709
std::string displacement_distribution
Definition ParametersOptions.h:711
double initial_random_structure_probability
Definition ParametersOptions.h:704
double grad2force_convergence
Definition ParametersOptions.h:747
double gradient_finite_difference
Definition ParametersOptions.h:744
double grad2energy_convergence
Definition ParametersOptions.h:746
bool diagonal_preconditioner
Heuristic | (H v)_i / v_i | preconditioner (not true diag(H); off by default).
Definition ParametersOptions.h:475
std::string phva_atoms
PHVA mobile/active set for the Ritz space; "All" = all free atoms.
Definition ParametersOptions.h:477
bool estimate_neb_eigenvalues
Definition ParametersOptions.h:799
long write_movies_interval
Definition ParametersOptions.h:797
bool write_deprecated_outs
Definition ParametersOptions.h:798
std::string move_method
Definition ParametersOptions.h:725
double target_energy
Definition ParametersOptions.h:731
std::string decision_method
Definition ParametersOptions.h:726
bool linear_path_always
Definition ParametersOptions.h:382
std::string out_dir
Definition ParametersOptions.h:366
double offset_mid_point
Definition ParametersOptions.h:371
int debug_level
Definition ParametersOptions.h:365
int report_level
Definition ParametersOptions.h:364
std::string pos_file
Definition ParametersOptions.h:367
std::string energy_file
Definition ParametersOptions.h:368
std::string grad_file
Definition ParametersOptions.h:369
std::string hyper_opt_method
Definition ParametersOptions.h:341
double noise_sigma2
Definition ParametersOptions.h:344
double prior_sigma2
Definition ParametersOptions.h:346
double jitter_sigma2
Definition ParametersOptions.h:343
long lambda_limit
Definition ParametersOptions.h:354
int max_iterations
Definition ParametersOptions.h:351
bool check_derivatives
Definition ParametersOptions.h:350
long lambda_init
Definition ParametersOptions.h:355
double threshold
Definition ParametersOptions.h:361
bool use_prune
Definition ParametersOptions.h:358
long init_rotations_max
Definition ParametersOptions.h:324
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
Definition ParametersOptions.h:327
long max_inner_iterations
Definition ParametersOptions.h:328
long divisor_t_dimer_gp
Definition ParametersOptions.h:326
struct eonc::gpr_dimer_options_t::debug_params_t debug_params
std::string trans_opt_method
Definition ParametersOptions.h:331
struct eonc::gpr_dimer_options_t::opt_params_t opt_params
std::string rot_opt_method
Definition ParametersOptions.h:330
double midpoint_max_disp
Definition ParametersOptions.h:329
double relax_conv_angle
Definition ParametersOptions.h:323
long relax_rotations_max
Definition ParametersOptions.h:325
std::string checkpoint_path
Definition ParametersOptions.h:509
std::string boost_atom_list
Definition ParametersOptions.h:692
double rmd_time_input
Definition ParametersOptions.h:693
std::string bias_potential
Definition ParametersOptions.h:691
bool deterministic_strict
Definition ParametersOptions.h:449
struct eonc::metatomic_options_t::variants_t variant
std::string energy_uncertainty_output
Definition ParametersOptions.h:429
double uncertainty_threshold
Definition ParametersOptions.h:425
bool check_consistency
Definition ParametersOptions.h:424
long n_symmetry_rotations
Definition ParametersOptions.h:442
std::string extensions_directory
Definition ParametersOptions.h:423
bool use_mmf
Definition ParametersOptions.h:564
bool converged_only
Definition ParametersOptions.h:554
bool enabled
Definition ParametersOptions.h:553
double trigger_force
Definition ParametersOptions.h:560
double band_slack
When converged_only is on, the rest of the band may still be this many times the force tolerance.
Definition ParametersOptions.h:558
double trigger_factor
Definition ParametersOptions.h:561
struct eonc::neb_options_t::climbing_image_options_t::hybrid_dimer_t ocineb
bool use_old_tangent
Definition ParametersOptions.h:559
bool use_path_file
Definition ParametersOptions.h:611
double tolerance
Definition ParametersOptions.h:524
OptType opt_method
Definition ParametersOptions.h:604
double k_min
Definition ParametersOptions.h:540
bool enabled
Definition ParametersOptions.h:538
double k_max
Definition ParametersOptions.h:541
double trigger
Definition ParametersOptions.h:539
double k_max
Definition ParametersOptions.h:548
double k_min
Definition ParametersOptions.h:547
bool optimize_k
Definition ParametersOptions.h:545
bool enabled
Definition ParametersOptions.h:544
double k_scale
Definition ParametersOptions.h:546
struct eonc::neb_options_t::spring_options_t::energy_weighting_t weighting
bool use_switching
Definition ParametersOptions.h:535
bool doubly_nudged
Definition ParametersOptions.h:534
struct eonc::neb_options_t::spring_options_t::onsager_machlup_t om
bool use_elastic_band
Definition ParametersOptions.h:533
std::string match_method
"ira" uses IRACompare. "hungarian" is accepted and falls back to ira.
Definition ParametersOptions.h:529
struct eonc::neb_options_t::climbing_image_options_t climbing_image
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
bool match_endpoints
Permute+rotate the reactant onto the product before interpolation.
Definition ParametersOptions.h:527
struct eonc::neb_options_t::path_initialization_t initialization
struct eonc::neb_options_t::mmf_peak_options_t mmf_peaks
std::string symmetry_products
Definition ParametersOptions.h:905
std::string product_filename
Definition ParametersOptions.h:880
std::string reactant_filename
Definition ParametersOptions.h:879
struct eonc::optimizer_options_t::refine_t refine
double record_interval_input
Definition ParametersOptions.h:644
double dephase_time_input
Definition ParametersOptions.h:639
double corr_time_input
Definition ParametersOptions.h:646
double state_check_interval
Definition ParametersOptions.h:643
double record_interval
Definition ParametersOptions.h:645
long dephase_loop_max
Definition ParametersOptions.h:641
bool dephase_loop_stop
Definition ParametersOptions.h:638
double state_check_interval_input
Definition ParametersOptions.h:642
bool refine_transition
Definition ParametersOptions.h:636
bool thread_safe
When false, NEB/dimer/process_search never share one Potential across threads, even if the backend re...
Definition ParametersOptions.h:59
double min_displacement
Definition ParametersOptions.h:486
double sampling_time
Definition ParametersOptions.h:682
double temperature_low
Definition ParametersOptions.h:684
double temperature_high
Definition ParametersOptions.h:683
long exchange_trials
Definition ParametersOptions.h:680
double exchange_period
Definition ParametersOptions.h:686
double exchange_period_input
Definition ParametersOptions.h:685
double sampling_time_input
Definition ParametersOptions.h:681
std::string temperature_distribution
Definition ParametersOptions.h:678
double uncertainty_threshold
Definition ParametersOptions.h:173
double xtb_electronic_temperature
Definition ParametersOptions.h:178
bool torch_determinism_strict
Definition ParametersOptions.h:174
std::string extensions_directory
Definition ParametersOptions.h:171
double boost
Definition ParametersOptions.h:227
double scale_ratio
Definition ParametersOptions.h:226
bool enabled
Definition ParametersOptions.h:222
bool bowl_breakout
Definition ParametersOptions.h:223
double min_force
Definition ParametersOptions.h:225
long min_active
Definition ParametersOptions.h:228
long bowl_active
Definition ParametersOptions.h:224
double state_check_interval
Definition ParametersOptions.h:215
double record_interval
Definition ParametersOptions.h:217
double state_check_interval_input
Definition ParametersOptions.h:214
double record_interval_input
Definition ParametersOptions.h:216
double temperature
Definition ParametersOptions.h:213
bool linear_interpolation
Definition ParametersOptions.h:218
double max_init_curvature
Definition ParametersOptions.h:219
long nonlocal_count_abort
Definition ParametersOptions.h:208
double max_single_displace
Definition ParametersOptions.h:203
bool nonnegative_displacement_abort
Definition ParametersOptions.h:207
double perp_force_ratio
Definition ParametersOptions.h:206
struct eonc::saddle_search_options_t::dynamics_t dynamics
std::string displace_type
Definition ParametersOptions.h:199
double converged_force
Definition ParametersOptions.h:205
bool remove_rotation
Definition ParametersOptions.h:210
double displace_magnitude
Definition ParametersOptions.h:202
std::string minmode_method
Definition ParametersOptions.h:198
double displace_radius
Definition ParametersOptions.h:204
std::vector< long > displace_atom_list
Definition ParametersOptions.h:200
struct eonc::saddle_search_options_t::confine_positive_t confine_positive
double nonlocal_distance_abort
Definition ParametersOptions.h:209
double zero_mode_abort_curvature
Definition ParametersOptions.h:211
std::string nwchem_settings
Definition ParametersOptions.h:129
bool make_template_input
Definition ParametersOptions.h:132
bool unix_socket_mode
Definition ParametersOptions.h:131
std::string unix_socket_path
Definition ParametersOptions.h:130
double langevin_friction
Definition ParametersOptions.h:665
double langevin_friction_input
Definition ParametersOptions.h:664
double andersen_tcol_input
Definition ParametersOptions.h:661
◆ load_json()
| int eonc::config::load_json | ( | std::string_view | json_str, |
| Parameters & | params ) |
Load Parameters from a JSON string. Returns 0 on success.
Definition at line 836 of file ParametersJSON.cpp.
836 {
837 try {
838 auto j = json::parse(json_str);
839 from_json(j, params);
840 return 0;
841 } catch (const json::exception &e) {
842 return 1;
843 } catch (const std::invalid_argument &) {
844 return 1;
845 }
846}
void from_json(const json &j, Parameters &p)
Deserialize JSON into Parameters, then resolve computed fields.
Definition ParametersJSON.cpp:445
◆ lowerCopy()
|
static |
Definition at line 366 of file ParametersJSON.cpp.
366 {
367 for (char &ch : value) {
368 ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
369 }
370 return value;
371}
◆ readBathKeys()
|
static |
Definition at line 430 of file ParametersJSON.cpp.
430 {
432 if (s.contains("thermostat")) {
434 }
435 if (s.contains("kind")) {
437 }
442 readPathIntegralKeys(s, p);
443}
static void readPathIntegralKeys(const json &s, Parameters &p)
Definition ParametersJSON.cpp:406
◆ readPathIntegralKeys()
|
static |
Definition at line 406 of file ParametersJSON.cpp.
406 {
409 if (s.contains("path_springs")) {
411 if (th.path_springs != "trotter" && th.path_springs != "eco") {
412 throw std::invalid_argument(
413 "[Dynamics] path_springs must be trotter or eco, not " +
414 th.path_springs);
415 }
416 }
421 if (s.contains("path_seed")) {
422 const long seed = s.at("path_seed").get<long>();
423 if (seed < 0) {
424 throw std::invalid_argument("[Dynamics] path_seed must be non-negative");
425 }
426 th.path_seed = static_cast<std::uint64_t>(seed);
427 }
428}
◆ ssot_has_field()
| bool eonc::config::ssot_has_field | ( | const char * | section, |
| const char * | key ) |
Return true if section/*key* (snake_case INI name) is declared in the Cap'n Proto L0 catalog for covered groups.
Definition at line 250 of file ParametersSSOT.cpp.
250 {
251 if (!section || !key)
252 return false;
253 std::string id = std::string(section) + "." + key;
254 return field_index().count(id) > 0;
255}
◆ temperaturesFromJson()
|
static |
Definition at line 373 of file ParametersJSON.cpp.
373 {
374 if (value.is_array()) {
375 return value.get<std::vector<double>>();
376 }
377 if (!value.is_string()) {
378 throw std::invalid_argument(
379 "[Instanton] temperatures must be a list or a comma-separated "
380 "string");
381 }
382 std::vector<double> out;
383 std::stringstream ss(value.get<std::string>());
384 std::string token;
385 while (std::getline(ss, token, ',')) {
386 const size_t start = token.find_first_not_of(" \t");
387 const size_t end = token.find_last_not_of(" \t");
388 if (start == std::string::npos) {
389 continue;
390 }
391 try {
392 out.push_back(std::stod(token.substr(start, end - start + 1)));
393 } catch (const std::exception &) {
394 throw std::invalid_argument(
395 "[Instanton] temperatures must be comma-separated kelvin "
396 "values, not " +
397 token);
398 }
399 }
400 return out;
401}
◆ to_json()
| nlohmann::json eonc::config::to_json | ( | const Parameters & | p | ) |
Serialize all Parameters to JSON.
Definition at line 50 of file ParametersJSON.cpp.
50 {
51 json j;
52
53 // [Main]
54 j["Main"] = {
63 {"finite_difference",
66 {"remove_net_force",
68 {"write_con_forces",
70 };
71
72 // [Potential]
73 j["Potential"] = {
74 {"potential",
76 {"mpi_poll_period",
78 {"lammps_logging",
80 {"lammps_threads",
82 {"emt_rasmussen",
84 {"log_potential",
87 {"potentials_path",
89 };
90
91 // [Structure Comparison]
92 j["Structure Comparison"] = {
93 {"distance_difference",
95 .distance_difference},
96 {"neighbor_cutoff",
98 {"check_rotation",
100 {"indistinguishable_atoms",
102 .indistinguishable_atoms},
103 {"energy_difference",
105 {"remove_translation",
107 .remove_translation},
108 };
109
110 // [Optimizer]
111 j["Optimizer"] = {
112 {"opt_method",
114 {"convergence_metric",
116 {"max_iterations",
119 {"converged_force",
122 {"max_time_step",
124 };
125 j["Optimizer"]["LBFGS"] = {
127 {"inverse_curvature",
129 {"max_inverse_curvature",
131 {"auto_scale",
133 {"angle_reset",
135 {"distance_reset",
138 {"project_rigid",
145 {"extra_updates",
147 {"cautious_eps",
149 {"cautious_alpha",
153 {"precon_rcut",
155 };
156 j["Optimizer"]["Xtsci"] = {
163 };
164
165 // [Dynamics]
166 j["Dynamics"] = {
169 };
170
171 // [Thermostat]
172 j["Thermostat"] = {
174 {"andersen_alpha",
176 {"andersen_collision_period",
179 {"langevin_friction",
182 {"path_springs",
184 {"path_eco_omega_max",
186 {"path_gle_file",
188 {"path_pile_tau",
190 {"path_pile_scale",
193 };
194
195 // [Nudged Elastic Band]
196 j["Nudged Elastic Band"] = {
199 {"opt_method",
203 {"solid_state_weight",
205 {"solid_state_pressure",
207 };
208 j["Nudged Elastic Band"]["spring"] = {
210 {"elastic_band",
212 {"doubly_nudged",
214 };
215 j["Nudged Elastic Band"]["climbing_image"] = {
217 {"converged_only",
219 {"band_slack",
221 };
222 {
224 j["Nudged Elastic Band"]["zoom"] = {
225 {"enabled", zoom.enabled},
226 {"alpha", zoom.alpha},
227 {"offset", zoom.offset},
229 {"activation_threshold", zoom.activation_threshold},
231 {"stability_count", zoom.stability_count},
232 {"max_iterations", zoom.max_iterations},
233 };
234 }
235
236 // [Dimer]
237 j["Dimer"] = {
240 {"converged_angle",
243 {"opt_method",
245 {"rotation_backend",
247 {"lor_residual_tol",
249 };
250
251 // [Saddle Search]
252 j["Saddle Search"] = {
254 {"min_mode_method",
257 {"max_iterations",
259 {"displace_magnitude",
261 {"displace_radius",
263 };
264
265 // [Prefactor]
266 j["Prefactor"] = {
267 {"default_value",
271 };
272
273 // [Lanczos]
274 j["Lanczos"] = {
276 {"max_iterations",
280 };
281
282 // [Davidson]
283 j["Davidson"] = {
285 {"max_iterations",
287 {"diagonal_preconditioner",
290 };
291
292 // [Hessian]
293 j["Hessian"] = {
295 {"zero_freq_value",
299 {"checkpoint_path",
302 };
303
304 // [Instanton]
305 {
307 j["Instanton"] = {
308 {"mode", o.mode},
309 {"reactant_filename", o.reactant_filename},
310 {"product_filename", o.product_filename},
311 {"initial_path", o.initial_path},
312 {"beads", o.beads},
313 {"beta_hbar_omega", o.beta_hbar_omega},
314 {"max_iterations", o.max_iterations},
315 {"force_tolerance", o.force_tolerance},
316 {"hessian_stride", o.hessian_stride},
317 {"saddle_filename", o.saddle_filename},
318 {"temperature", o.temperature},
319 {"temperatures", o.temperatures},
320 {"half_ring", o.half_ring},
321 {"initial_hessians", o.initial_hessians},
322 {"energy_shift", o.energy_shift},
323 {"bead_ladder", o.bead_ladder},
324 {"hessian_final", o.hessian_final},
325 {"springs", o.springs},
326 {"pi_planes", o.pi_planes},
327 {"pi_beads", o.pi_beads},
328 {"pi_equilibration_steps", o.pi_equilibration_steps},
329 {"pi_sampling_steps", o.pi_sampling_steps},
330 {"pi_time_step", o.pi_time_step},
331 {"pi_thermostat", o.pi_thermostat},
332 {"pi_gle_file", o.pi_gle_file},
333 {"pi_pile_tau", o.pi_pile_tau},
334 {"pi_pile_scale", o.pi_pile_scale},
335 {"pi_seed", o.pi_seed},
336 {"pi_direction", o.pi_direction},
337 {"pi_reactant_extent", o.pi_reactant_extent},
338 {"pi_recrossing_parents", o.pi_recrossing_parents},
339 {"pi_recrossing_children", o.pi_recrossing_children},
340 {"pi_recrossing_time", o.pi_recrossing_time},
341 {"pi_recrossing_spacing", o.pi_recrossing_spacing},
342 };
343 }
344
345 // [Debug]
346 j["Debug"] = {
348 {"write_movies_interval",
350 {"write_deprecated_outs",
352 };
353
354 // [Serve]
355 j["Serve"] = {
361 };
362
363 return j;
364}
double path_pile_tau_input
Definition ParametersOptions.h:670
std::string path_gle_file
Definition ParametersOptions.h:669
double path_eco_omega_max
Definition ParametersOptions.h:668
◆ validate_and_link()
| void eonc::config::validate_and_link | ( | Parameters & | params | ) |
Resolve cross-group defaults and time unit conversions.
Called after INI (or JSON) loading to finalize computed fields.
Definition at line 2059 of file ParametersINI.cpp.
2059 {
2060 // Time unit conversions
2066
2073 static_cast<long>(std::floor(
2074 ParametersLoadAccess::dynamics_options(params).time /
2075 ParametersLoadAccess::dynamics_options(params).time_step +
2076 0.5));
2077 } else {
2079 }
2080
2083 tu;
2084
2086 ParametersLoadAccess::parallel_replica_options(params)
2087 .dephase_time_input /
2088 tu;
2090 ParametersLoadAccess::parallel_replica_options(params)
2091 .state_check_interval_input /
2092 tu;
2094 ParametersLoadAccess::parallel_replica_options(params)
2095 .record_interval_input /
2096 tu;
2099 tu;
2100
2102 ParametersLoadAccess::replica_exchange_options(params)
2103 .sampling_time_input /
2104 tu;
2107
2110
2111 ParametersLoadAccess::saddle_search_options(params)
2113 ParametersLoadAccess::saddle_search_options(params)
2115 tu;
2117 ParametersLoadAccess::saddle_search_options(params)
2119 tu;
2120
2121 // Cross-group defaults
2126}
- Generated by
1.17.0