eonc::XtsciOptimizer Class Reference

xtsci-optimize backend. More...

#include <XtsciOptimizer.h>

Inheritance diagram for eonc::XtsciOptimizer:

Public Member Functions
	XtsciOptimizer (std::shared_ptr< ObjectiveFunction > a_objf, const Parameters &a_params)
	~XtsciOptimizer () override
	XtsciOptimizer (const XtsciOptimizer &)=delete
XtsciOptimizer &	operator= (const XtsciOptimizer &)=delete
int	step (double a_maxMove) override
int	run (size_t a_maxIterations, double a_maxMove) override
Public Member Functions inherited from eonc::Optimizer
	Optimizer (std::shared_ptr< ObjectiveFunction > a_objf, const OptimizerConfig &a_config)
	Optimizer (std::shared_ptr< ObjectiveFunction > a_objf, OptType a_optype, const OptimizerConfig &a_config)
	Optimizer (std::shared_ptr< ObjectiveFunction > a_objf, const Parameters &a_params)
	Optimizer (std::shared_ptr< ObjectiveFunction > a_objf, OptType a_optype, const Parameters &a_params)
virtual	~Optimizer ()=default

Private Member Functions
void	ensureSolver (double a_maxMove)

Private Attributes
xts_solver_t *	m_solver {nullptr}
xtsci_eindir::State *	m_eindir {nullptr}
Eigen::VectorXd	m_cached_x
Eigen::VectorXd	m_x

Additional Inherited Members
Protected Attributes inherited from eonc::Optimizer
const OptimizerConfig	m_optConfig
std::shared_ptr< ObjectiveFunction >	m_objf

Detailed Description

xtsci-optimize backend.

Newton / RFO live in Rust; this class is the ObjectiveFunction + pair-Hessian waist.

Definition at line 23 of file XtsciOptimizer.h.

Constructor & Destructor Documentation

XtsciOptimizer() [1/2]

eonc::XtsciOptimizer::XtsciOptimizer ( std::shared_ptr< ObjectiveFunction > a_objf, const Parameters & a_params )

inline

Definition at line 25 of file XtsciOptimizer.h.

      : Optimizer(a_objf, OptType::XTSCI,
                  OptimizerConfig::fromParams(a_params)) {}

~XtsciOptimizer()

eonc::XtsciOptimizer::~XtsciOptimizer ( )

override

Definition at line 252 of file XtsciOptimizer.cpp.

                                {
  xts_solver_free(m_solver);
  xtsci_eindir::release(m_eindir);
  m_eindir = nullptr;
}

XtsciOptimizer() [2/2]

eonc::XtsciOptimizer::XtsciOptimizer ( const XtsciOptimizer & )

delete

Member Function Documentation

ensureSolver()

void eonc::XtsciOptimizer::ensureSolver ( double a_maxMove )

private

Definition at line 258 of file XtsciOptimizer.cpp.

                                                  {
  if (m_solver != nullptr) {
    return;
  }
  const auto dim = static_cast<size_t>(m_objf->degreesOfFreedom());
  if (dim == 0) {
    return;
  }
  const auto stamp = xts_abi_stamp();
  if (xts_abi_compatible(&stamp) == 0) {
    throw std::runtime_error("incompatible xtsci-optimize ABI");
  }
  const auto &lbfgs = m_optConfig.opts.lbfgs;
  const xts_method_t method = method_from_name(m_optConfig.opts.xtsci.method);
  double istep = std::max(a_maxMove, 1.0e-12);
  if (method == XTS_FIRE || method == XTS_FIRE2) {
    istep = m_optConfig.opts.time_step;
    if (istep <= 0.0) {
      istep = m_optConfig.opts.time_step_input;
    }
    if (istep <= 0.0) {
      istep = 0.1;
    }
  }
  xts_control_t control{
      static_cast<size_t>(std::max<long>(1, m_optConfig.opts.max_iterations)),
      m_optConfig.opts.converged_force,
      istep,
      static_cast<size_t>(std::max<long>(0, lbfgs.memory)),
      0.0,
  };
  m_solver = xts_solver_create(method, &control, dim);
  if (m_solver == nullptr) {
    throw std::runtime_error(xts_last_error());
  }
  const auto step = resolved_qn_step(m_optConfig.opts);
  if (step == "newton") {
    xts_solver_set_qn_step(m_solver, XTS_QN_NEWTON);
  } else if (step == "rfo") {
    xts_solver_set_qn_step(m_solver, XTS_QN_RFO);
  } else {
    xts_solver_set_qn_step(m_solver, XTS_QN_LBFGS);
  }
  const auto accept = resolved_accept(m_optConfig.opts);
  if (accept == "energy") {
    xts_solver_set_accept(m_solver, XTS_ACCEPT_ENERGY);
  } else if (accept == "nonmonotone") {
    xts_solver_set_accept(m_solver, XTS_ACCEPT_NONMONOTONE);
  } else {
    xts_solver_set_accept(m_solver, XTS_ACCEPT_NONE);
  }
  xts_solver_set_project_rigid(m_solver, lbfgs.project_rigid ? 1 : 0);
  xts_solver_set_extra_updates(
      m_solver, static_cast<size_t>(std::max<long>(0, lbfgs.extra_updates)));
  if (lbfgs.curvature == "cautious") {
    xts_solver_set_cautious(m_solver, lbfgs.cautious_eps, lbfgs.cautious_alpha);
  } else {
    xts_solver_set_cautious(m_solver, 0.0, lbfgs.cautious_alpha);
  }
  if (m_optConfig.opts.xtsci.highs) {
    if (xts_solver_set_highs(m_solver, 1) != 0) {
      throw std::runtime_error(
          "Xtsci.highs needs xtsci-optimize built with --features highs");
    }
  }
  const auto &mani = m_optConfig.opts.xtsci.manifold;
  if (mani == "so3" && dim != 9) {
    throw std::runtime_error(
        "Xtsci.manifold=so3 needs length 9; a 3N cluster is "
        "rigid_quotient (Sella R^{3N}/SE(3)), not a packed rotation");
  }
  if (mani == "se3" && dim != 12) {
    throw std::runtime_error(
        "Xtsci.manifold=se3 needs length 12; a 3N cluster is "
        "rigid_quotient (Sella R^{3N}/SE(3)), not an SE(3) prefix");
  }
  if ((mani == "rigid_quotient" || mani == "mw_rigid" || mani == "sella" ||
       mani == "eckart" || mani == "irc") &&
      (dim < 6 || dim % 3 != 0)) {
    throw std::runtime_error("Xtsci.manifold=" + mani +
                             " needs 3N Cartesians with N >= 2");
  }
  if (mani == "sphere") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_SPHERE);
  } else if (mani == "so3") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_SO3);
  } else if (mani == "stiefel") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_STIEFEL);
  } else if (mani == "se3") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_SE3);
  } else if (mani == "rigid_quotient" || mani == "sella") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_RIGID_QUOTIENT);
  } else if (mani == "mw_rigid" || mani == "eckart" || mani == "irc") {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_MW_RIGID);
    const auto masses = m_objf->getMasses();
    if (masses.size() > 0) {
      xts_solver_set_masses(m_solver, masses.data(),
                            static_cast<size_t>(masses.size()));
    }
  } else {
    xts_solver_set_manifold(m_solver, XTS_MANIFOLD_EUCLIDEAN);
  }
  if (mani == "rigid_quotient" || mani == "mw_rigid" || mani == "sella" ||
      mani == "eckart" || mani == "irc") {
    xts_solver_set_periodic(m_solver, m_objf->getPeriodic() ? 1 : 0);
  }
  if (m_eindir == nullptr) {
    m_eindir = xtsci_eindir::bind(m_objf.get(), &m_cached_x);
  }
}

operator=()

XtsciOptimizer & eonc::XtsciOptimizer::operator= ( const XtsciOptimizer & )

delete

run()

int eonc::XtsciOptimizer::run ( size_t a_maxIterations, double a_maxMove )

overridevirtual

Implements eonc::Optimizer.

Definition at line 420 of file XtsciOptimizer.cpp.

                                                                {
  if (m_objf->degreesOfFreedom() <= 0 || a_maxIterations == 0) {
    return m_objf->isConverged() ? 1 : 0;
  }
  ensureSolver(a_maxMove);
  const auto &lbfgs = m_optConfig.opts.lbfgs;
  std::string precon = resolved_precon(m_optConfig.opts);
  const xts_method_t method = method_from_name(m_optConfig.opts.xtsci.method);
  if (method == XTS_DOGLEG && !is_host_precon(precon)) {
    precon = "pair";
  }
  const bool want_hess = method == XTS_NEWTON || method == XTS_RFO ||
                         method == XTS_DOGLEG || is_host_precon(precon);
  // A full minimize without a host Hessian goes through the eindir entry.
  // step() stays one session iteration so the host loop keeps its memory.
  if (m_eindir != nullptr && !want_hess) {
    if (m_x.size() == 0) {
      m_x = m_objf->getPositions();
    }
    double value = 0.0;
    const int status = xtsci_eindir::minimize(
        m_eindir, m_x.data(), static_cast<size_t>(m_x.size()), a_maxIterations,
        m_optConfig.opts.converged_force, std::max(a_maxMove, 1.0e-12),
        static_cast<size_t>(std::max<long>(0, lbfgs.memory)),
        static_cast<int>(method), &value);
    if (status != XTS_SUCCESS) {
      throw std::runtime_error(xts_last_error());
    }
    m_objf->setPositions(m_x);
    m_cached_x = m_x;
    (void)value;
    return m_objf->isConverged() ? 1 : 0;
  }
  for (size_t i = 0; i < a_maxIterations; ++i) {
    if (step(a_maxMove) != 0) {
      return 1;
    }
  }
  return m_objf->isConverged() ? 1 : 0;
}

step()

int eonc::XtsciOptimizer::step ( double a_maxMove )

overridevirtual

Implements eonc::Optimizer.

Definition at line 369 of file XtsciOptimizer.cpp.

                                         {
  if (m_objf->degreesOfFreedom() <= 0) {
    return m_objf->isConverged() ? 1 : 0;
  }
  ensureSolver(a_maxMove);
  if (m_solver == nullptr) {
    return m_objf->isConverged() ? 1 : 0;
  }
  // Native LBFGS clips by the largest per-atom move, not ||d||_2.
  xts_solver_set_maxmove(m_solver, 0.0);
  xts_solver_set_atom_maxmove(m_solver, std::max(a_maxMove, 0.0));
 
  if (m_x.size() == 0) {
    m_x = m_objf->getPositions();
  }
  if (m_x.size() != m_objf->degreesOfFreedom()) {
    throw std::runtime_error("xtsci objective position dimension mismatch");
  }
  auto *tensor =
      xts_tensor_borrow_cpu_f64(m_x.data(), static_cast<size_t>(m_x.size()));
  if (tensor == nullptr) {
    throw std::runtime_error("could not allocate xtsci objective tensor");
  }
  const auto &lbfgs = m_optConfig.opts.lbfgs;
  std::string precon = resolved_precon(m_optConfig.opts);
  const xts_method_t method = method_from_name(m_optConfig.opts.xtsci.method);
  if (method == XTS_DOGLEG && !is_host_precon(precon)) {
    precon = "pair";
  }
  XtsObjectiveContext context{
      m_objf.get(),    m_optConfig.potential, precon,      lbfgs.precon_A,
      lbfgs.precon_mu, lbfgs.precon_rcut,     &m_cached_x, m_eindir,
  };
  xts_report_t report{};
  const bool want_hess = method == XTS_NEWTON || method == XTS_RFO ||
                         method == XTS_DOGLEG || is_host_precon(precon);
  xts_status_t status;
  if (want_hess) {
    status = xts_solver_step_hess_fg(m_solver, evaluate_gradient, hessian,
                                     &context, tensor, &report);
  } else {
    status = xts_solver_step_fg(m_solver, evaluate_gradient, &context, tensor,
                                &report);
  }
  xts_tensor_free(tensor);
  if (status != XTS_SUCCESS) {
    throw std::runtime_error(xts_last_error());
  }
  return m_objf->isConverged() ? 1 : 0;
}

Member Data Documentation

m_cached_x

Eigen::VectorXd eonc::XtsciOptimizer::m_cached_x

private

Definition at line 44 of file XtsciOptimizer.h.

m_eindir

xtsci_eindir::State* eonc::XtsciOptimizer::m_eindir {nullptr}

private

Definition at line 41 of file XtsciOptimizer.h.

{nullptr};

m_solver

xts_solver_t* eonc::XtsciOptimizer::m_solver {nullptr}

private

Definition at line 39 of file XtsciOptimizer.h.

{nullptr};

m_x

Eigen::VectorXd eonc::XtsciOptimizer::m_x

private

Definition at line 47 of file XtsciOptimizer.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/eOn/eOn/include/eon/XtsciOptimizer.h
• /home/runner/work/eOn/eOn/client/XtsciOptimizer.cpp