ParametersOptions.h

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Copyright (c) 2010--present, eOn Development Team
** All rights reserved.
**
** Repo:
** https://github.com/TheochemUI/eOn
*/
#pragma once
 
#include "BaseStructures.h"
#include "StructureComparisonOptions.h"
#include <cstdint>
#include <limits>
#include <string>
#include <vector>
 
namespace eonc {
 
// Physical Constants
struct constants_t {
  double kB{8.6173324e-5};     // eV/K
  double timeUnit{10.1805055}; // fs
};
 
// [Main] //
struct main_options_t {
  JobType job{JobType::Process_Search};
  long randomSeed{-1};
  double temperature{300.0};
  bool quiet{false};
  bool writeLog{true};
  bool checkpoint{false};
  std::string iniFilename{"config.ini"};
  std::string conFilename{"pos.con"};
  double finiteDifference{0.01};
  long maxForceCalls{0};
  bool removeNetForce{true};
  bool parallel{true}; // parallel force evaluation via std::jthread
  bool writeConForces{false};
};
 
// [Potential] //
struct potential_options_t {
  PotType potential{PotType::LJ};
  double MPIPollPeriod{0.25};
  bool LAMMPSLogging{false};
  int LAMMPSThreads{0};
  bool EMTRasmussen{false};
  bool LogPotential{false};
  bool thread_safe{true};
  std::string extPotPath{"./ext_pot"};
  std::string potentialsPath{
      ""}; // colon-separated dirs for Fortran potential .so files
  int MPIPotentialRank{-1};
  std::uintptr_t MPIClientComm{0};
};
 
// [AMS] and [AMS_IO] //
struct ams_options_t {
  std::string engine;
  std::string forcefield;
  std::string model;
  std::string resources;
  std::string xc;
  std::string basis;
  struct env_t {
    std::string amshome;
    std::string scm_tmpdir;
    std::string scmlicense;
    std::string scm_pythondir;
    std::string amsbin;
    std::string amsresources;
  } env;
};
 
// [XTBPot] //
struct xtb_options_t {
  std::string paramset{"GFNFF"};
  double elec_temperature{0.0};
  size_t maxiter{250};
  double acc{1.0};
  double charge{0.0};
  int uhf{0};
};
 
// [ZBLPot] //
struct zbl_options_t {
  double cut_inner{2.0};
  double cut_global{2.5};
};
 
// [D3Pot] / [D4Pot]: rgpot 3.1 in-process Grimme DFT-D (s-dftd3 / dftd4).
struct dftd_options_t {
  std::string functional{"pbe"};
  bool atm{true};
  std::string d3_damping{"bj"};
  double d4_charge{0.0};
};
 
// [ExprPot]: rgpot 3.1 Lepton algebra over named child kernels.
struct expr_options_t {
  std::string expression;
  std::string terms;
};
 
// [MOPACPot]: rgpot 3.2 MOPACPot (libmopacc, default AM1).
struct mopac_options_t {
  int charge{0};
  int spin{0};
  int model{4};
  std::string engine_path;
};
 
// [SocketNWChemPot] //
struct socket_nwchem_options_t {
  std::string host{"127.0.0.1"};
  int port{9999};
  int mem_in_gb{2};
  std::string nwchem_settings{"nwchem_settings.nwi"};
  std::string unix_socket_path{"eon_nwchem"};
  bool unix_socket_mode{false};
  bool make_template_input{true};
};
 
// [RgpotPot] — in-process rgpot (dlopen engines; no potserv). Packaging
// prefers metatomic/xtb via RGPOT over fat -Dwith_metatomic / -Dwith_xtb.
struct rgpot_options_t {
  std::string backend{"nwchemc"};
  std::string basis{"sto-3g"};
  std::string theory{"scf"};
  std::string scf_type{"rhf"};
  std::string functional{"BLYP"};
  // [cpmd] cutOffRy wins when params_path is empty. cutoff_ry and
  // cpmd_cut_off_ry on [cpmd] or [RgpotPot] still load.
  double cutoff_ry{70.0};
  int charge{0};
  int multiplicity{1};
  std::string engine_path{};
  std::string engine_library{};
  std::string engine_root{};
  std::string title{};
  int memory_mb{0};
  std::string scratch_dir{};
  // [cpmd] input_block wins over this [RgpotPot] key for a CPMD backend.
  // The text is appended to inputBlocks and does not replace inputSections.
  std::string input_block{};
  std::string permanent_dir{};
  // Serialized Cap'n Proto CPMDParams. When set, it is the method and the
  // scalar keys above are not written over it. [cpmd] supplies those
  // scalars when this path is empty.
  std::string params_path{};
  // cpmdc: split the MPI world into groups of this many ranks, one CPMD
  // session per group, and spread NEB images over the groups. 0 keeps one
  // session on every rank.
  int ranks_per_image{0};
  // Metatomic dlopen (backend=metatomic)
  std::string model_path{};
  std::string device{"cpu"};
  std::string length_unit{"angstrom"};
  std::string extensions_directory{};
  bool check_consistency{false};
  double uncertainty_threshold{-1.0};
  bool torch_determinism_strict{false};
  // XTB dlopen (backend=xtb); dual-read [XTBPot] when unset
  std::string xtb_paramset{"GFN2xTB"};
  double xtb_accuracy{1.0};
  double xtb_electronic_temperature{300.0};
  int xtb_max_iterations{250};
  double xtb_charge{0.0};
  int xtb_uhf{0};
};
 
// [Structure Comparison] //
using structure_comparison_options_t = StructureComparisonOptions;
 
// [Process Search] //
struct process_search_options_t {
  bool minimize_first{true};
  double minimization_offset{0.2}; // resolved to optimizer_options.max_move
};
 
// [Saddle Search] //
struct saddle_search_options_t {
  long max_jump_attempts{0};
  long max_iterations{1000};
  std::string method{"min_mode"};
  std::string minmode_method{"dimer"};
  std::string displace_type{"load"};
  std::vector<long> displace_atom_list;
  double max_energy{20.0};
  double displace_magnitude{0.1};
  double max_single_displace{10.0};
  double displace_radius{4.0};
  double converged_force{0.0};
  double perp_force_ratio{0.0};
  bool nonnegative_displacement_abort{false};
  long nonlocal_count_abort{0};
  double nonlocal_distance_abort{0.0};
  bool remove_rotation{false};
  double zero_mode_abort_curvature{0.0};
  struct dynamics_t {
    double temperature{0.0};
    double state_check_interval_input{100.0};
    double state_check_interval{0.0}; // computed: input / timeUnit
    double record_interval_input{10.0};
    double record_interval{0.0}; // computed
    bool linear_interpolation{true};
    double max_init_curvature{0.0};
  } dynamics;
  struct confine_positive_t {
    bool enabled{false};
    bool bowl_breakout{false};
    long bowl_active{20};
    double min_force{0.5};
    double scale_ratio{0.9};
    double boost{10.0};
    long min_active{30};
  } confine_positive;
};
 
// [Optimizer] //
struct optimizer_options_t {
  OptType method{OptType::CG};
  std::string xtsci_method{"lbfgs"};
  struct xtsci_t {
    std::string method{"lbfgs"};
    std::string qn_step{"lbfgs"};
    std::string precon{"none"};
    std::string accept{"energy"};
    bool highs{false};
    std::string manifold{"euclidean"};
  } xtsci;
  std::string convergence_metric{"norm"};
  std::string convergence_metric_label;
  size_t max_iterations{1000};
  double max_move{0.2};
  double converged_force{0.01};
  double time_step_input{1.0};
  double time_step{0.0}; // computed: input / timeUnit
  double max_time_step_input{2.5};
  double max_time_step{0.0}; // computed: input / timeUnit
  struct refine_t {
    OptType method{OptType::None};
    double threshold{0.5};
  } refine;
  struct lbfgs_t {
    long memory{20};
    double inverse_curvature{0.01};
    double max_inverse_curvature{0.0};
    bool auto_scale{true};
    bool angle_reset{true};
    bool distance_reset{true};
    // reset: wipe memory on bad s·y (ASE). skip: Li-Fukushima cautious
    // skip of that pair. damped: Powell (1978) ŷ = θy+(1-θ)B0 s.
    std::string curvature{"reset"};
    // Isolated clusters: project 6 rigid-body modes out of the
    // L-BFGS force and step. Off for PBC / frozen atoms.
    bool project_rigid{false};
    std::string secant{"standard"};
    std::string precon{"none"};
    std::string step{"lbfgs"};
    std::string h0{"sy_yy"};
    std::string accept{"energy"};
    long extra_updates{0};
    double cautious_eps{1.0e-6};
    double cautious_alpha{0.01};
    double precon_A{3.0};
    double precon_mu{1.0};
    double precon_rcut{0.0};
  } lbfgs;
  struct cg_t {
    bool no_overshooting{false};
    bool knock_out_max_move{false};
    bool line_search{false};
    double line_converged{0.1};
    long line_search_max_iter{10};
    long max_iter_before_reset{0};
  } cg;
  struct quickmin_t {
    bool steepest_descent{false};
  } quickmin;
  struct sd_t {
    double alpha{0.1};
    bool two_point{false};
  } sd;
};
 
// [Dimer] //
struct dimer_options_t {
  double rotation_angle{0.005};
  bool improved{true};
  double converged_angle{5.0};
  long max_iterations{1000};
  OptType opt_method{OptType::CG};
  long rotations_max{10};
  long rotations_min{1};
  double torque_max{1.0};
  double torque_min{0.1};
  bool remove_rotation{false};
  // Mode estimation for dimer: classical rotation loop, or FD min-mode
  // (Lanczos/Davidson) replacing constrained IDimerRot / Dimer::rotate.
  DimerRotationBackend rotation_backend{DimerRotationBackend::Classical};
  // LOR relative residual stop: ||F_perp|| / (|C_N|+1) < max(1e-3, this).
  // Independent of classical torque_min (angular criterion).
  double lor_residual_tol{0.1};
};
 
// [GPR Dimer] //
struct gpr_dimer_options_t {
  double rotation_angle{0.005};
  double converged_angle{0.08};
  double relax_conv_angle{0.001};
  long init_rotations_max{6};
  long relax_rotations_max{10};
  long divisor_t_dimer_gp{10};
  long max_outer_iterations{300};
  long max_inner_iterations{1000};
  double midpoint_max_disp{0.5};
  std::string rot_opt_method{"lbfgs"};
  std::string trans_opt_method{"lbfgs"};
  double active_radius{5.0};
  double dimer_sep{0.01};
  double conv_step{0.1};
  double max_step{0.1};
  double ratio_at_limit{0.66667};
  bool init_rot_gp{false};
  bool init_trans_gp{false};
  bool many_iterations{true};
  struct gpr_params_t {
    std::string hyper_opt_method{"scg"};
    double sigma2{1e-8};
    double jitter_sigma2{0.0};
    double noise_sigma2{1e-8};
    double prior_mu{0.0};
    double prior_sigma2{1.0};
    long prior_nu{20};
  } gpr_params;
  struct opt_params_t {
    bool check_derivatives{false};
    int max_iterations{400};
    double tol_func{1e-4};
    double tol_sol{1e-4};
    long lambda_limit{static_cast<long>(1e17)};
    long lambda_init{10};
  } opt_params;
  struct prune_params_t {
    bool use_prune{false};
    int begin{8};
    int n_vals{3};
    double threshold{0.5};
  } prune_params;
  struct debug_params_t {
    int report_level{1};
    int debug_level{2};
    std::string out_dir{"output"};
    std::string pos_file{"position"};
    std::string energy_file{"energy"};
    std::string grad_file{"gradient"};
    std::string out_ext{"dat"};
    double offset_mid_point{3.0};
    double dy{0.1};
    double dz{0.1};
  } debug_params;
};
 
// [GP Surrogate] //
struct gp_surrogate_options_t {
  bool enabled{false};
  JobType sub_job{JobType::Unknown};
  double uncertainty{0.05};
  bool linear_path_always{false};
  PotType potential{PotType::CatLearn};
};
 
// [CatLearn] //
struct catlearn_options_t {
  std::string path;
  std::string model{"gp"};
  std::string prior{"median"};
  bool use_deriv{true};
  bool use_fingerprint{false};
  bool parallel{false};
};
 
// [ASE_ORCA] //
struct ase_orca_options_t {
  std::string path;
  std::string nproc{"1"};
  std::string simpleinput;
  int charge{0};
  int multiplicity{1};
};
 
// [ASE_NWCHEM] //
struct ase_nwchem_options_t {
  std::string path;
  std::string nproc{"1"};
  // MPI launcher for ASE NWChem command (issue #193): "mpirun" or "srun".
  std::string mpi_launcher{"mpirun"};
  std::string multiplicity;
  double scf_thresh{1e-5};
  long scf_maxiter{200};
  std::string basis{"3-21G"};
  std::string memory{"2 gb"};
};
 
// [Metatomic] //
struct metatomic_options_t {
  std::string model_path;
  std::string device{"cpu"};
  std::string length_unit{"angstrom"};
  std::string extensions_directory;
  bool check_consistency{false};
  double uncertainty_threshold{-1.0};
  // Literal model output keys (issue #215). When set, bypass pick_output
  // variant resolution and use this key if present in model capabilities.
  std::string energy_output;
  std::string energy_uncertainty_output;
  // Literal non-conservative force output key (issue #296); empty uses
  // pick_output("non_conservative_force", ...) when non_conservative.
  std::string force_output;
  // When true, read forces from non_conservative_force (with variants)
  // instead of autograd on energy (issue #296).
  bool non_conservative{false};
  // Apply a fresh random SO(3) rotation per force() call and rotate forces
  // back (issue #287 / PET-MAD broken-symmetry mitigation).
  bool random_rotation{false};
  // If >0, average energy/forces over this many random rotations for
  // approximate O(3) symmetrization (issue #292). Overrides single-shot
  // random_rotation when both are set.
  long n_symmetry_rotations{0};
  // PyTorch determinism (JIT profiling off, deterministic algorithms,
  // cudnn benchmark off). See
  // rgoswami.me/snippets/pytorch-deterministic-regression/
  bool deterministic{true};
  // If true, fail on nondeterministic CUDA ops (needs
  // CUBLAS_WORKSPACE_CONFIG).
  bool deterministic_strict{false};
  struct variants_t {
    std::string base;
    std::string energy;
    std::string energy_uncertainty;
    std::string force; // non_conservative_force variant (#296)
  } variant;
};
 
// [Lanczos] //
// phva_atoms: PHVA mobile/active set for the Krylov space (Li & Jensen).
// Not free/fixed — that is the optimizer mask on Matter. "All" = every free
// atom (historical default). Same polarity as [Hessian] phva_atoms.
struct lanczos_options_t {
  double tolerance{0.01};
  long max_iterations{20};
  bool quit_early{true};
  std::string phva_atoms{"All"};
};
 
// [Davidson] min-mode (alternative to dimer rotation / Lanczos)
struct davidson_options_t {
  double tolerance{0.01};
  long max_iterations{20};
  bool diagonal_preconditioner{false};
  std::string phva_atoms{"All"};
};
 
// [Prefactor] //
struct prefactor_options_t {
  double default_value{0.0};
  double max_value{1e+21};
  double min_value{1e+9};
  double within_radius{3.3};
  double min_displacement{0.25};
  std::string rate{"htst"};
  std::string configuration{"reactant"};
  bool all_free_atoms{false};
  std::string filter_scheme{"fraction"};
  double filter_fraction{0.90};
};
 
// [Hessian] //
// phva_atoms: mobile/displaced atoms for FD (hybrid/PHVA-class active set),
// or "All" = every non-fixed atom. Intersected with free flags in HessianJob.
// free/fixed stays the optimizer mask and is not rewritten.
struct hessian_options_t {
  std::string phva_atoms{"All"};
  double zero_freq_value{1e-6};
  // FD scheme: "one_sided" (default), "central", or "fourth"
  // (aliases fourth_order, central4). Fourth-order is real central
  // differences for this Hessian and for Lanczos/Davidson products.
  // Step size is Main.finite_difference (dx).
  std::string fd_scheme{"one_sided"};
  // If true and checkpoint_path is set, resume FD columns from checkpoint.
  bool resume{false};
  // Column checkpoint file (e.g. hessian.ckpt). Cleared on successful finish.
  std::string checkpoint_path{""};
  // Write every normal mode to modes.con: the Cartesian mode as a
  // readcon displacements section, its eigenvalue and hbar omega as
  // frame metadata.
  bool write_modes{true};
};
 
// [Nudged Elastic Band] //
struct neb_options_t {
  long image_count{5};
  long max_iterations{1000};
  OptType opt_method{OptType::LBFGS};
  double force_tolerance{0.01}; // resolved to optimizer_options.converged_force
  struct mmf_peak_options_t {
    bool enabled{true};
    double tolerance{0.05};
  } mmf_peaks;

  bool match_endpoints{false};
  std::string match_method{"ira"};
 
  struct spring_options_t {
    double constant{5.0};
    bool use_elastic_band{false};
    bool doubly_nudged{false};
    bool use_switching{false};
 
    struct energy_weighting_t {
      bool enabled{false};
      double trigger{10.0};
      double k_min{0.97};
      double k_max{9.7};
    } weighting;
    struct onsager_machlup_t {
      bool enabled{false};
      bool optimize_k{true};
      double k_scale{1.0};
      double k_min{0.1};
      double k_max{100.0};
    } om;
  } spring;
 
  struct climbing_image_options_t {
    bool enabled{true};
    bool converged_only{true};
    double band_slack{10.0};
    bool use_old_tangent{false};
    double trigger_force{std::numeric_limits<double>::infinity()};
    double trigger_factor{0.0};
 
    struct hybrid_dimer_t {
      bool use_mmf{false};
      double trigger_force{0.1};
      long max_steps{1000};
      long ci_stability_count{5};
      double angle_tol{0.7071}; // 1/sqrt(2): Householder stability bound
      double trigger_factor{0.0};
      // Off: Frontiers / published OCINEB. On: restore CI when MMF
      // does not improve the band force (OptBench pair 26).
      bool restore_unhelpful{false};
    } ocineb;
  } climbing_image;

  struct zoom_options_t {
    bool enabled{false};
    double alpha{0.5};
    int offset{1};
    enum class Mode { Auto, Manual };
    Mode mode{Mode::Auto};
    double activation_threshold{0.0};
    enum class Interpolation { Cubic, Linear };
    Interpolation interpolation{Interpolation::Cubic};
    int stability_count{5};
    int max_iterations{0};
  } zoom;
 
  struct path_initialization_t {
    NEBInit method{NEBInit::LINEAR};
    std::string input_path;
    int max_iterations{5000};
    int nsteps{250};
    double max_move{0.1};
    double force_tolerance{0.001};
    double sidpp_alpha{0.33};
    double sidpp_frontier_tol{0.01}; 
    bool sidpp_reparam{true};        
    bool sidpp_ideal_ksp{false};     
    OptType opt_method{OptType::LBFGS};
    bool oversampling{false};
    int oversampling_factor{3};
  } initialization;
 
  struct endpoint_options_t {
    bool minimize{false};
    bool use_path_file{false};
  } endpoints;

  struct solid_state_options_t {
    bool enabled{false};
    double weight{1.0};
    double pressure{0.0};
  } solid_state;
};
 
// [Molecular Dynamics] //
struct dynamics_options_t {
  double time_step_input{1.0};
  double time_step{0.0}; // computed: input / timeUnit
  double time_input{1000.0};
  double time{0.0}; // computed: input / timeUnit
  long steps{0};    // computed: time / time_step
};
 
// [Parallel Replica] //
struct parallel_replica_options_t {
  bool refine_transition{true};
  bool auto_stop{false};
  bool dephase_loop_stop{false};
  double dephase_time_input{1000.0};
  double dephase_time{0.0}; // computed: input / timeUnit
  long dephase_loop_max{5};
  double state_check_interval_input{1000.0};
  double state_check_interval{0.0}; // computed
  double record_interval_input{50.0};
  double record_interval{0.0}; // computed
  double corr_time_input{1000.0};
  double corr_time{0.0}; // computed
};
 
// [Temperature Accelerated Dynamics] //
struct tad_options_t {
  double low_temperature{300.0};
  double min_prefactor{0.001};
  double confidence{0.001};
};
 
// [Thermostat] //
struct thermostat_options_t {
  std::string kind{"none"};
  double andersen_alpha{1.0};
  double andersen_tcol_input{100.0};
  double andersen_tcol{0.0}; // computed
  double nose_mass{1.0};
  double langevin_friction_input{0.01};
  double langevin_friction{0.0}; // computed: input * timeUnit
  long path_beads{8};
  std::string path_springs{"trotter"};
  double path_eco_omega_max{0.0};
  std::string path_gle_file;
  double path_pile_tau_input{100.0}; // fs
  double path_pile_tau{0.0};         // input / timeUnit
  double path_pile_scale{1.0};
  std::uint64_t path_seed{1};
};
 
// [Replica Exchange] //
struct replica_exchange_options_t {
  std::string temperature_distribution{"exponential"};
  long replicas{10};
  long exchange_trials{10}; // resolved to replicas
  double sampling_time_input{1000.0};
  double sampling_time{0.0}; // computed
  double temperature_high{0.0};
  double temperature_low{0.0};
  double exchange_period_input{100.0};
  double exchange_period{0.0}; // computed
};
 
// [Bond Boost / Hyperdynamics] //
struct hyperdynamics_options_t {
  std::string bias_potential{"none"};
  std::string boost_atom_list{"All"};
  double rmd_time_input{100.0};
  double rmd_time{0.0}; // computed
  double dvmax{0.0};
  double qrr{0.2};
  double prr{0.95};
  double qcut{3.0};
};
 
// [Basin Hopping] //
struct basin_hopping_options_t {
  double displacement{0.5};
  double initial_random_structure_probability{0.0};
  double push_apart_distance{0.4};
  long steps{10000};
  long quenching_steps{0};
  bool significant_structure{true};
  bool single_atom_displace{false};
  std::string displacement_algorithm{"standard"};
  std::string displacement_distribution{"uniform"};
  double swap_probability{0.0};
  long jump_max{10};
  long jump_steps{0};
  bool adjust_displacement{true};
  long adjust_period{10};
  double adjust_fraction{0.05};
  double target_ratio{0.5};
  bool write_unique{false};
  double stop_energy{-std::numeric_limits<double>::max()};
};
 
// [Global Optimization] //
struct global_optimization_options_t {
  std::string move_method{"md"};
  std::string decision_method{"npew"};
  long steps{10000};
  double beta{1.05};
  double alpha{1.02};
  long mdmin{3};
  double target_energy{-1.0e50};
};
 
// [Monte Carlo] //
struct monte_carlo_options_t {
  double step_size{0.005};
  int steps{1000};
};
 
// [BGSD] //
struct bgsd_options_t {
  double alpha{10.0};
  double beta{0.2};
  double gradient_finite_difference{0.000001};
  double h_force_convergence{0.01};
  double grad2energy_convergence{0.000001};
  double grad2force_convergence{0.0001};
};
 
// [Serve] //
struct serve_options_t {
  std::string host{"localhost"};
  uint16_t port{12345};
  size_t replicas{1};
  uint16_t gateway_port{0};
  std::string endpoints;
};
 
// [ARTn] //
struct artn_options_t {
  double push_step_size{0.3};   // maps to pARTn "push_step_size"
  double force_threshold{0.05}; // maps to pARTn "forc_thr"
  int max_iterations{500};
  int ninit{-1}; // maps to pARTn "ninit" (-1 = use pARTn default): number
                 // of initial push steps before Lanczos eigenmode
                 // estimation. 0 skips the push (eOn supplies the mode);
                 // larger values let pARTn explore further from the
                 // minimum before switching to Lanczos.
  std::string nperp_limitation{"default"}; // maps to pARTn "nperp_limitation"
  int lanczos_min_size{
      -1};         // maps to pARTn "lanczos_min_size" (-1 = use default)
  int nsmooth{-1}; // maps to pARTn "nsmooth" (-1 = use default)
  int nnewchance{
      3}; // maps to pARTn "nnewchance": retries when lowest eigval > 0
          // (convex region). pARTn default is 0 (immediate fail), which
          // is too aggressive for small clusters where Lanczos can
          // momentarily settle on a positive eigenvalue before the
          // unstable mode emerges. 3 retries is a reasonable default.
  std::string filin{""}; // maps to pARTn "filin": path to an artn.in input
                         // file. Empty preserves pARTn's post-create default
                         // (NAN_STR sentinel "BBBB" set by artn_create in
                         // artn_api.f90), which tells m_setup_artn to skip
                         // reading any file. If set, pARTn opens the file
                         // with status="old" and errors out when absent.
};
 
// [IRA] //
struct ira_options_t {
  double distance_threshold{0.3};
  double symmetry_threshold{0.1};
  bool use_pbc{false};
};
 
// [Debug] //
struct debug_options_t {
  bool write_movies{false};
  long write_movies_interval{1};
  bool write_deprecated_outs{false};
  bool estimate_neb_eigenvalues{false};
  std::string neb_mmf{"dimer"};
};
 
// [Instanton] //
// Ring-polymer instanton: the tunnelling splitting between two minima
// (mode "splitting", eonc::tunneling::optimizeInstanton) or the thermal rate
// out of a minimum through a saddle (mode "rate"): the ring below the
// crossover temperature, and the parabolic barrier factor above it.
struct instanton_options_t {
  std::string mode{"splitting"};
  std::string reactant_filename{"reactant.con"};
  std::string product_filename{"product.con"};
  // Optional band to start from (neb.con or any multi-frame con file whose
  // first and last frames are the two minima); empty is a straight line.
  std::string initial_path{""};
  long beads{256};              // P, segments from one minimum to the other
  double beta_hbar_omega{30.0}; // imaginary time, in units of 1 / omega
  long max_iterations{5000};    // L-BFGS iterations on the action
  double force_tolerance{1e-3}; // eV / (amu^0.5 A), largest bead residual
  // FD Hessians on every stride-th bead, linear in between; 1 is every bead.
  long hessian_stride{1};
  // Mode "rate": the first-order saddle out of the reactant, and T in K.
  std::string saddle_filename{"saddle.con"};
  double temperature{0.0};
  // Mode rate: kelvin values, searched from the highest down. Empty uses
  // temperature.
  std::vector<double> temperatures{};
  // Mode rate: even bead count evaluates one half of a symmetric ring
  // and copies it. An odd count evaluates every bead.
  bool half_ring{true};
  double energy_shift{0.0}; // eV, subtracted from each bead potential
  // Mode rate: where the bead Hessian blocks start. "saddle" copies the
  // saddle Hessian to every bead (no force calls); "finite_difference"
  // takes 2 f gradient calls per bead first.
  std::string initial_hessians{"saddle"};
  // Mode rate: start at a quarter of the beads and double. Off leaves the
  // requested count alone.
  bool bead_ladder{false};
  // Mode rate: the rate uses a Hessian on every stride-th bead.
  std::string hessian_final{"recomputed"};
  // "trotter" or "eco". Economised springs are refused: the instanton
  // is a Trotter discretisation.
  std::string springs{"trotter"};
  // Mode rate: path-integral quantum TST after the instanton. Planes
  // from behind the reactant to the saddle, each holding the centroid of
  // a sampled ring; 0 leaves it off.
  long pi_planes{0};
  long pi_beads{16};
  long pi_equilibration_steps{500};
  long pi_sampling_steps{2000};
  double pi_time_step{0.5}; // fs
  // "pile", or "piglet" with pi_gle_file (the [Dynamics] path_gle_file
  // format).
  std::string pi_thermostat{"pile"};
  std::string pi_gle_file{""};
  double pi_pile_tau{100.0}; // fs, centroid Langevin time
  double pi_pile_scale{1.0}; // scales the internal-mode PILE damping
  long pi_seed{1};
  // Plane normal: "mode" is the saddle's unstable mode, "line" the
  // mass-weighted reactant-to-saddle line.
  std::string pi_direction{"mode"};
  // The first plane sits this fraction of the reactant-to-saddle distance
  // behind the reactant.
  double pi_reactant_extent{0.5};
  // Ring-polymer MD transmission factor on the top plane: parents sampled
  // on the plane every pi_recrossing_spacing steps, each launching
  // pi_recrossing_children momentum pairs for pi_recrossing_time fs.
  // 0 parents leaves it off.
  long pi_recrossing_parents{0};
  long pi_recrossing_children{20};
  double pi_recrossing_time{100.0}; // fs
  long pi_recrossing_spacing{50};
};
 
// [OH_TST] //
// Optimized hyperplanar TST (Johannesson-Jonsson, JCP 115, 9644
// (2001)): reversible-work progression of a hyperplanar dividing
// surface with constrained thermostatted sampling.
struct oh_tst_options_t {
  std::string reactant_filename{"pos.con"};
  std::string product_filename{"product.con"};
  double time_step{1.0};         // fs, constrained sampling dynamics
  long equil_steps{200};         // per-plane equilibration steps
  long sample_steps{800};        // per-plane averaging steps
  long max_planes{200};          // plane-progression iterations
  double plane_mass{50.0};       // m_s, inertia of the s coordinate
  double alpha_rot{50.0};        // rotational inertia of the normal
  double plane_time_step{0.1};   // Verlet step for (s, n) updates
  double ds_max{0.1};            // A, clamp on per-iteration plane moves
  double dtheta_max{0.05};       // rad, clamp on per-iteration rotations
  double force_tol{0.005};       // eV/A convergence on plane force
  double s_init{0.05};           // starting fraction along the guideline
  long reactant_md_steps{20000}; // unconstrained reactant trajectory
  double max_delta_a{10.0};      // eV, divergence guard on the work
  // Thermostat for the plane-constrained and reactant sampling:
  // "andersen" (default) or "gle" (colored noise, Ceriotti-Bussi-
  // Parrinello; drift matrix from gle_a_file, gle4md text layout,
  // units of inverse internal time; a 1x1 [gamma] file degenerates
  // to white-noise Langevin).
  std::string thermostat{"andersen"};
  std::string gle_a_file{""};
  // Comma-separated .con files of the OTHER symmetry-equivalent
  // product minima (Eqs 13-17): sampling is confined to the
  // subregion of the primary product by half-line distances with
  // mirror velocity reflection at the boundaries.
  std::string symmetry_products{""};
  // PMF-scan mode: hold the dividing plane normal fixed along the
  // guideline and step s uniformly reactant->product instead of
  // adaptively hunting the free-energy maximum. Robust where the
  // adaptive progression pins at s=0 (a shallow doorway or a
  // barrierless capture funnel whose A(s) has no interior maximum).
  bool pmf_scan{false};
  long scan_planes{40}; // uniform planes across the guideline
};
 
} // namespace eonc