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 guesstsATLJ():
from pygmin.potentials.ATLJ import ATLJ
pot = ATLJ(Z = 2.)
a = 1.12 #2.**(1./6.)
theta = 60./360*np.pi
coords1 = np.array([ 0., 0., 0., \
-a, 0., 0., \
-a/2, -a*np.cos(theta), 0. ])
coords2 = np.array([ 0., 0., 0., \
-a, 0., 0., \
a, 0., 0. ])
from pygmin.optimize import lbfgs_py as quench
from pygmin.transition_states import InterpolatedPath
ret1 = quench(coords1, pot.getEnergyGradient)
ret2 = quench(coords2, pot.getEnergyGradient)
coords1 = ret1[0]
coords2 = ret2[0]
from pygmin.transition_states import NEB
neb = NEB(InterpolatedPath(coords1, coords2, 30), pot)
neb.optimize()
neb.MakeAllMaximaClimbing()
#neb.optimize()
for i in xrange(len(neb.energies)):
if(neb.isclimbing[i]):
coords = neb.coords[i,:]
return pot, coords
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 guesstsATLJ():
from pygmin.potentials.ATLJ import ATLJ
pot = ATLJ(Z=2.)
a = 1.12 #2.**(1./6.)
theta = 60. / 360 * np.pi
coords1 = np.array([ 0., 0., 0., \
-a, 0., 0., \
-a/2, -a*np.cos(theta), 0. ])
coords2 = np.array([ 0., 0., 0., \
-a, 0., 0., \
a, 0., 0. ])
from pygmin.optimize import lbfgs_py as quench
from pygmin.transition_states import InterpolatedPath
ret1 = quench(coords1, pot.getEnergyGradient)
ret2 = quench(coords2, pot.getEnergyGradient)
coords1 = ret1[0]
coords2 = ret2[0]
from pygmin.transition_states import NEB
neb = NEB(InterpolatedPath(coords1, coords2, 30), pot)
neb.optimize()
neb.MakeAllMaximaClimbing()
#neb.optimize()
for i in xrange(len(neb.energies)):
if (neb.isclimbing[i]):
coords = neb.coords[i, :]
return pot, coords
if(np.linalg.norm(p2n - p1) > np.linalg.norm(p2 - p1)):
break
p2[:]=p2n
while True:
p2n = p2-n2
if(np.linalg.norm(p2n - p1) > np.linalg.norm(p2 - p1)):
break
p2[:]=p2n
defaults.NEBquenchParams["nsteps"]=2000
defaults.NEBquenchParams["maxErise"]=1e-1
defaults.NEBquenchParams["tol"]=1e-5
defaults.NEBquenchParams["iprint"]=1
defaults.NEBquenchParams["maxstep"]=.1
neb = NEB(path, pot, k=10., dneb=True, with_springenergy=True)
neb.optimize()
path = neb.coords
print np.linalg.norm(path[1] - path[0])
for x in neb.coords:
export_xyz(traj, x)
#np.savetxt("energies.txt", neb.energies)
import pylab as pl
pl.plot(neb.energies)
#pl.plot(e1)
#pl.plot(e2, "x")
defaults.NEBquenchParams["maxstep"] = 0.1
defaults.NEBquenchParams["maxErise"] = 0.1
defaults.NEBquenchParams["tol"] = 1e-6
defaults.NEBquenchRoutine = mylbfgs
k = 10.
nimages=50
dneb=True
#print coords2[-6:],coords1[-6:]
path = tip4p.get_path(system, coords1, coords2, nimages)
path_energy = [pot.getEnergy(coords) for coords in path]
# try the old neb
dump_path("interpolate.xyz", system, path)
neb = NEB(path, pot, k=k, dneb=dneb, with_springenergy = False)
neb.optimize()
neb_1 = neb.copy()
dump_path("neb1.xyz", system, neb_1.coords)
neb.optimize()
neb_2 = neb
dump_path("neb2.xyz", system, neb_2.coords)
# try the new neb
aaneb = NEB(path, pot, distance=system.neb_distance, k=k/20., dneb=dneb, with_springenergy = False)
aaneb.optimize()
aaneb_1 = aaneb.copy()
dump_path("aaneb1.xyz", system, aaneb_1.coords)
aaneb.optimize()
aaneb_2 = aaneb
decp["local_connect_params"]["NEBparams"]["NEBquenchParams"] = NEBquenchParams
decp["local_connect_params"]["NEBparams"][
"NEBquenchRoutine"] = NEBquenchRoutine
k = 10.
nimages = 50
dneb = True
#print coords2[-6:],coords1[-6:]
path = tip4p.get_path(system, coords1, coords2, nimages)
path_energy = [pot.getEnergy(coords) for coords in path]
# try the old neb
dump_path("interpolate.xyz", system, path)
neb = NEB(path, pot, k=k, dneb=dneb, with_springenergy=False)
neb.optimize()
neb_1 = neb.copy()
dump_path("neb1.xyz", system, neb_1.coords)
neb.optimize()
neb_2 = neb
dump_path("neb2.xyz", system, neb_2.coords)
# try the new neb
aaneb = NEB(path,
pot,
distance=system.neb_distance,
k=k / 20.,
dneb=dneb,
with_springenergy=False)
aaneb.optimize()
def create_NEB(pot,
coords1,
coords2,
image_density=10,
max_images=40,
iter_density=15,
NEBquenchParams=dict(),
interpolator=None,
verbose=False,
factor=1,
parallel=False,
ncores=4,
**NEBparams):
"""
a wrapper function to do the interpolation and set up the nudged elastic band object
Parameters
----------
image_density : float
how many NEB images per unit distance to use.
coords1, coords2 : array
the structures to connect with the band
max_images : int
the maximum number of NEB images
iter_density : float
NEBquenchParams : dict
parameters passed to the NEB minimization routine
NEBparams : dict
NEB setup parameters. These are passed directly to the NEB class. Use
NEBquenchParams for parameters related to the optimization of the band.
verbose : bool
factor : int
The number of images is multiplied by this factor. If the number of
images is already at it's maximum, then the number of iterations is
multiplied by this factor instead
parallel : bool
if True, then use class NEBPar to evaluate the image potentials in parallel
ncores : int
the number of cores to use. Ignored if parallel is False
interpolator : callable, optional
the function used to do the path interpolation for the NEB
Returns
-------
neb : an initialized NEB object
See Also
---------
NEB
InterpolatedPath
"""
#determine the number of images to use
dist = np.linalg.norm(coords1 - coords2)
nimages = int(max(1., dist) * image_density * factor)
if nimages > max_images:
nimages = max_images
#determine the number of iterations
NEBquenchParams = NEBquenchParams.copy()
if NEBquenchParams.has_key("nsteps"):
niter = NEBquenchParams["nsteps"]
else:
niter = int(iter_density * nimages)
NEBquenchParams["nsteps"] = niter
#if nimages is already max_images then increasing the number
#of images with factor will have no effect. so double the number of steps instead
if factor > 1. and nimages == max_images:
niter *= factor
NEBquenchParams["nsteps"] = niter
if verbose:
print " NEB: nimages", nimages
print " NEB: nsteps ", niter
if parallel:
return NEBPar(InterpolatedPath(coords1,
coords2,
nimages,
interpolator=interpolator),
pot,
quenchParams=NEBquenchParams,
ncores=ncores,
**NEBparams)
else:
return NEB(InterpolatedPath(coords1,
coords2,
nimages,
interpolator=interpolator),
pot,
quenchParams=NEBquenchParams,
**NEBparams)
while True:
p2n = p2 - n2
if (np.linalg.norm(p2n - p1) > np.linalg.norm(p2 - p1)):
break
p2[:] = p2n
NEBquenchParams = dict()
NEBquenchParams["nsteps"] = 2000
NEBquenchParams["maxErise"] = 1e-1
NEBquenchParams["tol"] = 1e-5
NEBquenchParams["iprint"] = 1
NEBquenchParams["maxstep"] = .1
neb = NEB(path,
pot,
k=10.,
dneb=True,
with_springenergy=True,
quenchParams=NEBquenchParams)
neb.optimize()
path = neb.coords
print np.linalg.norm(path[1] - path[0])
for x in neb.coords:
export_xyz(traj, x)
#np.savetxt("energies.txt", neb.energies)
import pylab as pl
pl.plot(neb.energies)
#pl.plot(e1)
