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 test2(): 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)
class ATLJ(BasePotential): """ Lennard Jones + three body Axilrod-Teller term V = sum_ij VLJ_ij + sum_ijk Z * (1 + 3*cos(t1)*cos(t2)*cos(t3)) / (rij * rjk * rik)**3 ) where t1, t2, t3 are the internal angles of the triangle ijk Z > 0 stabilizes linear vs. triangular geometries """ 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) def getEnergySlow(self, coords): Elj = self.lj.getEnergy(coords) natoms = coords.size / 3 X = np.reshape(coords, [natoms, 3]) Z = self.Z energy = 0. for i in range(natoms): for j in range(i): for k in range(j): drij = X[i, :] - X[j, :] drik = X[i, :] - X[k, :] drjk = X[j, :] - X[k, :] rij = np.linalg.norm(drij) rik = np.linalg.norm(drik) rjk = np.linalg.norm(drjk) energy += (Z * (1. + 3. * np.dot(drij, -drjk) * np.dot(-drij, -drik) * np.dot(drik, drjk) / (rij * rik * rjk) ** 2) / (rij * rik * rjk) ** 3 ) energy += Elj return energy def getEnergyFortran(self, coords): garbage, e = ATfort.axt(coords, False, self.Z) Elj = self.lj.getEnergy(coords) return e + Elj def getEnergyGradientFortran(self, coords): grad, e = ATfort.axt(coords, True, self.Z) elj, gradlj = self.lj.getEnergyGradient(coords) return e + elj, grad + gradlj def getEnergy(self, coords): return self.getEnergyFortran(coords) def getEnergyGradient(self, coords): return self.getEnergyGradientFortran(coords)
class ATLJ(BasePotential): """ Lennard Jones + three body Axilrod-Teller term V = sum_ij VLJ_ij + sum_ijk Z * (1 + 3*cos(t1)*cos(t2)*cos(t3)) / (rij * rjk * rik)**3 ) where t1, t2, t3 are the internal angles of the triangle ijk Z > 0 stabilizes linear vs. triangular geometries """ 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) def getEnergySlow(self, coords): Elj = self.lj.getEnergy(coords) natoms = coords.size // 3 X = np.reshape(coords, [natoms, 3]) Z = self.Z energy = 0. for i in range(natoms): for j in range(i): for k in range(j): drij = X[i, :] - X[j, :] drik = X[i, :] - X[k, :] drjk = X[j, :] - X[k, :] rij = np.linalg.norm(drij) rik = np.linalg.norm(drik) rjk = np.linalg.norm(drjk) energy += (Z * (1. + 3. * np.dot(drij, -drjk) * np.dot(-drij, -drik) * np.dot(drik, drjk) / (rij * rik * rjk)**2) / (rij * rik * rjk)**3) energy += Elj return energy def getEnergyFortran(self, coords): garbage, e = ATfort.axt(coords, False, self.Z) Elj = self.lj.getEnergy(coords) return e + Elj def getEnergyGradientFortran(self, coords): grad, e = ATfort.axt(coords, True, self.Z) elj, gradlj = self.lj.getEnergyGradient(coords) return e + elj, grad + gradlj def getEnergy(self, coords): return self.getEnergyFortran(coords) def getEnergyGradient(self, coords): return self.getEnergyGradientFortran(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 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 = FrozenPotentialWrapper(pot, reference_coords, frozen_dof) reduced_coords = fpot.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.get_full_coords(ret.coords)
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)
# finalize the rigid body setup 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)
class ATLJ(BasePotential): """ Lennard Jones + three body Axilrod-Teller term V = sum_ij VLJ_ij + sum_ijk Z * (1 + 3*cos(t1)*cos(t2)*cos(t3)) / (rij * rjk * rik)**3 ) where t1, t2, t3 are the internal angles of the triangle ijk Z > 0 stabilizes linear vs. triangular geometries """ 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) # def getEnergyWeave(self, coords): # """ # use weave inline # """ # Elj = self.lj.getEnergy(coords) # # natoms = coords.size/3 # coords = np.reshape(coords, [natoms,3]) # energy=0. # Z = self.Z # #support_code # code = """ # double drij[3]; # double drik[3]; # double drjk[3]; # energy = 0.; # for (int i=0; i < natoms; ++i){ # for (int j=0; j<i; ++j){ # for (int k=0; k<j; ++k){ # # double rij = 0.; # double rik = 0.; # double rjk = 0.; # # for (int d=0; d<3; ++d){ # drij[d] = coords(i,d) - coords(j,d); # rij += drij[d]*drij[d]; # } # for (int d=0; d<3; ++d){ # drjk[d] = coords(j,d) - coords(k,d); # rjk += drjk[d]*drjk[d]; # } # for (int d=0; d<3; ++d){ # drik[d] = coords(i,d) - coords(k,d); # rik += drik[d]*drik[d]; # } # # rij = sqrt(rij); # rjk = sqrt(rjk); # rik = sqrt(rik); # # double ctijk = ( -(drij[0]*drjk[0] + drij[1]*drjk[1] + drij[2]*drjk[2]) / (rij * rjk) ); # double ctjki = ( (drjk[0]*drik[0] + drjk[1]*drik[1] + drjk[2]*drik[2]) / (rjk * rik) ); # double ctkij = ( (drik[0]*drij[0] + drik[1]*drij[1] + drik[2]*drij[2]) / (rik * rij) ); # # double r3 = rij*rjk*rik; # energy += Z*(1. + 3. * ctijk * ctjki * ctkij) / (r3*r3*r3); # } # } # } # return_val= energy; # """ # energy = weave.inline(code, ["coords", "energy", "Z", "natoms"], type_converters=converters.blitz, verbose=2) # #print "fast energy", Elj, energy # energy += Elj # return energy def getEnergySlow(self, coords): Elj = self.lj.getEnergy(coords) natoms = coords.size/3 X = np.reshape(coords, [natoms,3]) Z = self.Z energy = 0. for i in range(natoms): for j in range(i): for k in range(j): #print i, j, k drij = X[i,:] - X[j,:] drik = X[i,:] - X[k,:] drjk = X[j,:] - X[k,:] rij = np.linalg.norm( drij ) rik = np.linalg.norm( drik ) rjk = np.linalg.norm( drjk ) energy += Z * (1. + 3.*\ np.dot( drij, -drjk ) * \ np.dot(-drij, -drik ) * \ np.dot( drik, drjk ) / (rij*rik*rjk)**2) \ / (rij*rik*rjk)**3 #print "slow energy", Elj, energy energy += Elj return energy def getEnergyFortran(self, coords): #grad,potel = axt(x,gradt,zstar,[n]) natoms = len(coords)/3 garbage, e = ATfort.axt(coords, False, self.Z) Elj = self.lj.getEnergy(coords) return e + Elj def getEnergyGradientFortran(self, coords): #grad,potel = axt(x,gradt,zstar,[n]) natoms = len(coords)/3 grad, e = ATfort.axt(coords, True, self.Z) elj, gradlj = self.lj.getEnergyGradient(coords) return e + elj, grad + gradlj def getEnergy(self, coords): return self.getEnergyFortran(coords) def getEnergyGradient(self, coords): #return self.getEnergyGradientNumerical(coords) return self.getEnergyGradientFortran(coords)
def getEnergy(self, coords): atom_coords = self.aatopology.to_atomistic(coords) return LJ.getEnergy(self, atom_coords.flatten())