23#if RGMIN_ABI_VERSION_MINOR < 10
24#error "rgmin ABI minor 10 or newer is required for set_periodic"
29struct XtsObjectiveContext {
30 eonc::ObjectiveFunction *objective;
36 Eigen::VectorXd *cached_x;
37 eonc::xtsci_eindir::State *eindir;
40Eigen::Map<const Eigen::VectorXd>
41map_input(
const DLManagedTensorVersioned *tensor) {
42 const auto &dl = tensor->dl_tensor;
43 if (dl.ndim != 1 || dl.dtype.code != kDLFloat || dl.dtype.bits != 64 ||
44 dl.dtype.lanes != 1 || dl.device.device_type != kDLCPU ||
45 dl.shape ==
nullptr || dl.data ==
nullptr) {
46 throw std::runtime_error(
"rgmin objective requires a CPU f64 vector");
48 return {
static_cast<const double *
>(dl.data) +
49 dl.byte_offset /
sizeof(
double),
50 static_cast<Eigen::Index
>(dl.shape[0])};
53Eigen::Map<Eigen::VectorXd> map_output(DLManagedTensorVersioned *tensor) {
54 const auto &dl = tensor->dl_tensor;
55 if (dl.ndim != 1 || dl.dtype.code != kDLFloat || dl.dtype.bits != 64 ||
56 dl.dtype.lanes != 1 || dl.device.device_type != kDLCPU ||
57 dl.shape ==
nullptr || dl.data ==
nullptr) {
58 throw std::runtime_error(
"rgmin tensor requires a CPU f64 vector");
60 return {
static_cast<double *
>(dl.data) + dl.byte_offset /
sizeof(
double),
61 static_cast<Eigen::Index
>(dl.shape[0])};
68 const Eigen::VectorXd &x,
69 Eigen::VectorXd *cached) {
70 if (cached !=
nullptr && cached->size() == x.size() &&
71 (*cached - x).isZero(0.0)) {
77 if (cur.size() == x.size() && (cur - x).isZero(0.0)) {
78 if (cached !=
nullptr) {
84 if (cached !=
nullptr) {
90rgmin_status_t evaluate_gradient(
void *user,
const DLManagedTensorVersioned *x,
92 DLManagedTensorVersioned *gradient_out) {
94 auto *context =
static_cast<XtsObjectiveContext *
>(user);
95 if (context->eindir !=
nullptr) {
97 context->eindir, x, value_out, gradient_out));
99 const auto positions = map_input(x);
100 set_positions_if_changed(context->objective, positions, context->cached_x);
101 *value_out = context->objective->getEnergy();
102 const auto gradient_value = context->objective->getGradient();
103 auto output = map_output(gradient_out);
104 if (output.size() != gradient_value.size()) {
105 return RGMIN_INVALID_PARAMETER;
107 output = gradient_value;
108 return RGMIN_SUCCESS;
110 return RGMIN_INTERNAL_ERROR;
114rgmin_status_t hessian(
void *user,
const DLManagedTensorVersioned *x,
115 DLManagedTensorVersioned *hess_out) {
117 auto *context =
static_cast<XtsObjectiveContext *
>(user);
118 const auto positions = map_input(x);
120 positions, context->precon, context->pot, context->precon_A,
121 context->precon_mu, context->precon_rcut, *context->objective);
122 auto output = map_output(hess_out);
123 const Eigen::Index n = H.rows();
124 if (output.size() != n * n) {
125 return RGMIN_INVALID_PARAMETER;
127 for (Eigen::Index i = 0; i < n; ++i) {
128 for (Eigen::Index j = 0; j < n; ++j) {
129 output[i * n + j] = H(i, j);
132 return RGMIN_SUCCESS;
134 return RGMIN_INTERNAL_ERROR;
138rgmin_method_t method_from_name(
const std::string &name) {
139 if (name ==
"lbfgs") {
142 if (name ==
"bfgs") {
151 if (name ==
"newton") {
157 if (name ==
"steepest") {
158 return RGMIN_STEEPEST;
160 if (name ==
"adam") {
166 if (name ==
"polak_ribiere" || name ==
"nlcg" || name ==
"pr") {
167 return RGMIN_POLAK_RIBIERE;
169 if (name ==
"fletcher_reeves") {
170 return RGMIN_FLETCHER_REEVES;
172 if (name ==
"hestenes_stiefel") {
173 return RGMIN_HESTENES_STIEFEL;
175 if (name ==
"dai_yuan") {
176 return RGMIN_DAI_YUAN;
178 if (name ==
"conjugate_descent") {
179 return RGMIN_CONJUGATE_DESCENT;
181 if (name ==
"hager_zhang") {
182 return RGMIN_HAGER_ZHANG;
184 if (name ==
"liu_storey") {
185 return RGMIN_LIU_STOREY;
187 if (name ==
"fr_pr") {
190 if (name ==
"fire") {
193 if (name ==
"bb" || name ==
"barzilai_borwein") {
196 if (name ==
"dogleg") {
199 if (name ==
"fire2") {
202#if RGMIN_ABI_VERSION_MINOR >= 29
203 if (name ==
"quickmin") {
204 return RGMIN_QUICKMIN;
207 throw std::invalid_argument(
208 "unknown Xtsci.method '" + name +
209 "' (lbfgs, bfgs, sr1, sr2, newton, rfo, steepest, adam, pso, "
210 "polak_ribiere, fletcher_reeves, hestenes_stiefel, dai_yuan, "
211 "conjugate_descent, hager_zhang, liu_storey, fr_pr, fire, bb, "
212 "dogleg, fire2, quickmin)");
215bool is_dynamics(rgmin_method_t method) {
216 bool dynamics = method == RGMIN_FIRE || method == RGMIN_FIRE2;
217#if RGMIN_ABI_VERSION_MINOR >= 29
218 dynamics = dynamics || method == RGMIN_QUICKMIN;
225double initial_step(rgmin_method_t method,
228 if (!is_dynamics(method)) {
229 return std::max(a_maxMove, 1.0e-12);
240bool is_host_precon(
const std::string &name) {
241 return name ==
"pair" || name ==
"pair_abs" || name ==
"pair_full" ||
242 name ==
"exp" || name ==
"c1" || name ==
"lindh" ||
243 name ==
"lindh_full" || name ==
"fischer" || name ==
"schlegel" ||
292 const auto dim =
static_cast<size_t>(
m_objf->degreesOfFreedom());
296 const auto stamp = rgmin_abi_stamp();
297 if (rgmin_abi_compatible(&stamp) == 0) {
298 throw std::runtime_error(
"incompatible rgmin ABI");
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");
309 rgmin_control_t control{
310 static_cast<size_t>(std::max<long>(1,
m_optConfig.opts.max_iterations)),
313 static_cast<size_t>(std::max<long>(0, lbfgs.memory)),
318 throw std::runtime_error(rgmin_last_error());
320#if RGMIN_ABI_VERSION_MINOR >= 27
323 if (
method == RGMIN_FIRE2) {
324 rgmin_solver_set_fire_variant(
m_solver, RGMIN_FIRE_GUENOLE2020);
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);
333 rgmin_solver_set_qn_step(
m_solver, RGMIN_QN_LBFGS);
335 const auto accept =
m_objf->gradientMatchesEnergy()
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);
343 rgmin_solver_set_accept(
m_solver, RGMIN_ACCEPT_NONE);
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);
352 rgmin_solver_set_cautious(
m_solver, 0.0, lbfgs.cautious_alpha);
355 if (rgmin_solver_set_highs(
m_solver, 1) != 0) {
356 throw std::runtime_error(
357 "Xtsci.highs needs rgmin built with --features highs");
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");
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");
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");
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()));
395 rgmin_solver_set_manifold(
m_solver, RGMIN_MANIFOLD_EUCLIDEAN);
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);
407 if (
m_objf->degreesOfFreedom() <= 0) {
408 return m_objf->isConverged() ? 1 : 0;
412 return m_objf->isConverged() ? 1 : 0;
415 rgmin_solver_set_maxmove(
m_solver, 0.0);
416 rgmin_solver_set_atom_maxmove(
m_solver, std::max(a_maxMove, 0.0));
418 if (
m_x.size() == 0) {
421 if (
m_x.size() !=
m_objf->degreesOfFreedom()) {
422 throw std::runtime_error(
"rgmin objective position dimension mismatch");
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");
430 std::string precon = resolved_precon(
m_optConfig.opts);
432 if (
method == RGMIN_DOGLEG && !is_host_precon(precon)) {
435 XtsObjectiveContext context{
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;
444 status = rgmin_solver_step_hess_fg(
m_solver, evaluate_gradient, hessian,
445 &context, tensor, &report);
447 status = rgmin_solver_step_fg(
m_solver, evaluate_gradient, &context, tensor,
450 rgmin_tensor_free(tensor);
451 if (status != RGMIN_SUCCESS) {
452 throw std::runtime_error(rgmin_last_error());
454 return m_objf->isConverged() ? 1 : 0;
458 if (
m_objf->degreesOfFreedom() <= 0 || a_maxIterations == 0) {
459 return m_objf->isConverged() ? 1 : 0;
463 std::string precon = resolved_precon(
m_optConfig.opts);
465 if (
method == RGMIN_DOGLEG && !is_host_precon(precon)) {
468 const bool want_hess =
method == RGMIN_NEWTON ||
method == RGMIN_RFO ||
469 method == RGMIN_DOGLEG || is_host_precon(precon);
475 if (
m_x.size() == 0) {
480 m_eindir,
m_x.data(),
static_cast<size_t>(
m_x.size()), a_maxIterations,
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());
490 static_cast<void>(value);
491 return m_objf->isConverged() ? 1 : 0;
493 for (
size_t i = 0; i < a_maxIterations; ++i) {
494 if (
step(a_maxMove) != 0) {
498 return m_objf->isConverged() ? 1 : 0;
virtual VectorXd getPositions()=0
virtual void setPositions(const VectorXd &x)=0
const OptimizerConfig m_optConfig
std::shared_ptr< ObjectiveFunction > m_objf
eonc::optimizer_options_t optimizer_options_t
int run(size_t a_maxIterations, double a_maxMove) override
void ensureSolver(double a_maxMove)
~XtsciOptimizer() override
Eigen::VectorXd m_cached_x
const std::string & method() const
rgmin_solver_t * m_solver
int step(double a_maxMove) override
xtsci_eindir::State * m_eindir
Eigen::MatrixXd build(const Eigen::VectorXd &pos, const std::string &kind, PotType pot, double A, double mu, double rcut_in, ObjectiveFunction &objf)
Analytic pair or model Hessian.
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.
void release(State *state)
State * bind(ObjectiveFunction *objective, Eigen::VectorXd *cached)
Borrow an ObjectiveFunction as an eindir objective.
int eval_grad(State *state, const DLManagedTensorVersioned *x, double *value, DLManagedTensorVersioned *gradient)
One fused energy and gradient through the borrowed eindir handle.
RAII resource manager for the ARTn C library with global synchronization.
struct eonc::optimizer_options_t::xtsci_t xtsci
struct eonc::optimizer_options_t::lbfgs_t lbfgs