def testGradient(self):
natoms = 10
coords = np.random.uniform(-1, 1, natoms * 3) * 2
atlj = ATLJ(Z=3.)
e, Gf = atlj.getEnergyGradientFortran(coords)
Gn = atlj.NumericalDerivative(coords)
print(Gf)
print(Gn)
maxdiff = np.max(np.abs(Gf - Gn))
maxnorm = np.max(np.abs(Gf + Gn)) / 2
maxrel = np.max(np.abs((Gf - Gn) / (Gf + Gn) * 2.))
print("maximum relative difference in gradients", maxdiff, maxdiff / maxnorm)
self.assertTrue(maxdiff / maxnorm < 1e-4, "ATLJ: gradient differs from numerical gradient by %g" % maxdiff)
def testCoords(coordslist, Z=2.0, opt_class=LBFGS_CPP):
# quench.gtol = 1.e-5
pot = ATLJ(Z=Z)
finish = []
count = 0
ntot = len(coordslist)
optimizer_initialized = False
for coords, Xp in coordslist:
if optimizer_initialized is False:
optimizer = opt_class(coords, pot, T=5)
optimizer_initialized = True
else:
optimizer.reset(coords)
if count % 1000 == 0:
print("quenching", count, "out of", ntot)
count += 1
initen = pot.getEnergy(coords)
ret = optimizer.run(5)
coordsnew = ret.coords
print(ret.nfev)
finish.append((Xp, OrderParam(xyz2internal(coordsnew)), initen))
with open("finish_radford_main.pkl", "wb") as f:
pickle.dump(finish, f)
print("this works")
# from pele.utils.xyz import printAtomsXYZ as printxyz
# with open("finishradford.xyz","w") as fout:
# for ret in finish:
# coords= ret[2]
# e = ret[3]
# printxyz(fout, coords, line2=str(e))
return finish
def testGradient(self):
natoms = 10
coords = np.random.uniform(-1, 1, natoms * 3) * 2
atlj = ATLJ(Z=3.)
e, Gf = atlj.getEnergyGradientFortran(coords)
Gn = atlj.NumericalDerivative(coords)
print Gf
print Gn
maxdiff = np.max(np.abs(Gf - Gn))
maxnorm = np.max(np.abs(Gf + Gn)) / 2
maxrel = np.max(np.abs((Gf - Gn) / (Gf + Gn) * 2.))
print "maximum relative difference in gradients", maxdiff, maxdiff / maxnorm
self.assertTrue(
maxdiff / maxnorm < 1e-4,
"ATLJ: gradient differs from numerical gradient by %g" % maxdiff)
def testenergy(self):
natoms = 10
coords = np.random.uniform(-1,1,natoms*3)*2
from pele.optimize import mylbfgs as quench
lj = LJ()
ret = quench(coords, lj)
coords = ret.coords
atlj = ATLJ(Z=3.)
e2 = atlj.getEnergySlow(coords)
# e1 = atlj.getEnergyWeave(coords)
# #print "%g - %g = %g" % (e1, e2, e1-e2)
# self.assertTrue( abs(e1 - e2) < 1e-12, "ATLJ: two energy methods give different results: %g - %g = %g" % (e1, e2, e1-e2) )
e1 = atlj.getEnergyFortran(coords)
#print "%g - %g = %g" % (e1, e2, e1-e2)
#print e1/e2
self.assertTrue( abs(e1 - e2) < 1e-12, "ATLJ: fortran energy gives different results: %g - %g = %g" % (e1, e2, e1-e2) )
def testenergy(self):
natoms = 10
coords = np.random.uniform(-1, 1, natoms * 3) * 2
from pele.optimize import mylbfgs as quench
lj = LJ()
ret = quench(coords, lj)
coords = ret.coords
atlj = ATLJ(Z=3.)
e2 = atlj.getEnergySlow(coords)
# e1 = atlj.getEnergyWeave(coords)
# #print "%g - %g = %g" % (e1, e2, e1-e2)
# self.assertTrue( abs(e1 - e2) < 1e-12, "ATLJ: two energy methods give different results: %g - %g = %g" % (e1, e2, e1-e2) )
e1 = atlj.getEnergyFortran(coords)
#print "%g - %g = %g" % (e1, e2, e1-e2)
#print e1/e2
self.assertTrue(
abs(e1 - e2) < 1e-12,
"ATLJ: fortran energy gives different results: %g - %g = %g" %
(e1, e2, e1 - e2))
def testCoordsquench(coordslist,
Z=2.0,
quench=ode_julia_naive,
precision=10,
opt_class=LBFGS_CPP):
""" Compares to the steepest descent version of the potential
"""
pot = ATLJ(Z=Z)
finish = []
count = 0
ntot = len(coordslist)
optimizer_initialized = False
correctminima = []
orderparamlist = []
nfevlist = []
nstepslist = []
for coords, Xp in coordslist:
if count % 1 == 0:
print("quenching", count, "out of", ntot)
count += 1
initen = pot.getEnergy(coords)
ret = quench(coords, pot)
coordsnew = ret.coords
nfevlist.append(ret.nfev)
nstepslist.append(ret.nsteps)
print(ret.nfev, "function evaluations")
op1 = OrderParam(xyz2internal(coordsnew))
orderparamlist.append(op1)
finish.append((Xp, OrderParam(xyz2internal(coordsnew)), initen))
print(np.average(nfevlist))
print(np.average(nstepslist))
np.savetxt(
"/home/praharsh/Dropbox/research/bv-libraries/orderparamliststeepest.txt",
orderparamlist,
delimiter=",",
)
# percent = np.average(np.array(correctminima, dtype=float))
# print(percent)
print("this works")
# from pele.utils.xyz import printAtomsXYZ as printxyz
# with open("finishradford.xyz","w") as fout:
# for ret in finish:
# coords= ret[2]
# e = ret[3]
# printxyz(fout, coords, line2=str(e))
return finish
def testCoordsquenchl(
coordslist,
Z=2.0,
quench=steepest_descent,
precision=23,
opt_class=MixedOptimizer,
T=1,
M=1,
):
""" Tests
"""
pot = ATLJ(Z=Z)
finish = []
count = 0
ntot = len(coordslist)
optimizer_initialized = False
correctminima = []
opsteep = np.loadtxt(
"/home/praharsh/Dropbox/research/bv-libraries/orderparamliststeepest.txt",
delimiter=",",
)
nfevlist = []
niterlist = []
oplist = []
# [16690:] not working nmesh=700 backtracking
for coords, Xp in coordslist:
if count % 1 == 0:
print("quenching", count, "out of", ntot)
# optimizer = opt_class(coords, pot, M=M, T=T, iprint=-1, maxstep=1, tol=1e-4)
# for steepest descent
optimizer = opt_class(coords, pot, tol=1e-4, T=10)
# optimizer_initialized = True
# optimizer = opt_class(coords, pot, M=M, T=T, iprint=-1, maxstep=1, tol = 1e-4)
# optimizer_initialized = True
initen = pot.getEnergy(coords)
optimizer.set_H0(1e-6)
ret2 = optimizer.run(100)
op1 = opsteep[count]
# op1 = 0
coordsnew2 = ret2.coords
op2 = OrderParam(xyz2internal(coordsnew2))
print(coordsnew2)
correctminima.append(op1 == op2)
# print(op1 == op2)
oplist.append(op2)
finish.append((Xp, OrderParam(xyz2internal(coordsnew2)), initen))
nfevlist.append(ret2.nfev)
print(ret2.nfev)
niterlist.append(ret2.nsteps)
count += 1
th = 1 - np.average(np.array(correctminima, dtype=float))
np.savetxt(
"/home/praharsh/Dropbox/research/bv-libraries/nfevlistM4precon.txt",
nfevlist,
delimiter=",",
)
np.savetxt(
"/home/praharsh/Dropbox/research/bv-libraries/orderparamliststeepesdescentnew.txt",
oplist,
delimiter=",",
)
print(th, "percentage of wrong minima")
# from pele.utils.xyz import printAtomsXYZ as printxyz
# with open("finishradford.xyz","w") as fout:
# for ret in finish:
# coords= ret[2]
# e = ret[3]
# printxyz(fout, coords, line2=str(e))
print(np.average(niterlist), "number of iterations")
print(np.average(nfevlist), "number of function evaluations")
return finish, np.average(nfevlist), th
struct = 3.0
else:
struct = 4.0
return struct
if __name__ == "__main__":
picklef = "finish.pkl"
Z = 2
Re = 2.0**(1.0 / 6.0)
alpha = np.sqrt(3.0) * Re
nmesh = 50
coordslist = getCoords(alpha=alpha, nmesh=nmesh)
pot = ATLJ(Z=Z)
path = "/home/praharsh/Dropbox/research/bv-libraries/tests/data"
# M = 4
# T = 1
# try:
# with open(picklef, "r") as fin:
# finish = pickle.load(fin)
# print("loading data from pickle file", picklef)
# except:
coordslist = getCoords(alpha=alpha, nmesh=nmesh)
# finish, nfevlist, correctminima = testCoordsquenchl(coordslist, Z=Z, T=T, M=M)
finish = testCoordsquench(coordslist, Z=Z)
# with open(picklef, "w") as fout:
# pickle.dump(finish, fout)
