def test_pot_wrapper(self):
from pele.angleaxis import _cpp_aa
from pele.potentials import LJ
rbpot_cpp = _cpp_aa.RBPotentialWrapper(self.topology, LJ())
rbpot = RBPotentialWrapper(self.topology, LJ())
self.assertAlmostEqual(rbpot_cpp.getEnergy(self.x0),
rbpot.getEnergy(self.x0), 4)
e1, grad1 = rbpot_cpp.getEnergyGradient(self.x0)
e2, grad2 = rbpot.getEnergyGradient(self.x0)
self.assertAlmostEqual(e1, e2, 4)
for g1, g2 in zip(grad1, grad2):
self.assertAlmostEqual(g1, g2, 3)
def test2(): # pragma: no cover
import numpy as np
from pele.potentials import LJ
from pele.utils.frozen_atoms import FrozenPotWrapper
from pele.optimize import mylbfgs
natoms = 4
pot = LJ()
reference_coords = np.random.uniform(-1, 1, [3 * natoms])
print reference_coords
# freeze the first two atoms (6 degrees of freedom)
frozen_dof = range(6)
fpot = FrozenPotWrapper(pot, reference_coords, frozen_dof)
reduced_coords = fpot.coords_converter.get_reduced_coords(reference_coords)
print "the energy in the full representation:"
print pot.getEnergy(reference_coords)
print "is the same as the energy in the reduced representation:"
print fpot.getEnergy(reduced_coords)
ret = mylbfgs(reduced_coords, fpot)
print "after a minimization the energy is ", ret.energy, "and the rms gradient is", ret.rms
print "the coordinates of the frozen degrees of freedom are unchanged"
print "starting coords:", reference_coords
print "minimized coords:", fpot.coords_converter.get_full_coords(
ret.coords)
def main():
natoms = 4
pot = LJ()
reference_coords = np.random.uniform(-1, 1, [3 * natoms])
print reference_coords
# freeze the first two atoms (6 degrees of freedom)
frozen_dof = range(6)
fpot = FrozenPotWrapper(pot, reference_coords, frozen_dof)
reduced_coords = fpot.coords_converter.get_reduced_coords(reference_coords)
print "the energy in the full representation:"
print pot.getEnergy(reference_coords)
print "is the same as the energy in the reduced representation:"
print fpot.getEnergy(reduced_coords)
ret = mylbfgs(reduced_coords, fpot)
print "after a minimization the energy is ", ret.energy, "and the rms gradient is", ret.rms
print "the coordinates of the frozen degrees of freedom are unchanged"
print "starting coords:", reference_coords
print "minimized coords:", fpot.coords_converter.get_full_coords(
ret.coords)
def setup_aatopology(self):
water_sites, ref = water(self.xyzfile)
rbsystem = RBTopology()
rbsystem.add_sites(water_sites)
rbsystem.finalize_setup()
#print len(rbsystem.sites), len(rbsystem.indices)
print "I have %d water molecules in the system" % len(rbsystem.sites)
rbcoords = rbsystem.coords_adapter(np.zeros(len(rbsystem.sites)*6))
for site, com in zip(rbsystem.sites, rbcoords.posRigid):
com[:] = ref.coords[site.atom_indices[0]] - site.atom_positions[0]
pot = LJ(eps=0.1550, sig=3.1536)
# get the flattened coordinate array
print "The initial energy is", pot.getEnergy(ref.coords.flatten())
rbpot = rigidbody.RBPotentialWrapper(rbsystem, pot)
print "rbpot.getEnergy(rbcoords.coords)", rbpot.getEnergy(rbcoords.coords)
e, g = rbpot.getEnergyGradient(rbcoords.coords)
g_n = rbpot.NumericalDerivative(rbcoords.coords, eps=1e-4)
cg = rbsystem.coords_adapter(g-g_n)
# coords = rbpot.getCoords()
# nrigid = rbcoords.size / 6
# print "nrigid", nrigid
self.potential = rbpot
self.nrigid = len(rbsystem.sites)
self.render_scale = 0.3
self.atom_types = rbsystem.get_atomtypes()
def setUp(self):
self.natoms = 18
self.pot = _lj.LJ()
self.pot_comp = LJ()
x = np.random.uniform(-1, 1, 3 * self.natoms)
ret = mylbfgs(x, self.pot_comp, tol=10.)
self.x = ret.coords
def setUp(self):
self.natoms = 200
boxl = 7.
self.boxvec = [boxl] * 3
self.pot = _lj.LJ(boxvec=self.boxvec)
self.pot_comp = LJ(boxl=boxl)
x = np.random.uniform(-1, 1, 3 * self.natoms)
ret = mylbfgs(x, self.pot_comp, tol=10.)
self.x = ret.coords
def get_potential(self):
"""construct the rigid body potential"""
try:
return self.pot
except AttributeError:
# construct the potential which will compute the energy and gradient in atomistic (cartesian) coordinates
cartesian_potential = LJ()
# wrap it so it can be used with angle axis coordinates
self.pot = RBPotentialWrapper(self.aatopology.cpp_topology, cartesian_potential)
# self.aasystem.set_cpp_topology(self.pot.topology)
return self.pot
def setUp(self):
self.natoms = 18
self.ilist = np.array([(i,j) for i in range(self.natoms) for j in range(i+1,self.natoms)]).reshape(-1)
assert self.ilist.size == self.natoms*(self.natoms-1)
# print self.ilist
self.pot = _lj.LJInteractionList(self.ilist)
self.pot_comp = LJ()
x = np.random.uniform(-1,1, 3*self.natoms)
ret = mylbfgs(x, self.pot_comp, tol=10.)
self.x = ret.coords
def test1(self):
np.random.seed(0)
pot = LJ()
neb = NEBDriver(pot,
_x1,
_x2,
adjustk_freq=10,
adaptive_nimages=True,
adaptive_niter=True,
reinterpolate=10)
neb.run()
def test_to_atomistic2(self):
x0 = np.array(list(range(self.nrigid * 6)), dtype=float)
x2 = x0.reshape([-1, 3])
for p in x2[self.nrigid:, :]:
p /= np.linalg.norm(p)
atomistic = self.topology.to_atomistic(x0).flatten()
from pele.potentials import LJ
lj = LJ()
e, g = lj.getEnergyGradient(atomistic.reshape(-1))
grb = self.topology.transform_gradient(x0, g)
rbpot = RBPotentialWrapper(self.topology, lj)
print(rbpot.getEnergy(x0))
def setUp(self):
nrigid = 3
self.topology = RBTopology()
self.topology.add_sites([make_otp() for i in range(nrigid)])
self.topology.finalize_setup()
cartesian_potential = LJ()
self.pot = RBPotentialWrapper(self.topology, cartesian_potential)
self.x0 = _x03
self.x0 = np.array(self.x0)
self.e0 = -17.3387670023
assert nrigid * 6 == self.x0.size
self.x0atomistic = _x03_atomistic
self.nrigid = nrigid
def test_potential(self):
topology, atom_indices = self.make_atom_indices_python_topology()
normal_topology = self.make_normal_python_topology()
lj = LJ()
pot = pythonRBPotentialWrapper(topology, lj)
pot_normal = pythonRBPotentialWrapper(normal_topology, lj)
coords = self.get_random_rbcoords()
energy_atom_indices = pot.getEnergy(coords.copy())
energy_normal = pot_normal.getEnergy(coords.copy())
self.assertAlmostEqual(energy_atom_indices, energy_normal)
e1, gei = pot.getEnergyGradient(coords.copy())
e2, gnorm = pot_normal.getEnergyGradient(coords.copy())
assert_arrays_almost_equal(self, gei, gnorm)
def bh_no_system_class():
import numpy as np
from pele.potentials import LJ
natoms = 17
potential = LJ()
x0 = np.random.uniform(-1, 1, 3*natoms)
from pele.takestep import RandomDisplacement, AdaptiveStepsizeTemperature
displace = RandomDisplacement()
adaptive_displacement = AdaptiveStepsizeTemperature(displace)
from pele.storage import Database
database = Database("lj17.sqlite")
from pele.basinhopping import BasinHopping
bh = BasinHopping(x0, potential, adaptive_displacement, storage=database.minimum_adder)
bh.run(10)
for m in database.minima():
print m.energy
def test_cpp_potential(self):
python_topology, atom_indices = self.make_atom_indices_python_topology(
)
cpp_topology, atom_indices = self.make_atom_indices_cpp_topology(
atom_indices=atom_indices.copy())
lj = LJ()
pot_python = pythonRBPotentialWrapper(python_topology, lj)
pot_cpp = pythonRBPotentialWrapper(cpp_topology, lj)
coords = self.get_random_rbcoords()
e_python = pot_python.getEnergy(coords.copy())
e_cpp = pot_cpp.getEnergy(coords.copy())
self.assertAlmostEqual(e_python, e_cpp)
e1, g_python = pot_python.getEnergyGradient(coords.copy())
e2, g_cpp = pot_cpp.getEnergyGradient(coords.copy())
assert_arrays_almost_equal(self, g_python, g_cpp)
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 test_transform_gradient(self):
tai, atom_indices = self.make_atom_indices_python_topology()
tnorm = self.make_normal_python_topology()
coords = self.get_random_rbcoords()
aai = tai.to_atomistic(coords.copy())
anorm = tnorm.to_atomistic(coords.copy())
lj = LJ()
# atomistic_coords = np.random.uniform(-1, 1, 3*len(atom_indices))
# e, atomistic_grad = lj.getEnergyGradient(atomistic_coords)
e1, gai = lj.getEnergyGradient(aai.ravel())
e2, gnorm = lj.getEnergyGradient(anorm.ravel())
self.assertAlmostEqual(e1, e2)
assert_arrays_almost_equal(self,
gai.reshape(-1, 3)[atom_indices],
gnorm.reshape(-1, 3))
rb_gai = tai.transform_gradient(coords.copy(), gai)
rb_gnorm = tnorm.transform_gradient(coords.copy(), gnorm)
assert_arrays_almost_equal(self, rb_gai, rb_gnorm)
def setUp(self):
from pele.potentials import LJ
self.x0 = np.zeros(6)
self.x0[0] = 2.
self.pot = LJ()
# 0.3464601,-1.37722735,-1.30968712,-0.12150755,-1.02059093,1.37780291,
# -1.15472311,-0.25677839,-0.88824791,0.25781619,0.90928202,-0.35987022,
# 0.45434582,1.56354974,-1.20590082,0.41425323,1.2978406,0.67123977,
# -0.96365292,0.14063053,0.1074299,0.11754687,0.52112844,-1.41019987,
# 0.89892003,0.05030545,-0.14158607,-0.61370579,1.16407401,0.25903675,
# 0.76311679,-0.34748748,-1.16950066,0.2565447,0.01168485,1.54106553,
# 0.24769915,-1.6362588,0.5225262,-0.85826368,-1.5714381,0.73425918,
# -1.64261439,0.95488524,-0.16297967])
#===========================================================================
from pele.optimize import LBFGS_CPP
# import time
nparticles = 31
ndim = nparticles * 3
pot = LJ()
#build start configuration
# Emax = 3
# xrand = vector_random_uniform_hypersphere(ndim) * np.sqrt(2*Emax) #coordinates sampled from Pow(ndim)
# e, grad = pot.getEnergyGradient(xrand)
# lbfgs = LBFGS_CPP(xrand, pot, energy=e, gradient=grad)
# res = lbfgs.run()
# print res.coords
#start_coords6 = np.array([1,1,1,1,1,-1,1,-1,1,-1,1,1,1,-1,-1,-1,1,-1])
#Lennard-Jones 32 example
from pele.potentials import LJ
from pele.utils import read_xyz
start_coords = read_xyz(open("lj32.xyz", "r"))
temperature = 0.2
for rb in rb_sites:
rb.finalize_setup()
# define a new rigid body system
rbsystem = rigidbody.RBSystem()
rbsystem.add_sites(rb_sites)
print(len(rbsystem.sites), len(rbsystem.indices))
rbcoords = rbsystem.coords_adapter(np.zeros(len(rbsystem.sites) * 6))
for site, com in zip(rbsystem.sites, rbcoords.posRigid):
com[:] = ref.coords[site.indices[0]] - site.atom_positions[0]
# for simplicity just use a lj potential here
pot = LJ(sigma=2.)
# get the flattened coordinate array
print(pot.getEnergy(ref.coords.flatten()))
rbpot = rigidbody.RBPotentialWrapper(rbsystem, pot)
print(rbpot.getEnergy(rbcoords.coords))
e, g = rbpot.getEnergyGradient(rbcoords.coords)
g_n = rbpot.NumericalDerivative(rbcoords.coords, eps=1e-4)
cg = rbsystem.coords_adapter(g - g_n)
print(cg.posRigid)
print(cg.rotRigid)
ret = lbfgs_py(rbcoords.coords, rbpot)
print(ret.energy)
xyz.write_xyz(open("quenched.xyz", "w"),
rbsystem.to_atomistic(ret.coords),
atomtypes=ref.atomtypes)
import _pele
import numpy as np
import time
import sys
import _lj
import _lbfgs
from pele.optimize import mylbfgs
import _lj_cython
import _pythonpotential
N = int(sys.argv[2])
natoms = int(sys.argv[1])
print "benchmarking lennard jones potential, %d atoms, %d calls" % (natoms, N)
pot_old = LJ()
pot = _lj.LJ()
t0 = time.time()
for i in xrange(N):
x = 1. * (np.random.random(3 * natoms) - 0.5)
clbfgs = _lbfgs.LBFGS_CPP(pot, x, tol=1e-4)
ret = clbfgs.run()
t1 = time.time()
for i in xrange(N):
x = 1. * (np.random.random(3 * natoms) - 0.5)
ret = mylbfgs(x, pot_old, tol=1e-4)
t2 = time.time()
for rb in rb_sites:
rb.finalize_setup()
# define a new rigid body system
rbsystem = rigidbody.RBSystem()
rbsystem.add_sites(rb_sites)
print len(rbsystem.sites), len(rbsystem.indices)
rbcoords = rbsystem.coords_adapter(np.zeros(len(rbsystem.sites) * 6))
for site, com in zip(rbsystem.sites, rbcoords.posRigid):
com[:] = ref.coords[site.indices[0]] - site.atom_positions[0]
# for simplicity just use a lj potential here
pot = LJ(eps=0.1550, sig=3.1536)
# get the flattened coordinate array
print pot.getEnergy(ref.coords.flatten())
rbpot = rigidbody.RBPotentialWrapper(rbsystem, pot)
print rbpot.getEnergy(rbcoords.coords)
e, g = rbpot.getEnergyGradient(rbcoords.coords)
g_n = rbpot.NumericalDerivative(rbcoords.coords, eps=1e-4)
cg = rbsystem.coords_adapter(g - g_n)
print cg.posRigid
print cg.rotRigid
ret = lbfgs_py(rbcoords.coords, rbpot)
print ret.energy
xyz.write_xyz(open("quenched.xyz", "w"),
rbsystem.to_atomistic(ret.coords),
atomtypes=ref.atomtypes)
def __init__(self, eps=1.0, sig=1.0, Z=1.):
""" simple lennard jones potential"""
self.sig = sig
self.eps = eps
self.Z = Z
self.lj = LJ(self.sig, self.eps)
# benchmark all interface
from pele.potentials import LJ
import _pele
import numpy as np
import time
import sys
import _lj
import _lbfgs
from pele.optimize import mylbfgs
N=100
natoms=[10, 13, 20, 30, 31, 38, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150]
print "benchmarking lennard jones potential, %d atoms, %d calls", natoms, N
pot_old = LJ()
pot = _lj.LJ()
clbfgs = _lbfgs.LBFGS(pot)
res = open("results.txt", "w")
for na in natoms:
t0 = time.time()
for i in xrange(N):
x = np.random.random(3*na) - 0.5
ret = clbfgs.run(x)
t1 = time.time()
for i in xrange(N):
x = np.random.random(3*na) - 0.5
ret = mylbfgs(x, pot_old, tol=1e-5)
def get_potential(self):
return LJ()
def get_potential(self):
return LJ(self.natoms)
def get_potential(self, eps, sig, boxl=None):
# return LJ(self.natoms, sig=sig, boxl = boxl)
return LJ(eps, sig, boxl=boxl)
