class TestMinimizers(unittest.TestCase):
def setUp(self):
from pygmin.systems import LJCluster
natoms = 31
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
# get a partially minimized structure
x0 = self.system.get_random_configuration()
ret = lbfgs_py(x0, self.pot, tol=1e-1)
self.x0 = ret.coords.copy()
self.E0 = ret.energy
ret = lbfgs_py(self.x0, self.pot, tol=1e-7)
self.x = ret.coords.copy()
self.E = ret.energy
def check_attributes(self, res):
self.assertTrue(hasattr(res, "energy"))
self.assertTrue(hasattr(res, "coords"))
self.assertTrue(hasattr(res, "nsteps"))
self.assertTrue(hasattr(res, "nfev"))
self.assertTrue(hasattr(res, "rms"))
self.assertTrue(hasattr(res, "grad"))
self.assertTrue(hasattr(res, "success"))
def test_lbfgs_py(self):
res = lbfgs_py(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_mylbfgs(self):
res = mylbfgs(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_fire(self):
res = fire(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_lbfgs_scipy(self):
res = lbfgs_scipy(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_bfgs_scipy(self):
res = bfgs_scipy(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
class TestMinimizers(unittest.TestCase):
def setUp(self):
from pygmin.systems import LJCluster
natoms = 31
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
# get a partially minimized structure
x0 = self.system.get_random_configuration()
ret = lbfgs_py(x0, self.pot, tol=1e-1)
self.x0 = ret.coords.copy()
self.E0 = ret.energy
ret = lbfgs_py(self.x0, self.pot, tol=1e-7)
self.x = ret.coords.copy()
self.E = ret.energy
def check_attributes(self, res):
self.assertTrue(hasattr(res, "energy"))
self.assertTrue(hasattr(res, "coords"))
self.assertTrue(hasattr(res, "nsteps"))
self.assertTrue(hasattr(res, "nfev"))
self.assertTrue(hasattr(res, "rms"))
self.assertTrue(hasattr(res, "grad"))
self.assertTrue(hasattr(res, "success"))
def test_lbfgs_py(self):
res = lbfgs_py(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_mylbfgs(self):
res = mylbfgs(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_fire(self):
res = fire(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_lbfgs_scipy(self):
res = lbfgs_scipy(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def test_bfgs_scipy(self):
res = bfgs_scipy(self.x0, self.pot, tol=1e-7)
self.assertTrue(res.success)
self.assertAlmostEqual(self.E, res.energy, 4)
self.check_attributes(res)
def size_scaling_smallest_eig(natoms):
from pygmin.systems import LJCluster
import time, sys
system = LJCluster(natoms)
pot = system.get_potential()
quencher = system.get_minimizer(tol=10.)
time1 = 0.
time2 = 0.
time3 = 0.
time4 = 0.
for i in range(100):
coords = system.get_random_configuration()
# print "len(coords)", len(coords)
coords = quencher(coords)[0]
e, g, h = pot.getEnergyGradientHessian(coords)
t0 = time.time()
w1, v1 = get_smallest_eig(h)
t1 = time.time()
w, v = get_smallest_eig_arpack(h)
t2 = time.time()
w2, v2 = get_smallest_eig_sparse(h)
t3 = time.time()
w3, v3 = get_smallest_eig_nohess(coords, system, tol=1e-3)
t4 = time.time()
time1 += t1 - t0
time2 += t2 - t1
time3 += t3 - t2
time4 += t4 - t3
wdiff = np.abs(w - w1) / np.max(np.abs([w, w1]))
if wdiff > 5e-3:
sys.stderr.write(
"eigenvalues for dense are different %g %g normalized diff %g\n"
% (w1, w, wdiff))
wdiff = np.abs(w - w2) / np.max(np.abs([w, w2]))
if wdiff > 5e-2:
sys.stderr.write(
"eigenvalues for sparse are different %g %g normalized diff %g\n"
% (w2, w, wdiff))
wdiff = np.abs(w - w3) / np.max(np.abs([w, w3]))
if wdiff > 5e-2:
sys.stderr.write(
"eigenvalues for nohess are different %g %g normalized diff %g\n"
% (w3, w, wdiff))
# print "times", n, t1-t0, t2-t1, w1, w
print "times", n, time1, time2, time3, time4
sys.stdout.flush()
def size_scaling_smallest_eig(natoms):
from pygmin.systems import LJCluster
import time, sys
system = LJCluster(natoms)
pot = system.get_potential()
quencher = system.get_minimizer(tol=10.)
time1 = 0.
time2 = 0.
time3 = 0.
time4 = 0.
for i in range(100):
coords = system.get_random_configuration()
# print "len(coords)", len(coords)
coords = quencher(coords)[0]
e, g, h = pot.getEnergyGradientHessian(coords)
t0 = time.time()
w1, v1 = get_smallest_eig(h)
t1 = time.time()
w, v = get_smallest_eig_arpack(h)
t2 = time.time()
w2, v2 = get_smallest_eig_sparse(h)
t3 = time.time()
w3, v3 = get_smallest_eig_nohess(coords, system, tol=1e-3)
t4 = time.time()
time1 += t1-t0
time2 += t2-t1
time3 += t3-t2
time4 += t4-t3
wdiff = np.abs(w-w1) / np.max(np.abs([w,w1]))
if wdiff > 5e-3:
sys.stderr.write("eigenvalues for dense are different %g %g normalized diff %g\n" % (w1, w, wdiff))
wdiff = np.abs(w-w2) / np.max(np.abs([w,w2]))
if wdiff > 5e-2:
sys.stderr.write("eigenvalues for sparse are different %g %g normalized diff %g\n" % (w2, w, wdiff))
wdiff = np.abs(w-w3) / np.max(np.abs([w,w3]))
if wdiff > 5e-2:
sys.stderr.write("eigenvalues for nohess are different %g %g normalized diff %g\n" % (w3, w, wdiff))
# print "times", n, t1-t0, t2-t1, w1, w
print "times", n, time1, time2, time3, time4
sys.stdout.flush()
class TestMinimizers(unittest.TestCase):
def setUp(self):
from pygmin.systems import LJCluster
natoms = 31
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
# get a partially minimized structure
x0 = self.system.get_random_configuration()
ret = lbfgs_py(x0, self.pot.getEnergyGradient, tol=1.e-1)
self.x0 = ret[0]
self.E0 = ret[1]
ret = lbfgs_py(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.x = ret[0]
self.E = ret[1]
def test_lbfgs_py(self):
res = lbfgs_py(self.x0, self.pot.getEnergyGradient)
self.assertAlmostEqual(self.E, res[1], 4)
def test_mylbfgs(self):
res = mylbfgs(self.x0, self.pot.getEnergyGradient)
self.assertAlmostEqual(self.E, res[1], 4)
def test_fire(self):
res = fire(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
def test_lbfgs_scipy(self):
res = lbfgs_scipy(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
def test_bfgs_scipy(self):
res = bfgs(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
class TestMinimizers(unittest.TestCase):
def setUp(self):
from pygmin.systems import LJCluster
natoms = 31
self.system = LJCluster(natoms)
self.pot = self.system.get_potential()
# get a partially minimized structure
x0 = self.system.get_random_configuration()
ret = lbfgs_py(x0, self.pot.getEnergyGradient, tol=1.e-1)
self.x0 = ret[0]
self.E0 = ret[1]
ret = lbfgs_py(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.x = ret[0]
self.E = ret[1]
def test_lbfgs_py(self):
res = lbfgs_py(self.x0, self.pot.getEnergyGradient)
self.assertAlmostEqual(self.E, res[1], 4)
def test_mylbfgs(self):
res = mylbfgs(self.x0, self.pot.getEnergyGradient)
self.assertAlmostEqual(self.E, res[1], 4)
def test_fire(self):
res = fire(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
def test_lbfgs_scipy(self):
res = lbfgs_scipy(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
def test_bfgs_scipy(self):
res = bfgs(self.x0, self.pot.getEnergyGradient, tol=1e-7)
self.assertAlmostEqual(self.E, res[1], 4)
print "times", n, time1, time2, time3, time4
sys.stdout.flush()
def plot_hist(hess):
import pylab as pl
pl.hist(np.log10(np.abs(hess.reshape(-1))))
pl.show()
if __name__ == "__main__":
from pygmin.systems import LJCluster
natoms = 30
system = LJCluster(natoms)
pot = system.get_potential()
coords = system.get_random_configuration()
xmin = system.get_random_minimized_configuration()[0]
e, g, h = pot.getEnergyGradientHessian(xmin)
evals = get_eigvals(h)
print evals
quencher = system.get_minimizer(tol=10.)
coords = quencher(coords)[0]
e, g, h = pot.getEnergyGradientHessian(coords)
w1, v1 = get_smallest_eig(h)
print w1
w, v = get_smallest_eig_arpack(h)
print w
w2, v2 = get_smallest_eig_sparse(h)
print w2, w2 / w1
if __name__ == '__main__':
unittest.main()
if __name__ == "__main__":
from pygmin.systems import LJCluster
natoms = 20
rho = .5
boxl = (float(natoms) / rho)**(1./3)
boxlengths = np.ones(3) * boxl
permlist = [range(natoms)]
measure = MeasurePeriodic(boxlengths, permlist)
system = LJCluster(natoms)
x1 = system.get_random_configuration()
x2 = x1.copy()
x2 = randomly_permute(x2, permlist)
exact_match = ExactMatchPeriodic(measure)
em = exact_match.are_exact(x1, x2)
print em
unittest.main()
else:
faccept = float(ndiff_accept) / ndiff
if faccept > self.target_new_min_accept_prob:
driver.acceptTest.temperature *= self.Tfactor
else:
driver.acceptTest.temperature /= self.Tfactor
if self.verbose:
print " temperature is now %.4g ratio %.4g target %.4g" % (driver.acceptTest.temperature,
faccept, self.target_new_min_accept_prob)
if __name__ == "__main__":
import numpy as np
from pygmin.takestep import displace
from pygmin.systems import LJCluster
#from pygmin.takestep import adaptive
natoms = 38
sys = LJCluster(natoms=38)
# random initial coordinates
coords = sys.get_random_configuration()
takeStep = displace.RandomDisplacement( stepsize=0.4 )
tsAdaptive = AdaptiveStepsizeTemperature(takeStep, interval=300, verbose=True)
db = sys.create_database()
opt = sys.get_basinhopping(database=db, takestep=tsAdaptive, coords=coords)
opt.printfrq = 50
opt.run(5000)
