def setUp(self):
from pygmin.landscape import DoubleEndedConnect
from pygmin.landscape._graph import create_random_database
from pygmin.systems import LJCluster
# from pygmin.mindist import minPermDistStochastic, MinDistWrapper
# from pygmin.potentials import LJ
nmin = 10
natoms=13
sys = LJCluster(natoms)
pot = sys.get_potential()
mindist = sys.get_mindist()
db = create_random_database(nmin=nmin, natoms=natoms, nts=nmin/2)
min1, min2 = list(db.minima())[:2]
connect = DoubleEndedConnect(min1, min2, pot, mindist, db, use_all_min=True,
merge_minima=True, max_dist_merge=1e100)
self.connect = connect
self.db = db
self.natoms = natoms
def setUp(self):
from pygmin.landscape import DoubleEndedConnect
from pygmin.landscape._graph import create_random_database
from pygmin.systems import LJCluster
# from pygmin.mindist import minPermDistStochastic, MinDistWrapper
# from pygmin.potentials import LJ
nmin = 10
natoms = 13
sys = LJCluster(natoms)
pot = sys.get_potential()
mindist = sys.get_mindist()
db = create_random_database(nmin=nmin, natoms=natoms, nts=nmin / 2)
min1, min2 = list(db.minima())[:2]
connect = DoubleEndedConnect(min1,
min2,
pot,
mindist,
db,
use_all_min=True,
merge_minima=True,
max_dist_merge=1e100)
self.connect = connect
self.db = db
self.natoms = natoms
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 getPairLJ(natoms=38):
from pygmin.systems import LJCluster
system = LJCluster(natoms)
ret1 = system.get_random_minimized_configuration()
ret2 = system.get_random_minimized_configuration()
coords1, coords2 = ret1[0], ret2[0]
E1, E2 = ret1[1], ret2[1]
mindist = system.get_mindist()
mindist(coords1, coords2)
return coords1, coords2, system.get_potential(), mindist, E1, E2
def getPairLJ(natoms=38):
from pygmin.systems import LJCluster
system = LJCluster(natoms)
ret1 = system.get_random_minimized_configuration()
ret2 = system.get_random_minimized_configuration()
coords1, coords2 = ret1[0], ret2[0]
E1, E2 = ret1[1], ret2[1]
mindist = system.get_mindist()
mindist(coords1, coords2)
return coords1, coords2, system.get_potential(), mindist, E1, E2
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)
self.nsteps = nsteps
self.mcstep = RandomDisplacement(stepsize=stepsize)
def takeStep(self, coords, **kwargs):
#make a new monte carlo class
mc = MonteCarlo(coords, self.potential, self.mcstep,
temperature = self.T, outstream=None)
mc.run( self.nsteps )
coords[:] = mc.coords[:]
def updateStep(self, acc, **kwargs):
pass
natoms = 12
niter = 100
system = LJCluster(natoms)
db = system.create_database()
# create takestep routine manually
potential = system.get_potential()
step = TakeStepMonteCarlo(potential)
bh = system.get_basinhopping(database=db, takestep=step)
bh.run(niter)
print "the lowest energy found after", niter, " basinhopping steps is", db.minima()[0].energy
print ""
# print "times", n, t1-t0, t2-t1, w1, w
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)
