示例#1
0
    def setUp(self):
        from pygmin.potentials.rigid_bodies.molecule import Molecule, setupLWOTP
        from pygmin.potentials.rigid_bodies.sandbox import RBSandbox
        from pygmin.potentials.lj import LJ
        from pygmin.optimize import lbfgs_py as quench

        #set up system
        nmol = 5
        self.nmol = nmol
        otp = setupLWOTP()
        #set up a list of molecules
        mols = [otp for i in range(nmol)]
        # define the interaction matrix for the system.
        # for LWOTP there is only one atom type, so this is trivial
        lj = LJ()
        interaction_matrix = [[lj]]
        #set up the RBSandbox object
        mysys = RBSandbox(mols, interaction_matrix)
        self.pot = mysys
        self.nsites = mysys.nsites

        self.permlist = [range(nmol)]

        self.coords1 = testmindist.randomCoordsAA(nmol)
        ret = quench(self.coords1, self.pot.getEnergyGradient)
        self.coords1 = ret[0]
示例#2
0
def dumbbell(sig1=0.35, sig2=0.65):
    """
    return a dumbell molecule.  i.e. two lj sites attached rigidly
    """
    pos1 = [0., 0., 0.5]
    pos2 = [0., 0., -0.5]
    dbel = Molecule()
    dbel.insert_site(0, pos1)
    dbel.insert_site(1, pos2)
    dbel.correctCoM()

    from pygmin.potentials.lj import LJ
    lj1 = LJ(sig=2. * sig1)
    lj2 = LJ(sig=2. * sig2)
    lj12 = LJ(sig=sig1 + sig2)
    interaction_matrix = [[lj1, lj12], [lj12, lj2]]
    return dbel, interaction_matrix
示例#3
0
文件: _bfgs.py 项目: js850/PyGMIN
def test():
    natoms = 100
    tol = 1e-6
    
    from pygmin.potentials.lj import LJ
    pot = LJ()
    
    X = getInitialCoords(natoms, pot)
    X += np.random.uniform(-1,1,[3*natoms]) * 0.3
    
    #do some steepest descent steps so we don't start with a crazy structure
    #from optimize.quench import _steepest_descent as steepestDescent
    #ret = steepestDescent(X, pot.getEnergyGradient, iprint = 1, dx = 1e-4, nsteps = 100, gtol = 1e-3, maxstep = .5)
    #X = ret[0]
    #print X

    
    Xinit = np.copy(X)
    e, g = pot.getEnergyGradient(X)
    print "energy", e
    
    lbfgs = BFGS(X, pot, maxstep = 0.1)
    
    ret = lbfgs.run(100, tol = tol, iprint=1)
    print "done", ret[1], ret[2], ret[3]
    
    print "now do the same with scipy lbfgs"
    from pygmin.optimize import lbfgs_scipy as quench
    ret = quench(Xinit, pot.getEnergyGradient, tol = tol)
    print ret[1], ret[2], ret[3]    
    
    print "now do the same with scipy bfgs"
    from pygmin.optimize import bfgs as oldbfgs
    ret = oldbfgs(Xinit, pot.getEnergyGradient, tol = tol)
    print ret[1], ret[2], ret[3]    
    
    print "now do the same with old gradient + linesearch"
    gpl = GradientPlusLinesearch(Xinit, pot, maxstep = 0.1)  
    ret = gpl.run(100, tol = 1e-6)
    print ret[1], ret[2], ret[3]    
示例#4
0
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
示例#5
0
def test_LWOTP(nmol=5):
    from pygmin.potentials.rigid_bodies.molecule import Molecule, setupLWOTP
    from pygmin.potentials.rigid_bodies.sandbox import RBSandbox
    from pygmin.potentials.lj import LJ
    from pygmin.optimize import lbfgs_py as quench

    printlist = []

    #set up system
    otp = setupLWOTP()
    #set up a list of molecules
    mols = [otp for i in range(nmol)]
    # define the interaction matrix for the system.
    # for LWOTP there is only one atom type, so this is trivial
    lj = LJ()
    interaction_matrix = [[lj]]
    #set up the RBSandbox object
    mysys = RBSandbox(mols, interaction_matrix)
    nsites = mysys.nsites

    permlist = [range(nmol)]

    #define initial coords
    coords1 = randomCoords(nmol)
    printlist.append((coords1.copy(), "very first"))
    #quench X1
    ret = quench(coords1, mysys.getEnergyGradient)
    coords1 = ret[0]

    #define initial coords2
    coords2 = randomCoords(nmol)
    printlist.append((coords2.copy(), "very first"))
    #quench X2
    ret = quench(coords2, mysys.getEnergyGradient)
    coords2 = ret[0]
    coords2in = coords2.copy()

    printlist.append((coords1.copy(), "after quench"))
    printlist.append((coords2.copy(), "after quench"))

    print "******************************"
    print "testing for OTP not isomer"
    print "******************************"
    d, c1new, c2new = test(coords1, coords2, mysys, permlist)

    print "******************************"
    print "testing for OTP ISOMER"
    print "******************************"
    coords1 = coords2in.copy()
    coords2 = c2new.copy()
    #try to reverse the permutations and symmetry operations we just applied
    test(coords1, coords2, mysys, permlist)
示例#6
0
def testpot2():
    from pygmin.potentials.lj import LJ
    import itertools
    pot = LJ()
    a = 1.12  #2.**(1./6.)
    theta = 20. / 360 * np.pi
    coords = [ 0., 0., 0., \
              -a, 0., 0., \
              a*np.cos(theta), a*np.sin(theta), 0. ]
    c = np.reshape(coords, [3, 3])
    for i, j in itertools.combinations(range(3), 2):
        r = np.linalg.norm(c[i, :] - c[j, :])
        print i, j, r
示例#7
0
def test():
    natoms = 100
    tol = 1e-6

    from pygmin.potentials.lj import LJ
    pot = LJ()

    X = getInitialCoords(natoms, pot)
    X += np.random.uniform(-1, 1, [3 * natoms]) * 0.3

    #do some steepest descent steps so we don't start with a crazy structure
    #from optimize.quench import _steepest_descent as steepestDescent
    #ret = steepestDescent(X, pot.getEnergyGradient, iprint = 1, dx = 1e-4, nsteps = 100, gtol = 1e-3, maxstep = .5)
    #X = ret[0]
    #print X

    Xinit = np.copy(X)
    e, g = pot.getEnergyGradient(X)
    print "energy", e

    lbfgs = BFGS(X, pot, maxstep=0.1)

    ret = lbfgs.run(100, tol=tol, iprint=1)
    print "done", ret[1], ret[2], ret[3]

    print "now do the same with scipy lbfgs"
    from pygmin.optimize import lbfgs_scipy as quench
    ret = quench(Xinit, pot.getEnergyGradient, tol=tol)
    print ret[1], ret[2], ret[3]

    print "now do the same with scipy bfgs"
    from pygmin.optimize import bfgs as oldbfgs
    ret = oldbfgs(Xinit, pot.getEnergyGradient, tol=tol)
    print ret[1], ret[2], ret[3]

    print "now do the same with old gradient + linesearch"
    gpl = GradientPlusLinesearch(Xinit, pot, maxstep=0.1)
    ret = gpl.run(100, tol=1e-6)
    print ret[1], ret[2], ret[3]
示例#8
0
def getSetOfMinLJ(natoms = 11): #for testing purposes
    from pygmin.potentials.lj import LJ
    pot = LJ()
    coords = np.random.uniform(-1,1,natoms*3)
    from pygmin.basinhopping import BasinHopping
    from pygmin.takestep.displace import RandomDisplacement
    from pygmin.takestep.adaptive import AdaptiveStepsize
    from pygmin.storage.savenlowest import SaveN
    saveit = SaveN(10)
    takestep1 = RandomDisplacement()
    takestep = AdaptiveStepsize(takestep1, frequency=15)
    bh = BasinHopping(coords, pot, takestep, storage=saveit, outstream=None)
    bh.run(100)
    return pot, saveit
示例#9
0
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 guesstsLJ():
    from pygmin.potentials.lj import LJ
    pot = LJ()
    natoms = 9
    coords = np.random.uniform(-1, 1, natoms * 3)
    from pygmin.basinhopping import BasinHopping
    from pygmin.takestep.displace import RandomDisplacement
    from pygmin.takestep.adaptive import AdaptiveStepsize
    from pygmin.storage.savenlowest import SaveN
    saveit = SaveN(10)
    takestep1 = RandomDisplacement()
    takestep = AdaptiveStepsize(takestep1, frequency=15)
    bh = BasinHopping(coords, pot, takestep, storage=saveit, outstream=None)
    bh.run(100)
    coords1 = saveit.data[0].coords
    coords2 = saveit.data[1].coords

    return guessts(coords1, coords2, pot)
示例#11
0
def testpot1():
    from pygmin.potentials.lj import LJ
    import itertools
    pot = LJ()
    a = 1.12  #2.**(1./6.)
    theta = 60. / 360 * np.pi
    coords = [ 0., 0., 0., \
              -a, 0., 0., \
              -a/2, a*np.cos(theta), 0., \
              -a/2, -a*np.cos(theta), 0.1 \
              ]
    natoms = len(coords) / 3
    c = np.reshape(coords, [-1, 3])
    for i, j in itertools.combinations(range(natoms), 2):
        r = np.linalg.norm(c[i, :] - c[j, :])
        print i, j, r

    e, g = pot.getEnergyGradient(coords)
    print "initial E", e
    print "initial G", g, np.linalg.norm(g)

    eigpot = LowestEigPot(coords, pot)
    vec = np.random.rand(len(coords))
    e, g = eigpot.getEnergyGradient(vec)
    print "eigenvalue", e
    print "eigenvector", g

    if True:
        e, g, hess = pot.getEnergyGradientHessian(coords)
        print "shape hess", np.shape(hess)
        print "hessian", hess
        u, v = np.linalg.eig(hess)
        print "max imag value", np.max(np.abs(u.imag))
        print "max imag vector", np.max(np.abs(v.imag))
        u = u.real
        v = v.real
        print "eigenvalues", u
        for i in range(len(u)):
            print "eigenvalue", u[i], "eigenvector", v[:, i]
        #find minimum eigenvalue, vector
        imin = 0
        umin = 10.
        for i in range(len(u)):
            if np.abs(u[i]) < 1e-10: continue
            if u[i] < umin:
                umin = u[i]
                imin = i
        print "lowest eigenvalue ", umin, imin
        print "lowest eigenvector", v[:, imin]

    from pygmin.optimize import lbfgs_py as quench
    ret = quench(vec, eigpot.getEnergyGradient, iprint=10, tol = 1e-5, maxstep = 1e-3, \
                 rel_energy = True)
    print ret

    print "lowest eigenvalue "
    print umin, imin
    print "lowest eigenvector"
    print v[:, imin]
    print "now the estimate"
    print ret[1]
    print ret[0]
示例#12
0
# from potentials.soft_sphere import SoftSphere, putInBox
from pygmin.potentials.lj import LJ as SoftSphere

np.random.seed(0)

natoms = 120
rho = 1.6
boxl = 1.0
meandiam = boxl / (float(natoms) / rho) ** (1.0 / 3)
print "mean diameter", meandiam

# set up potential
# diams = np.array([meandiam for i in range(natoms)]) #make them all the same
# pot = SoftSphere(diams = diams)
pot = SoftSphere()


# initial coordinates
coords = np.random.uniform(-1, 1, [natoms * 3]) * (natoms) ** (1.0 / 3)
E = pot.getEnergy(coords)
print "initial energy", E

printlist = []  # list of coordinates saved for printing
printlist.append((coords.copy(), "intial coords"))


# test a quench with default lbfgs
# from optimize.quench import quench
from pygmin.optimize import lbfgs_ase as quench
示例#13
0
def test_sandbox(nmol=6):
    import copy
    from pygmin.potentials.lj import LJ

    #define the molecule types.
    #here use only one type, LWOTP
    otp = molecule.setupLWOTP()

    # define the interaction matrix for the system.
    # for LWOTP there is only one atom type, so this is trivial
    lj = LJ()
    interaction_matrix = [[lj]]

    #set up a list of molecules
    mols = [otp for i in range(nmol)]

    #set up the RBSandbox object
    mysys = RBSandbox(mols, interaction_matrix)
    nsites = mysys.nsites

    #get an initial set of coordinates
    comcoords = np.random.uniform(-1, 1, [nmol * 3]) * 1.3 * (nsites)**(1. / 3)
    aacoords = np.array([copy.copy(rot.random_aa()) for i in range(nmol)])
    aacoords = aacoords.reshape(3 * nmol)
    coords = np.zeros(2 * 3 * nmol, np.float64)
    coords[0:3 * nmol] = comcoords[:]
    coords[3 * nmol:2 * 3 * nmol] = aacoords[:]
    print "lencoords, len aacoords", len(coords), len(aacoords), len(comcoords)

    #print "xyz coords", mysys.transformToXYZ(coords)

    #save the initial set of coords
    printlist = []
    xyz = mysys.getxyz(coords)
    printlist.append((xyz.copy(), "initial"))

    #calculate the initial energy
    Einit = mysys.getEnergy(coords)
    print "initial energy", Einit

    #test the gradient
    numericV = mysys.NumericalDerivative(coords, 1e-10)
    numericV = numericV.copy()
    print "numeric V", numericV

    E, V = mysys.getEnergyGradient(coords)
    print "energy from gradient", E, "difference", E - Einit
    #print "analytic gradient", V
    maxgrad_relative = np.max(np.abs(V - numericV) / np.abs(V))
    maxgraddiff = np.max(np.abs(V - numericV))
    print "max error in gradient", maxgraddiff, "max relative", maxgrad_relative

    #do a quench to make sure everything is working well
    from pygmin.optimize import lbfgs_scipy
    coords, E, rms, funcalls = lbfgs_scipy(coords,
                                           mysys.getEnergyGradient,
                                           iprint=-1)
    print "postquench E", E, "rms", rms, "funtion calls", funcalls
    xyz = mysys.getxyz(coords)
    printlist.append((xyz.copy(), "post quench"))

    #print the saved coords
    fname = "otp.xyz"
    print "saving xyz coords to", fname
    from pygmin.printing.print_atoms_xyz import printAtomsXYZ as printxyz
    with open(fname, "w") as fout:
        for xyz, line2 in printlist:
            printxyz(fout, xyz, line2=line2, atom_type=["N", "O", "O"])

    test_symmetries(coords, mysys)
示例#14
0
def testpot1():
    from pygmin.potentials.lj import LJ
    import itertools
    pot = LJ()
    a = 1.12 #2.**(1./6.)
    theta = 60./360*np.pi
    coords = [ 0., 0., 0., \
              -a, 0., 0., \
              -a/2, a*np.cos(theta), 0., \
              -a/2, -a*np.cos(theta), 0.1 \
              ]
    natoms = len(coords)/3
    c = np.reshape(coords, [-1,3])
    for i, j in itertools.combinations(range(natoms), 2):
        r = np.linalg.norm(c[i,:] - c[j,:])
        print i, j, r 
    
    e, g = pot.getEnergyGradient(coords)
    print "initial E", e
    print "initial G", g, np.linalg.norm(g)

    eigpot = LowestEigPot(coords, pot)
    vec = np.random.rand(len(coords))
    e, g = eigpot.getEnergyGradient(vec)
    print "eigenvalue", e 
    print "eigenvector", g
    
    if True:
        e, g, hess = pot.getEnergyGradientHessian(coords)
        print "shape hess", np.shape(hess)
        print "hessian", hess
        u, v = np.linalg.eig(hess)
        print "max imag value", np.max(np.abs(u.imag))
        print "max imag vector", np.max(np.abs(v.imag))
        u = u.real
        v = v.real
        print "eigenvalues", u
        for i in range(len(u)):
            print "eigenvalue", u[i], "eigenvector", v[:,i]
        #find minimum eigenvalue, vector
        imin = 0
        umin = 10.
        for i in range(len(u)):
            if np.abs(u[i]) < 1e-10: continue
            if u[i] < umin:
                umin = u[i]
                imin = i
        print "lowest eigenvalue ", umin, imin
        print "lowest eigenvector", v[:,imin]

    
    from pygmin.optimize import lbfgs_py as quench
    ret = quench(vec, eigpot.getEnergyGradient, iprint=10, tol = 1e-5, maxstep = 1e-3, \
                 rel_energy = True)
    print ret
    
    print "lowest eigenvalue "
    print umin, imin
    print "lowest eigenvector"
    print v[:,imin]
    print "now the estimate"
    print ret[1]
    print ret[0]
示例#15
0
"""

import numpy as np
import os

from pygmin.potentials.lj import LJ
from pygmin.optimize import lbfgs_py
from pygmin.landscape import DoubleEndedConnect, smoothPath
from pygmin.mindist import MinPermDistAtomicCluster
from pygmin.transition_states import orthogopt
from pygmin.storage import Database, Minimum
from pygmin.printing import printAtomsXYZ
np.random.seed(0)

#set up the potential
pot = LJ()

#import the starting and ending points and quench them, 
coords1 = np.genfromtxt("coords.A")
coords2 = np.genfromtxt("coords.B")
res1 = lbfgs_py(coords1.reshape(-1), pot)
res2 = lbfgs_py(coords2.reshape(-1), pot)
coords1 = res1.coords
coords2 = res2.coords
E1 = res1.energy
E2 = res2.energy
natoms = len(coords1)/3

#add the minima to a database
dbfile = "database.sqlite"
database = Database(dbfile)
示例#16
0
    def printwrapper(self, E, coords, accepted):
        if self.count % self.printfrq == 0:
            self.center(coords)
            printxyz(self.fout, coords, line2=str(E))
        self.count += 1


#def center(E, coords, accepted):
#   c = np.reshape()

natoms = 40

coords = np.random.rand(natoms * 3)

lj = LJ()

ret = quench(coords, lj)
coords = ret.coords

takestep = TakeStep(stepsize=0.1)

#do equilibration steps, adjusting stepsize
tsadapt = AdaptiveStepsize(takestep)
mc = MonteCarlo(coords, lj, tsadapt, temperature=0.5)
equilout = open("equilibration", "w")
#mc.outstream = equilout
mc.setPrinting(equilout, 1)
mc.run(10000)

#fix stepsize and do production run
示例#17
0
import numpy as np
#from potentials.soft_sphere import SoftSphere, putInBox
from pygmin.potentials.lj import LJ as SoftSphere

np.random.seed(0)

natoms = 120
rho = 1.6
boxl = 1.
meandiam = boxl / (float(natoms) / rho)**(1. / 3)
print "mean diameter", meandiam

#set up potential
#diams = np.array([meandiam for i in range(natoms)]) #make them all the same
#pot = SoftSphere(diams = diams)
pot = SoftSphere()

#initial coordinates
coords = np.random.uniform(-1, 1, [natoms * 3]) * (natoms)**(1. / 3)
E = pot.getEnergy(coords)
print "initial energy", E

printlist = []  #list of coordinates saved for printing
printlist.append((coords.copy(), "intial coords"))

#test a quench with default lbfgs
#from optimize.quench import quench
from pygmin.optimize import lbfgs_ase as quench

coords, E, rms, funcalls = quench(coords, pot.getEnergyGradient, iprint=1)
printlist.append((coords.copy(), "intial coords"))