def test_binary_LJ(natoms=12, **kwargs):
import pygmin.defaults
import pygmin.utils.rotations as rot
quench = pygmin.defaults.quenchRoutine
printlist = []
ntypea = int(natoms * .8)
from pygmin.potentials.ljpshift import LJpshift
lj = LJpshift(natoms, ntypea)
permlist = [range(ntypea), range(ntypea, natoms)]
X1 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3) / 2
printlist.append((X1.copy(), "very first"))
#quench X1
ret = quench(X1, lj.getEnergyGradient)
X1 = ret[0]
printlist.append((X1.copy(), "after quench"))
X2 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3)
#make X2 a rotation of X1
print "testing with", natoms, "atoms,", ntypea, "type A 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])
printlist.append((X2.copy(), "x2 after rotation"))
import random, copy
from pygmin.mindist.permutational_alignment import permuteArray
for atomlist in permlist:
perm = copy.copy(atomlist)
random.shuffle(perm)
print perm
X2 = permuteArray(X2, perm)
printlist.append((X2.copy(), "x2 after permutation"))
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
X1i = copy.copy(X1)
X2i = copy.copy(X2)
atomtypes = ["N" for i in range(ntypea)]
for i in range(natoms - ntypea):
atomtypes.append("O")
print "******************************"
print "testing binary LJ ISOMER"
print "******************************"
test(X1, X2, lj, atomtypes=atomtypes, permlist=permlist, **kwargs)
print "******************************"
print "testing binary LJ non isomer"
print "******************************"
X2 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3)
ret = quench(X2, lj.getEnergyGradient)
X2 = ret[0]
test(X1, X2, lj, atomtypes=atomtypes, permlist=permlist, **kwargs)
def testBLJ_isomer(self):
"""
test with BLJ potential. We have two classes of permutable atoms
test case where X2 is an isomer of X1.
"""
import pygmin.utils.rotations as rot
X1i = np.copy(self.X1)
X1 = np.copy(self.X1)
X2 = np.copy(X1)
#rotate X2 randomly
aa = rot.random_aa()
rot_mx = rot.aa2mx(aa)
for j in range(self.natoms):
i = 3 * j
X2[i:i + 3] = np.dot(rot_mx, X1[i:i + 3])
#permute X2
import random, copy
from pygmin.mindist.permutational_alignment import permuteArray
for atomlist in self.permlist:
perm = copy.copy(atomlist)
random.shuffle(perm)
X2 = permuteArray(X2, perm)
X2i = np.copy(X2)
#distreturned, X1, X2 = self.runtest(X1, X2)
distreturned, X1, X2 = self.runtest(X1, X2, minPermDistStochastic)
#it's an isomer, so the distance should be zero
self.assertTrue(
abs(distreturned) < 1e-14,
"didn't find isomer: dist = %g" % (distreturned))
def testBLJ_isomer(self):
"""
test with BLJ potential. We have two classes of permutable atoms
test case where X2 is an isomer of X1.
"""
import pygmin.utils.rotations as rot
X1i = np.copy(self.X1)
X1 = np.copy(self.X1)
X2 = np.copy(X1)
#rotate X2 randomly
aa = rot.random_aa()
rot_mx = rot.aa2mx( aa )
for j in range(self.natoms):
i = 3*j
X2[i:i+3] = np.dot( rot_mx, X1[i:i+3] )
#permute X2
import random, copy
from pygmin.mindist.permutational_alignment import permuteArray
for atomlist in self.permlist:
perm = copy.copy(atomlist)
random.shuffle( perm )
X2 = permuteArray( X2, perm)
X2i = np.copy(X2)
#distreturned, X1, X2 = self.runtest(X1, X2)
distreturned, X1, X2 = self.runtest(X1, X2, minPermDistStochastic)
#it's an isomer, so the distance should be zero
self.assertTrue( abs(distreturned) < 1e-14, "didn't find isomer: dist = %g" % (distreturned) )
def test_LJ(natoms = 12, **kwargs):
from pygmin.potentials.lj import LJ
from pygmin.optimize import mylbfgs
import pygmin.utils.rotations as rot
from pygmin.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 = range(natoms)
random.shuffle( perm )
print perm
X2 = permuteArray( X2, perm)
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
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
def test_LJ(natoms=12, **kwargs):
from pygmin.potentials.lj import LJ
from pygmin.optimize import mylbfgs
import pygmin.utils.rotations as rot
from pygmin.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 = range(natoms)
random.shuffle(perm)
print perm
X2 = permuteArray(X2, perm)
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
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
def test_LJ(natoms = 12, **kwargs):
from pygmin.potentials.lj import LJ
import pygmin.defaults
import pygmin.utils.rotations as rot
from pygmin.mindist.permutational_alignment import permuteArray
import random
quench = pygmin.defaults.quenchRoutine
lj = LJ()
X1 = np.random.uniform(-1,1,[natoms*3])*(float(natoms))**(1./3)
#quench X1
ret = quench( X1, lj.getEnergyGradient)
X1 = ret[0]
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 = range(natoms)
random.shuffle( perm )
print perm
X2 = permuteArray( X2, perm)
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
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.getEnergyGradient)
X2 = ret[0]
test(X1, X2, lj, **kwargs)
distinit = np.linalg.norm(X1-X2)
print "distinit", distinit
def test_LJ(natoms=12, **kwargs):
from pygmin.potentials.lj import LJ
import pygmin.defaults
import pygmin.utils.rotations as rot
from pygmin.mindist.permutational_alignment import permuteArray
import random
quench = pygmin.defaults.quenchRoutine
lj = LJ()
X1 = np.random.uniform(-1, 1, [natoms * 3]) * (float(natoms))**(1. / 3)
#quench X1
ret = quench(X1, lj.getEnergyGradient)
X1 = ret[0]
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 = range(natoms)
random.shuffle(perm)
print perm
X2 = permuteArray(X2, perm)
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
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.getEnergyGradient)
X2 = ret[0]
test(X1, X2, lj, **kwargs)
distinit = np.linalg.norm(X1 - X2)
print "distinit", distinit
def test_binary_LJ(natoms = 12, **kwargs):
import pygmin.defaults
import pygmin.utils.rotations as rot
quench = pygmin.defaults.quenchRoutine
printlist = []
ntypea = int(natoms*.8)
from pygmin.potentials.ljpshift import LJpshift
lj = LJpshift(natoms, ntypea)
permlist = [range(ntypea), range(ntypea, natoms)]
X1 = np.random.uniform(-1,1,[natoms*3])*(float(natoms))**(1./3)/2
printlist.append( (X1.copy(), "very first"))
#quench X1
ret = quench( X1, lj.getEnergyGradient)
X1 = ret[0]
printlist.append((X1.copy(), "after quench"))
X2 = np.random.uniform(-1,1,[natoms*3])*(float(natoms))**(1./3)
#make X2 a rotation of X1
print "testing with", natoms, "atoms,", ntypea, "type A 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] )
printlist.append((X2.copy(), "x2 after rotation"))
import random, copy
from pygmin.mindist.permutational_alignment import permuteArray
for atomlist in permlist:
perm = copy.copy(atomlist)
random.shuffle( perm )
print perm
X2 = permuteArray( X2, perm)
printlist.append((X2.copy(), "x2 after permutation"))
#X1 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 0., 1.,] )
#X2 = np.array( [ 0., 0., 0., 1., 0., 0., 0., 1., 0.,] )
X1i = copy.copy(X1)
X2i = copy.copy(X2)
atomtypes = ["N" for i in range(ntypea)]
for i in range(natoms-ntypea):
atomtypes.append("O")
print "******************************"
print "testing binary LJ ISOMER"
print "******************************"
test(X1, X2, lj, atomtypes=atomtypes, permlist = permlist, **kwargs)
print "******************************"
print "testing binary LJ non isomer"
print "******************************"
X2 = np.random.uniform(-1,1,[natoms*3])*(float(natoms))**(1./3)
ret = quench( X2, lj.getEnergyGradient)
X2 = ret[0]
test(X1, X2, lj, atomtypes=atomtypes, permlist=permlist, **kwargs)