class LJTest(unittest.TestCase): def setUp(self): self.natoms = 10 self.coords = np.random.uniform(-1,1.,3*self.natoms) * self.natoms**(-1./3) self.pot = LJ() self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords) import itertools self.ilist = [] #np.zeros([self.natoms*(self.natoms-1)/2, 2]) k = 0 for i in range(self.natoms): for j in range(i): k += 1 self.ilist.append( [i,j] ) self.ilist = np.array(self.ilist) #print self.ilist def test_grad_e(self): self.assertAlmostEqual(self.E, self.Egrad, 7) def test_lists_e(self): e = self.pot.getEnergyList(self.coords, self.ilist) self.assertAlmostEqual(self.E, e, 7) def test_lists_eg(self): e, g = self.pot.getEnergyGradientList(self.coords, self.ilist) self.assertAlmostEqual(self.E, e, 7) gdiffmax = np.max(np.abs( g-self.grad )) / np.max(np.abs(self.grad)) self.assertLess(gdiffmax, 1e-7)
class LJTest(unittest.TestCase): def setUp(self): self.natoms = 10 self.coords = np.random.uniform(-1, 1., 3 * self.natoms) * self.natoms ** (-1. / 3) self.pot = LJ() self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords) self.ilist = [] # np.zeros([self.natoms*(self.natoms-1)/2, 2]) k = 0 for i in range(self.natoms): for j in range(i): k += 1 self.ilist.append([i, j]) self.ilist = np.array(self.ilist) # print self.ilist def test_grad_e(self): self.assertAlmostEqual(self.E, self.Egrad, 7) def test_lists_e(self): e = self.pot.getEnergyList(self.coords, self.ilist) self.assertAlmostEqual(self.E, e, 7) def test_lists_eg(self): e, g = self.pot.getEnergyGradientList(self.coords, self.ilist) self.assertAlmostEqual(self.E, e, 7) gdiffmax = np.max(np.abs(g - self.grad)) / np.max(np.abs(self.grad)) self.assertLess(gdiffmax, 1e-7)
def setUp(self): from pele.optimize import mylbfgs self.natoms = 10 self.coords = np.random.uniform(-1, 1., 3 * self.natoms) * self.natoms ** (-1. / 3) self.pot = LJ() ret = mylbfgs(self.coords, self.pot, tol=2.) self.coords = ret.coords self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords)
def setUp(self): self.natoms = 10 self.coords = np.random.uniform(-1, 1., 3 * self.natoms) * self.natoms ** (-1. / 3) self.pot = LJ() self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords) self.ilist = [] # np.zeros([self.natoms*(self.natoms-1)/2, 2]) k = 0 for i in range(self.natoms): for j in range(i): k += 1 self.ilist.append([i, j]) self.ilist = np.array(self.ilist)
def setUp(self): from pele.optimize import mylbfgs self.natoms = 10 self.coords = np.random.uniform(-1,1.,3*self.natoms) * self.natoms**(-1./3) self.pot = LJ() ret = mylbfgs(self.coords, self.pot, tol=2.) self.coords = ret.coords self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords)
def test(): natoms = 100 tol = 1e-6 from pele.potentials.lj import LJ pot = LJ() X = getInitialCoords(natoms, pot) X += np.random.uniform(-1,1,[3*natoms]) * 0.3 #do some steepest descent steps so we don't start with a crazy structure #from optimize.quench import _steepest_descent as steepestDescent #ret = steepestDescent(X, pot.getEnergyGradient, iprint = 1, dx = 1e-4, nsteps = 100, gtol = 1e-3, maxstep = .5) #X = ret[0] #print X Xinit = np.copy(X) e, g = pot.getEnergyGradient(X) print "energy", e lbfgs = BFGS(X, pot, maxstep = 0.1) ret = lbfgs.run(100, tol = tol, iprint=1) print "done", ret[1], ret[2], ret[3] print "now do the same with scipy lbfgs" from pele.optimize import lbfgs_scipy as quench ret = quench(Xinit, pot.getEnergyGradient, tol = tol) print ret[1], ret[2], ret[3] print "now do the same with scipy bfgs" from pele.optimize import bfgs as oldbfgs ret = oldbfgs(Xinit, pot.getEnergyGradient, tol = tol) print ret[1], ret[2], ret[3] print "now do the same with old gradient + linesearch" gpl = GradientPlusLinesearch(Xinit, pot, maxstep = 0.1) ret = gpl.run(100, tol = 1e-6) print ret[1], ret[2], ret[3]
def test_LJ(natoms=12, **kwargs): # pragma: no cover from pele.potentials.lj import LJ from pele.optimize import mylbfgs import pele.utils.rotations as rot from pele.mindist.permutational_alignment import permuteArray import random quench = mylbfgs lj = LJ() X1 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3) # quench X1 ret = quench(X1, lj) X1 = ret.coords X2 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3) # make X2 a rotation of X1 print("testing with", natoms, "atoms, with X2 a rotated and permuted isomer of X1") aa = rot.random_aa() rot_mx = rot.aa2mx(aa) for j in range(natoms): i = 3 * j X2[i:i + 3] = np.dot(rot_mx, X1[i:i + 3]) perm = list(range(natoms)) random.shuffle(perm) print(perm) X2 = permuteArray(X2, perm) import copy X1i = copy.copy(X1) X2i = copy.copy(X2) print("******************************") print("testing normal LJ ISOMER") print("******************************") test(X1, X2, lj, **kwargs) print("******************************") print("testing normal LJ non isomer") print("******************************") X2 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3) ret = quench(X2, lj) X2 = ret.coords Y = X1.reshape([-1, 3]) Y += np.random.random(3) X1[:] = Y.flatten() test(X1, X2, lj, **kwargs) distinit = np.linalg.norm(X1 - X2) print("distinit", distinit)
class TestLJAfterQuench(unittest.TestCase): """do the tests after a short quench so that the energies are not crazy large """ def setUp(self): from pele.optimize import mylbfgs self.natoms = 10 self.coords = np.random.uniform(-1, 1., 3 * self.natoms) * self.natoms ** (-1. / 3) self.pot = LJ() ret = mylbfgs(self.coords, self.pot, tol=2.) self.coords = ret.coords self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords) def test_gradient(self): e0 = self.pot.getEnergy(self.coords) e, g, hess = self.pot.getEnergyGradientHessian(self.coords) gnum = self.pot.NumericalDerivative(self.coords) maxg = np.max(np.abs(g)) maxgdiff = np.max(np.abs(g - gnum)) self.assertAlmostEqual(e0, e, 5) self.assertLess(maxgdiff / maxg, 1e-5) def test_hessian(self): e, g, hess = self.pot.getEnergyGradientHessian(self.coords) nhess = self.pot.NumericalHessian(self.coords, eps=1e-8) # print "hess", hess # print "numerical", nhess # diff = hess - nhess maxhess = np.max(np.abs(hess)) maxdiff = np.max(np.abs(hess - nhess)) # print "diff", hess[:2,:2] - nhess[:2,:2] # print maxhess, maxdiff, maxdiff / maxhess # print "diff", (hess[:2,:2] - nhess[:2,:2])/maxhess # print "diff", (hess - nhess)/maxhess # print np.max(np.abs((hess-nhess)/nhess)) self.assertLess(maxdiff / maxhess, 1e-5)
""" an example for finding the minimum distance and best alignment between two lennard jones clusters """ from __future__ import print_function from builtins import range import numpy as np from pele.potentials.lj import LJ from pele.optimize import lbfgs_py from pele.mindist import MinPermDistAtomicCluster pot = LJ() natoms = 40 # get two random quenched structures to compare coords1 = np.random.rand(natoms * 3) * natoms ** (1. / 3) * 1.5 coords2 = np.random.rand(natoms * 3) * natoms ** (1. / 3) * 1.5 ret1 = lbfgs_py(coords1, pot) ret2 = lbfgs_py(coords2, pot) coords1 = ret1.coords coords2 = ret2.coords # all the atoms are permutable permlist = [list(range(natoms))] mindist = MinPermDistAtomicCluster(niter=100, permlist=permlist, verbose=False) dist, newcoords1, newcoords2 = mindist(coords1, coords2) print("")
import numpy as np #from potentials.soft_sphere import SoftSphere, putInBox from pele.potentials.lj import LJ as SoftSphere np.random.seed(0) natoms = 120 rho = 1.6 boxl = 1. meandiam = boxl / (float(natoms)/rho)**(1./3) print "mean diameter", meandiam #set up potential #diams = np.array([meandiam for i in range(natoms)]) #make them all the same #pot = SoftSphere(diams = diams) pot = SoftSphere() #initial coordinates coords = np.random.uniform(-1,1,[natoms*3]) * (natoms)**(1./3) E = pot.getEnergy(coords) print "initial energy", E printlist = [] #list of coordinates saved for printing printlist.append((coords.copy(), "intial coords")) #test a quench with default lbfgs #from optimize.quench import quench from pele.optimize import lbfgs_ase as quench
def testpot1(): from pele.potentials.lj import LJ import itertools pot = LJ() a = 1.12 #2.**(1./6.) theta = 60./360*np.pi coords = [ 0., 0., 0., \ -a, 0., 0., \ -a/2, a*np.cos(theta), 0., \ -a/2, -a*np.cos(theta), 0.1 \ ] natoms = len(coords)/3 c = np.reshape(coords, [-1,3]) for i, j in itertools.combinations(range(natoms), 2): r = np.linalg.norm(c[i,:] - c[j,:]) print i, j, r e, g = pot.getEnergyGradient(coords) print "initial E", e print "initial G", g, np.linalg.norm(g) eigpot = LowestEigPot(coords, pot) vec = np.random.rand(len(coords)) e, g = eigpot.getEnergyGradient(vec) print "eigenvalue", e print "eigenvector", g if True: e, g, hess = pot.getEnergyGradientHessian(coords) print "shape hess", np.shape(hess) print "hessian", hess u, v = np.linalg.eig(hess) print "max imag value", np.max(np.abs(u.imag)) print "max imag vector", np.max(np.abs(v.imag)) u = u.real v = v.real print "eigenvalues", u for i in range(len(u)): print "eigenvalue", u[i], "eigenvector", v[:,i] #find minimum eigenvalue, vector imin = 0 umin = 10. for i in range(len(u)): if np.abs(u[i]) < 1e-10: continue if u[i] < umin: umin = u[i] imin = i print "lowest eigenvalue ", umin, imin print "lowest eigenvector", v[:,imin] from pele.optimize import lbfgs_py as quench ret = quench(vec, eigpot.getEnergyGradient, iprint=10, tol = 1e-5, maxstep = 1e-3, \ rel_energy = True) print ret print "lowest eigenvalue " print umin, imin print "lowest eigenvector" print v[:,imin] print "now the estimate" print ret[1] print ret[0]