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 test():
from pygmin.systems import LJCluster
natoms = 13
system = LJCluster(natoms)
db = system.create_database()
# get some minima
bh = system.get_basinhopping(database=db, outstream=None)
bh.run(100)
manager = ConnectManager(db, clust_min=2)
for i in range(4):
min1, min2 = manager.get_connect_job(strategy="random")
print "connecting", min1._id, min2._id
connect = system.get_double_ended_connect(min1, min2, db, verbosity=0)
connect.connect()
print "\n\ntesting untrap"
for i in range(10):
min1, min2 = manager.get_connect_job(strategy="untrap")
print min1._id, min2._id
print "\n\ntesting combine"
for i in range(5):
min1, min2 = manager.get_connect_job(strategy="combine")
print min1._id, min2._id
print "\n\ntesting gmin"
for i in range(5):
min1, min2 = manager.get_connect_job(strategy="gmin")
print min1._id, min2._id
def guessts(coords1, coords2, pot):
from pygmin.optimize import lbfgs_py as quench
# from pygmin.mindist.minpermdist_stochastic import minPermDistStochastic as mindist
from pygmin.transition_states import NEB
from pygmin.systems import LJCluster
ret1 = quench(coords1, pot.getEnergyGradient)
ret2 = quench(coords2, pot.getEnergyGradient)
coords1 = ret1[0]
coords2 = ret2[0]
natoms = len(coords1) / 3
system = LJCluster(natoms)
mindist = system.get_mindist()
dist, coords1, coords2 = mindist(coords1, coords2)
print "dist", dist
print "energy coords1", pot.getEnergy(coords1)
print "energy coords2", pot.getEnergy(coords2)
from pygmin.transition_states import InterpolatedPath
neb = NEB(InterpolatedPath(coords1, coords2, 20), pot)
#neb.optimize(quenchParams={"iprint" : 1})
neb.optimize(iprint=-30, nsteps=100)
neb.MakeAllMaximaClimbing()
#neb.optimize(quenchParams={"iprint": 30, "nsteps":100})
for i in xrange(len(neb.energies)):
if (neb.isclimbing[i]):
coords = neb.coords[i, :]
return pot, coords, neb.coords[0, :], neb.coords[-1, :]
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 test(Connect=DoubleEndedConnect, natoms=16):
# from pygmin.landscape import TSGraph
# from pygmin.storage.database import Database
from pygmin.systems import LJCluster
#get min1
system = LJCluster(natoms)
pot, database = getSetOfMinLJ(system)
# from pygmin.potentials.lj import LJ
# pot = LJ()
# saveit = Database(db="test.db")
minima = database.minima()
min1 = minima[0]
min2 = minima[1]
print min1.energy, min2.energy
mindist = system.get_mindist()
if False:
#test to see if min1 and min2 are already connected
connected = graph.areConnected(min1, min2)
print "at start are minima connected?", connected
return
connect = Connect(min1, min2, pot, mindist, database)
connect.connect()
graph = connect.graph
if False:
print graph
for node in graph.graph.nodes():
print node._id, node.energy
for ts in graph.storage.transition_states():
print ts.minimum1._id, ts.minimum2._id, "E", ts.minimum1.energy, ts.minimum2.energy, ts.energy
ret = graph.getPath(min1, min2)
if ret is None:
print "no path found"
return
distances, path = ret
with open("path.out", "w") as fout:
for i in range(len(path) - 1):
m1 = path[i]
m2 = path[i + 1]
n1 = m1._id
m2 = m2._id
# ts = graph._getTS(n1, n2)
# print "path", n1, "->", n2, m1.E, "/->", ts.E, "\->", m2.E
fout.write("%f\n" % m1.energy)
fout.write("%f\n" % ts.energy)
m2 = path[-1]
n2 = m2._id
fout.write("%f\n" % m2.energy)
def setUp(self):
from pygmin.systems import LJCluster
natoms = 10
self.system = LJCluster(natoms)
system = self.system
self.pot = system.get_potential()
quencher = system.get_minimizer(tol=2.)
x = system.get_random_configuration()
ret = quencher(x)
self.x = ret[0]
self.xmin = system.get_random_minimized_configuration()[0]
e, g, self.h = self.pot.getEnergyGradientHessian(self.x)
e, g, self.hmin = self.pot.getEnergyGradientHessian(self.xmin)
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 spawnlj(**kwargs):
from pygmin.systems import LJCluster
from pygmin.config import config
import os
natoms = 13
sys = LJCluster(natoms)
db = sys.create_database()
x1, E1 = sys.get_random_minimized_configuration()[:2]
x2, E2 = sys.get_random_minimized_configuration()[:2]
m1 = db.addMinimum(E1, x1)
m2 = db.addMinimum(E2, x2)
optim = "/home/js850/git/OPTIM/source/build/OPTIM"
optim = config.get("exec", "OPTIM")
optim = os.path.expandvars(os.path.expanduser(optim))
spawner = SpawnOPTIM_LJ(x1, x2, sys, OPTIM=optim, **kwargs)
spawner.run()
spawner.load_results(db)
def get_database(natoms=13, nconn=5):
"""create a database for a lennard jones system
fill it with minima from a basinhopping run, then connect
some of those minima using DoubleEndedConnect
"""
ljsys = LJCluster(natoms)
db = ljsys.create_database()
bh = ljsys.get_basinhopping(database=db, outstream=None)
while (len(db.minima()) < nconn + 1):
bh.run(100)
minima = list(db.minima())
m1 = minima[0]
for m2 in minima[1:nconn + 1]:
connect = ljsys.get_double_ended_connect(m1, m2, db)
connect.connect()
return db
# 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
#########################################################################
return self.acceptstep, self.trial_coords, self.trial_energy
def printStep(self):
if self.stepnum % self.printfrq == 0:
if self.outstream != None:
self.outstream.write("Qu " + str(self.stepnum) + " E= " +
str(self.trial_energy) +
" quench_steps= " + str(self.funcalls) +
" RMS= " + str(self.rms) + " Markov E= " +
str(self.markovE_old) + " accepted= " +
str(self.acceptstep) + "\n")
def __getstate__(self):
ddict = self.__dict__.copy()
del ddict["outstream"]
del ddict["potential"]
return ddict #.items()
def __setstate__(self, dct):
self.__dict__.update(dct)
self.outstream = sys.stdout
if __name__ == "__main__":
from pygmin.systems import LJCluster
natoms = 13
sys = LJCluster(natoms)
bh = sys.get_basinhopping()
bh.run(100)
def create_system():
natoms = 38
system = LJCluster(natoms)
return system
import scipy import numpy as np from pygmin.systems import LJCluster from pygmin.mindist import ExactMatchAtomicCluster from pygmin.mindist import PointGroupOrderCluster from pygmin.thermodynamics import normalmode_frequencies, logproduct_freq2 beta = 1. system = LJCluster(13) db = system.create_database() pot = system.get_potential() bh = system.get_basinhopping(database=db) bh.run(50) min1 = db.minima()[0] coords = min1.coords print print "Done with basinghopping, performing frequency analysis" print #min1 = db.transition_states()[0] # determine point group order of system determine_pgorder = PointGroupOrderCluster(system.get_compare_exact()) pgorder = determine_pgorder(min1.coords) # free energy from symmetry Fpg = np.log(pgorder) / beta # get the hession e, g, hess = pot.getEnergyGradientHessian(min1.coords)
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)
def setUp(self):
natoms = 6
self.system = LJCluster(natoms)
self.e1 = -12.7120622568
self.e2 = -12.302927529580728
