29 const double norm = t.norm();
30 if (!(norm > 0.0) || !(dr > 0.0)) {
31 throw std::invalid_argument(
"modeCurvature: zero mode or step");
42#if defined(WITH_RGSADDLE) && RGSADDLE_ABI_MINOR >= 15
56rgsaddle_status_t refineCallback(
void *user, rgsaddle_surface_request_t *req) {
57 auto *s =
static_cast<RefineSurface *
>(user);
58 if (s ==
nullptr || req ==
nullptr || req->positions ==
nullptr ||
59 req->energies ==
nullptr || req->gradients ==
nullptr ||
61 return RGSADDLE_SURFACE_FAILED;
63 const auto dof = s->x.size();
64 if (3 * req->n_atoms != dof) {
65 return RGSADDLE_SHAPE;
68 const Eigen::Map<const VectorXd> x(req->positions, dof);
71 s->matter->setPositionsFreeV((s->mask.array() > 0.5).select(x, s->start));
73 s->energy = s->matter->getPotentialEnergy();
74 s->gradient = -s->matter->getForcesFreeV();
76 req->energies[0] = s->energy;
77 Eigen::Map<VectorXd>(req->gradients, dof) = s->gradient;
80 return RGSADDLE_SURFACE_FAILED;
84void check(
int rc,
const char *what) {
85 if (rc != RGSADDLE_OK) {
86 throw std::runtime_error(
87 std::string(what) +
": " +
88 rgsaddle_status_name(
static_cast<rgsaddle_status_t
>(rc)));
94 if (!(opt.force > 0.0) || opt.max_iterations < 1) {
95 throw std::invalid_argument(
"prfo_refine_force must be positive and "
96 "prfo_refine_max_iterations at least 1");
101void checkPrfoLibrary() {
102 rgsaddle_version_t stamp{};
103 check(rgsaddle_abi_stamp(&stamp),
"rgsaddle_abi_stamp");
104 if (stamp.major != RGSADDLE_ABI_MAJOR || stamp.minor < 15) {
105 throw std::runtime_error(
106 "prfo_refine needs rgsaddle ABI 1.15 or newer at run time (loaded " +
107 std::to_string(stamp.major) +
"." + std::to_string(stamp.minor) +
")");
112std::vector<long> freeAtoms(
const Matter &matter) {
114 std::vector<long> rows;
115 for (
long i = 0; i < free.rows(); ++i) {
116 if (free.row(i).sum() > 0.5) {
127 checkPrfoKeys(params);
135 checkPrfoKeys(params);
137 const std::vector<long> rows = freeAtoms(matter);
138 const auto nFree =
static_cast<long>(rows.size());
140 const Matter start(matter);
141 const double startForce = matter.
maxForce();
145 VectorXd masses(nFree);
146 for (
long j = 0; j < nFree; ++j) {
147 freeMask.row(j) = free.row(rows[j]);
148 freeMode.row(j) = mode.row(rows[j]).cwiseProduct(free.row(rows[j]));
149 masses[j] = matter.
getMass(rows[j]);
152 RefineSurface surf{&matter,
153 VectorXd::Map(freeMask.data(), 3 * nFree),
159 rgsaddle_sella_saddle_config_t
config{};
160 config.version = RGSADDLE_VERSION_INIT;
161 config.force_tol = opt.force;
162 config.force_gate = RGSADDLE_FORCE_MAX_ATOM;
166 rgsaddle_constraints_config_t chartConfig{};
167 chartConfig.version = RGSADDLE_VERSION_INIT;
168 RgsaddleConstraints *chart = rgsaddle_constraints_create(&chartConfig, nFree);
169 if (chart ==
nullptr) {
170 throw std::runtime_error(
"rgsaddle_constraints_create failed");
172 RgsaddleSellaSaddle *session = rgsaddle_sella_saddle_create_on(
173 &
config, nFree, surf.start.data(), masses.data(), chart);
174 rgsaddle_constraints_free(chart);
175 if (session ==
nullptr) {
176 throw std::runtime_error(
"rgsaddle_sella_saddle_create_on failed");
183 check(rgsaddle_sella_saddle_set_hess_update(session, 1),
184 "rgsaddle_sella_saddle_set_hess_update");
185 check(rgsaddle_sella_saddle_seed_mode(session, freeMode.data(), curvature),
186 "rgsaddle_sella_saddle_seed_mode");
187 rgsaddle_report_t report{};
188 while (!result.converged && result.steps < opt.max_iterations) {
189 check(rgsaddle_sella_saddle_step(session, refineCallback, &surf, &report),
190 "rgsaddle_sella_saddle_step");
192 result.converged = report.status == RGSADDLE_STATUS_CONVERGED;
194 VectorXd x(3 * nFree);
195 check(rgsaddle_sella_saddle_position(session, x.data()),
196 "rgsaddle_sella_saddle_position");
201 rgsaddle_sella_saddle_free(session);
204 rgsaddle_sella_saddle_free(session);
206 result.maxForce = matter.
maxForce();
208 if (result.maxForce > startForce) {
210 result.restored =
true;
211 result.converged =
false;
212 result.maxForce = startForce;
215 EONC_LOG_INFO(
"[P-RFO] {} steps, {} force calls, max atom force {:.3e} -> "
217 result.steps, result.forceCalls, startForce, result.maxForce,
218 result.restored ?
", kept the starting point" :
"");
226[[noreturn]]
void missingSession() {
227 throw std::runtime_error(
"[Saddle Search] prfo_refine needs eOn built with "
228 "-Dwith_rgsaddle=true against rgsaddle ABI 1.15 or "
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
#define EONC_LOG_INFO(...)
VectorXd getForcesFreeV() const
AtomMatrix getFree() const
void setPositionsFreeV(const VectorXd &pos)
long getForceCalls() const
VectorXd getPositionsFreeV() const
double getMass(long int atom) const
double getPotentialEnergy() const
void assignKeepingBias(const Matter &other)
Copy another structure in and keep this Matter's own bias potential.
double maxForce(void) const
const saddle_search_options_t & saddle_search_options() const
const AtomMatrix & getPositions() const
void setPositions(const AtomMatrix &pos)
AtomMatrix getFree() const
const AtomMatrix & getForces() const
const saddle_search_options_t & saddle_search_options() const
RAII resource manager for the ARTn C library with global synchronization.
PrfoRefineResult prfoRefineSaddle(Matter &, const AtomMatrix &, double, const Parameters &)
Partitioned rational function optimization (P-RFO) of a first-order saddle in the rgsaddle Sella orde...
void requirePrfoRefine(const Parameters ¶ms)
Does nothing unless [Saddle Search] prfo_refine is on.
double modeCurvature(const Matter &matter, const AtomMatrix &mode, double dr)
Curvature along mode from one forward difference of the forces over dr Angstrom.
struct eonc::saddle_search_options_t::prfo_refine_t prfo_refine