Loading...
Searching...
No Matches
XtsciOptimizer Class Referencefinal

rgmin backend (opt_method = xtsci, or opt_backend = rgmin). More...

#include <XtsciOptimizer.h>

Inheritance diagram for XtsciOptimizer:

Public Member Functions

 XtsciOptimizer (std::shared_ptr< ObjectiveFunction > a_objf, const Parameters &a_params, std::string a_method={})
 a_method is an [Xtsci] method token; empty reads [Xtsci] method.
 XtsciOptimizer (const XtsciOptimizer &)=delete
 ~XtsciOptimizer () override
XtsciOptimizer & operator= (const XtsciOptimizer &)=delete
int step (double a_maxMove) override
int run (size_t a_maxIterations, double a_maxMove) override
const std::string & method () const
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
virtual void onTranslationPulledBack ()

Private Member Functions

void ensureSolver (double a_maxMove)

Private Attributes

std::string m_method
rgmin_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

rgmin backend (opt_method = xtsci, or opt_backend = rgmin).

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

Definition at line 26 of file XtsciOptimizer.h.

Constructor & Destructor Documentation

◆ XtsciOptimizer() [1/2]

eonc::XtsciOptimizer::XtsciOptimizer ( std::shared_ptr< ObjectiveFunction > a_objf,
const Parameters & a_params,
std::string a_method = {} )
inline

a_method is an [Xtsci] method token; empty reads [Xtsci] method.

Definition at line 29 of file XtsciOptimizer.h.

30 {})
31 : Optimizer(a_objf, OptType::XTSCI,
32 OptimizerConfig::fromParams(a_params)),
33 m_method(a_method.empty() ? m_optConfig.opts.xtsci.method
34 : std::move(a_method)) {}
std::string m_method
const std::string & method() const
const OptimizerConfig m_optConfig
Definition Optimizer.h:73
Optimizer(std::shared_ptr< ObjectiveFunction > a_objf, const OptimizerConfig &a_config)
Definition Optimizer.h:77

◆ XtsciOptimizer() [2/2]

◆ ~XtsciOptimizer()

Definition at line 282 of file XtsciOptimizer.cpp.

282 {
283 rgmin_solver_free(m_solver);
285 m_eindir = nullptr;
286}
rgmin_solver_t * m_solver
xtsci_eindir::State * m_eindir
void release(State *state)

Member Function Documentation

◆ ensureSolver()

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

Definition at line 288 of file XtsciOptimizer.cpp.

288 {
289 if (m_solver != nullptr) {
290 return;
291 }
292 const auto dim = static_cast<size_t>(m_objf->degreesOfFreedom());
293 if (dim == 0) {
294 return;
295 }
296 const auto stamp = rgmin_abi_stamp();
297 if (rgmin_abi_compatible(&stamp) == 0) {
298 throw std::runtime_error("incompatible rgmin ABI");
299 }
300 const auto &lbfgs = m_optConfig.opts.lbfgs;
301 const rgmin_method_t method = method_from_name(m_method);
302#if RGMIN_ABI_VERSION_MINOR < 27
303 if (method == RGMIN_FIRE2) {
304 throw std::runtime_error(
305 "Xtsci.method = fire2 needs rgmin ABI minor 27 or newer for "
306 "rgmin_solver_set_fire_variant");
307 }
308#endif
309 rgmin_control_t control{
310 static_cast<size_t>(std::max<long>(1, m_optConfig.opts.max_iterations)),
311 m_optConfig.opts.converged_force,
312 initial_step(method, m_optConfig.opts, a_maxMove),
313 static_cast<size_t>(std::max<long>(0, lbfgs.memory)),
314 0.0,
315 };
316 m_solver = rgmin_solver_create(method, &control, dim);
317 if (m_solver == nullptr) {
318 throw std::runtime_error(rgmin_last_error());
319 }
320#if RGMIN_ABI_VERSION_MINOR >= 27
321 // The default RGMIN_FIRE2 schedule keeps the FIRE 1.0 parameters.
322 // The variant reads dt0 from control.istep, so it follows create.
323 if (method == RGMIN_FIRE2) {
324 rgmin_solver_set_fire_variant(m_solver, RGMIN_FIRE_GUENOLE2020);
325 }
326#endif
327 const auto step = resolved_qn_step(m_optConfig.opts);
328 if (step == "newton") {
329 rgmin_solver_set_qn_step(m_solver, RGMIN_QN_NEWTON);
330 } else if (step == "rfo") {
331 rgmin_solver_set_qn_step(m_solver, RGMIN_QN_RFO);
332 } else {
333 rgmin_solver_set_qn_step(m_solver, RGMIN_QN_LBFGS);
334 }
335 const auto accept = m_objf->gradientMatchesEnergy()
336 ? resolved_accept(m_optConfig.opts)
337 : std::string("none");
338 if (accept == "energy") {
339 rgmin_solver_set_accept(m_solver, RGMIN_ACCEPT_ENERGY);
340 } else if (accept == "nonmonotone") {
341 rgmin_solver_set_accept(m_solver, RGMIN_ACCEPT_NONMONOTONE);
342 } else {
343 rgmin_solver_set_accept(m_solver, RGMIN_ACCEPT_NONE);
344 }
345 rgmin_solver_set_project_rigid(m_solver, lbfgs.project_rigid ? 1 : 0);
346 rgmin_solver_set_extra_updates(
347 m_solver, static_cast<size_t>(std::max<long>(0, lbfgs.extra_updates)));
348 if (lbfgs.curvature == "cautious") {
349 rgmin_solver_set_cautious(m_solver, lbfgs.cautious_eps,
350 lbfgs.cautious_alpha);
351 } else {
352 rgmin_solver_set_cautious(m_solver, 0.0, lbfgs.cautious_alpha);
353 }
354 if (m_optConfig.opts.xtsci.highs) {
355 if (rgmin_solver_set_highs(m_solver, 1) != 0) {
356 throw std::runtime_error(
357 "Xtsci.highs needs rgmin built with --features highs");
358 }
359 }
360 const auto &mani = m_optConfig.opts.xtsci.manifold;
361 if (mani == "so3" && dim != 9) {
362 throw std::runtime_error(
363 "Xtsci.manifold=so3 needs length 9; a 3N cluster is "
364 "rigid_quotient (Sella R^{3N}/SE(3)), not a packed rotation");
365 }
366 if (mani == "se3" && dim != 12) {
367 throw std::runtime_error(
368 "Xtsci.manifold=se3 needs length 12; a 3N cluster is "
369 "rigid_quotient (Sella R^{3N}/SE(3)), not an SE(3) prefix");
370 }
371 if ((mani == "rigid_quotient" || mani == "mw_rigid" || mani == "sella" ||
372 mani == "eckart" || mani == "irc") &&
373 (dim < 6 || dim % 3 != 0)) {
374 throw std::runtime_error("Xtsci.manifold=" + mani +
375 " needs 3N Cartesians with N >= 2");
376 }
377 if (mani == "sphere") {
378 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_SPHERE);
379 } else if (mani == "so3") {
380 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_SO3);
381 } else if (mani == "stiefel") {
382 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_STIEFEL);
383 } else if (mani == "se3") {
384 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_SE3);
385 } else if (mani == "rigid_quotient" || mani == "sella") {
386 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_RIGID_QUOTIENT);
387 } else if (mani == "mw_rigid" || mani == "eckart" || mani == "irc") {
388 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_MW_RIGID);
389 const auto masses = m_objf->getMasses();
390 if (masses.size() > 0) {
391 rgmin_solver_set_masses(m_solver, masses.data(),
392 static_cast<size_t>(masses.size()));
393 }
394 } else {
395 rgmin_solver_set_manifold(m_solver, RGMIN_MANIFOLD_EUCLIDEAN);
396 }
397 if (mani == "rigid_quotient" || mani == "mw_rigid" || mani == "sella" ||
398 mani == "eckart" || mani == "irc") {
399 rgmin_solver_set_periodic(m_solver, m_objf->getPeriodic() ? 1 : 0);
400 }
401 if (m_eindir == nullptr) {
403 }
404}
Eigen::VectorXd m_cached_x
int step(double a_maxMove) override
std::shared_ptr< ObjectiveFunction > m_objf
Definition Optimizer.h:74
State * bind(ObjectiveFunction *objective, Eigen::VectorXd *cached)
Borrow an ObjectiveFunction as an eindir objective.

◆ method()

const std::string & eonc::XtsciOptimizer::method ( ) const
inline

Definition at line 43 of file XtsciOptimizer.h.

43{ return m_method; }

◆ 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 457 of file XtsciOptimizer.cpp.

457 {
458 if (m_objf->degreesOfFreedom() <= 0 || a_maxIterations == 0) {
459 return m_objf->isConverged() ? 1 : 0;
460 }
461 ensureSolver(a_maxMove);
462 const auto &lbfgs = m_optConfig.opts.lbfgs;
463 std::string precon = resolved_precon(m_optConfig.opts);
464 const rgmin_method_t method = method_from_name(m_method);
465 if (method == RGMIN_DOGLEG && !is_host_precon(precon)) {
466 precon = "pair";
467 }
468 const bool want_hess = method == RGMIN_NEWTON || method == RGMIN_RFO ||
469 method == RGMIN_DOGLEG || is_host_precon(precon);
470 // A full minimize without a host Hessian goes through the eindir entry.
471 // step() stays one session iteration so the host loop keeps its memory.
472 // rgmin_minimize_eindir takes no FIRE variant, so fire2 stays on the
473 // session.
474 if (m_eindir != nullptr && !want_hess && method != RGMIN_FIRE2) {
475 if (m_x.size() == 0) {
476 m_x = m_objf->getPositions();
477 }
478 double value = 0.0;
479 const int status = xtsci_eindir::minimize(
480 m_eindir, m_x.data(), static_cast<size_t>(m_x.size()), a_maxIterations,
481 m_optConfig.opts.converged_force,
482 initial_step(method, m_optConfig.opts, a_maxMove),
483 static_cast<size_t>(std::max<long>(0, lbfgs.memory)),
484 static_cast<int>(method), &value);
485 if (status != RGMIN_SUCCESS) {
486 throw std::runtime_error(rgmin_last_error());
487 }
488 m_objf->setPositions(m_x);
489 m_cached_x = m_x;
490 static_cast<void>(value);
491 return m_objf->isConverged() ? 1 : 0;
492 }
493 for (size_t i = 0; i < a_maxIterations; ++i) {
494 if (step(a_maxMove) != 0) {
495 return 1;
496 }
497 }
498 return m_objf->isConverged() ? 1 : 0;
499}
Eigen::VectorXd m_x
void ensureSolver(double a_maxMove)
int step(double a_maxMove) override
int minimize(State *state, double *x, std::size_t n, std::size_t maxiter, double gtol, double istep, std::size_t memory, int method, double *value_out)
xts_minimize_eindir on a caller-owned buffer. The caller keeps State.

◆ step()

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

Implements eonc::Optimizer.

Definition at line 406 of file XtsciOptimizer.cpp.

406 {
407 if (m_objf->degreesOfFreedom() <= 0) {
408 return m_objf->isConverged() ? 1 : 0;
409 }
410 ensureSolver(a_maxMove);
411 if (m_solver == nullptr) {
412 return m_objf->isConverged() ? 1 : 0;
413 }
414 // Native LBFGS clips by the largest per-atom move, not ||d||_2.
415 rgmin_solver_set_maxmove(m_solver, 0.0);
416 rgmin_solver_set_atom_maxmove(m_solver, std::max(a_maxMove, 0.0));
417
418 if (m_x.size() == 0) {
419 m_x = m_objf->getPositions();
420 }
421 if (m_x.size() != m_objf->degreesOfFreedom()) {
422 throw std::runtime_error("rgmin objective position dimension mismatch");
423 }
424 auto *tensor =
425 rgmin_tensor_borrow_cpu_f64(m_x.data(), static_cast<size_t>(m_x.size()));
426 if (tensor == nullptr) {
427 throw std::runtime_error("could not allocate rgmin objective tensor");
428 }
429 const auto &lbfgs = m_optConfig.opts.lbfgs;
430 std::string precon = resolved_precon(m_optConfig.opts);
431 const rgmin_method_t method = method_from_name(m_method);
432 if (method == RGMIN_DOGLEG && !is_host_precon(precon)) {
433 precon = "pair";
434 }
435 XtsObjectiveContext context{
436 m_objf.get(), m_optConfig.potential, precon, lbfgs.precon_A,
437 lbfgs.precon_mu, lbfgs.precon_rcut, &m_cached_x, m_eindir,
438 };
439 rgmin_report_t report{};
440 const bool want_hess = method == RGMIN_NEWTON || method == RGMIN_RFO ||
441 method == RGMIN_DOGLEG || is_host_precon(precon);
442 rgmin_status_t status;
443 if (want_hess) {
444 status = rgmin_solver_step_hess_fg(m_solver, evaluate_gradient, hessian,
445 &context, tensor, &report);
446 } else {
447 status = rgmin_solver_step_fg(m_solver, evaluate_gradient, &context, tensor,
448 &report);
449 }
450 rgmin_tensor_free(tensor);
451 if (status != RGMIN_SUCCESS) {
452 throw std::runtime_error(rgmin_last_error());
453 }
454 return m_objf->isConverged() ? 1 : 0;
455}

Member Data Documentation

◆ m_cached_x

Eigen::VectorXd eonc::XtsciOptimizer::m_cached_x
private

Definition at line 53 of file XtsciOptimizer.h.

◆ m_eindir

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

Definition at line 50 of file XtsciOptimizer.h.

50{nullptr};

◆ m_method

std::string eonc::XtsciOptimizer::m_method
private

Definition at line 46 of file XtsciOptimizer.h.

◆ m_solver

rgmin_solver_t* eonc::XtsciOptimizer::m_solver {nullptr}
private

Definition at line 48 of file XtsciOptimizer.h.

48{nullptr};

◆ m_x

Eigen::VectorXd eonc::XtsciOptimizer::m_x
private

Definition at line 56 of file XtsciOptimizer.h.


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