oqp.library.liboqp

OQP geometry optimizer backend for OpenQP.

A NumPy/SciPy-only alternative to the external ``geomeTRIC`` driver.  The
electronic-structure work, convergence test and logging are reused verbatim from
:class:`oqp.library.libscipy.StateSpecificOpt`; this module only supplies the
step-determination loop through :class:`oqp.library.oqp_engine.OQPEngine`
(redundant internal coordinates + restricted-step RFO / P-RFO with model-Hessian
BFGS/Bofill updates).

Selected with ``[optimize] lib=oqp``.  Supported runtypes:

* ``optimize`` -> :class:`OQPOpt`   (state-specific minimum)
* ``ts``       -> :class:`OQPTSOpt` (transition state, eigenvector following)

Options are read from the ``[oqp]`` input section (see
``oqp.molecule.oqpdata``).

Attributes

ANGSTROM_TO_BOHR

Classes

`OQPOpt`
`OQPTSOpt`
`OQPMECIOpt`
`OQPAutoMECIOpt`
`OQPMECPOpt`
`OQPBaekAOpt`
`OQPTCIOpt`
`OQPNEBOpt`
`OQPIRCOpt`
`OQPMEPOpt`

Module Contents

ANGSTROM_TO_BOHR = 1.8897261245650618

class OQPOpt(mol)

Bases: _OQPRunner, oqp.library.libscipy.StateSpecificOpt

State-specific minimum via redundant internals + restricted-step RFO.

mode = 'min'

class OQPTSOpt(mol)

Bases: _OQPRunner, oqp.library.libscipy.StateSpecificOpt

Transition-state search via partitioned RFO (eigenvector following).

mode = 'ts'

class OQPMECIOpt(mol)

Bases: _OQPRunner, oqp.library.libscipy.MECIOpt

MECI search: minimize the penalty/UBP objective with the oqp engine.

Reuses ``MECIOpt.one_step`` (which returns the penalty objective and its
gradient) and ``MECIOpt.check_convergence`` (which adds the energy-gap
criterion) verbatim -- only the step determination is oqp.

mode = 'min'

class OQPAutoMECIOpt(mol)

Native MECI strategy that escalates a two-state search to BaekA.

A short conventional penalty phase is inexpensive and usually reaches the
crossing seam quickly.  If it does not satisfy both geometry and gap
criteria, the lowest-objective geometry retained by :class:`OQPMECIOpt` is
handed to the Baek adaptive penalty algorithm.  For three or more states,
BaekA is the only well-defined implementation and is selected directly.

mol

metrics

penalty_optimizer = None

baeka_optimizer = None

optimize()

class OQPMECPOpt(mol)

Bases: _OQPRunner, oqp.library.libscipy.MECPOpt

MECP search: minimize the gap-penalty objective with the oqp engine.

mode = 'min'

class OQPBaekAOpt(mol, states=None)

Bases: _OQPRunner, oqp.library.libscipy.Optimizer

Generalized Baek adaptive-penalty CI search for ``N >= 2`` states.

The selected roots are ordered and only adjacent energy gaps are penalized,
removing the redundant outer gap of an all-pairs formulation.  ``sigma`` is
increased additively by ``pen_delta`` on ordinary iterations and by the next
entry of ``pen_jump`` when the projected objective is locally stationary but
the outer-state span still exceeds ``energy_gap``.

Reference: Y. S. Baek, S. Lee, M. Filatov, and C. H. Choi,
J. Phys. Chem. A 125, 1994--2006 (2021),
https://doi.org/10.1021/acs.jpca.0c11294.

mode = 'min'

states

alpha

delta_beta

jump_schedule

weights

baeka

optimize()

Run BaekA with same-sigma-rebased native RFO/BFGS steps.

one_step(coordinates)

check_convergence()

class OQPTCIOpt(mol)

Bases: _OQPRunner, oqp.library.libscipy.MECIOpt

Legacy three-state CI search retained for input compatibility.

This is the historical OpenQP TCI prototype: it penalizes the two
consecutive gaps and multiplies ``sigma`` by ``pen_incre`` every step.
The published additive Baek adaptive algorithm is independently selected
with ``runtype=meci`` and ``meci_search=baeka``.

mode = 'min'

one_step(coordinates)

class OQPNEBOpt(mol)

Bases: oqp.library.libscipy.StateSpecificOpt

Nudged elastic band reaction path via the oqp FIRE band optimizer.

Reactant is the ``[input] system`` geometry; product is read from the
``[neb] product`` XYZ endpoint.  Images are linearly interpolated and the
interior images optimized with improved-tangent NEB + optional climbing
image (see :mod:`oqp.library.oqp_neb`).  Energies/gradients per image use
the state-specific (``istate``) surface via the reused OQP machinery.

nimage

product

k_spring

climbing

neb_fmax

neb_frms

climb_fmax

neb_dt

maxmove

align

opt_ends

end_fmax

neb_output = ''

optimize()

class OQPIRCOpt(mol)

Bases: oqp.library.libscipy.StateSpecificOpt

Intrinsic reaction coordinate by the oqp Gonzalez-Schlegel IRC.

Computes the Hessian at the starting transition state, takes the
imaginary-frequency mode as the initial (mass-weighted) direction, and
traces the mass-weighted steepest-descent path forward or backward (see
:mod:`oqp.library.oqp_irc`).

irc_step

irc_sign = -1

path_gtol

optimize()

class OQPMEPOpt(mol)

Bases: oqp.library.libscipy.StateSpecificOpt

Minimum energy path: mass-weighted steepest descent from the start point.

Reuses the Gonzalez-Schlegel constrained-hypersphere integrator
(:mod:`oqp.library.oqp_irc`) but, unlike IRC, begins at an arbitrary
(non-stationary) geometry along the steepest-descent direction
``-g`` instead of a transition-state imaginary mode, tracing the path down
to the nearest minimum.  Matches the semantics of the mass-weighted
constrained-sphere ``MEP``/``ConstrainOpt`` driver.

mep_step

path_gtol

optimize()