def quenchCrystal(coords, pot, **kwargs): ''' Special quench routine for crystals which makes sure that the final structure is a reduced cell ''' coords, E, rms, calls = mylbfgs(coords, pot, **kwargs) #while(GMIN.reduceCell(coords)): if(GMIN.reduceCell(coords)): #print "Reduced cell, redo minimization" coords, E, rms, callsn = mylbfgs(coords, pot, **kwargs) calls+=callsn return coords, E, rms, calls
def test(natoms = 40, boxl=None): import pygmin.potentials.ljpshiftfast as ljpshift from pygmin.optimize import mylbfgs ntypeA = int(natoms*0.8) rcut = 2.5 coords = np.random.uniform(-1,1,natoms*3)*(natoms)**(1./3)/2 blj = ljpshift.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) pot = makeBLJNeighborListPot(natoms, ntypeA=ntypeA, rcut=rcut, boxl=boxl) eblj = blj.getEnergy(coords) print "blj energy", eblj epot = pot.getEnergy(coords) print "mcpot energy", epot print "difference", (epot - eblj)/eblj ret1 = mylbfgs(coords, blj, iprint=-11) np.savetxt("out.coords", ret1.coords) print "energy from quench1", ret1.energy ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "ret1 evaluated in both potentials", pot.getEnergy(ret1.coords), blj.getEnergy(ret1.coords) print "ret2 evaluated in both potentials", pot.getEnergy(ret2.coords), blj.getEnergy(ret2.coords) coords = ret1.coords e1, g1 = blj.getEnergyGradient(coords) e2, g2 = pot.getEnergyGradient(coords) print "energy difference from getEnergyGradient", (e2 - e1) print "largest gradient difference", np.max(np.abs(g2-g1)) print "rms gradients", np.linalg.norm(g1)/np.sqrt(len(g1)), np.linalg.norm(g2)/np.sqrt(len(g1)) for subpot in pot.potentials: nl = subpot.neighborList print "number of times neighbor list was remade", nl.buildcount, "out of", nl.count if False: try: import pygmin.utils.pymolwrapper as pym pym.start() pym.draw_spheres(np.reshape(coords,[-1,3]), "A", 1) pym.draw_spheres(np.reshape(ret1.coords,[-1,3]), "A", 2) pym.draw_spheres(np.reshape(ret2.coords,[-1,3]), "A", 3) except ImportError: print "Could not draw using pymol, skipping this step"
def test(natoms=40, boxl=None): import pygmin.potentials.ljpshiftfast as ljpshift from pygmin.optimize import mylbfgs ntypeA = int(natoms * 0.8) rcut = 2.5 coords = np.random.uniform(-1, 1, natoms * 3) * (natoms)**(1. / 3) / 2 blj = ljpshift.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) pot = makeBLJNeighborListPot(natoms, ntypeA=ntypeA, rcut=rcut, boxl=boxl) eblj = blj.getEnergy(coords) print "blj energy", eblj epot = pot.getEnergy(coords) print "mcpot energy", epot print "difference", (epot - eblj) / eblj ret1 = mylbfgs(coords, blj, iprint=-11) np.savetxt("out.coords", ret1.coords) print "energy from quench1", ret1.energy ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "ret1 evaluated in both potentials", pot.getEnergy( ret1.coords), blj.getEnergy(ret1.coords) print "ret2 evaluated in both potentials", pot.getEnergy( ret2.coords), blj.getEnergy(ret2.coords) coords = ret1.coords e1, g1 = blj.getEnergyGradient(coords) e2, g2 = pot.getEnergyGradient(coords) print "energy difference from getEnergyGradient", (e2 - e1) print "largest gradient difference", np.max(np.abs(g2 - g1)) print "rms gradients", np.linalg.norm(g1) / np.sqrt( len(g1)), np.linalg.norm(g2) / np.sqrt(len(g1)) for subpot in pot.potentials: nl = subpot.neighborList print "number of times neighbor list was remade", nl.buildcount, "out of", nl.count if False: try: import pygmin.utils.pymolwrapper as pym pym.start() pym.draw_spheres(np.reshape(coords, [-1, 3]), "A", 1) pym.draw_spheres(np.reshape(ret1.coords, [-1, 3]), "A", 2) pym.draw_spheres(np.reshape(ret2.coords, [-1, 3]), "A", 3) except ImportError: print "Could not draw using pymol, skipping this step"
def test(): pi = np.pi nspins = 6 #phases = np.zeros(nspins) pot = XYModel(nspins, phi=np.pi / 8.) #, phases=phases) angles = np.random.uniform(-pi / 4, pi / 4, nspins) print angles e = pot.getEnergy(angles) print e print "numerical gradient" ret = pot.getEnergyGradientNumerical(angles) print ret[1] print "analytical gradient" ret2 = pot.getEnergyGradient(angles) print ret2[1] print ret[0] print ret2[0] #try a quench from pygmin.optimize import mylbfgs ret = mylbfgs(angles, pot) print "quenched e = ", ret.energy print ret.coords test_basin_hopping(pot, angles)
def test(): pi = np.pi nspins = 6 #phases = np.zeros(nspins) pot = XYModel(nspins, phi = np.pi/8.) #, phases=phases) angles = np.random.uniform(-pi/4, pi/4, nspins) print angles e = pot.getEnergy(angles) print e print "numerical gradient" ret = pot.getEnergyGradientNumerical(angles) print ret[1] print "analytical gradient" ret2 = pot.getEnergyGradient(angles) print ret2[1] print ret[0] print ret2[0] #try a quench from pygmin.optimize import mylbfgs ret = mylbfgs(angles, pot) print "quenched e = ", ret.energy print ret.coords test_basin_hopping(pot, angles)
def testBLJ(self): X1 = np.copy(self.X1) X2 = np.random.uniform(-1,1,[self.natoms*3])*(float(self.natoms))**(1./3)/2 #run a quench so the structure is not crazy ret = mylbfgs(X2, self.pot) X2 = ret.coords self.runtest(X1, X2, MinPermDistCluster(measure=MeasureAtomicCluster(permlist=self.permlist)))
def setUp(self): from pygmin.optimize import mylbfgs self.natoms = 10 self.coords = np.random.uniform(-1,1.,3*self.natoms) * self.natoms**(-1./3) self.pot = LJ() ret = mylbfgs(self.coords, self.pot, tol=2.) self.coords = ret.coords self.E = self.pot.getEnergy(self.coords) self.Egrad, self.grad = self.pot.getEnergyGradient(self.coords)
def setUp(self): from pygmin.potentials.ljpshiftfast import LJpshift as BLJ self.natoms = 25 self.ntypeA = int(self.natoms * .8) self.pot = BLJ(self.natoms, self.ntypeA) self.permlist = [range(self.ntypeA), range(self.ntypeA, self.natoms)] self.X1 = np.random.uniform(-1,1,[self.natoms*3])*(float(self.natoms))**(1./3)/2 #run a quench so the structure is not crazy ret = mylbfgs(self.X1, self.pot) self.X1 = ret.coords
def __init__(self, coords, potential, takeStep, storage=None, event_after_step=[], \ acceptTest=None, \ temperature=1.0, \ quench = None, \ confCheck = [], \ outstream = sys.stdout, insert_rejected = False ): ######################################################################### #initialize MonteCarlo base class ######################################################################### MonteCarlo.__init__(self, coords, potential, takeStep, \ storage=storage, \ event_after_step=event_after_step, \ acceptTest=acceptTest, \ temperature=temperature, \ confCheck = confCheck, \ outstream=outstream,store_initial=False) if quench is None: quench = lambda coords : mylbfgs(coords, self.potential) self.quench = quench ######################################################################### #do initial quench ######################################################################### self.markovE_old = self.markovE res = self.quench(self.coords) self.coords = res.coords self.markovE = res.energy self.rms = res.rms self.funcalls = res.nfev self.insert_rejected = insert_rejected if(self.storage): self.storage(self.markovE, self.coords) #print the initial quench self.acceptstep = True self.trial_energy = self.markovE self.printStep() self.result.energy = self.markovE self.result.coords = self.coords.copy()
def __init__(self, coords, potential, takeStep, storage=None, event_after_step=[], \ acceptTest=None, \ temperature=1.0, \ quench = None, \ confCheck = [], \ outstream = sys.stdout, insert_rejected = False ): ######################################################################### #initialize MonteCarlo base class ######################################################################### MonteCarlo.__init__(self, coords, potential, takeStep, \ storage=storage, \ event_after_step=event_after_step, \ acceptTest=acceptTest, \ temperature=temperature, \ confCheck = confCheck, \ outstream=outstream,store_initial=False) if quench is None: quench = lambda coords: mylbfgs(coords, self.potential) self.quench = quench ######################################################################### #do initial quench ######################################################################### self.markovE_old = self.markovE res = self.quench(self.coords) self.coords = res.coords self.markovE = res.energy self.rms = res.rms self.funcalls = res.nfev self.insert_rejected = insert_rejected if (self.storage): self.storage(self.markovE, self.coords) #print the initial quench self.acceptstep = True self.trial_energy = self.markovE self.printStep() self.result.energy = self.markovE self.result.coords = self.coords.copy()
def minima_from_ts(pot, xt, n=None, quench=None, **kwargs): """ step off either side of a transition state and quench to find the minima Parameters ---------- pot : potential object xt : array transition state coords stepmin : float initial guess for size of pushoff when stepping off the transition state stepmax : float maximum size of pushoff when stepping off the transition state gdiff : float criterion for choosing a step size. Try to choose a stepsize so that:: (gradpar - gradpar_ts) / gradpar_ts >= gdiff where gradpar and gradpar_ts is the parallel component of the gradient after the step and at the top of the transition state quenchRoutine : callable routine to use to do the quenching quenchParams : dict parameters to pass to quenchRoutine verbose : bool """ # if no direction is given, choose random direction if n==None: # TODO: replace by better algorithm with uniform sampling n = np.random.random(xt.shape)-0.5 if quench is None: quench = lambda coords : mylbfgs(coords, pot) #x1 = xt - displace*n x1 = determinePushoff(pot, xt, n, **kwargs) x2 = determinePushoff(pot, xt, -n, **kwargs) #x2 = xt + displace*n #e1,g1 = getEnergyGradient(x1) #e2,g2 = getEnergyGradient(x2) #print np.dot(g1,g2) minimum1 = quench(x1) minimum2 = quench(x2) return minimum1, minimum2
def test2(): import pygmin.potentials.ljpshiftfast as ljpshiftfast import pygmin.potentials.ljpshift as ljpshift from pygmin.optimize import mylbfgs fname = "/scratch/scratch2/js850/library/cluster/spherical/1620/PTMC/q4/oneatom/cavity200-8/ts/coords1.quench" fname = "/scratch/scratch2/js850/library/cluster/spherical/1620/PTMC/q4/oneatom/cavity200-8/ts/test.coords" #fname = "out.coords" if False: coords = np.array(np.loadtxt(fname)) coords = coords.reshape(-1) boxl = 11.05209 else: natoms = 200 coords = np.random.uniform(-1, 1, natoms * 3) * (natoms)**(1. / 3) / 2 print "max, min coords", coords.max(), coords.min() boxl = 5 natoms = len(coords) / 3 ntypeA = int(natoms * 0.8) rcut = 2.5 print "natoms", natoms, "ntypea", ntypeA blj = ljpshift.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) bljfast = ljpshiftfast.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) pot = makeBLJNeighborListPot(natoms, ntypeA=ntypeA, rcut=rcut, boxl=boxl) eblj = blj.getEnergy(coords) print "blj energy", eblj epot = pot.getEnergy(coords) print "mcpot energy", epot print "energy difference", (epot - eblj) e1, g1 = blj.getEnergyGradient(coords) e2, g2 = pot.getEnergyGradient(coords) print "energy difference from getEnergyGradient", (e2 - e1) print "largest gradient difference", np.max(np.abs(g2 - g1)) print "rms gradients", np.linalg.norm(g1) / np.sqrt( len(g1)), np.linalg.norm(g2) / np.sqrt(len(g1)) if False: print "quenching" ret1 = mylbfgs(coords, blj, iprint=-11) np.savetxt("out.coords", ret1.coords) print "energy from quench1", ret1.energy ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "max, min quenched coords", coords.max(), coords.min() print "ret1 evaluated in both potentials", pot.getEnergy( ret1.coords), blj.getEnergy(ret1.coords) print "ret2 evaluated in both potentials", pot.getEnergy( ret2.coords), blj.getEnergy(ret2.coords) elif True: print "quenching" ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "max, min quenched coords", ret2.coords.max(), ret2.coords.min() print "ret2 evaluated in both potentials", pot.getEnergy( ret2.coords), blj.getEnergy(ret2.coords) print "and in blj fast ", bljfast.getEnergy( ret2.coords)
vec = rotations.vec_random() coords[i, :] = make2dVector(vec) coords = np.reshape(coords, [nspins * 2]) #print np.shape(coords) coordsinit = np.copy(coords) #print "fields", pot.fields print coords e = pot.getEnergy(coords) print "energy ", e print "try a quench" from pygmin.optimize import mylbfgs ret = mylbfgs(coords, pot) print "quenched e = ", ret.energy, "funcalls", ret.nfev print ret.coords m = getm(ret[0]) print "magnetization after quench", m #do basin hopping from pygmin.basinhopping import BasinHopping from pygmin.takestep.displace import RandomDisplacement from pygmin.takestep.adaptive import AdaptiveStepsize from pygmin.storage import savenlowest takestep = RandomDisplacement(stepsize=np.pi / 4)
def get_minimizer(self, **kwargs): """return a function to minimize the structure""" pot = self.get_potential() kwargs = dict_copy_update(self.params["structural_quench_params"], kwargs) return lambda coords: mylbfgs(coords, pot, **kwargs)
vec = rotations.vec_random() coords[i,:] = make2dVector(vec) coords = np.reshape(coords, [nspins*2]) #print np.shape(coords) coordsinit = np.copy(coords) #print "fields", pot.fields print coords e = pot.getEnergy(coords) print "energy ", e print "try a quench" from pygmin.optimize import mylbfgs ret = mylbfgs(coords, pot) print "quenched e = ", ret.energy, "funcalls", ret.nfev print ret.coords m = getm( ret[0] ) print "magnetization after quench", m #do basin hopping from pygmin.basinhopping import BasinHopping from pygmin.takestep.displace import RandomDisplacement from pygmin.takestep.adaptive import AdaptiveStepsize from pygmin.storage import savenlowest
ntypeA = int(natoms*0.8) rcut = 2.5 print "natoms", natoms, "ntypea", ntypeA bljslow = ljpshift.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) blj = LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) ebljslow = bljslow.getEnergy(coords) print "blj energy slow", ebljslow eblj = blj.getEnergy(coords) print "blj energy ", eblj blj.test_potential(coords) print "" print "partially quenching coords" ret1 = mylbfgs(coords, blj, iprint=-11, tol=1.) coords = ret1.coords ebljslow = bljslow.getEnergy(coords) print "blj energy slow", ebljslow eblj = blj.getEnergy(coords) print "blj energy ", eblj blj.test_potential(coords, eps=1e-6) print "" print "quenching coords" ret1 = mylbfgs(coords, blj, iprint=-11) coords = ret1.coords ebljslow = bljslow.getEnergy(coords) print "blj energy slow", ebljslow
def test(): pi = np.pi L = 8 nspins = L**2 #phases = np.zeros(nspins) pot = HeisenbergModel(dim=[L, L], field_disorder=1.) #, phases=phases) coords = np.zeros([nspins, 2]) for i in range(nspins): vec = rotations.vec_random() coords[i, :] = make2dVector(vec) coords = np.reshape(coords, [nspins * 2]) if False: normfields = np.copy(pot.fields) for i in range(nspins): normfields[i, :] /= np.linalg.norm(normfields[i, :]) coords = coords3ToCoords2(np.reshape(normfields, [nspins * 3])) coords = np.reshape(coords, nspins * 2) #print np.shape(coords) coordsinit = np.copy(coords) #print "fields", pot.fields print coords if False: coords3 = coords2ToCoords3(coords) coords2 = coords3ToCoords2(coords3) print np.reshape(coords, [nspins, 2]) print coords2 coords3new = coords2ToCoords3(coords2) print coords3 print coords3new e = pot.getEnergy(coords) print "energy ", e if False: print "numerical gradient" ret = pot.getEnergyGradientNumerical(coords) print ret[1] if True: print "analytical gradient" ret2 = pot.getEnergyGradient(coords) print ret2[1] print ret[0] print ret2[0] print "ratio" print ret2[1] / ret[1] print "inverse sin" print 1. / sin(coords) print cos(coords) print "try a quench" from pygmin.optimize import mylbfgs ret = mylbfgs(coords, pot) print "quenched e = ", ret.energy, "funcalls", ret.nfev print ret.coords with open("out.spins", "w") as fout: s = coords2ToCoords3(ret.coords) h = pot.fields c = coords2ToCoords3(coordsinit) for node in pot.G.nodes(): i = pot.indices[node] fout.write( "%g %g %g %g %g %g %g %g %g %g %g\n" % (node[0], node[1], \ s[i,0], s[i,1], s[i,2], h[i,0], h[i,1], h[i,2], c[i,0], c[i,1], c[i,2] ) ) coords3 = coords2ToCoords3(ret.coords) m = np.linalg.norm(coords3.sum(0)) / nspins print "magnetization after quench", m test_basin_hopping(pot, coords)
import sys import _lj import _lbfgs from pygmin.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) res.write("%d %f %f\n"%(na, t1-t0, time.time()-t1)) print "%d %f %f\n"%(na, t1-t0, time.time()-t1) res.close()
def test(): pi = np.pi L = 8 nspins = L**2 #phases = np.zeros(nspins) pot = HeisenbergModel( dim = [L,L], field_disorder = 1.) #, phases=phases) coords = np.zeros([nspins, 2]) for i in range(nspins): vec = rotations.vec_random() coords[i,:] = make2dVector(vec) coords = np.reshape(coords, [nspins*2]) if False: normfields = np.copy(pot.fields) for i in range(nspins): normfields[i,:] /= np.linalg.norm(normfields[i,:]) coords = coords3ToCoords2( np.reshape(normfields, [nspins*3] ) ) coords = np.reshape(coords, nspins*2) #print np.shape(coords) coordsinit = np.copy(coords) #print "fields", pot.fields print coords if False: coords3 = coords2ToCoords3(coords) coords2 = coords3ToCoords2(coords3) print np.reshape(coords, [nspins,2]) print coords2 coords3new = coords2ToCoords3(coords2) print coords3 print coords3new e = pot.getEnergy(coords) print "energy ", e if False: print "numerical gradient" ret = pot.getEnergyGradientNumerical(coords) print ret[1] if True: print "analytical gradient" ret2 = pot.getEnergyGradient(coords) print ret2[1] print ret[0] print ret2[0] print "ratio" print ret2[1] / ret[1] print "inverse sin" print 1./sin(coords) print cos(coords) print "try a quench" from pygmin.optimize import mylbfgs ret = mylbfgs(coords, pot) print "quenched e = ", ret.energy, "funcalls", ret.nfev print ret.coords with open("out.spins", "w") as fout: s = coords2ToCoords3( ret.coords ) h = pot.fields c = coords2ToCoords3( coordsinit ) for node in pot.G.nodes(): i = pot.indices[node] fout.write( "%g %g %g %g %g %g %g %g %g %g %g\n" % (node[0], node[1], \ s[i,0], s[i,1], s[i,2], h[i,0], h[i,1], h[i,2], c[i,0], c[i,1], c[i,2] ) ) coords3 = coords2ToCoords3( ret.coords ) m = np.linalg.norm( coords3.sum(0) ) / nspins print "magnetization after quench", m test_basin_hopping(pot, coords)
def test2(): import pygmin.potentials.ljpshiftfast as ljpshiftfast import pygmin.potentials.ljpshift as ljpshift from pygmin.optimize import mylbfgs fname = "/scratch/scratch2/js850/library/cluster/spherical/1620/PTMC/q4/oneatom/cavity200-8/ts/coords1.quench" fname = "/scratch/scratch2/js850/library/cluster/spherical/1620/PTMC/q4/oneatom/cavity200-8/ts/test.coords" #fname = "out.coords" if False: coords = np.array(np.loadtxt(fname)) coords = coords.reshape(-1) boxl = 11.05209 else: natoms = 200 coords = np.random.uniform(-1,1,natoms*3)*(natoms)**(1./3)/2 print "max, min coords", coords.max(), coords.min() boxl = 5 natoms = len(coords) /3 ntypeA = int(natoms*0.8) rcut = 2.5 print "natoms", natoms, "ntypea", ntypeA blj = ljpshift.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) bljfast = ljpshiftfast.LJpshift(natoms, ntypeA, rcut=rcut, boxl=boxl) pot = makeBLJNeighborListPot(natoms, ntypeA=ntypeA, rcut=rcut, boxl=boxl) eblj = blj.getEnergy(coords) print "blj energy", eblj epot = pot.getEnergy(coords) print "mcpot energy", epot print "energy difference", (epot - eblj) e1, g1 = blj.getEnergyGradient(coords) e2, g2 = pot.getEnergyGradient(coords) print "energy difference from getEnergyGradient", (e2 - e1) print "largest gradient difference", np.max(np.abs(g2-g1)) print "rms gradients", np.linalg.norm(g1)/np.sqrt(len(g1)), np.linalg.norm(g2)/np.sqrt(len(g1)) if False: print "quenching" ret1 = mylbfgs(coords, blj, iprint=-11) np.savetxt("out.coords", ret1.coords) print "energy from quench1", ret1.energy ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "max, min quenched coords", coords.max(), coords.min() print "ret1 evaluated in both potentials", pot.getEnergy(ret1.coords), blj.getEnergy(ret1.coords) print "ret2 evaluated in both potentials", pot.getEnergy(ret2.coords), blj.getEnergy(ret2.coords) elif True: print "quenching" ret2 = mylbfgs(coords, pot, iprint=-1) print "energy from quench2", ret2.energy print "max, min quenched coords", ret2.coords.max(), ret2.coords.min() print "ret2 evaluated in both potentials", pot.getEnergy(ret2.coords), blj.getEnergy(ret2.coords) print "and in blj fast ", bljfast.getEnergy(ret2.coords)
clbfgs = _lbfgs.LBFGS(pot) t0 = time.time() for i in xrange(100): x = 1. * (np.random.random(3 * natoms) - 0.5) ret = clbfgs.run(x) #print ret #print ret[0] #print pot.get_energy(ret[0]) e, g = pot.get_energy_gradient(ret[0]) print "C", np.linalg.norm(g) t1 = time.time() for i in xrange(100): x = 1. * np.random.random(3 * natoms) ret = mylbfgs(x, pot_old, tol=1e-5) print "PY:", np.linalg.norm(pot_old.getEnergyGradient(ret[0])[1]) print time.time() - t1, t1 - t0 t0 = time.time() for i in xrange(N): e, g = pot_old.getEnergyGradient(x) time_f2py = time.time() - t0 print "f2py potential", e, "time", time.time() - t0 t0 = time.time() for i in xrange(N): e, g = pot.get_energy_gradient(x) time_cython = time.time() - t0 print "cython potential", e, "time", time.time() - t0
#phases = np.zeros(nspins) pot = XYModel( dim = [L,L], phi = np.pi) #, phases=phases) angles = np.random.uniform(-pi, pi, nspins) print angles e = pot.getEnergy(angles) print "energy ", e #try a quench if False: from pygmin.optimize import mylbfgs ret = mylbfgs(angles, pot) print ret #set up and run basin hopping from pygmin.basinhopping import BasinHopping from pygmin.takestep.displace import RandomDisplacement from pygmin.takestep.adaptive import AdaptiveStepsize from pygmin.storage import savenlowest #should probably use a different take step routine which takes into account #the cyclical periodicity of angles takestep = RandomDisplacement(stepsize = np.pi/4) takestepa = AdaptiveStepsize(takestep, frequency = 20)
L = 24 nspins = L**2 #phases = np.zeros(nspins) pot = XYModel(dim=[L, L], phi=np.pi) #, phases=phases) angles = np.random.uniform(-pi, pi, nspins) print angles e = pot.getEnergy(angles) print "energy ", e #try a quench if False: from pygmin.optimize import mylbfgs ret = mylbfgs(angles, pot) print ret #set up and run basin hopping from pygmin.basinhopping import BasinHopping from pygmin.takestep.displace import RandomDisplacement from pygmin.takestep.adaptive import AdaptiveStepsize from pygmin.storage import savenlowest #should probably use a different take step routine which takes into account #the cyclical periodicity of angles takestep = RandomDisplacement(stepsize=np.pi / 4) takestepa = AdaptiveStepsize(takestep, frequency=20) storage = savenlowest.SaveN(500)