def __init__(self,
coords,
pot,
eigenvec0=None,
orthogZeroEigs=0,
dx=1e-6,
first_order=True,
gradient=None,
**minimizer_kwargs):
self.minimizer_kwargs = minimizer_kwargs
if eigenvec0 is None:
# this random vector should be distributed uniformly on a hypersphere.
eigenvec0 = rotations.vec_random_ndim(coords.shape)
eigenvec0 = eigenvec0 / np.linalg.norm(eigenvec0)
# change some default in the minimizer unless manually set
if "nsteps" not in minimizer_kwargs:
minimizer_kwargs["nsteps"] = 500
if "logger" not in minimizer_kwargs:
minimizer_kwargs["logger"] = logging.getLogger(
"pele.connect.findTS.leig_quench")
self.eigpot = LowestEigPot(coords,
pot,
orthogZeroEigs=orthogZeroEigs,
dx=dx,
gradient=gradient,
first_order=first_order)
self.minimizer = MYLBFGS(eigenvec0,
self.eigpot,
rel_energy=True,
**self.minimizer_kwargs)
def setUp1(self, verbose=False, **kwargs):
np.random.seed(0)
natoms = 18
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
x = self.system.get_random_configuration()
ret = lbfgs_py(x, self.pot, tol=10)
self.x = ret.coords
self.kwargs = kwargs
self.verbose = verbose
self.M = 4
if self.verbose: iprint = 1
else: iprint = -1
self.myo = MYLBFGS(self.x,
self.pot,
iprint=iprint,
debug=True,
M=self.M)
self.o = LBFGS(self.x,
self.pot,
iprint=iprint,
debug=True,
M=self.M,
**self.kwargs)
def test_state(self):
# do several minimization iterations
for i in range(10):
self.minimizer.one_iteration()
# get the state and save it
ret = self.minimizer.get_result()
state = self.minimizer.get_state()
x1 = ret.coords.copy()
# do several more iteration steps
for i in range(10):
self.minimizer.one_iteration()
# now make a new minimizer and do several iterations
minimizer2 = MYLBFGS(x1, self.pot)
minimizer2.set_state(state)
for i in range(10):
minimizer2.one_iteration()
# test that the two minimizers are in the same state
ret1 = self.minimizer.get_result()
ret2 = minimizer2.get_result()
self.assertEqual(ret1.energy, ret2.energy)
self.assertTrue((ret1.coords == ret2.coords).all())
state1 = self.minimizer.get_state()
state2 = minimizer2.get_state()
self.assertTrue((state1.W == state2.W).all())
self.assertTrue((state1.dXold == state2.dXold).all())
self.assertTrue((state1.dGold == state2.dGold).all())
self.assertEqual(state1.H0, state2.H0)
self.assertEqual(state1.point, state2.point)
self.assertEqual(state1.iter, state2.iter)
def update_coords(self, coords, energy=None, gradient=None):
"""update the position at which to compute the eigenvector"""
self.eigpot.update_coords(coords, gradient=gradient)
state = self.minimizer.get_state()
ret = self.get_result()
self.minimizer = MYLBFGS(ret.eigenvec,
self.eigpot,
rel_energy=True,
**self.minimizer_kwargs)
self.minimizer.set_state(state)
def _minimize_transverse(self,
nsteps,
transverse_energy=None,
transverse_gradient=None):
# must update
minimizer = MYLBFGS(self.coords,
self.transverse_potential,
nsteps=self.nsteps_tangent,
energy=transverse_energy,
gradient=transverse_gradient,
**self.transverse_kwargs)
if self._transverse_walker_state is not None:
minimizer.set_state(self._transverse_walker_state)
ret = minimizer.run()
self._transverse_walker_state = minimizer.get_state()
self._stop_criterion_satisfied = minimizer.stop_criterion_satisfied()
return ret
def mylbfgs(coords, pot, **kwargs):
lbfgs = MYLBFGS(coords, pot, **kwargs)
return lbfgs.run()
def setUp(self):
self.system = LJCluster(13)
self.x = self.system.get_random_configuration()
self.pot = self.system.get_potential()
self.minimizer = MYLBFGS(self.x, self.pot)
